@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-PJYTUUTH.js

@@ -0,0 +1,34 @@
+import {
+  lane_implement_rate,
+  lane_size_stats
+} from "./chunk-KP2BVAS5.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+
+// scripts/lane/lane-implement-rate-read.ts
+var PERIOD_DAYS = 3;
+async function read_ledger(context) {
+  const path = context.ledger_path ?? await lane_ledger.target();
+  return path === void 0 ? [] : lane_ledger.read_entries(path);
+}
+async function implement_rate(context = {}, now_ms = Date.now()) {
+  const window = lane_stats.window_of(PERIOD_DAYS, now_ms);
+  return lane_implement_rate.rate(await read_ledger(context), window);
+}
+async function measurements(context = {}, now_ms = Date.now()) {
+  const entries = await read_ledger(context);
+  const window = lane_stats.window_of(PERIOD_DAYS, now_ms);
+  return {
+    implement_rate: lane_implement_rate.rate(entries, window),
+    growth: lane_size_stats.ratios(entries, window)
+  };
+}
+var lane_implement_rate_read = { PERIOD_DAYS, implement_rate, measurements, read_ledger };
+
+export {
+  lane_implement_rate_read
+};

package/dist/commands/chunk-PKXTISWR.js

@@ -0,0 +1,58 @@
+import {
+  git_issue
+} from "./chunk-QTVVFV4Q.js";
+import {
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+
+// scripts/run/ship/run-ship-planned.ts
+import path from "node:path";
+var PRECONDITION = "unplanned";
+var SEPARATOR = "/";
+var NON_CODE_PREFIXES = ["docs/", ".josh/"];
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".cjs", ".js", ".mjs", ".sh", ".svelte", ".ts"]);
+function is_planned(claims, file) {
+  return claims.some(
+    (claim) => claim.endsWith(SEPARATOR) ? file.startsWith(claim) : claim === file
+  );
+}
+function is_code(file) {
+  return CODE_EXTENSIONS.has(path.extname(file)) && NON_CODE_PREFIXES.every((prefix) => !file.startsWith(prefix));
+}
+function unplanned_of(claims, changed) {
+  return test_declared_logic.runtime_files(changed).filter((file) => is_code(file) && !is_planned(claims, file));
+}
+function problem_text(issue, claims, files) {
+  const replan = ["pnpm josh lane:plan", issue, ...claims, ...files].join(" ");
+  return `unplanned: ${files.join(", ")} \u2014 the lane's lane:plan record does not list these code files. In scope: run \`${replan}\` and comment the reason on the Issue in one line, then re-detach; if it answers \`yield\` or \`split\`, follow what it prints instead. Out of scope: revert the change and file it with \`pnpm josh issue:file\`.`;
+}
+function held_claims(plan) {
+  return plan?.yielded === true ? void 0 : plan?.paths;
+}
+async function unplanned() {
+  const issue = git_issue.branch_number(await git_branch.current());
+  if (issue === void 0) return void 0;
+  const claims = held_claims(lane_plan.read(Number(issue), process.cwd()));
+  if (claims === void 0) return void 0;
+  const files = unplanned_of(claims, await changed_paths.read_changed_paths(false));
+  if (files.length === 0) return void 0;
+  return { issue: Number(issue), files, text: problem_text(issue, claims, files) };
+}
+async function problems() {
+  const found = await unplanned();
+  return found === void 0 ? [] : [found.text];
+}
+var run_ship_planned = { PRECONDITION, problems, unplanned, unplanned_of };
+
+export {
+  run_ship_planned
+};

package/dist/commands/chunk-PSGLUBSB.js

@@ -0,0 +1,74 @@
+import {
+  issue_outcome
+} from "./chunk-2WRDAQPJ.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/issue/issue-comment-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var BODY_FLAG = "--body";
+var BODY_FILE_FLAG = "--body-file";
+var USAGE = `Usage: josh issue:comment <issue-number> ${BODY_FLAG} <text> | ${BODY_FILE_FLAG} <path>`;
+var OPTIONS = {
+  body: { type: "string" },
+  "body-file": { type: "string" },
+  outcome: { type: "string" },
+  "evidence-url": { type: "string" }
+};
+function parse_request(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const issue_number = issue_number_shape.single_of(parsed.positionals);
+  if (issue_number === void 0) return void 0;
+  const body = cli_body.resolve({
+    inline: parsed.values.body,
+    file_path: parsed.values["body-file"],
+    inline_flag: BODY_FLAG,
+    file_flag: BODY_FILE_FLAG
+  });
+  if (body === void 0 || body.length === 0) return void 0;
+  return {
+    issue_number,
+    body: issue_outcome.body_of({
+      body,
+      summary: parsed.values.outcome,
+      url: parsed.values["evidence-url"]
+    })
+  };
+}
+function resolve_request(argv, usage = USAGE) {
+  try {
+    const request = parse_request(argv);
+    if (request === void 0) console.error(usage);
+    return request;
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return void 0;
+  }
+}
+async function run(argv) {
+  const request = resolve_request(argv);
+  if (request === void 0) return FAILURE_EXIT_CODE;
+  const url = await git_gh_command.issue_comment(request.issue_number, request.body);
+  console.info(url);
+  return SUCCESS_EXIT_CODE;
+}
+var issue_comment_cli = { USAGE, resolve_request, run };
+
+export {
+  issue_comment_cli
+};

package/dist/commands/chunk-PUQA7F6Y.js

@@ -0,0 +1,186 @@
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/ship/run-ship-stage.ts
+import { z } from "zod";
+var STAGE = {
+  PREFLIGHT: "preflight",
+  REVIEW: "review",
+  GATE: "gate",
+  SYNC: "sync",
+  COMMIT: "commit",
+  ROUND_TWO: "round-2",
+  FOLLOWUP: "followup",
+  REPORT: "report"
+};
+var PHASE = {
+  START: "start",
+  DONE: "done",
+  FAILED: "failed",
+  SKIPPED: "skipped"
+};
+var RECORD_PREFIX = "josh-ship-stages-";
+var RECORD_SEPARATOR = "-";
+var SKIP_COMMIT_FLAG = "--skip-commit";
+var SKIP_PUSH_FLAG = "--skip-push";
+var WORD_SEPARATOR = " ";
+var STARTED_SEPARATOR = ",";
+var STARTED_INDEX = 3;
+var WORD_COUNT = STARTED_INDEX + 1;
+var REASON_SEPARATOR = " | ";
+var record_schema = z.object({
+  done: z.array(z.string()),
+  started: z.array(z.string()).default([]),
+  is_merge_waiting: z.boolean().default(false),
+  is_place_waiting: z.boolean().default(false)
+});
+var EMPTY_RECORD = {
+  done: [],
+  started: [],
+  is_merge_waiting: false,
+  is_place_waiting: false
+};
+function record_path(repository, issue) {
+  return stamp_file.stamp_path(`${RECORD_PREFIX}${issue}${RECORD_SEPARATOR}`, repository);
+}
+function parse_record(raw) {
+  return json_value.parse_with(raw, record_schema) ?? EMPTY_RECORD;
+}
+function read_record(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? EMPTY_RECORD : parse_record(raw);
+}
+function read_done(target) {
+  return new Set(read_record(target).done);
+}
+function mark_done(target, stage) {
+  const record = read_record(target);
+  stamp_file.replace_stamp(target, { ...record, done: [.../* @__PURE__ */ new Set([...record.done, stage])] });
+}
+function read_started(target) {
+  return read_record(target).started;
+}
+function mark_started(target, stage) {
+  const record = read_record(target);
+  stamp_file.replace_stamp(target, { ...record, started: [.../* @__PURE__ */ new Set([...record.started, stage])] });
+}
+function end_attempt(target) {
+  stamp_file.replace_stamp(target, { ...read_record(target), started: [], is_merge_waiting: false });
+}
+function read_merge_waiting(target) {
+  return read_record(target).is_merge_waiting;
+}
+function mark_merge_waiting(target, is_merge_waiting) {
+  stamp_file.replace_stamp(target, { ...read_record(target), is_merge_waiting });
+}
+function read_place_waiting(target) {
+  return read_record(target).is_place_waiting;
+}
+function mark_place_waiting(target, is_place_waiting) {
+  stamp_file.replace_stamp(target, { ...read_record(target), is_place_waiting });
+}
+function clear_waits(target) {
+  stamp_file.replace_stamp(target, {
+    ...read_record(target),
+    is_merge_waiting: false,
+    is_place_waiting: false
+  });
+}
+function clear(target) {
+  stamp_file.remove_stamp(target);
+}
+function is_shipped(state) {
+  return state.is_committed && state.is_pushed;
+}
+var DONE_BY = {
+  // The preflight asks what the commit stage would refuse on, so a commit is
+  // its output; a resumed commit stage still asks `git -y`'s own preflight.
+  [STAGE.PREFLIGHT]: (done, state) => state.is_merged || done.has(STAGE.PREFLIGHT) && state.is_committed,
+  // The sync stage commits locally before the review round and the gate, without pushing
+  // (`run-ship-sync.ts`), so a commit is neither's output: a pushed one on a clean tree is, as only the
+  // commit stage after the gate pushes — unless the issue changed since.
+  [STAGE.REVIEW]: (done, state) => state.is_merged || done.has(STAGE.REVIEW) && is_shipped(state) && state.is_review_stale !== true,
+  [STAGE.GATE]: (done, state) => state.is_merged || done.has(STAGE.GATE) && is_shipped(state),
+  // The merge of the default branch before the gate: once pushed, a default branch that
+  // moved is the followup's to merge again.
+  [STAGE.SYNC]: (done, state) => state.is_merged || done.has(STAGE.SYNC) && is_shipped(state),
+  [STAGE.COMMIT]: (done, state) => state.is_merged || done.has(STAGE.COMMIT) && is_shipped(state),
+  // The final review precedes the push. Its own tree stamp decides reuse after a stop.
+  [STAGE.ROUND_TWO]: (_done, state) => state.is_merged,
+  // A recorded followup still needs the shipped state: a record left by a merged ship whose report
+  // failed must not pass over the followup of new, not-yet-pushed work on the same issue.
+  [STAGE.FOLLOWUP]: (done, state) => state.is_merged || done.has(STAGE.FOLLOWUP) && is_shipped(state),
+  [STAGE.REPORT]: (done) => done.has(STAGE.REPORT)
+};
+function is_done(stage, done, state, has_body = false) {
+  if (has_body && stage === STAGE.COMMIT && !state.is_merged) return false;
+  return DONE_BY[stage](done, state);
+}
+function commit_flags(state) {
+  if (!state.is_committed) return [];
+  return state.is_pushed ? [SKIP_COMMIT_FLAG, SKIP_PUSH_FLAG] : [SKIP_COMMIT_FLAG];
+}
+function event_text(issue, stage, phase, started = []) {
+  const words = [issue_cite.plain_for("program", issue), stage, phase];
+  const listed = [...new Set(started)].join(STARTED_SEPARATOR);
+  const full = started.length > 0 ? [...words, listed] : words;
+  return full.join(WORD_SEPARATOR);
+}
+function with_reason(text, reason) {
+  return reason === void 0 ? text : `${text}${REASON_SEPARATOR}${reason}`;
+}
+function words_part(text) {
+  return text.split(REASON_SEPARATOR, 1)[0] ?? "";
+}
+function started_of(text) {
+  return words_part(text).split(WORD_SEPARATOR, WORD_COUNT)[STARTED_INDEX]?.split(STARTED_SEPARATOR);
+}
+function words_of(text) {
+  const [, stage = "", phase = ""] = words_part(text).split(WORD_SEPARATOR, WORD_COUNT);
+  return { stage, phase };
+}
+function reason_of(text) {
+  const at = text.indexOf(REASON_SEPARATOR);
+  return at === -1 ? void 0 : text.slice(at + REASON_SEPARATOR.length);
+}
+var CONFLICT = "conflict";
+function stop_reason(stage, conflicts = []) {
+  return conflicts.length > 0 ? CONFLICT : stage;
+}
+var run_ship_stage = {
+  CONFLICT,
+  PHASE,
+  STAGE,
+  clear,
+  clear_waits,
+  commit_flags,
+  end_attempt,
+  event_text,
+  is_done,
+  is_shipped,
+  mark_done,
+  mark_merge_waiting,
+  mark_place_waiting,
+  mark_started,
+  read_done,
+  read_merge_waiting,
+  read_place_waiting,
+  read_started,
+  reason_of,
+  record_path,
+  started_of,
+  with_reason,
+  words_of,
+  stop_reason
+};
+
+export {
+  run_ship_stage
+};

package/dist/commands/chunk-PVRDJU2B.js

@@ -0,0 +1,126 @@
+import {
+  run_hold
+} from "./chunk-F5N2QIFD.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/run/run-halfrun-resume.ts
+var MARKED = "marked";
+var FOREIGN = "foreign";
+var UNREADABLE = "unreadable";
+function hold_of(read) {
+  return read.kind === "held" || read.kind === "stale" ? read.hold : void 0;
+}
+function is_stop_record(read, issue) {
+  const hold = hold_of(read);
+  return hold?.issue === issue && hold.is_halfrun_stop === true;
+}
+function is_halfrun_stop(read, issue, is_dirty) {
+  return is_dirty && is_stop_record(read, issue);
+}
+function is_own_record(read, issue) {
+  const hold = hold_of(read);
+  return hold === void 0 || hold.issue === issue || hold.issue === run_hold.UNNUMBERED_ISSUE;
+}
+function mark_stop_at(target, issue, mark = run_hold.HALFRUN_STOP_FIELDS) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "unreadable") return UNREADABLE;
+  if (!is_own_record(read, issue)) return FOREIGN;
+  run_hold.release_hold(target);
+  return run_hold.create_stop_hold(target, issue, mark) ? MARKED : FOREIGN;
+}
+function take_over(target, issue) {
+  run_hold.release_hold(target);
+  return run_hold.create_hold(target, issue, /* @__PURE__ */ new Date(), true);
+}
+function reopen_at(target, issue) {
+  const read = run_hold.read_hold(target);
+  if (read.kind === "unreadable") return UNREADABLE;
+  if (!is_stop_record(read, issue)) return FOREIGN;
+  run_hold.release_hold(target);
+  return run_hold.create_hold(target, issue) ? MARKED : FOREIGN;
+}
+async function resume_lane(issue, command) {
+  const lane = await lane_state.read_state(issue);
+  if (lane?.state === "human-review") {
+    await lane_state.record_change({ issue, state: "running", command });
+  }
+}
+async function reopen(target, issue) {
+  const mark = reopen_at(target, issue);
+  if (mark === MARKED) await resume_lane(issue, "run:hold --halfrun-round");
+  return mark;
+}
+function no_stop_message(issue) {
+  return `run:hold: this tree holds no stopped \`halfrun\` of ${session_cite.issue(issue)} \u2014 a fix round re-opens only that record.`;
+}
+function adopt_at(target, issue, is_dirty) {
+  if (!is_halfrun_stop(run_hold.read_hold(target), issue, is_dirty)) return false;
+  return take_over(target, issue);
+}
+async function hold_target() {
+  try {
+    const directory = await run_hold.worktree_directory();
+    return directory === void 0 ? void 0 : run_hold.hold_path(directory);
+  } catch {
+    return void 0;
+  }
+}
+async function is_pending(issue) {
+  const target = await hold_target();
+  if (target === void 0) return false;
+  return is_halfrun_stop(run_hold.read_hold(target), issue, await run_hold.is_tree_dirty());
+}
+async function adopt(issue) {
+  const target = await hold_target();
+  if (target === void 0) return false;
+  const is_adopted = adopt_at(target, issue, await run_hold.is_tree_dirty());
+  if (is_adopted) await resume_lane(issue, "run:entry");
+  return is_adopted;
+}
+var run_halfrun_resume = {
+  FOREIGN,
+  MARKED,
+  UNREADABLE,
+  adopt,
+  adopt_at,
+  hold_of,
+  hold_target,
+  is_pending,
+  mark_stop_at,
+  no_stop_message,
+  reopen,
+  reopen_at,
+  take_over
+};
+
+// scripts/run/hold/run-hold-session.ts
+function is_same_start(recorded, own) {
+  return recorded === void 0 || own === void 0 || recorded === own;
+}
+function is_session_hold(hold, owner = run_hold.session_owner()) {
+  if (hold.owner_pid === void 0 || owner.owner_pid === void 0) return true;
+  return hold.owner_pid === owner.owner_pid && is_same_start(hold.owner_start, owner.owner_start);
+}
+function is_notified_since(hold, pause_start) {
+  if (pause_start === void 0 || hold.notified_at === void 0) return false;
+  return Date.parse(hold.notified_at) >= Date.parse(pause_start);
+}
+function mark_notified(target, now = /* @__PURE__ */ new Date()) {
+  const hold = run_halfrun_resume.hold_of(run_hold.read_hold(target, now));
+  if (hold === void 0) return;
+  stamp_file.write_stamp(target, { ...hold, notified_at: now.toISOString() });
+}
+var run_hold_session = { is_notified_since, is_session_hold, mark_notified };
+
+export {
+  run_halfrun_resume,
+  run_hold_session
+};

package/dist/commands/chunk-Q3HM2BEH.js

@@ -0,0 +1,45 @@
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/josh/session-model-record.ts
+import { text } from "node:stream/consumers";
+import { z } from "zod";
+var RECORD_PREFIX = "josh-session-model-";
+var RECORD_SUFFIX = ".txt";
+var payload_schema = z.object({
+  transcript_path: z.string().min(1),
+  model: z.string().min(1)
+});
+function record_path(transcript_path) {
+  return stamp_file.stamp_path(RECORD_PREFIX, transcript_path, RECORD_SUFFIX);
+}
+function record(raw_payload) {
+  const payload = json_value.parse_with(raw_payload, payload_schema);
+  if (payload === void 0) return void 0;
+  try {
+    stamp_file.write_text_stamp(record_path(payload.transcript_path), payload.model);
+  } catch {
+    return void 0;
+  }
+  return payload.model;
+}
+function recorded(transcript_path) {
+  if (transcript_path === void 0 || transcript_path === null) return void 0;
+  const model = stamp_file.read_stamp_text(record_path(transcript_path))?.trim();
+  return model === "" ? void 0 : model;
+}
+async function read_stdin() {
+  return process.stdin.isTTY ? "" : await text(process.stdin);
+}
+async function record_from_stdin() {
+  return record(await read_stdin());
+}
+var session_model_record = { read_stdin, record, record_from_stdin, record_path, recorded };
+
+export {
+  session_model_record
+};

package/dist/commands/chunk-Q42NF2TL.js

@@ -0,0 +1,47 @@
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/lines/line-targets.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var LINT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte"
+]);
+var WHOLE_TREE_PATHSPEC = ":/";
+var LS_FILES_FLAGS = [
+  "ls-files",
+  "--cached",
+  "--others",
+  "--exclude-standard",
+  "--full-name",
+  "-z"
+];
+var NUL = "\0";
+function is_lint_target(relative_path) {
+  return LINT_EXTENSIONS.has(path.extname(relative_path));
+}
+function split_names(output) {
+  return output.split(NUL).filter((name) => name.length > 0);
+}
+async function lint_target_files(root) {
+  const output = await git_spawn.read([...LS_FILES_FLAGS, WHOLE_TREE_PATHSPEC]);
+  return split_names(output).filter((name) => is_lint_target(name)).map((name) => path.resolve(root, name)).filter((file_path) => existsSync(file_path));
+}
+var line_targets = {
+  is_lint_target,
+  lint_target_files,
+  split_names
+};
+
+export {
+  line_targets
+};

package/dist/commands/chunk-Q4ULMZAS.js

@@ -0,0 +1,106 @@
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  lane_reap
+} from "./chunk-ON4IKRGS.js";
+import {
+  run_carry,
+  run_carry_session,
+  run_headless_keys
+} from "./chunk-DS53UUDH.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+
+// scripts/run/run-headless.ts
+var { HEADLESS_ENV_KEY, HANDOFF_CHILD_KEY, BESIDE_CHILD_KEY } = run_headless_keys;
+var HEADLESS_VALUE = "1";
+var SESSION_CUT = { cuts: 1 };
+function environment() {
+  return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
+}
+function handoff_child_environment() {
+  return { [HEADLESS_ENV_KEY]: void 0, [HANDOFF_CHILD_KEY]: HEADLESS_VALUE };
+}
+function beside_environment() {
+  return { ...environment(), [BESIDE_CHILD_KEY]: HEADLESS_VALUE };
+}
+function is_started_child(source) {
+  return lane_child_marker.marked_issue(source) !== void 0 || source[HANDOFF_CHILD_KEY] === HEADLESS_VALUE || source[BESIDE_CHILD_KEY] === HEADLESS_VALUE;
+}
+function is_headless(source = process.env) {
+  return source[HEADLESS_ENV_KEY] === 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) {
+  if (carry.owner_session !== void 0) return carry.owner_session === run_carry_session.own();
+  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,
+  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
+};