@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-RW64VHEB.js

@@ -1,130 +0,0 @@
-import {
-  gh_author_association
-} from "./chunk-XXNEY4B3.js";
-import {
-  read_json_listing
-} from "./chunk-XDF25GSU.js";
-
-// scripts/issue/issue-watch-diff.ts
-import { z } from "zod";
-var RUN_MARKER = "<!-- josh:run -->";
-var BOT_TYPE = "Bot";
-var BOT_SUFFIX = "[bot]";
-var NO_COMMENT_ID = 0;
-var UNKNOWN_AUTHOR = "(unknown)";
-var UNKNOWN_TIME = "(undated)";
-var UNVERIFIED_BODY = "(body withheld \u2014 the author's write access could not be checked; read it with `josh issue:read`)";
-var WITHHELD_BODY_EDIT = `The body of this run's issue was edited, but its author is not ${gh_author_association.TRUSTED_LIST}, so the edit is withheld: it is not an instruction to this run and holds nothing \u2014 carry on.`;
-var BODY_HEADING = "Body edited:";
-var REMOVED_PREFIX = "- ";
-var ADDED_PREFIX = "+ ";
-var COMMENT_HEADING = "New comment by ";
-var AT = " at ";
-var SECTION_SEPARATOR = "\n\n";
-var LINE_SEPARATOR = "\n";
-var CRLF = "\r\n";
-var TASK_STATE_PATTERN = /^([\t ]*(?:[-*+]|\d+[.)])[\t ]+\[)[ xX](\](?:[\t ]|$))/gmu;
-var comment_schema = z.looseObject({
-  id: z.number(),
-  user: z.looseObject({ login: z.string(), type: z.string().optional() }).nullish(),
-  created_at: z.string().optional(),
-  body: z.string().nullish(),
-  author_association: z.string().nullish()
-});
-function is_bot(user) {
-  return user?.type === BOT_TYPE || (user?.login.endsWith(BOT_SUFFIX) ?? false);
-}
-function is_automated(raw, is_trusted) {
-  return is_bot(raw.user) || is_trusted === true && (raw.body?.includes(RUN_MARKER) ?? false);
-}
-async function to_comment(raw, timeout_ms) {
-  const login = raw.user?.login;
-  const is_trusted = await gh_author_association.trust_of({
-    login,
-    association: raw.author_association,
-    timeout_ms
-  });
-  return {
-    id: raw.id,
-    author: login ?? UNKNOWN_AUTHOR,
-    is_trusted,
-    is_automated: is_automated(raw, is_trusted),
-    created_at: raw.created_at ?? UNKNOWN_TIME,
-    body: raw.body ?? ""
-  };
-}
-async function parse_comments(json, timeout_ms) {
-  if (json === void 0) return void 0;
-  const listing = read_json_listing(json, comment_schema);
-  if (listing.kind !== "read") return void 0;
-  return await Promise.all(listing.rows.map(async (row) => await to_comment(row, timeout_ms)));
-}
-function last_comment_id(comments) {
-  return Math.max(NO_COMMENT_ID, ...comments.map((comment) => comment.id));
-}
-function baseline_of(snapshot) {
-  return { body: snapshot.body, last_comment_id: last_comment_id(snapshot.comments) };
-}
-function lines_missing_from(source, other) {
-  const present = new Set(other.split(LINE_SEPARATOR));
-  return source.split(LINE_SEPARATOR).filter((line) => line.trim() !== "" && !present.has(line));
-}
-function comparable_body(body) {
-  return body.split(CRLF).join(LINE_SEPARATOR).replaceAll(TASK_STATE_PATTERN, "$1 $2");
-}
-function body_section(previous_raw, current_raw) {
-  const previous = comparable_body(previous_raw);
-  const current = comparable_body(current_raw);
-  if (previous === current) return void 0;
-  const removed = lines_missing_from(previous, current).map((line) => `${REMOVED_PREFIX}${line}`);
-  const added = lines_missing_from(current, previous).map((line) => `${ADDED_PREFIX}${line}`);
-  return [BODY_HEADING, ...removed, ...added].join(LINE_SEPARATOR);
-}
-function comment_section(comment) {
-  const body = comment.is_trusted === true ? comment.body : UNVERIFIED_BODY;
-  return `${COMMENT_HEADING}${comment.author}${AT}${comment.created_at}${LINE_SEPARATOR}${body}`;
-}
-function new_person_comments(baseline, snapshot) {
-  return snapshot.comments.filter(
-    (comment) => comment.id > baseline.last_comment_id && comment.is_trusted !== false && !comment.is_automated
-  );
-}
-function is_body_edited(baseline, snapshot) {
-  return comparable_body(baseline.body) !== comparable_body(snapshot.body);
-}
-function unread_body(baseline, snapshot) {
-  if (snapshot.is_body_trusted === true) return body_section(baseline.body, snapshot.body);
-  if (snapshot.is_body_trusted === false || !is_body_edited(baseline, snapshot)) return void 0;
-  return `${BODY_HEADING}${LINE_SEPARATOR}${UNVERIFIED_BODY}`;
-}
-function unread_diff(baseline, snapshot) {
-  const body = unread_body(baseline, snapshot);
-  const comments = new_person_comments(baseline, snapshot).map(
-    (comment) => comment_section(comment)
-  );
-  const sections = [...body === void 0 ? [] : [body], ...comments];
-  return sections.length === 0 ? void 0 : sections.join(SECTION_SEPARATOR);
-}
-function landed_times(baseline, snapshot, body_at) {
-  const comments = new_person_comments(baseline, snapshot).map((comment) => comment.created_at);
-  return is_body_edited(baseline, snapshot) ? [body_at, ...comments] : comments;
-}
-function withheld_notice(baseline, snapshot) {
-  if (snapshot.is_body_trusted !== false || !is_body_edited(baseline, snapshot)) return void 0;
-  return WITHHELD_BODY_EDIT;
-}
-var issue_watch_diff = {
-  BOT_SUFFIX,
-  RUN_MARKER,
-  WITHHELD_BODY_EDIT,
-  baseline_of,
-  is_automated,
-  landed_times,
-  parse_comments,
-  unread_diff,
-  withheld_notice
-};
-
-export {
-  issue_watch_diff
-};

package/dist/commands/chunk-RXYMJPJB.js

@@ -1,114 +0,0 @@
-import {
-  backlog_ready,
-  backlog_stalled
-} from "./chunk-M4UV3BEV.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  lane_ledger_write
-} from "./chunk-I63RNFFR.js";
-
-// scripts/backlog/backlog-stalled-detect.ts
-var NO_FREE = 0;
-var NO_READY = 0;
-var NO_AGE = 0;
-function ready_count_of(ready) {
-  return async function() {
-    const issues = await ready.ready_issues();
-    return issues.length;
-  };
-}
-async function real_emit_stall(text) {
-  const { STALL, CHILD_LAUNCH } = run_event_stream.EVENT_KIND;
-  return await run_event_stream_emit.emit_once_since(STALL, text, CHILD_LAUNCH);
-}
-async function read_real_ledger() {
-  const path = await lane_ledger.target();
-  return path === void 0 ? [] : lane_ledger.read_entries(path);
-}
-async function real_mark_offerable(is_offerable) {
-  await lane_ledger_write.record_offerable(is_offerable);
-}
-function ports_over(ready) {
-  return {
-    resolve_target: run_event_stream_emit.stream_target,
-    read_events: run_event_stream.read_events,
-    now_ms: () => Date.now(),
-    free_lane_count: ready.free_lane_count,
-    ready_count: ready_count_of(ready),
-    read_ledger: read_real_ledger,
-    mark_offerable: real_mark_offerable,
-    emit_stall: real_emit_stall
-  };
-}
-var DEFAULT_PORTS = ports_over(backlog_ready.DEFAULT_PORTS);
-function ok_reading() {
-  return { ready_count: NO_READY, free_lanes: NO_FREE, waiting_ms: NO_AGE };
-}
-async function read_counts(ports) {
-  const free_lanes = await ports.free_lane_count();
-  if (free_lanes <= NO_FREE) return { ready_count: NO_READY, free_lanes };
-  return { ready_count: await ports.ready_count(), free_lanes };
-}
-function has_both(counts) {
-  return counts.ready_count > NO_READY && counts.free_lanes > NO_FREE;
-}
-async function waiting_ms(ports, entries, clock, is_offerable) {
-  const opened_ms = backlog_stalled.open_offerable_ms(entries, clock.reference_ms);
-  if (is_offerable === (opened_ms !== void 0)) return clock.now_ms - (opened_ms ?? clock.now_ms);
-  await ports.mark_offerable(is_offerable);
-  return NO_AGE;
-}
-async function probe_reading(ports, clock) {
-  const counts = await read_counts(ports);
-  const entries = await ports.read_ledger();
-  const waited = await waiting_ms(ports, entries, clock, has_both(counts));
-  return { ...counts, waiting_ms: waited, hold: backlog_stalled.open_hold(entries) };
-}
-function clock_of(ports, target) {
-  const now_ms = ports.now_ms();
-  const age = backlog_stalled.dispatch_age_ms(ports.read_events(target), now_ms);
-  return age === void 0 ? void 0 : { reference_ms: now_ms - age, now_ms };
-}
-async function gather(ports, threshold_ms) {
-  const target = await ports.resolve_target();
-  if (target === void 0) return void 0;
-  const clock = clock_of(ports, target);
-  if (clock === void 0 || clock.now_ms - clock.reference_ms <= threshold_ms) return ok_reading();
-  return await probe_reading(ports, clock);
-}
-async function observe_offerable(is_offerable, ports = DEFAULT_PORTS) {
-  try {
-    const target = await ports.resolve_target();
-    const clock = target === void 0 ? void 0 : clock_of(ports, target);
-    if (clock !== void 0) await waiting_ms(ports, await ports.read_ledger(), clock, is_offerable);
-  } catch {
-  }
-}
-async function report(ports, reading) {
-  await ports.emit_stall(backlog_stalled.describe(reading));
-}
-async function detect_and_report(ports = DEFAULT_PORTS, threshold_ms = backlog_stalled.STALL_THRESHOLD_MS) {
-  const reading = await gather(ports, threshold_ms);
-  const verdict = backlog_stalled.assess(reading, threshold_ms);
-  if (reading !== void 0 && verdict === backlog_stalled.STALLED) await report(ports, reading);
-  return verdict;
-}
-async function run_stall_check(ready = backlog_ready.DEFAULT_PORTS) {
-  try {
-    await detect_and_report(ports_over(ready));
-  } catch {
-  }
-}
-var backlog_stalled_detect = { detect_and_report, observe_offerable, run_stall_check };
-
-export {
-  backlog_stalled_detect
-};

package/dist/commands/chunk-S4M6UWR2.js

@@ -1,103 +0,0 @@
-import {
-  run_cut
-} from "./chunk-DYZOOWVW.js";
-import {
-  RUN_STALLED_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-
-// scripts/run/park/run-stalled.ts
-var SESSION_UNFINISHED = {
-  short: "session unfinished",
-  why: "the child\u2019s session ended with its issue still open and unfinished."
-};
-var CUT_NOT_RELAUNCHED = {
-  short: "cut not relaunched",
-  why: "its lane held a declared cut, but no successor could be relaunched from it (or it already was once)."
-};
-var STALE_HANDOFF = {
-  short: "stale hand-off",
-  why: "the child stopped at `resume: handed-off` because an old hand-off cut record was already adopted."
-};
-var RESUME_COMMAND = "fullrun";
-var CAUSE_LEAD = `${RUN_STALLED_LABEL}: `;
-function resume_of(child, is_backlog_live = false) {
-  return is_backlog_live ? `pnpm josh run:add ${String(child)} --retry` : `${RESUME_COMMAND} ${issue_cite.plain_for("program", child)}`;
-}
-function recovery_of(cause) {
-  if (cause === STALE_HANDOFF.why) {
-    return `repair the stale hand-off cut record with \`${run_cut.END_COMMAND}\` (retry alone does not clear it)`;
-  }
-  return /cut.*(?:handed-off|already handed off)/iu.test(cause) ? `clear the handed-off cut with \`${run_cut.END_COMMAND}\`` : "fix the cause";
-}
-function next_step(child, cause = "") {
-  const recovery = recovery_of(cause);
-  return `${recovery}, then use \`${resume_of(child, true)}\` in the live backlogrun or resume it with \`${resume_of(child, false)}\``;
-}
-var ESCALATION_REQUESTED = {
-  short: "escalation requested",
-  why: "the worker declared that its Issue needs a stronger josh.worker profile."
-};
-var CARRYING_CLASSES = [SESSION_UNFINISHED, ESCALATION_REQUESTED];
-function lead_of(cause) {
-  return `${cause.short}: `;
-}
-function carrying(cause, message) {
-  const first = message.split(/\r?\n/u, 1)[0]?.trim() ?? "";
-  return first === "" ? cause : { short: `${lead_of(cause)}${first}`, why: first };
-}
-function session_unfinished(message) {
-  return carrying(SESSION_UNFINISHED, message);
-}
-function escalation_requested(reason) {
-  return carrying(ESCALATION_REQUESTED, reason);
-}
-function class_of(cause) {
-  const carried = CARRYING_CLASSES.find((known) => cause.startsWith(lead_of(known)));
-  return carried?.short ?? cause;
-}
-function park_event(child, cause) {
-  return `${issue_cite.plain_for("program", child)} parked (${CAUSE_LEAD}${cause})`;
-}
-function cause_of(reason) {
-  if (reason === RUN_STALLED_LABEL) return "";
-  return reason.startsWith(CAUSE_LEAD) ? reason.slice(CAUSE_LEAD.length) : void 0;
-}
-function cause_in(text) {
-  const lead = ` parked (${CAUSE_LEAD}`;
-  const start = text.indexOf(lead);
-  return start === -1 || !text.endsWith(")") ? void 0 : text.slice(start + lead.length, -1);
-}
-function stop_of(event) {
-  return event.stop;
-}
-function row_text(child, cause = "", is_backlog_live = false) {
-  const resume = `\u2192 resume: ${resume_of(child, is_backlog_live)}`;
-  return cause === "" ? resume : `${resume} (${cause})`;
-}
-function waiting_text(waits) {
-  return `waiting on ${waits.map((wait) => wait.includes("#") ? wait : issue_cite.plain_for("program", wait)).join(", ")}`;
-}
-var run_stalled = {
-  CUT_NOT_RELAUNCHED,
-  ESCALATION_REQUESTED,
-  SESSION_UNFINISHED,
-  STALE_HANDOFF,
-  cause_in,
-  cause_of,
-  class_of,
-  escalation_requested,
-  next_step,
-  park_event,
-  resume_of,
-  row_text,
-  session_unfinished,
-  stop_of,
-  waiting_text
-};
-
-export {
-  run_stalled
-};

package/dist/commands/chunk-SASX3W2M.js

@@ -1,99 +0,0 @@
-import {
-  run_hold
-} from "./chunk-X3TNPALI.js";
-import {
-  lane_state
-} from "./chunk-ZZXO6TFH.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.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_halfrun_stop(read, issue, is_dirty) {
-  const hold = hold_of(read);
-  return is_dirty && hold?.issue === issue && hold.is_halfrun_stop === true;
-}
-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 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());
-  const lane = is_adopted ? await lane_state.read_state(issue) : void 0;
-  if (lane?.state === "human-review") {
-    await lane_state.record_change({ issue, state: "running", command: "run:entry" });
-  }
-  return is_adopted;
-}
-var run_halfrun_resume = {
-  FOREIGN,
-  MARKED,
-  UNREADABLE,
-  adopt,
-  adopt_at,
-  hold_of,
-  hold_target,
-  is_pending,
-  mark_stop_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-SFNBUB6D.js

@@ -1,110 +0,0 @@
-import {
-  security_audit,
-  security_audit_logic,
-  security_audit_provision_logic
-} from "./chunk-4EADHJVC.js";
-import {
-  timed_fetch
-} from "./chunk-5HVYOIIK.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-import {
-  atomic_write
-} from "./chunk-KSR23NYN.js";
-
-// scripts/security/security-audit-provision.ts
-var EXECUTABLE_MODE = 493;
-var FAILURE_STAMP_PREFIX = "josh-audit-provision-";
-var FORCE_FLAG = "--force";
-var PATH_LOCATION = "on PATH";
-var { RETRY_INTERVAL_MS } = security_audit_provision_logic;
-async function download(url, timeout_ms) {
-  try {
-    const response = await timed_fetch(url, {}, timeout_ms);
-    if (!response.ok) return { reason: `HTTP ${String(response.status)}` };
-    return { content: Buffer.from(await response.arrayBuffer()), reason: "" };
-  } catch (error) {
-    return { reason: error_text.message_of(error) };
-  }
-}
-function install(target_path, content) {
-  atomic_write.replace_file(target_path, content, { mode: EXECUTABLE_MODE });
-}
-function failure_stamp_path(target_path) {
-  return stamp_file.stamp_path(FAILURE_STAMP_PREFIX, target_path);
-}
-function is_in_backoff(target_path) {
-  const recorded = Number(stamp_file.read_stamp_text(failure_stamp_path(target_path)));
-  return Number.isFinite(recorded) && Date.now() - recorded < RETRY_INTERVAL_MS;
-}
-function record_failure(target_path, message) {
-  stamp_file.write_stamp(failure_stamp_path(target_path), Date.now());
-  return message;
-}
-async function provision(target_path, asset, timeout_ms) {
-  const { format_checksum_mismatch, format_download_failure, format_installed } = security_audit_provision_logic;
-  const outcome = await download(asset.url, timeout_ms);
-  if (outcome.content === void 0) {
-    return { is_installed: false, message: format_download_failure(asset.url, outcome.reason) };
-  }
-  const actual = stamp_file.digest(outcome.content);
-  if (actual !== asset.sha256) {
-    return {
-      is_installed: false,
-      message: format_checksum_mismatch(asset.name, asset.sha256, actual)
-    };
-  }
-  install(target_path, outcome.content);
-  return { is_installed: true, message: format_installed(target_path) };
-}
-async function attempt(target_path, asset, timeout_ms) {
-  try {
-    const outcome = await provision(target_path, asset, timeout_ms);
-    if (!outcome.is_installed) return record_failure(target_path, outcome.message);
-    stamp_file.remove_stamp(failure_stamp_path(target_path));
-    return outcome.message;
-  } catch (error) {
-    return record_failure(
-      target_path,
-      security_audit_provision_logic.format_provision_error(error_text.message_of(error))
-    );
-  }
-}
-function existing_scanner(target_path) {
-  const { BINARY_NAME } = security_audit_logic;
-  if (security_audit.meets_floor(BINARY_NAME)) return PATH_LOCATION;
-  const is_managed_usable = security_audit.is_executable_file(target_path) && security_audit.meets_floor(target_path);
-  return is_managed_usable ? target_path : void 0;
-}
-async function report(project_root, platform, architecture, is_forced) {
-  const logic = security_audit_provision_logic;
-  const target_path = security_audit.managed_binary_path(project_root, platform);
-  const existing = existing_scanner(target_path);
-  if (existing !== void 0) return logic.format_already_present(existing);
-  const asset = logic.resolve_asset(platform, architecture);
-  if (asset === void 0) return logic.format_unsupported_platform(platform, architecture);
-  if (!is_forced && is_in_backoff(target_path)) return logic.format_recent_failure();
-  return await attempt(target_path, asset, logic.build_download_timeout(is_forced));
-}
-async function run(argv) {
-  const is_forced = argv.includes(FORCE_FLAG);
-  try {
-    console.info(await report(PROJECT_ROOT, process.platform, process.arch, is_forced));
-  } catch (error) {
-    console.warn(
-      security_audit_provision_logic.format_provision_error(error_text.message_of(error))
-    );
-  }
-}
-var security_audit_provision = { attempt, provision, report, run };
-
-export {
-  security_audit_provision
-};

package/dist/commands/chunk-SJ2ZN575.js

@@ -1,90 +0,0 @@
-import {
-  lane_plan_signals
-} from "./chunk-2QM72JCJ.js";
-import {
-  lane_ledger_archive
-} from "./chunk-5UJGACVN.js";
-import {
-  lane_stage_stats
-} from "./chunk-IBAYXCMU.js";
-import {
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-plan-wait.ts
-var WAIT_CAP_MINUTES = 30;
-var WAIT_CAP_MS = WAIT_CAP_MINUTES * MS_PER_MINUTE;
-var MEDIAN_PERIOD_DAYS = 3;
-var ASK_MINUTES = 9;
-var ASK_MS = ASK_MINUTES * MS_PER_MINUTE;
-function deadline_of(facts) {
-  const { own_at_ms, holder_at_ms, now_ms } = facts;
-  if (!facts.has_commits || own_at_ms >= holder_at_ms) return void 0;
-  const remaining = facts.median_ms - (now_ms - holder_at_ms);
-  const bound = Math.min(now_ms - own_at_ms, WAIT_CAP_MS);
-  return remaining <= bound ? now_ms + bound : void 0;
-}
-function dispatched_at(entries, issue) {
-  const starts = entries.filter((entry) => lane_stage_stats.is_dispatch(entry) && entry.issue === issue).map((entry) => Date.parse(entry.at));
-  return lane_stats.peak(starts);
-}
-function median_ms(entries, now_ms) {
-  const period = lane_stats.in_window(entries, lane_stats.window_of(MEDIAN_PERIOD_DAYS, now_ms));
-  const minutes = lane_stats.median(lane_stats.merge_minutes(entries, period));
-  return minutes === void 0 ? void 0 : minutes * MS_PER_MINUTE;
-}
-function facts_from(entries, pair, has_commits, now_ms) {
-  const own_at_ms = dispatched_at(entries, pair.issue);
-  const holder_at_ms = dispatched_at(entries, pair.holder);
-  const median = median_ms(entries, now_ms);
-  if (own_at_ms === void 0 || holder_at_ms === void 0 || median === void 0) {
-    return void 0;
-  }
-  return { own_at_ms, holder_at_ms, has_commits, median_ms: median, now_ms };
-}
-async function entries_of() {
-  const ledger = await lane_ledger.target();
-  return ledger === void 0 ? [] : lane_ledger_archive.history_at(ledger);
-}
-async function deadline(issue, holder, now_ms) {
-  const [entries, signals] = await Promise.all([entries_of(), lane_plan_signals.signals_of(issue)]);
-  const facts = facts_from(entries, { issue, holder }, signals.committed_files.length > 0, now_ms);
-  return facts === void 0 ? void 0 : deadline_of(facts);
-}
-async function hold(until_ms, is_free, sleeper = poll.sleep) {
-  const ask_end_ms = Date.now() + ASK_MS;
-  return await poll.wait_for(
-    async () => {
-      if (Date.now() >= until_ms) return "expired";
-      if (await is_free()) return "free";
-      return Date.now() + MS_PER_MINUTE > ask_end_ms ? "again" : void 0;
-    },
-    { interval_ms: MS_PER_MINUTE, sleeper }
-  );
-}
-var lane_plan_wait = { deadline, deadline_of, facts_from, hold };
-
-// scripts/lane/lane-plan-wait-until.ts
-async function until(plan, holder) {
-  const now_ms = Date.now();
-  if (plan.waits_until !== void 0) {
-    return Date.parse(plan.waits_until) > now_ms ? plan.waits_until : void 0;
-  }
-  const deadline2 = await lane_plan_wait.deadline(plan.issue, holder, now_ms);
-  return deadline2 === void 0 ? void 0 : new Date(deadline2).toISOString();
-}
-var lane_plan_wait_until = { until };
-
-export {
-  lane_plan_wait,
-  lane_plan_wait_until
-};