@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-FT33ZCSB.js

@@ -1,298 +0,0 @@
-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

@@ -1,170 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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
-};