@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-7ABHNNY3.js

@@ -1,529 +0,0 @@
-import {
-  main_merge_guard
-} from "./chunk-P4D5RESF.js";
-import {
-  REFUSED_VERDICT,
-  observation_record
-} from "./chunk-ZYFHYQA7.js";
-import {
-  review_comment_round
-} from "./chunk-CKUKK7JG.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  test_related_pins
-} from "./chunk-HE5S4XRE.js";
-import {
-  observation_ledger_home
-} from "./chunk-WWVYEHQT.js";
-import {
-  vitest_failure_summary
-} from "./chunk-KB3OQWDT.js";
-import {
-  yaml_document
-} from "./chunk-UCI4AL3Q.js";
-import {
-  git_branch
-} from "./chunk-Q5Q2QYVU.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  git_gh_helpers
-} from "./chunk-4PUKDAXL.js";
-import {
-  POLL_BACKOFF,
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  git_gh_api_path
-} from "./chunk-RDRN56E4.js";
-import {
-  git_gh_exec
-} from "./chunk-XDF25GSU.js";
-import {
-  changed_paths
-} from "./chunk-V5FD7DVV.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/followup/followup-job-rerun.ts
-import { stripVTControlCharacters } from "node:util";
-import { z as z2 } from "zod";
-
-// scripts/followup/followup-failed-tests.ts
-import path from "node:path";
-var LOG_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\S+Z /u;
-var TEST_SUFFIX = /\.test(?<extension>\.[^./]+)$/u;
-var SEGMENT_SEPARATOR = ".";
-var OBSERVATION_SLUG = "followup-unrelated-test-rerun";
-var OBSERVATION_DEPTH = "d1";
-var NAME_SEPARATOR = "; ";
-var UNNAMED_ISSUE = "Did not record the failed tests outside the change: the branch names no issue to post them on.";
-var RERUN_VERDICT = "rerun";
-var KEPT_VERDICT = "kept";
-var UNNAMED_VERDICT = "unnamed";
-function read_failed_tests(log) {
-  const lines = log.split("\n").map((line) => line.replace(LOG_TIMESTAMP, ""));
-  const names = vitest_failure_summary.failed_tests(lines.join("\n"));
-  return { files: vitest_failure_summary.failed_files(names), names };
-}
-function subjects_of(test_file) {
-  const extension = TEST_SUFFIX.exec(test_file)?.groups?.["extension"];
-  if (extension === void 0) return [test_file];
-  const directory = path.posix.dirname(test_file);
-  const segments = path.posix.basename(test_file, `.test${extension}`).split(SEGMENT_SEPARATOR);
-  const modules = segments.map(
-    (_, index) => path.posix.join(
-      directory,
-      `${segments.slice(0, index + 1).join(SEGMENT_SEPARATOR)}${extension}`
-    )
-  );
-  return [test_file, ...modules];
-}
-function is_in_change(test_file, changed) {
-  if (test_related_pins.pinned_tests(changed).includes(test_file)) return true;
-  return subjects_of(test_file).some((subject) => changed.has(subject));
-}
-function verdict_of(tests, changed) {
-  if (tests.files.length === 0) return UNNAMED_VERDICT;
-  return tests.files.every((file) => !is_in_change(file, changed)) ? RERUN_VERDICT : KEPT_VERDICT;
-}
-function observation_of(failures) {
-  const files = new Set(failures.flatMap(({ tests }) => tests.files));
-  const names = new Set(failures.flatMap(({ tests }) => tests.names));
-  const listed = [...names].map((name) => name.replaceAll("|", "/"));
-  const jobs = failures.map(({ job }) => job);
-  return {
-    slug: OBSERVATION_SLUG,
-    depth: OBSERVATION_DEPTH,
-    where: [...files].join(", "),
-    what: `followup reran ${jobs.join(", ")}; failed outside the change: ${listed.join(NAME_SEPARATOR)}`
-  };
-}
-async function post(entry, issue) {
-  const assessment = await observation_record.assess({
-    entry,
-    checkout: observation_ledger_home.ledger_root(),
-    now: /* @__PURE__ */ new Date()
-  });
-  if (assessment.verdict === REFUSED_VERDICT) return `${REFUSED_VERDICT}: ${assessment.reason}`;
-  await git_gh_issue_write.issue_comment(
-    String(issue),
-    review_comment_round.observation_body_of([assessment.line])
-  );
-  return assessment.verdict;
-}
-async function record_entry(entry, issue) {
-  if (issue === void 0) {
-    console.info(`\u26A0\uFE0F ${UNNAMED_ISSUE}`);
-    return;
-  }
-  try {
-    console.info(`\u{1F4DD} Recorded the ${entry.slug} observation: ${await post(entry, issue)}`);
-  } catch (error) {
-    console.info(`\u26A0\uFE0F Could not record the ${entry.slug} observation: ${String(error)}`);
-  }
-}
-async function record(failures, issue) {
-  if (failures.length === 0) return;
-  await record_entry(observation_of(failures), issue);
-}
-var followup_failed_tests = {
-  observation_of,
-  read_failed_tests,
-  record,
-  record_entry,
-  subjects_of,
-  verdict_of
-};
-
-// scripts/followup/followup-job-needs.ts
-import { readFile } from "node:fs/promises";
-import { z } from "zod";
-var EXPRESSION = /\$\{\{[^}]*\}\}/u;
-var EXPRESSION_MARK = "${{";
-var ANY_TEXT = ".+";
-var MATRIX_SUFFIX = String.raw`(?: \(.+\))?`;
-var CALLED_JOB_SUFFIX = " / .+";
-var REGEX_SPECIAL = /[$()*+.?[\\\]^{|}]/gu;
-var RESULT_READ = /\bneeds\.[\w-]+\.result\b/u;
-var PASSED_CONCLUSIONS = /* @__PURE__ */ new Set(["success", "skipped"]);
-var FAILURE_CONCLUSION = "failure";
-var needs_schema = z.array(z.string());
-var step_schema = z.looseObject({
-  name: z.string().optional(),
-  if: z.unknown().optional(),
-  env: z.unknown().optional()
-});
-var job_schema = z.looseObject({
-  name: z.string().optional(),
-  needs: z.union([z.string(), needs_schema]).optional(),
-  uses: z.string().optional(),
-  steps: z.array(step_schema).optional()
-});
-var workflow_schema = z.looseObject({ jobs: z.record(z.string(), job_schema) });
-function escape(text) {
-  return text.replaceAll(REGEX_SPECIAL, String.raw`\$&`);
-}
-function name_source(name) {
-  if (!name.includes(EXPRESSION_MARK)) return `${escape(name)}${MATRIX_SUFFIX}`;
-  return name.split(EXPRESSION).map((part) => escape(part)).join(ANY_TEXT);
-}
-function needs_list(needs = []) {
-  return typeof needs === "string" ? [needs] : needs;
-}
-function pattern_of(jobs, id) {
-  const job = jobs[id];
-  const suffix = job?.uses === void 0 ? "" : CALLED_JOB_SUFFIX;
-  return new RegExp(`^${name_source(job?.name ?? id)}${suffix}$`, "u");
-}
-function gate_steps(steps = []) {
-  return steps.filter((step) => RESULT_READ.test(JSON.stringify([step.if, step.env]))).flatMap((step) => step.name ?? []);
-}
-function parse_graph(workflow) {
-  const parsed = workflow_schema.safeParse(yaml_document.parse_yaml(workflow));
-  if (!parsed.success) return [];
-  const { jobs } = parsed.data;
-  return Object.entries(jobs).map(([id, job]) => ({
-    pattern: pattern_of(jobs, id),
-    needs: needs_list(job.needs).map((need) => pattern_of(jobs, need)),
-    gates: gate_steps(job.steps)
-  }));
-}
-function needs_of(graph, job_name) {
-  return graph.filter(({ pattern }) => pattern.test(job_name)).flatMap((job) => job.needs);
-}
-function is_waiting_on(graph, job_name, upstream) {
-  const needs = needs_of(graph, job_name);
-  return upstream.some((name) => needs.some((pattern) => pattern.test(name)));
-}
-function is_missing_need(graph, job_name, run_jobs) {
-  return needs_of(graph, job_name).some((pattern) => run_jobs.every((name) => !pattern.test(name)));
-}
-function has_passed(pattern, run_jobs) {
-  return run_jobs.every(
-    ({ name, conclusion }) => !pattern.test(name) || PASSED_CONCLUSIONS.has(conclusion ?? "")
-  );
-}
-function is_gate_of_successes(graph, job, run_jobs) {
-  const failed = job.steps.find(({ conclusion }) => conclusion === FAILURE_CONCLUSION)?.name;
-  const entries = graph.filter(({ pattern }) => pattern.test(job.name));
-  const needs = entries.flatMap((entry) => entry.needs);
-  if (entries.every(({ gates }) => gates.every((gate) => gate !== failed))) return false;
-  return needs.length > 0 && needs.every((pattern) => has_passed(pattern, run_jobs));
-}
-async function read_graph(workflow_path) {
-  try {
-    return parse_graph(await readFile(workflow_path, "utf8"));
-  } catch {
-    return [];
-  }
-}
-var followup_job_needs = {
-  is_gate_of_successes,
-  is_missing_need,
-  is_waiting_on,
-  parse_graph,
-  read_graph
-};
-
-// scripts/followup/followup-main-move.ts
-var OBSERVATION_SLUG2 = "followup-main-merge-first";
-var OBSERVATION_DEPTH2 = "d1";
-var LATEST_COMMIT = 1;
-var SHORT_SHA_LENGTH = 12;
-function moved_tests(test_files, incoming) {
-  return test_files.flatMap((file) => {
-    const moved = followup_failed_tests.subjects_of(file).find((subject) => incoming.has(subject));
-    return moved === void 0 ? [] : { file, moved };
-  });
-}
-async function latest_commit(file, main_reference) {
-  const [commit] = await git_command.log_first_parent(LATEST_COMMIT, file, main_reference);
-  return commit ?? main_reference;
-}
-async function read_main_move(test_files) {
-  if (test_files.length === 0) return void 0;
-  const default_branch = await git_command.get_default_branch();
-  await git_command.fetch_branch(default_branch);
-  const incoming = new Set(await main_merge_guard.incoming_paths(default_branch));
-  const moved = moved_tests(test_files, incoming);
-  const [first] = moved;
-  if (first === void 0) return void 0;
-  return {
-    files: moved.map(({ file }) => file),
-    commit: await latest_commit(first.moved, `origin/${default_branch}`)
-  };
-}
-function observation_of2(move) {
-  return {
-    slug: OBSERVATION_SLUG2,
-    depth: OBSERVATION_DEPTH2,
-    where: move.files.join(", "),
-    what: `followup put the main merge before the rerun; the failed test moved on main at ${move.commit.slice(0, SHORT_SHA_LENGTH)}`
-  };
-}
-async function read_or_rerun(test_files) {
-  try {
-    return await read_main_move(test_files);
-  } catch (error) {
-    console.info(`\u26A0\uFE0F Could not compare the failed tests with main, rerunning: ${String(error)}`);
-    return void 0;
-  }
-}
-async function should_merge_first(test_files, issue) {
-  const move = await read_or_rerun(test_files);
-  if (move === void 0) return false;
-  console.info(
-    `\u{1F500} Not rerunning: main changed the failed tests since the branch point (${move.files.join(", ")}); merge main first.`
-  );
-  await followup_failed_tests.record_entry(observation_of2(move), issue);
-  return true;
-}
-var followup_main_move = {
-  read_main_move,
-  should_merge_first
-};
-
-// scripts/followup/followup-job-rerun.ts
-var FAILURE_CONCLUSION2 = "failure";
-var FAILED_CONCLUSIONS = [FAILURE_CONCLUSION2, "cancelled", "timed_out"];
-var FAILED_JOB_CONCLUSIONS = new Set(FAILED_CONCLUSIONS);
-var ACTIONS_APP_SLUG = "github-actions";
-var PASSING_STEP_CONCLUSIONS = /* @__PURE__ */ new Set(["success", "skipped"]);
-var RUN_COMPLETED = "completed";
-var FIRST_ATTEMPT = 1;
-var DOWNLOAD_ERRORS = [
-  /^\S+ ##\[error\]Failed to (?:download archive|resolve action download info)/mu,
-  /^\S+ curl: \(22\) The requested URL returned error: 5\d\d\r?\n\S+ ##\[error\]Process completed with exit code 22\.$/mu,
-  /^\S+ curl: \(22\) The requested URL returned error: 5\d\d\r?\n\S+ \[ERROR\] Failed to download from https:\/\/\S+\r?\n\S+ ##\[error\]Process completed with exit code 1\.$/mu,
-  /^\S+ ##\[error\]Unable to download and extract CodeQL CLI: Unexpected HTTP response: 5\d\d$/mu
-];
-var COMPLETE_ATTEMPTS = 40;
-var COMPLETE_INTERVAL_MS = 15e3;
-var REGISTER_ATTEMPTS = 10;
-var REGISTER_INTERVAL_MS = 3e3;
-var REGISTER_BACKOFF = { ...POLL_BACKOFF, initial_ms: REGISTER_INTERVAL_MS };
-var MAX_CHECK_RERUNS = 3;
-var RERUN_BACKOFF_MS = 12e4;
-var RERUN_BACKOFF_FACTOR = 2;
-var MS_PER_SECOND = 1e3;
-var RERUNS_SPENT_MESSAGE = "CI infrastructure failures outlasted every followup rerun";
-var failed_check_schema = z2.looseObject({
-  id: z2.number(),
-  conclusion: z2.enum(FAILED_CONCLUSIONS),
-  app: z2.looseObject({ slug: z2.literal(ACTIONS_APP_SLUG) })
-});
-var rollup_schema = z2.looseObject({ statusCheckRollup: z2.array(z2.unknown()) });
-var step_schema2 = z2.looseObject({ name: z2.string().optional(), conclusion: z2.string().nullish() });
-var job_schema2 = z2.looseObject({
-  id: z2.number(),
-  name: z2.string(),
-  run_id: z2.number(),
-  run_attempt: z2.number().nullish(),
-  conclusion: z2.string().nullish(),
-  steps: z2.array(step_schema2)
-});
-var run_schema = z2.looseObject({ status: z2.string(), path: z2.string().optional() });
-var jobs_page_schema = z2.looseObject({ jobs: z2.array(job_schema2) });
-function actions_api_path(rest) {
-  return `${git_gh_api_path.repo_api_path()}/actions/${rest}`;
-}
-async function read_actions(rest, schema) {
-  const json = await git_gh_exec.exec_gh_api({ path: actions_api_path(rest) });
-  return schema.parse(JSON.parse(json));
-}
-async function read_failed_check_ids(branch_name) {
-  const { snapshot_json } = await git_gh_command.pr_get_checks_snapshot(branch_name);
-  const rollup = rollup_schema.parse(JSON.parse(snapshot_json)).statusCheckRollup;
-  return rollup.flatMap((item) => {
-    const parsed = failed_check_schema.safeParse(item);
-    return parsed.success ? parsed.data.id : [];
-  });
-}
-async function read_failed_run_ids(branch_name) {
-  const ids = await read_failed_check_ids(branch_name);
-  const jobs = await Promise.all(
-    ids.map(async (id) => await read_actions(`jobs/${String(id)}`, job_schema2))
-  );
-  return [...new Set(jobs.map((job) => job.run_id))];
-}
-async function await_run_completed(run_id) {
-  let status = "";
-  return await poll.poll_until(
-    async () => {
-      ;
-      ({ status } = await read_actions(`runs/${String(run_id)}`, run_schema));
-      return status === RUN_COMPLETED;
-    },
-    {
-      attempts: COMPLETE_ATTEMPTS,
-      interval_ms: COMPLETE_INTERVAL_MS,
-      backoff: { seen: () => status }
-    }
-  );
-}
-function has_every_step_passed(job) {
-  if (job.steps.length === 0) return false;
-  return job.steps.every((step) => PASSING_STEP_CONCLUSIONS.has(step.conclusion ?? ""));
-}
-function is_first_attempt(job) {
-  return (job.run_attempt ?? FIRST_ATTEMPT) <= FIRST_ATTEMPT;
-}
-async function read_job_log(job) {
-  return await git_gh_exec.exec_gh_api({
-    path: actions_api_path(`jobs/${String(job.id)}/logs`),
-    should_allow_escapes: true
-  });
-}
-function is_download_failure(log) {
-  const plain_log = stripVTControlCharacters(log);
-  return DOWNLOAD_ERRORS.some((error) => error.test(plain_log));
-}
-async function judge_job(job, changed) {
-  if (has_every_step_passed(job)) return { job, verdict: RERUN_VERDICT };
-  if (job.conclusion !== FAILURE_CONCLUSION2) return { job, verdict: KEPT_VERDICT };
-  const log = await read_job_log(job);
-  if (is_download_failure(log)) return { job, verdict: RERUN_VERDICT };
-  if (!is_first_attempt(job)) return { job, verdict: UNNAMED_VERDICT };
-  const tests = followup_failed_tests.read_failed_tests(log);
-  return { job, verdict: followup_failed_tests.verdict_of(tests, changed), tests };
-}
-function is_infra_failure(job, graph, reruns, run_jobs) {
-  if (followup_job_needs.is_gate_of_successes(graph, job, run_jobs)) return true;
-  if (!is_first_attempt(job)) return false;
-  const names = run_jobs.map(({ name }) => name);
-  return followup_job_needs.is_waiting_on(graph, job.name, reruns) || followup_job_needs.is_missing_need(graph, job.name, names);
-}
-function settle_unnamed(judged, graph, run_jobs) {
-  const reruns = judged.filter(({ verdict }) => verdict === RERUN_VERDICT).map(({ job }) => job.name);
-  return judged.map((entry) => {
-    if (entry.verdict !== UNNAMED_VERDICT) return entry;
-    return is_infra_failure(entry.job, graph, reruns, run_jobs) ? { job: entry.job, verdict: RERUN_VERDICT } : entry;
-  });
-}
-async function read_needs_graph(run_id, judged) {
-  if (judged.every(({ verdict }) => verdict !== UNNAMED_VERDICT)) return [];
-  const run = await read_actions(`runs/${String(run_id)}`, run_schema);
-  return run.path === void 0 ? [] : await followup_job_needs.read_graph(run.path);
-}
-async function read_rerun_jobs(run_id, changed) {
-  if (!await await_run_completed(run_id)) return void 0;
-  const { jobs } = await read_actions(
-    `runs/${String(run_id)}/jobs?filter=latest&per_page=100`,
-    jobs_page_schema
-  );
-  const failed = jobs.filter((job) => FAILED_JOB_CONCLUSIONS.has(job.conclusion ?? ""));
-  const judged = await Promise.all(failed.map(async (job) => await judge_job(job, changed)));
-  const graph = await read_needs_graph(run_id, judged);
-  const settled = settle_unnamed(judged, graph, jobs);
-  return settled.every(({ verdict }) => verdict === RERUN_VERDICT) ? settled : void 0;
-}
-async function rerun_runs(run_ids) {
-  await Promise.all(
-    run_ids.map(
-      async (run_id) => await git_gh_exec.exec_gh_api({
-        path: actions_api_path(`runs/${String(run_id)}/rerun-failed-jobs`),
-        method: "POST",
-        should_retry: false
-      })
-    )
-  );
-}
-async function await_rerun_registered(branch_name, jobs) {
-  const rerun_ids = new Set(jobs.map((job) => job.id));
-  let failed = [];
-  await poll.poll_until(
-    async () => {
-      failed = await read_failed_check_ids(branch_name);
-      return failed.every((id) => !rerun_ids.has(id));
-    },
-    {
-      attempts: REGISTER_ATTEMPTS,
-      interval_ms: REGISTER_INTERVAL_MS,
-      backoff: { seen: () => failed.join(","), schedule: REGISTER_BACKOFF }
-    }
-  );
-}
-async function find_rerun_jobs(branch_name) {
-  const run_ids = await read_failed_run_ids(branch_name);
-  if (run_ids.length === 0) return [];
-  const changed = new Set(await changed_paths.read_changed_paths(false));
-  const per_run = await Promise.all(
-    run_ids.map(async (run_id) => await read_rerun_jobs(run_id, changed))
-  );
-  return per_run.every((jobs) => jobs !== void 0) ? per_run.flat() : [];
-}
-async function rerun(branch_name, entries) {
-  const jobs = entries.map(({ job }) => job);
-  const names = jobs.map((job) => job.name);
-  console.info(
-    `\u{1F501} Rerunning CI jobs that stopped after every step passed, failed on a download, or failed only outside the change: ${names.join(", ")}`
-  );
-  await followup_failed_tests.record(
-    entries.flatMap(({ job, tests }) => tests === void 0 ? [] : { job: job.name, tests }),
-    git_branch.issue_from_branch(branch_name)
-  );
-  await rerun_runs([...new Set(jobs.map((job) => job.run_id))]);
-  await await_rerun_registered(branch_name, jobs);
-  return names;
-}
-async function should_merge_first2(branch_name, entries) {
-  const files = [...new Set(entries.flatMap(({ tests }) => tests?.files ?? []))];
-  return await followup_main_move.should_merge_first(
-    files,
-    git_branch.issue_from_branch(branch_name)
-  );
-}
-function rerun_delay_ms(round) {
-  return round === 0 ? 0 : RERUN_BACKOFF_MS * RERUN_BACKOFF_FACTOR ** (round - 1);
-}
-async function wait_before_rerun(round) {
-  const delay_ms = rerun_delay_ms(round);
-  if (delay_ms === 0) return;
-  console.info(
-    `\u23F3 Waiting ${String(delay_ms / MS_PER_SECOND)}s before CI job rerun ${String(round + 1)}`
-  );
-  await poll.sleep(delay_ms);
-}
-function report_rerun_error(error) {
-  console.info(`\u26A0\uFE0F CI job rerun failed: ${git_gh_helpers.get_error_message_with_stderr(error)}`);
-  return [];
-}
-async function rerun_failed_jobs(branch_name, round = 0) {
-  try {
-    const entries = await find_rerun_jobs(branch_name);
-    if (entries.length === 0 || await should_merge_first2(branch_name, entries)) return [];
-    await wait_before_rerun(round);
-    return await rerun(branch_name, entries);
-  } catch (error) {
-    return report_rerun_error(error);
-  }
-}
-async function read_rerun_names(branch_name) {
-  try {
-    const entries = await find_rerun_jobs(branch_name);
-    return entries.map(({ job }) => job.name);
-  } catch (error) {
-    return report_rerun_error(error);
-  }
-}
-function reruns_spent_message(names) {
-  return `${RERUNS_SPENT_MESSAGE} (${String(MAX_CHECK_RERUNS)} reruns; still failing: ${names.join(", ")}). Rerun the failed jobs once CI recovers, then run followup again.`;
-}
-var followup_job_rerun = {
-  actions_api_path,
-  read_actions,
-  read_rerun_names,
-  rerun_failed_jobs,
-  reruns_spent_message
-};
-
-export {
-  MAX_CHECK_RERUNS,
-  RERUNS_SPENT_MESSAGE,
-  followup_job_rerun
-};

package/dist/commands/chunk-7C7FOKJK.js

@@ -1,115 +0,0 @@
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  lane_reap
-} from "./chunk-2DJLAUYB.js";
-import {
-  run_carry
-} from "./chunk-MPGJ4ONJ.js";
-
-// scripts/run/run-headless-keys.ts
-var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
-var HANDOFF_CHILD_KEY = "JOSH_HANDOFF_CHILD";
-var BESIDE_CHILD_KEY = "JOSH_BESIDE_CHILD";
-var MARK_KEYS = [HEADLESS_ENV_KEY, HANDOFF_CHILD_KEY, BESIDE_CHILD_KEY];
-var run_headless_keys = {
-  BESIDE_CHILD_KEY,
-  HANDOFF_CHILD_KEY,
-  HEADLESS_ENV_KEY,
-  MARK_KEYS
-};
-
-// scripts/run/run-headless.ts
-var { HEADLESS_ENV_KEY: HEADLESS_ENV_KEY2, HANDOFF_CHILD_KEY: HANDOFF_CHILD_KEY2, BESIDE_CHILD_KEY: BESIDE_CHILD_KEY2 } = run_headless_keys;
-var HEADLESS_VALUE = "1";
-var SESSION_CUT = { cuts: 1 };
-function environment() {
-  return { [HEADLESS_ENV_KEY2]: HEADLESS_VALUE };
-}
-function handoff_child_environment() {
-  return { [HEADLESS_ENV_KEY2]: void 0, [HANDOFF_CHILD_KEY2]: HEADLESS_VALUE };
-}
-function beside_environment() {
-  return { ...environment(), [BESIDE_CHILD_KEY2]: HEADLESS_VALUE };
-}
-function is_started_child(source) {
-  return lane_child_marker.marked_issue(source) !== void 0 || source[HANDOFF_CHILD_KEY2] === HEADLESS_VALUE || source[BESIDE_CHILD_KEY2] === HEADLESS_VALUE;
-}
-function is_headless(source = process.env) {
-  return source[HEADLESS_ENV_KEY2] === HEADLESS_VALUE;
-}
-function is_headless_parent(source) {
-  return is_headless(source) && lane_child_marker.marked_issue(source) === void 0;
-}
-function is_cut_capped(carry, source = process.env) {
-  return !is_headless_parent(source) && run_carry.is_at_cut_cap(carry);
-}
-function is_driving(read) {
-  return read?.kind === "carried" && read.carry.is_handed_off !== true;
-}
-async function carry_target_here() {
-  const repository = await run_carry.repository_directory();
-  return repository === void 0 ? void 0 : run_carry.carry_path(repository);
-}
-async function read_carry_here() {
-  const target = await carry_target_here();
-  return target === void 0 ? void 0 : run_carry.read_carry(target);
-}
-async function current_carry() {
-  const read = await read_carry_here();
-  return read?.kind === "carried" ? read.carry : void 0;
-}
-function is_owned_here(carry, ancestry) {
-  return carry.owner_pid !== void 0 && ancestry().has(carry.owner_pid);
-}
-function driven_here(read, ancestry) {
-  if (read?.kind !== "carried" || !is_driving(read)) return void 0;
-  return is_owned_here(read.carry, ancestry) ? read.carry : void 0;
-}
-async function driving_carry(source = process.env, ancestry = lane_reap.own_ancestry) {
-  if (is_started_child(source)) return void 0;
-  return driven_here(await read_carry_here(), ancestry);
-}
-async function is_backlog_parent(source = process.env, ancestry = lane_reap.own_ancestry) {
-  return await driving_carry(source, ancestry) !== void 0;
-}
-async function must_keep_waiting(source = process.env, ancestry = lane_reap.own_ancestry) {
-  if (!is_headless_parent(source) || !await lane_registry.has_lanes_in_flight()) return false;
-  return await is_backlog_parent(source, ancestry);
-}
-async function write_cut(source, ancestry) {
-  const target = await carry_target_here();
-  const carry = await driving_carry(source, ancestry);
-  if (target !== void 0 && carry !== void 0) {
-    run_carry.apply_change(target, carry, SESSION_CUT);
-  }
-}
-async function hand_back_at_turn_end(source = process.env, ancestry = lane_reap.own_ancestry) {
-  if (!is_headless_parent(source)) return false;
-  await write_cut(source, ancestry);
-  return await must_keep_waiting(source, ancestry);
-}
-var run_headless = {
-  HEADLESS_ENV_KEY: HEADLESS_ENV_KEY2,
-  beside_environment,
-  current_carry,
-  hand_back_at_turn_end,
-  driven_here,
-  driving_carry,
-  environment,
-  handoff_child_environment,
-  is_backlog_parent,
-  is_cut_capped,
-  is_headless,
-  is_headless_parent,
-  is_owned_here,
-  must_keep_waiting
-};
-
-export {
-  run_headless
-};