@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-6CFHLMKM.js

@@ -1,555 +0,0 @@
-import {
-  build_upgrade_command
-} from "./chunk-P7FPXAHP.js";
-import {
-  create_version_command_config
-} from "./chunk-SADJPNDB.js";
-import {
-  pr_classification
-} from "./chunk-WAEN2RTT.js";
-import {
-  git_gh_issue_write
-} from "./chunk-RN2YDNLF.js";
-import {
-  status_icons
-} from "./chunk-65E4OZJ7.js";
-import {
-  ls_remote_branch_arguments
-} from "./chunk-ZBFNQUY7.js";
-import {
-  OTHER_CHANGE_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  GATE_COMMAND
-} from "./chunk-TBIX5FRN.js";
-import {
-  git_gh_exec
-} from "./chunk-XDF25GSU.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  git_location_environment,
-  git_spawn_sync
-} from "./chunk-B77ZMVHS.js";
-import {
-  GIT_TIMEOUT_MS,
-  SUITE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/propagate/propagate-git.ts
-import { existsSync } from "node:fs";
-import path from "node:path";
-var REMOTE_TIMEOUT_MS = 6e4;
-var DEFAULT_BRANCH_REF = "refs/remotes/origin/HEAD";
-var FALLBACK_DEFAULT_BRANCH = "main";
-var ORIGIN_PREFIX = "refs/remotes/origin/";
-var PRE_PUSH_HOOK = "pre-push";
-function run_git(repository_path, args, timeout_ms = GIT_TIMEOUT_MS) {
-  return git_spawn_sync.read(args, {
-    cwd: repository_path,
-    timeout: timeout_ms,
-    env: { ...git_spawn_sync.C_LOCALE, ...git_location_environment.location_free_environment() }
-  });
-}
-function default_branch(repository_path) {
-  const reference = run_git(repository_path, ["symbolic-ref", DEFAULT_BRANCH_REF]);
-  if (reference?.startsWith(ORIGIN_PREFIX) !== true) return FALLBACK_DEFAULT_BRANCH;
-  return reference.slice(ORIGIN_PREFIX.length);
-}
-function current_branch(repository_path) {
-  return run_git(repository_path, ["rev-parse", "--abbrev-ref", "HEAD"]);
-}
-function is_clean(repository_path) {
-  return run_git(repository_path, ["status", "--porcelain"]) === "";
-}
-function fetch_branch(repository_path, branch) {
-  run_git(repository_path, ["fetch", "--quiet", "origin", branch]);
-}
-function is_up_to_date(repository_path, branch) {
-  fetch_branch(repository_path, branch);
-  const local = run_git(repository_path, ["rev-parse", branch]);
-  const remote = run_git(repository_path, ["rev-parse", `origin/${branch}`]);
-  if (local === void 0 || remote === void 0) return false;
-  return local === remote;
-}
-function commit_ahead(repository_path, default_name) {
-  const head = run_git(repository_path, ["rev-parse", "HEAD"]);
-  const base = run_git(repository_path, ["rev-parse", default_name]);
-  if (head === void 0 || head === base) return void 0;
-  return run_git(repository_path, ["rev-parse", "--short", "HEAD"]);
-}
-function has_remote_branch(repository_path, branch) {
-  const heads = run_git(repository_path, ls_remote_branch_arguments(branch), REMOTE_TIMEOUT_MS);
-  return heads !== void 0 && heads !== "";
-}
-function hooks_directory(repository_path) {
-  const configured = run_git(repository_path, ["config", "--get", "core.hooksPath"]);
-  if (configured !== void 0 && configured !== "") return configured;
-  return run_git(repository_path, ["rev-parse", "--git-path", "hooks"]);
-}
-function has_pre_push_hook(repository_path) {
-  const directory = hooks_directory(repository_path);
-  if (directory === void 0 || directory === "") return false;
-  return existsSync(path.resolve(repository_path, directory, PRE_PUSH_HOOK));
-}
-function can_push_without_hooks(repository_path, branch) {
-  const args = ["push", "--dry-run", "--no-verify", "origin", branch];
-  return run_git(repository_path, args, REMOTE_TIMEOUT_MS) !== void 0;
-}
-function decide_tree_state(branch, default_name, is_tree_clean, is_current) {
-  if (!is_tree_clean) return { is_ready: false, reason: "working tree has uncommitted changes" };
-  if (branch !== default_name) {
-    return { is_ready: false, reason: `on branch ${branch}, not ${default_name}` };
-  }
-  return is_current ? { is_ready: true } : { is_ready: false, reason: `${branch} is not up to date` };
-}
-function tree_state(repository_path) {
-  const branch = current_branch(repository_path);
-  if (branch === void 0) return { is_ready: false, reason: "not a readable git repository" };
-  const default_name = default_branch(repository_path);
-  return decide_tree_state(
-    branch,
-    default_name,
-    is_clean(repository_path),
-    is_up_to_date(repository_path, branch)
-  );
-}
-function return_to_default_branch(repository_path) {
-  const branch = default_branch(repository_path);
-  if (run_git(repository_path, ["checkout", branch]) === void 0) return false;
-  return run_git(repository_path, ["pull", "--ff-only", "origin", branch]) !== void 0;
-}
-var propagate_git = {
-  default_branch,
-  return_to_default_branch,
-  current_branch,
-  commit_ahead,
-  has_remote_branch,
-  has_pre_push_hook,
-  can_push_without_hooks,
-  is_clean,
-  decide_tree_state,
-  tree_state
-};
-
-// scripts/propagate/propagate-run.ts
-var STEP_PRECHECK = "working tree check";
-var STEP_UPGRADE = "josh vu";
-var STEP_SYNC = "josh sync";
-var STEP_LATEST = "josh latest";
-var STEP_LINT_RELATED = "related lint check";
-var STEP_TEST_RELATED = "related test check";
-var STEP_VERIFY = "verification gate";
-var STEP_ISSUE = "open issue";
-var STEP_PR = "josh git";
-var STEP_RETURN = "return to default branch";
-var STEP_ORDER = [
-  STEP_PRECHECK,
-  STEP_UPGRADE,
-  STEP_SYNC,
-  STEP_LINT_RELATED,
-  STEP_TEST_RELATED,
-  STEP_VERIFY,
-  STEP_ISSUE,
-  STEP_PR,
-  STEP_RETURN
-];
-var ADOPT_STEP_ORDER = STEP_ORDER.flatMap(
-  (step) => step === STEP_SYNC ? [step, STEP_LATEST] : step
-);
-var PROPAGATED_REASON = "opened a pull request";
-var SKIP_REASONS = {
-  up_to_date: "already carries this release",
-  not_downstream: "does not depend on this package",
-  missing_checkout: "no local checkout at the mapped path \u2014 reported, not cloned",
-  unreadable: "package.json could not be read",
-  not_selected: "not the repository --target named",
-  carried_above: "delivered by the propagation of a toolkit above this one"
-};
-function skip_reason(target) {
-  const reason = SKIP_REASONS[target.state] ?? "not eligible";
-  if (target.carriers === void 0) return reason;
-  return `${reason}: ${target.carriers.join(", ")}`;
-}
-var LEFTOVER_NOTE = "upgrade/sync changes left uncommitted";
-function has_leftover_changes(steps) {
-  return steps.some((result) => result.step === STEP_UPGRADE);
-}
-function leftover_of(result, steps) {
-  if (!has_leftover_changes(steps)) return void 0;
-  return result.leftover ?? LEFTOVER_NOTE;
-}
-function failure_reason(result, steps) {
-  const base = result.detail === void 0 ? `${result.step} failed` : `${result.step} failed: ${result.detail}`;
-  const leftover = leftover_of(result, steps);
-  return leftover === void 0 ? base : `${base} \u2014 ${leftover}`;
-}
-function terminal_result(repo, result, steps) {
-  if (!result.is_ok) {
-    return { repo, outcome: "failed", reason: failure_reason(result, steps), steps };
-  }
-  if (result.is_complete === true) {
-    return { repo, outcome: "skipped", reason: result.detail ?? "nothing to do", steps };
-  }
-  return void 0;
-}
-function run_target(target, run_step, success_reason = PROPAGATED_REASON, order = STEP_ORDER) {
-  const steps = [];
-  for (const step of order) {
-    const result = run_step(target, step);
-    steps.push(result);
-    const terminal = terminal_result(target.repo, result, steps);
-    if (terminal !== void 0) return terminal;
-  }
-  return { repo: target.repo, outcome: "propagated", reason: success_reason, steps };
-}
-function run_targets(targets, run_step, success_reason = PROPAGATED_REASON) {
-  return targets.map(
-    (target) => target.state === "ready" ? run_target(target, run_step, success_reason) : { repo: target.repo, outcome: "skipped", reason: skip_reason(target), steps: [] }
-  );
-}
-function has_failure(results) {
-  return results.some((result) => result.outcome === "failed");
-}
-var OUTCOME_ICONS = {
-  propagated: "\u2713",
-  failed: status_icons.FAIL_ICON,
-  skipped: "\u2013"
-};
-function format_result(result) {
-  return `  ${OUTCOME_ICONS[result.outcome]} ${result.repo}  ${result.reason}`;
-}
-function format_report(results) {
-  if (results.length === 0) return "No repositories were considered.";
-  return results.map((result) => format_result(result)).join("\n");
-}
-var propagate_run = {
-  PROPAGATED_REASON,
-  LEFTOVER_NOTE,
-  STEP_RETURN,
-  STEP_PRECHECK,
-  STEP_ISSUE,
-  STEP_UPGRADE,
-  STEP_SYNC,
-  STEP_LATEST,
-  STEP_LINT_RELATED,
-  STEP_TEST_RELATED,
-  STEP_VERIFY,
-  STEP_PR,
-  STEP_ORDER,
-  ADOPT_STEP_ORDER,
-  skip_reason,
-  run_target,
-  run_targets,
-  has_failure,
-  format_report
-};
-
-// scripts/propagate/propagate-steps.ts
-import { execaSync } from "execa";
-
-// scripts/propagate/propagate-git-failure.ts
-var TAIL_LINE_COUNT = 3;
-var TAIL_SEPARATOR = " / ";
-var ANSI_PATTERN = /\[[0-9;?]*[ -/]*[@-~]/gu;
-var LINE_BREAK_PATTERN = /[\r\n]/u;
-var TAIL_LABEL = "last output: ";
-var NO_COMMIT = "nothing was committed";
-var NOT_OPENED = "the branch reached origin, but the pull request was not opened";
-var HOOK_REFUSED = "but the consumer's pre-push hook refused the push";
-var PUSH_FAILED = "but the push did not reach origin";
-var NOTHING_LEFT = "nothing was left behind";
-var LEFTOVER_LABEL = "left behind: ";
-var LEFTOVER_JOIN = " and ";
-var UNCOMMITTED = "uncommitted changes";
-var NOT_PUSHED = { is_on_remote: false, is_push_hook_blocked: false };
-function push_reason(state) {
-  return state.is_push_hook_blocked ? HOOK_REFUSED : PUSH_FAILED;
-}
-function describe_failure(state) {
-  const { branch, head_commit } = state;
-  if (branch === void 0 || head_commit === void 0) return NO_COMMIT;
-  if (state.is_on_remote) return NOT_OPENED;
-  return `committed ${head_commit} on ${branch}, ${push_reason(state)}`;
-}
-function stream_tail(text) {
-  return text.replaceAll(ANSI_PATTERN, "").split(LINE_BREAK_PATTERN).map((line) => line.trim()).filter((line) => line !== "").slice(-TAIL_LINE_COUNT).join(TAIL_SEPARATOR);
-}
-function output_tail(streams) {
-  const tails = streams.map((text) => stream_tail(text)).filter((tail) => tail !== "");
-  if (tails.length === 0) return "";
-  return ` \u2014 ${TAIL_LABEL}${tails.join(TAIL_SEPARATOR)}`;
-}
-function leftover_note(state) {
-  const parts = [];
-  if (!state.is_tree_clean) parts.push(UNCOMMITTED);
-  if (state.branch !== void 0) parts.push(`the branch ${state.branch}`);
-  if (parts.length === 0) return NOTHING_LEFT;
-  return `${LEFTOVER_LABEL}${parts.join(LEFTOVER_JOIN)}`;
-}
-function feature_branch(repository_path, default_name) {
-  const branch = propagate_git.current_branch(repository_path);
-  return branch === void 0 || branch === default_name ? void 0 : branch;
-}
-function read_push_state(repository_path, branch, head_commit) {
-  if (branch === void 0 || head_commit === void 0) return NOT_PUSHED;
-  if (propagate_git.has_remote_branch(repository_path, branch)) {
-    return { is_on_remote: true, is_push_hook_blocked: false };
-  }
-  return {
-    is_on_remote: false,
-    is_push_hook_blocked: propagate_git.has_pre_push_hook(repository_path) && propagate_git.can_push_without_hooks(repository_path, branch)
-  };
-}
-function read_state(repository_path) {
-  const default_name = propagate_git.default_branch(repository_path);
-  const branch = feature_branch(repository_path, default_name);
-  const head_commit = branch === void 0 ? void 0 : propagate_git.commit_ahead(repository_path, default_name);
-  return {
-    branch,
-    head_commit,
-    is_tree_clean: propagate_git.is_clean(repository_path),
-    ...read_push_state(repository_path, branch, head_commit)
-  };
-}
-function attribute(repository_path, result, streams) {
-  const state = read_state(repository_path);
-  const detail = `${result.detail ?? "failed"} \u2014 ${describe_failure(state)}${output_tail(streams)}`;
-  return { ...result, detail, leftover: leftover_note(state) };
-}
-var propagate_git_failure = {
-  HOOK_REFUSED,
-  NOTHING_LEFT,
-  NO_COMMIT,
-  NOT_OPENED,
-  PUSH_FAILED,
-  UNCOMMITTED,
-  attribute,
-  describe_failure,
-  leftover_note,
-  output_tail,
-  read_state
-};
-
-// scripts/propagate/propagate-steps.ts
-var SUCCESS_EXIT_CODE = 0;
-var VERIFY_SCRIPT = `pnpm josh ${GATE_COMMAND}`;
-var LATEST_SCRIPT = "pnpm install --no-frozen-lockfile && pnpm josh latest";
-var STEP_COMMANDS = {
-  [propagate_run.STEP_LATEST]: ["sh", "-c", LATEST_SCRIPT],
-  [propagate_run.STEP_LINT_RELATED]: ["pnpm", "josh", "lint:related"],
-  [propagate_run.STEP_TEST_RELATED]: ["pnpm", "josh", "test:related"],
-  [propagate_run.STEP_VERIFY]: ["sh", "-c", VERIFY_SCRIPT]
-};
-var JOSH_BIN = "josh";
-function sync_command(bin_name) {
-  return ["pnpm", bin_name, "sync"];
-}
-function upgrade_command(package_name, version) {
-  const config = create_version_command_config({ package_name });
-  return build_upgrade_command(version, true, config).steps;
-}
-var PROPAGATE_ORIGIN = "Opened by `josh propagate` from the supplier repository after the release was published.";
-var RUN_NOTE = "The upgrade, the managed-file sync and the verification gate have already run here.";
-var UPGRADE_CLASSIFICATION = OTHER_CHANGE_LABEL;
-var EMPTY_PLAN_TITLE = "Upgrade the installed toolkits";
-var LAST_SEPARATOR = " and ";
-var NAME_SEPARATOR = ", ";
-function issue_title(package_name, version) {
-  return `Upgrade ${package_name} to ${version}`;
-}
-function release_names(releases) {
-  const names = releases.map((release) => release.package_name);
-  const last = names.at(-1) ?? "";
-  if (names.length <= 1) return last;
-  return `${names.slice(0, -1).join(NAME_SEPARATOR)}${LAST_SEPARATOR}${last}`;
-}
-function versioned_names(releases) {
-  const named = releases.map((release) => ({
-    ...release,
-    package_name: `${release.package_name} to ${release.version}`
-  }));
-  return `Upgrade ${release_names(named)}`;
-}
-function plan_title(releases) {
-  const [first] = releases;
-  if (first === void 0) return EMPTY_PLAN_TITLE;
-  const is_one_version = releases.every((release) => release.version === first.version);
-  return is_one_version ? issue_title(release_names(releases), first.version) : versioned_names(releases);
-}
-function plan_body(plan) {
-  const specs = plan.releases.map((release) => `\`${release.package_name}@${release.version}\``).join(NAME_SEPARATOR);
-  return [
-    `Carry ${specs} into this repository.`,
-    "",
-    plan.origin,
-    RUN_NOTE,
-    "",
-    pr_classification.declaration(UPGRADE_CLASSIFICATION)
-  ].join("\n");
-}
-function issue_body(package_name, version) {
-  return plan_body({
-    releases: [{ package_name, version, bin_name: JOSH_BIN }],
-    origin: PROPAGATE_ORIGIN
-  });
-}
-var NO_COMMAND = "no command defined";
-function captured(text = "") {
-  return text;
-}
-function step_result(step, exit_code) {
-  if (exit_code === SUCCESS_EXIT_CODE) return { step, is_ok: true };
-  return { step, is_ok: false, detail: `exit ${String(exit_code ?? "timed out")}` };
-}
-function spawn_step(target, step, command) {
-  const [executable, ...rest] = command;
-  if (executable === void 0) return { step, is_ok: false, detail: NO_COMMAND };
-  const spawned = execaSync(executable, rest, {
-    cwd: target.path,
-    reject: false,
-    stdio: "inherit",
-    timeout: SUITE_TIMEOUT_MS
-  });
-  return step_result(step, spawned.exitCode);
-}
-function spawn_captured(target, step, command) {
-  const [executable, ...rest] = command;
-  if (executable === void 0) {
-    return { result: { step, is_ok: false, detail: NO_COMMAND }, streams: [] };
-  }
-  const spawned = execaSync(executable, rest, {
-    cwd: target.path,
-    reject: false,
-    stdin: "inherit",
-    stdout: ["inherit", "pipe"],
-    stderr: ["inherit", "pipe"],
-    timeout: SUITE_TIMEOUT_MS
-  });
-  return {
-    result: step_result(step, spawned.exitCode),
-    streams: [captured(spawned.stdout), captured(spawned.stderr)]
-  };
-}
-function precheck_step(target, step) {
-  const state = propagate_git.tree_state(target.path);
-  if (state.is_ready) return { step, is_ok: true };
-  return { step, is_ok: false, detail: state.reason ?? "not ready" };
-}
-function to_issue_detail(error) {
-  const message = error_text.message_of(error);
-  return message.replaceAll("\n", " ").trim();
-}
-function create_issue(target, title, body) {
-  try {
-    const url = git_gh_exec.exec_gh_api_sync(
-      git_gh_issue_write.issue_create_request({ title, body, repo: target.repo })
-    );
-    return { url };
-  } catch (error) {
-    return { detail: to_issue_detail(error) };
-  }
-}
-function open_issue(target, package_name, version) {
-  return create_issue(target, issue_title(package_name, version), issue_body(package_name, version));
-}
-var ISSUE_NUMBER_PATTERN = /\/(?<number>\d+)\s*$/u;
-function parse_issue_number(issue_url) {
-  const { groups } = ISSUE_NUMBER_PATTERN.exec(issue_url.trim()) ?? {};
-  const { number: issue_number } = groups ?? {};
-  return issue_number;
-}
-function issue_step(target, step, plan, issue_numbers) {
-  if (propagate_git.is_clean(target.path)) {
-    return { step, is_ok: true, is_complete: true, detail: "already current \u2014 nothing to commit" };
-  }
-  const outcome = create_issue(target, plan_title(plan.releases), plan_body(plan));
-  const number = parse_issue_number(outcome.url ?? "");
-  if (number === void 0) {
-    return { step, is_ok: false, detail: outcome.detail ?? "could not open an issue" };
-  }
-  issue_numbers.set(target.repo, number);
-  return { step, is_ok: true };
-}
-function return_step(target, step) {
-  if (propagate_git.return_to_default_branch(target.path)) return { step, is_ok: true };
-  return { step, is_ok: false, detail: "left on the pull request branch" };
-}
-function pull_request_step(target, step, plan, issue_numbers) {
-  const number = issue_numbers.get(target.repo);
-  if (number === void 0) return { step, is_ok: false, detail: "no issue number" };
-  const argument = `${plan_title(plan.releases)} ${issue_cite.plain_for("github", number)}`;
-  const outcome = spawn_captured(target, step, ["pnpm", "josh", "git", "-y", argument]);
-  if (outcome.result.is_ok) return outcome.result;
-  return propagate_git_failure.attribute(target.path, outcome.result, outcome.streams);
-}
-function run_each(target, step, commands) {
-  for (const { package_name, command } of commands) {
-    const result = spawn_step(target, step, command);
-    if (!result.is_ok) return { ...result, detail: `${package_name}: ${result.detail ?? "failed"}` };
-  }
-  return { step, is_ok: true };
-}
-function upgrade_commands(plan) {
-  return plan.releases.flatMap(
-    (release) => upgrade_command(release.package_name, release.version).map((command) => ({
-      package_name: release.package_name,
-      command
-    }))
-  );
-}
-function sync_commands(plan) {
-  return plan.releases.map((release) => ({
-    package_name: release.package_name,
-    command: sync_command(release.bin_name)
-  }));
-}
-function create_step_runner(plan) {
-  const issue_numbers = /* @__PURE__ */ new Map();
-  const handlers = {
-    [propagate_run.STEP_PRECHECK]: precheck_step,
-    [propagate_run.STEP_UPGRADE]: (target, step) => run_each(target, step, upgrade_commands(plan)),
-    [propagate_run.STEP_SYNC]: (target, step) => run_each(target, step, sync_commands(plan)),
-    [propagate_run.STEP_ISSUE]: (target, step) => issue_step(target, step, plan, issue_numbers),
-    [propagate_run.STEP_PR]: (target, step) => pull_request_step(target, step, plan, issue_numbers),
-    [propagate_run.STEP_RETURN]: return_step
-  };
-  return (target, step) => {
-    console.info(`  ${target.repo}: ${step}`);
-    const handler = handlers[step];
-    if (handler !== void 0) return handler(target, step);
-    return spawn_step(target, step, STEP_COMMANDS[step] ?? []);
-  };
-}
-function describe_step(target, step) {
-  console.info(`  ${target.repo}: would run ${step}`);
-  return { step, is_ok: true };
-}
-var propagate_steps = {
-  JOSH_BIN,
-  PROPAGATE_ORIGIN,
-  sync_command,
-  upgrade_command,
-  upgrade_commands,
-  sync_commands,
-  VERIFY_SCRIPT,
-  issue_title,
-  issue_body,
-  plan_title,
-  plan_body,
-  parse_issue_number,
-  open_issue,
-  precheck_step,
-  create_step_runner,
-  describe_step
-};
-
-export {
-  propagate_git,
-  propagate_run,
-  propagate_steps
-};

package/dist/commands/chunk-6DDK5XWK.js

@@ -1,74 +0,0 @@
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-
-// scripts/lane/lane-plan-wait-event.ts
-var { EVENT_KIND } = run_event_stream;
-var START = "start";
-var END = "end";
-var TEXT = /^#(?<issue>[1-9]\d*) (?<phase>start|end) (?<holder>#[1-9]\d*)$/u;
-function text_of(pair, phase) {
-  return `${issue_cite.plain_for("program", pair.issue)} ${phase} ${issue_cite.plain_for("program", pair.holder)}`;
-}
-async function timed(pair, wait) {
-  await run_event_stream_emit.emit(EVENT_KIND.PLAN_WAIT, text_of(pair, START));
-  try {
-    return await wait();
-  } finally {
-    await run_event_stream_emit.emit(EVENT_KIND.PLAN_WAIT, text_of(pair, END));
-  }
-}
-function words_of(event) {
-  if (event.kind !== EVENT_KIND.PLAN_WAIT) return [];
-  return TEXT.exec(event.text)?.slice(1) ?? [];
-}
-function mark_of(event, issue) {
-  const [lane, phase = "", holder = ""] = words_of(event);
-  if (Number(lane) !== issue) return [];
-  return [{ at_ms: Date.parse(event.at), phase, holder }];
-}
-function pair_of(start, end) {
-  if (end.phase !== END || start?.phase !== START || start.holder !== end.holder) return [];
-  return [
-    {
-      from_ms: start.at_ms,
-      to_ms: end.at_ms,
-      name: `lane:plan wait (${end.holder})`
-    }
-  ];
-}
-function spans(events, issue) {
-  const marks = events.flatMap((event) => mark_of(event, issue)).toSorted((left, right) => left.at_ms - right.at_ms);
-  return marks.flatMap((mark, index) => pair_of(marks[index - 1], mark));
-}
-function inside_of(segment, waits) {
-  return waits.map((wait) => ({
-    ...wait,
-    from_ms: Math.max(segment.from_ms, wait.from_ms),
-    to_ms: Math.min(segment.to_ms, wait.to_ms)
-  })).filter((wait) => wait.to_ms > wait.from_ms);
-}
-function carved_one(segment, waits) {
-  const parts = [];
-  let { from_ms } = segment;
-  for (const wait of inside_of(segment, waits)) {
-    if (wait.from_ms > from_ms) parts.push({ ...segment, from_ms, to_ms: wait.from_ms });
-    parts.push({ ...segment, stage: wait.name, from_ms: wait.from_ms, to_ms: wait.to_ms });
-    from_ms = wait.to_ms;
-  }
-  return from_ms < segment.to_ms ? [...parts, { ...segment, from_ms }] : parts;
-}
-function carved(segments, waits) {
-  return segments.flatMap((segment) => carved_one(segment, waits));
-}
-var lane_plan_wait_event = { carved, spans, timed };
-
-export {
-  lane_plan_wait_event
-};