@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-FT33ZCSB.js

@@ -0,0 +1,298 @@
+import {
+  git_gh_issue_batch_read
+} from "./chunk-HYE3MBAN.js";
+import {
+  cutoff_cause,
+  cutoff_of
+} from "./chunk-DACNQAXC.js";
+import {
+  epic_parse
+} from "./chunk-VDGNXSP3.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  epic_child_schema,
+  epic_issue_schema,
+  rest_comment_schema
+} from "./chunk-34DND4BA.js";
+import {
+  EPIC_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  parse_json_array_or_undefined,
+  parse_json_object_or_undefined,
+  read_json_listing
+} from "./chunk-43DU7DYZ.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/epic/epic-close-comment.ts
+var CLOSE_ANNOUNCEMENT = "Closing this epic automatically.";
+var MARKER_OPEN = "<!-- josh:epic-auto-close children=";
+var MARKER_CLOSE = " -->";
+function child_references(epic) {
+  return [
+    ...epic.children.map((child) => issue_cite.plain_for("github", child)),
+    ...epic.external_children.map(
+      (child) => issue_cite.plain_for("github", child.number, child.repo)
+    )
+  ];
+}
+function build_marker(epic) {
+  return `${MARKER_OPEN}${child_references(epic).join(",")}${MARKER_CLOSE}`;
+}
+var INDENTED_CODE_SPACES = 4;
+function indent_of(line) {
+  return line.length - line.trimStart().length;
+}
+function marker_children(line) {
+  if (indent_of(line) >= INDENTED_CODE_SPACES) return void 0;
+  const trimmed = line.trim();
+  if (!trimmed.startsWith(MARKER_OPEN) || !trimmed.endsWith(MARKER_CLOSE)) return void 0;
+  const listed = trimmed.slice(MARKER_OPEN.length, -MARKER_CLOSE.length);
+  return listed.split(",").filter((reference) => reference.length > 0);
+}
+function is_same_children(left, right) {
+  const left_set = new Set(left);
+  const right_set = new Set(right);
+  return left_set.size === right_set.size && [...left_set].every((one) => right_set.has(one));
+}
+function build_close_comment(epic) {
+  return `All child issues are closed (${child_references(epic).join(", ")}). ${CLOSE_ANNOUNCEMENT}
+
+${build_marker(epic)}`;
+}
+var LEGACY_ANNOUNCEMENT_PATTERN = /^All child issues are closed \([^)]*\)\. Closing this epic automatically\.$/u;
+function is_legacy_announcement(body) {
+  return LEGACY_ANNOUNCEMENT_PATTERN.test(body.trim());
+}
+function has_marker(body, children) {
+  const mask = epic_parse.fence_mask(body);
+  return body.split("\n").some((line, index) => {
+    if (mask[index] !== true) return false;
+    const announced = marker_children(line);
+    return announced !== void 0 && is_same_children(announced, children);
+  });
+}
+function has_announcement(comments, children) {
+  return comments.some((comment) => {
+    const body = comment.body ?? "";
+    return has_marker(body, children) || is_legacy_announcement(body);
+  });
+}
+async function read_close_comment_state(epic_number, epic) {
+  const raw_json = await git_gh_command.issue_list_comments(epic_number);
+  if (raw_json === void 0) return "unreadable";
+  const listing = read_json_listing(raw_json, rest_comment_schema);
+  if (listing.kind !== "read") return "unreadable";
+  return has_announcement(listing.rows, child_references(epic)) ? "present" : "absent";
+}
+var epic_close_comment = {
+  build_close_comment,
+  read_close_comment_state
+};
+
+// scripts/epic/epic-close.ts
+var EPIC_LIST_LIMIT = 100;
+function truncated_epic_list_note(cutoff) {
+  const cause = cutoff_cause(cutoff, `hit its ${String(EPIC_LIST_LIMIT)}-epic cap`);
+  if (cause === void 0) return void 0;
+  return `\u26A0\uFE0F  The open epic listing ${cause}; an epic past it was not checked for completion.`;
+}
+var REOPENED = "reopened";
+function to_epic_issue(raw) {
+  return {
+    is_reopened: raw.stateReason === REOPENED,
+    number: raw.number,
+    children: epic_parse.parse_task_list_issue_numbers(raw.body),
+    external_children: epic_parse.parse_external_task_list_children(raw.body),
+    has_declared_order: epic_parse.has_declared_dependency_chain(raw.body)
+  };
+}
+async function fetch_open_epics() {
+  const { json, is_capped } = await git_gh_command.issue_list_by_label(EPIC_LABEL, EPIC_LIST_LIMIT);
+  if (json === void 0) return void 0;
+  const rows = parse_json_array_or_undefined(json, epic_issue_schema);
+  if (rows === void 0) return void 0;
+  const note = truncated_epic_list_note(cutoff_of(rows.length, EPIC_LIST_LIMIT, is_capped));
+  if (note !== void 0) console.info(note);
+  return rows.map((raw) => to_epic_issue(raw));
+}
+function parse_child(raw_json) {
+  if (raw_json === void 0) return void 0;
+  return parse_json_object_or_undefined(raw_json, epic_child_schema);
+}
+function has_blocked_by(child) {
+  const blocked_by = child?.blockedBy;
+  return (blocked_by?.totalCount ?? 0) > 0;
+}
+function to_sibling_state(raw_json) {
+  const child = parse_child(raw_json);
+  return {
+    is_closed: epic_parse.is_state_closed(child?.state),
+    has_blocked_by: has_blocked_by(child)
+  };
+}
+function state_reader(repo) {
+  return {
+    repo,
+    from_json: (json) => json,
+    read_rest: async (issue_number) => await git_gh_command.issue_get_state_and_relations(String(issue_number), repo)
+  };
+}
+function to_child_read(raw) {
+  return { ...to_sibling_state(raw), is_readable: parse_child(raw)?.state !== void 0 };
+}
+async function inspect_children(epic, merged_number) {
+  const siblings = epic.children.filter((child) => child !== merged_number).map((number) => ({ number }));
+  const reads = await git_gh_issue_batch_read.read_across(
+    [...siblings, ...epic.external_children],
+    state_reader
+  );
+  return reads.map((raw) => to_child_read(raw));
+}
+function warn_when_order_unrecorded(epic, states) {
+  if (states.length === 0 || !epic.has_declared_order || states.some((state) => state.has_blocked_by)) {
+    return;
+  }
+  console.info(
+    `\u2139\uFE0F  Epic ${session_cite.issue(epic.number)} has no blocked-by relation on any child; the batch order was never recorded natively (see the epic creation procedure).`
+  );
+}
+var CLOSE_MANUALLY = "close it manually.";
+var MAX_CASCADE_DEPTH = 10;
+var CASCADE_DEPTH_NOTE = `\u26A0\uFE0F  Epic auto-close cascade reached its ${String(
+  MAX_CASCADE_DEPTH
+)}-level cap; ${CLOSE_MANUALLY}`;
+var UNREADABLE_COMMENTS_NOTE = "'s comments could not be read; announcing again rather than leaving it open.";
+async function close_epic_with(epic_number, comment) {
+  const is_closed = await git_gh_command.issue_close(epic_number, comment);
+  console.info(
+    is_closed ? `\u{1F3C1} Closed epic ${session_cite.issue(epic_number)} \u2014 every child issue is complete.` : `\u26A0\uFE0F  Could not close epic ${session_cite.issue(epic_number)}; ${CLOSE_MANUALLY}`
+  );
+  return is_closed;
+}
+async function close_epic(epic) {
+  const epic_number = String(epic.number);
+  const state = await epic_close_comment.read_close_comment_state(epic_number, epic);
+  const note = `\u2139\uFE0F  Epic ${session_cite.issue(epic_number)}${UNREADABLE_COMMENTS_NOTE}`;
+  if (state === "unreadable") console.info(note);
+  const comment = state === "present" ? void 0 : epic_close_comment.build_close_comment(epic);
+  return await close_epic_with(epic_number, comment);
+}
+function warn_when_unread_blocks_close(epic, states) {
+  if (states.some((state) => state.is_readable && !state.is_closed)) return;
+  console.info(
+    `\u26A0\uFE0F  Epic ${session_cite.issue(epic.number)} has a child whose state could not be read; ${CLOSE_MANUALLY}`
+  );
+}
+async function close_epic_when_complete(epic, merged_number) {
+  const states = await inspect_children(epic, merged_number);
+  if (states.some((state) => !state.is_readable)) {
+    warn_when_unread_blocks_close(epic, states);
+    return false;
+  }
+  warn_when_order_unrecorded(epic, states);
+  if (states.some((state) => !state.is_closed)) return false;
+  return await close_epic(epic);
+}
+async function close_epic_isolated(epic, merged_number) {
+  try {
+    return await close_epic_when_complete(epic, merged_number);
+  } catch (error) {
+    const message = error_text.message_of(error);
+    console.info(`\u26A0\uFE0F  Skipped epic ${session_cite.issue(epic.number)}: ${message}`);
+    return false;
+  }
+}
+function parents_of(open_epics, child_number) {
+  return open_epics.filter((epic) => epic_parse.has_child(epic.children, child_number));
+}
+async function close_if_unseen(epic, child_number, evaluated) {
+  if (evaluated.has(epic.number)) return void 0;
+  evaluated.add(epic.number);
+  return await close_epic_isolated(epic, child_number) ? epic.number : void 0;
+}
+async function close_parents_of(open_epics, child_number, evaluated) {
+  const closed = [];
+  for (const epic of parents_of(open_epics, child_number)) {
+    const number = await close_if_unseen(epic, child_number, evaluated);
+    if (number !== void 0) closed.push(number);
+  }
+  return closed;
+}
+async function close_next_level(open_epics, frontier, evaluated) {
+  const next = [];
+  for (const child_number of frontier) {
+    next.push(...await close_parents_of(open_epics, child_number, evaluated));
+  }
+  return next;
+}
+async function cascade_from(open_epics, start, evaluated) {
+  let frontier = start;
+  for (let depth = 0; depth < MAX_CASCADE_DEPTH; depth++) {
+    if (frontier.length === 0) return true;
+    frontier = await close_next_level(open_epics, frontier, evaluated);
+  }
+  if (frontier.length > 0) console.info(CASCADE_DEPTH_NOTE);
+  return frontier.length === 0;
+}
+function tracks_children(epic) {
+  return epic.children.length + epic.external_children.length > 0;
+}
+function is_sweep_target(epic, evaluated) {
+  return !evaluated.has(epic.number) && !epic.is_reopened && tracks_children(epic);
+}
+async function sweep_unreached(open_epics, merged_number, evaluated) {
+  const closed = [];
+  const unreached = open_epics.filter((epic) => is_sweep_target(epic, evaluated));
+  for (const epic of unreached) {
+    if (await close_epic_isolated(epic, merged_number)) closed.push(epic.number);
+  }
+  for (const number of closed) evaluated.add(number);
+  return closed;
+}
+async function cascade_close(open_epics, merged_number) {
+  const evaluated = /* @__PURE__ */ new Set();
+  if (!await cascade_from(open_epics, [merged_number], evaluated)) return;
+  const swept = await sweep_unreached(open_epics, merged_number, evaluated);
+  await cascade_from(open_epics, swept, evaluated);
+}
+var UNREADABLE_EPIC_LIST_MESSAGE = "\u26A0\uFE0F  Could not read the open epic listing; skipped the epic auto-close check.";
+async function resolve_and_close(merged_number) {
+  const open_epics = await fetch_open_epics();
+  if (open_epics === void 0) {
+    console.info(UNREADABLE_EPIC_LIST_MESSAGE);
+    return;
+  }
+  await cascade_close(open_epics, merged_number);
+}
+async function resolve_and_close_safely(merged_number) {
+  try {
+    await resolve_and_close(merged_number);
+  } catch (error) {
+    const message = error_text.message_of(error);
+    console.info(`\u26A0\uFE0F  Skipped the epic auto-close check: ${message}`);
+  }
+}
+async function close_completed_epics(input) {
+  if (!input.is_merged) return;
+  const merged_number = Number(input.issue_number);
+  if (!Number.isSafeInteger(merged_number)) return;
+  await resolve_and_close_safely(merged_number);
+}
+var epic_close = {
+  close_completed_epics
+};
+
+export {
+  epic_close
+};

package/dist/commands/chunk-FTAWHAI7.js

@@ -0,0 +1,170 @@
+import {
+  lane_hand_back_hold
+} from "./chunk-AU563VKH.js";
+import {
+  lane_held_stats
+} from "./chunk-R3F7F3TX.js";
+import {
+  backlog_hold_codes
+} from "./chunk-MXPCEZL5.js";
+import {
+  type_check_step
+} from "./chunk-RMDLFLPE.js";
+import {
+  check_reuse
+} from "./chunk-HSZECERZ.js";
+import {
+  structural_checks
+} from "./chunk-3D5T6KMW.js";
+import {
+  metrics_totals
+} from "./chunk-HEFUC4ZW.js";
+import {
+  gate_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  gate_labels
+} from "./chunk-WQ6FS544.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+
+// scripts/run/ship/run-ship-pre-detach.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var SECTION_SEPARATOR = "\n\n";
+var PASSED = "pre-detach checks passed";
+var UNPINNED = "unpinned";
+var { METRICS_RERECORD_COMMAND } = metrics_totals;
+var STATIC_CHECKS = [
+  { list: ["josh", "exports:unused"], label: gate_labels.EXPORTS_LABEL },
+  { list: ["josh", "cspell:dot"] }
+];
+var GUARD_TEST_TARGETS = [
+  "scripts/document",
+  "scripts/claude",
+  "scripts/rules",
+  "scripts/josh/josh-command-map.test.ts",
+  ...structural_checks.STRUCTURAL_GUARD_TARGETS,
+  "tools/test/pure-files.test.ts"
+];
+var { GUARD_TEST_COMMAND, failure_prefix, failure_section } = structural_checks;
+function present_targets(directory) {
+  return GUARD_TEST_TARGETS.filter((target) => existsSync(path.join(directory, target)));
+}
+function guard_tests(directory) {
+  const targets = present_targets(directory);
+  return targets.length === 0 ? [] : [{ list: [...GUARD_TEST_COMMAND, ...targets] }];
+}
+async function metrics_runs(directory) {
+  const started = performance.now();
+  const result = await metrics_totals.totals_check(directory);
+  if (result === void 0) return [];
+  return [
+    { check: { list: METRICS_RERECORD_COMMAND }, result, elapsed_ms: performance.now() - started }
+  ];
+}
+async function command_lists(directory) {
+  const type_check = await type_check_step.resolve_type_check_args(directory);
+  return [
+    { list: type_check, label: gate_labels.TYPE_CHECK_LABEL },
+    ...STATIC_CHECKS,
+    ...guard_tests(directory)
+  ];
+}
+async function run_in(directory, check) {
+  const started = performance.now();
+  const result = await buffered_process.run_buffered_process(check.list, { cwd: directory });
+  return { check, result, elapsed_ms: performance.now() - started };
+}
+function is_gate_run(run) {
+  return run.check.label !== void 0;
+}
+function gate_results(runs) {
+  return runs.filter((run) => is_gate_run(run)).map(({ check, result, elapsed_ms }) => {
+    return { ...result, label: check.label, command: check.list.join(" "), elapsed_ms };
+  });
+}
+function verdict(runs) {
+  const failed = runs.filter(({ result }) => buffered_process.is_process_failed(result));
+  if (failed.length === 0) return { code: SUCCESS_EXIT_CODE, out: PASSED };
+  return {
+    code: FAILURE_EXIT_CODE,
+    out: failed.map(({ check, result }) => failure_section(check.list, result)).join(SECTION_SEPARATOR)
+  };
+}
+async function not_asked() {
+  return { code: SUCCESS_EXIT_CODE, out: PASSED };
+}
+function joined(result, pinned) {
+  if (pinned.code === SUCCESS_EXIT_CODE) return result;
+  if (result.code === SUCCESS_EXIT_CODE) return pinned;
+  return { code: FAILURE_EXIT_CODE, out: [result.out, pinned.out].join(SECTION_SEPARATOR) };
+}
+function red_kinds(result, pinned) {
+  return [
+    ...result.code === SUCCESS_EXIT_CODE ? [] : [lane_ledger_write.PRE_DETACH_STAGE],
+    ...pinned.code === SUCCESS_EXIT_CODE ? [] : [UNPINNED]
+  ];
+}
+function with_pinned(result, pinned) {
+  const preconditions = red_kinds(result, pinned);
+  const answer = joined(result, pinned);
+  return preconditions.length === 0 ? answer : { ...answer, preconditions };
+}
+async function checks(directory = process.cwd(), records = check_reuse.DEFAULT_RECORDS, pinned = not_asked) {
+  const metrics = await metrics_runs(directory);
+  const [lists, tree] = await Promise.all([command_lists(directory), gate_tree.read_gate_tree()]);
+  const [runs, pinned_result] = await Promise.all([
+    Promise.all(lists.map(async (check) => await run_in(directory, check))),
+    pinned()
+  ]);
+  await check_reuse.record_green_checks(gate_results(runs), tree, records);
+  return with_pinned(verdict([...runs, ...metrics]), pinned_result);
+}
+var run_ship_pre_detach = {
+  GUARD_TEST_TARGETS,
+  METRICS_RERECORD_COMMAND,
+  PASSED,
+  STATIC_CHECKS,
+  UNPINNED,
+  checks,
+  failure_prefix,
+  with_pinned
+};
+
+// scripts/lane/lane-hand-back-held.ts
+var { DRIVERLESS_PREFIX } = backlog_hold_codes;
+function is_driverless(reason) {
+  return reason.startsWith(DRIVERLESS_PREFIX);
+}
+function is_closed(ledger, now_ms) {
+  return lane_held_stats.open_reason(lane_ledger.read_entries(ledger), now_ms) === void 0;
+}
+async function hold(ledger, now_ms) {
+  const reason = lane_hand_back_hold.take(ledger);
+  if (reason !== void 0 && is_closed(ledger, now_ms)) {
+    await lane_ledger_write.record_held({ reason: `${DRIVERLESS_PREFIX}${reason}` }, ledger);
+  }
+}
+async function record(ledger, now_ms = Date.now()) {
+  try {
+    const resolved = ledger ?? await lane_ledger.target();
+    if (resolved !== void 0) await hold(resolved, now_ms);
+  } catch {
+  }
+}
+var lane_hand_back_held = { DRIVERLESS_PREFIX, is_driverless, record };
+
+export {
+  run_ship_pre_detach,
+  lane_hand_back_held
+};

package/dist/commands/chunk-G2DNS74C.js

@@ -0,0 +1,53 @@
+import {
+  issue_auto_ok
+} from "./chunk-QGATHT4S.js";
+import {
+  AUTO_OK_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+
+// scripts/issue/issue-publication-state.ts
+import { z } from "zod";
+var PREFIX = "<!-- josh:publication ";
+var PATTERN = /<!-- josh:publication (?<record>[^\n]*?) -->/u;
+var schema = z.object({ labels: z.array(z.string()) });
+function is_pending(body) {
+  return body?.includes(PREFIX) === true;
+}
+function prepare(body, labels) {
+  if (is_pending(body)) throw new Error("Issue already contains a publication record");
+  return `${body}
+
+${PREFIX}${JSON.stringify({ labels })} -->
+`;
+}
+function public_body(body) {
+  return body.replace(PATTERN, "").trimEnd();
+}
+function intended_labels(body = "") {
+  const record = PATTERN.exec(body)?.groups?.["record"];
+  return schema.parse(JSON.parse(record ?? "null")).labels;
+}
+function labels_of(body, current) {
+  const intended = intended_labels(body);
+  const labels = current.filter((label) => !has_label_name([label], AUTO_OK_LABEL));
+  const decision = issue_auto_ok.decide({
+    is_opted_out: !has_label_name(intended, AUTO_OK_LABEL),
+    is_cross_repository: false,
+    body: public_body(body ?? ""),
+    labels
+  });
+  return decision.is_applied ? [...labels, AUTO_OK_LABEL] : labels;
+}
+function creation(body, labels, is_prepared) {
+  if (!is_prepared) return { body, labels };
+  return {
+    body: prepare(body, labels),
+    labels: labels.filter((label) => !has_label_name([label], AUTO_OK_LABEL))
+  };
+}
+var issue_publication_state = { is_pending, prepare, public_body, labels_of, creation };
+
+export {
+  issue_publication_state
+};

package/dist/commands/chunk-G3BBCAAH.js

@@ -0,0 +1,90 @@
+import {
+  lane_plan_signals
+} from "./chunk-7K5ITPHR.js";
+import {
+  lane_ledger_archive
+} from "./chunk-ESUY7KTZ.js";
+import {
+  lane_stage_stats
+} from "./chunk-J4XHEOOW.js";
+import {
+  lane_stats
+} from "./chunk-2XLR7R6E.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.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
+};