@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-MT6TRLFD.js

@@ -0,0 +1,91 @@
+import {
+  durable_state_root
+} from "./chunk-5VQCL33M.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  GIT_LOCATION_VARIABLES,
+  git_location_environment
+} from "./chunk-B77ZMVHS.js";
+import {
+  git_utilities
+} from "./chunk-B5GXZK3E.js";
+
+// scripts/git/git-common-directory.ts
+import { execFileSync } from "node:child_process";
+var { STATE_DIRECTORY } = durable_state_root;
+var OWN_GIT_DIRECTORY = 0;
+var COMMON_GIT_DIRECTORY = 1;
+var PROBE_TIMEOUT_MS = 5e3;
+var answers = /* @__PURE__ */ new Map();
+function probe_environment(cwd) {
+  if (cwd === void 0) return process.env;
+  return { ...process.env, ...git_location_environment.location_free_environment() };
+}
+function cache_key(cwd) {
+  if (cwd !== void 0) return `explicit\0${cwd}`;
+  const locations = GIT_LOCATION_VARIABLES.map((name) => process.env[name] ?? "");
+  return ["inherited", process.cwd(), ...locations].join("\0");
+}
+function read_directories(cwd) {
+  try {
+    const output = execFileSync(
+      git_utilities.get_git_command_for_spawn(),
+      [...git_command.GIT_DIRECTORY_ARGUMENTS],
+      {
+        cwd,
+        env: probe_environment(cwd),
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: PROBE_TIMEOUT_MS
+      }
+    );
+    return output.split("\n").filter((line) => line !== "");
+  } catch {
+    return [];
+  }
+}
+function directories(cwd) {
+  const key = cache_key(cwd);
+  const known = answers.get(key);
+  if (known !== void 0) return known;
+  const read = read_directories(cwd);
+  if (read.length > 0) answers.set(key, read);
+  return read;
+}
+function own(cwd) {
+  return directories(cwd)[OWN_GIT_DIRECTORY];
+}
+function repository(cwd) {
+  return directories(cwd)[COMMON_GIT_DIRECTORY];
+}
+async function read_repository() {
+  try {
+    const found = await git_command.git_directories();
+    return found[COMMON_GIT_DIRECTORY];
+  } catch {
+    return void 0;
+  }
+}
+function select_linked(found) {
+  const own_directory = found[OWN_GIT_DIRECTORY];
+  const common = found[COMMON_GIT_DIRECTORY];
+  return own_directory === void 0 || common === void 0 || own_directory === common ? void 0 : common;
+}
+function resolve(cwd) {
+  return select_linked(directories(cwd));
+}
+var git_common_directory = {
+  STATE_DIRECTORY,
+  directories,
+  own,
+  read_repository,
+  repository,
+  resolve,
+  select_linked
+};
+
+export {
+  git_common_directory
+};

package/dist/commands/chunk-MTPFNRYF.js

@@ -0,0 +1,213 @@
+import {
+  lane_state_record
+} from "./chunk-UUH3DE77.js";
+import {
+  git_directory
+} from "./chunk-3NWAGIA6.js";
+import {
+  process_owner_schema
+} from "./chunk-HLUS2M3D.js";
+import {
+  issue_number_shape,
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  durable_state_root
+} from "./chunk-5VQCL33M.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  platform_temporary,
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/test/unit-worker-share.ts
+import { availableParallelism } from "node:os";
+
+// scripts/test/unit-lane-count.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+function is_idle_lane(lanes_root, issue, environment) {
+  const common = git_directory.resolve_git_directory(path.join(lanes_root, issue));
+  if (common === void 0) return false;
+  const override = environment[platform_temporary.TEMP_ROOT_KEY];
+  const state_root = durable_state_root.state_root(override, () => common);
+  return lane_state_record.is_idle(state_root, common, issue);
+}
+function own_lane(checkout, environment) {
+  return lane_paths.lane_issue_of(lane_paths.checkout_of(path.resolve(checkout)), environment);
+}
+function live_lane_count(checkout = process.cwd(), environment = process.env) {
+  try {
+    const lanes_root = lane_paths.lanes_root_of(checkout, environment);
+    const own = own_lane(checkout, environment);
+    const issues = readdirSync(lanes_root).filter(
+      (name) => issue_number_shape.ISSUE_NUMBER_PATTERN.test(name)
+    );
+    return issues.filter((issue) => issue === own || !is_idle_lane(lanes_root, issue, environment)).length;
+  } catch {
+    return 0;
+  }
+}
+var unit_lane_count = { live_lane_count };
+
+// scripts/test/unit-run-marker.ts
+import { readdirSync as readdirSync2 } from "node:fs";
+import path2 from "node:path";
+var RUN_PREFIX = "josh-unit-running-";
+var MIN_WORKERS = 1;
+var SOLO_RUNS = 1;
+function marker_path(pid = process.pid) {
+  return stamp_file.stamp_path(RUN_PREFIX, String(pid));
+}
+function is_running(marker) {
+  return process_identity.is_same_process(marker.pid, marker.process_start) !== false;
+}
+function read_marker(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  if (raw === void 0) return void 0;
+  const parsed = process_owner_schema.safeParse(json_value.parse_or_undefined(raw));
+  return parsed.success ? parsed.data : void 0;
+}
+function marker_files(directory = PLATFORM_TEMP_ROOT) {
+  try {
+    return readdirSync2(directory).filter((name) => name.startsWith(RUN_PREFIX));
+  } catch {
+    return [];
+  }
+}
+function sweep_marker(source) {
+  try {
+    stamp_file.remove_stamp(source);
+  } catch {
+  }
+}
+function is_marker_live(source) {
+  const marker = read_marker(source);
+  if (marker === void 0) return false;
+  if (is_running(marker)) return true;
+  sweep_marker(source);
+  return false;
+}
+function live_run_count(directory = PLATFORM_TEMP_ROOT) {
+  return marker_files(directory).filter((name) => is_marker_live(path2.join(directory, name))).length;
+}
+var NESTED_KEY = "JOSH_UNIT_RUN_MARKED";
+var NESTED_VALUE = "1";
+function is_nested_run() {
+  return process.env[NESTED_KEY] === NESTED_VALUE;
+}
+function resolve_unit_workers(available_cores, runs) {
+  if (runs <= SOLO_RUNS) return void 0;
+  return Math.max(MIN_WORKERS, Math.floor(available_cores / runs));
+}
+function sharing_runs(runs, lanes) {
+  return Math.max(runs, lanes);
+}
+function mark_run_started(target) {
+  try {
+    stamp_file.write_stamp(target, process_identity.own_fields());
+  } catch {
+  }
+}
+var unit_run_marker = {
+  MIN_WORKERS,
+  NESTED_KEY,
+  NESTED_VALUE,
+  RUN_PREFIX,
+  SOLO_RUNS,
+  is_nested_run,
+  live_run_count,
+  mark_run_started,
+  marker_path,
+  read_marker,
+  resolve_unit_workers,
+  sharing_runs
+};
+
+// scripts/test/unit-worker-share.ts
+var { MIN_WORKERS: MIN_WORKERS2, NESTED_KEY: NESTED_KEY2, NESTED_VALUE: NESTED_VALUE2, SOLO_RUNS: SOLO_RUNS2 } = unit_run_marker;
+var {
+  is_nested_run: is_nested_run2,
+  live_run_count: live_run_count2,
+  mark_run_started: mark_run_started2,
+  marker_path: marker_path2,
+  resolve_unit_workers: resolve_unit_workers2,
+  sharing_runs: sharing_runs2
+} = unit_run_marker;
+var WORKER_FLAG = "--maxWorkers";
+var WORKER_FLAGS = [WORKER_FLAG, "--max-workers"];
+var MAIN_PROCESS_CORES = 1;
+function cap_to_free(workers, free_cores, available_cores) {
+  if (free_cores === void 0 || free_cores >= (workers ?? available_cores)) return workers;
+  return Math.max(MIN_WORKERS2, Math.floor(free_cores));
+}
+var UNREAD_CAPACITY = { cores: void 0, memory_workers: void 0 };
+function cap_to_capacity(workers, free, available_cores) {
+  const core_capped = cap_to_free(workers, free.cores, available_cores);
+  return cap_to_free(core_capped, free.memory_workers, available_cores);
+}
+function cap_to_claim(share, claim) {
+  if (claim === void 0) return share;
+  const bound = Math.max(MIN_WORKERS2, (claim.granted ?? claim.weight) - MAIN_PROCESS_CORES);
+  return Math.min(share ?? bound, bound);
+}
+function own_run() {
+  return is_nested_run2() ? 0 : SOLO_RUNS2;
+}
+function admitted_capacity(free, claim, live_runs, live_lanes) {
+  const is_sharing = sharing_runs2(live_runs + own_run(), live_lanes) > SOLO_RUNS2;
+  if (claim === void 0 || !is_sharing) return free;
+  return { cores: void 0, memory_workers: free.memory_workers };
+}
+function current_share(available_cores = availableParallelism(), live_runs = live_run_count2(), free = UNREAD_CAPACITY, live_lanes = SOLO_RUNS2) {
+  const share = resolve_unit_workers2(
+    available_cores,
+    sharing_runs2(live_runs + own_run(), live_lanes)
+  );
+  return cap_to_capacity(share, free, available_cores);
+}
+function is_worker_flag(argument) {
+  return WORKER_FLAGS.some((flag) => argument === flag || argument.startsWith(`${flag}=`));
+}
+function has_worker_flag(vitest_arguments) {
+  return vitest_arguments.some((argument) => is_worker_flag(argument));
+}
+function worker_arguments(vitest_arguments, share) {
+  if (share === void 0 || has_worker_flag(vitest_arguments)) return [];
+  return [`${WORKER_FLAG}=${String(share)}`];
+}
+async function with_run_marker(run) {
+  if (is_nested_run2()) return await run();
+  const target = marker_path2();
+  mark_run_started2(target);
+  process.env[NESTED_KEY2] = NESTED_VALUE2;
+  try {
+    return await run();
+  } finally {
+    process.env[NESTED_KEY2] = "";
+    stamp_file.remove_stamp(target);
+  }
+}
+var unit_worker_share = {
+  ...unit_run_marker,
+  ...unit_lane_count,
+  MAIN_PROCESS_CORES,
+  admitted_capacity,
+  cap_to_capacity,
+  cap_to_claim,
+  cap_to_free,
+  current_share,
+  has_worker_flag,
+  with_run_marker,
+  worker_arguments
+};
+
+export {
+  unit_worker_share
+};

package/dist/commands/chunk-N2EE7MMH.js

@@ -0,0 +1,305 @@
+import {
+  epic_index
+} from "./chunk-2ROVUERM.js";
+import {
+  issue_not_before
+} from "./chunk-JUXKVN77.js";
+import {
+  issue_publication_state
+} from "./chunk-5RCBXYYD.js";
+import {
+  issue_sample_prime
+} from "./chunk-FBZD6LOK.js";
+import {
+  epic_issue
+} from "./chunk-GXXWRH6F.js";
+import {
+  git_next_issues
+} from "./chunk-ERAABGU7.js";
+import {
+  cutoff_cause,
+  cutoff_of
+} from "./chunk-SK3GDQOI.js";
+import {
+  epic_graph
+} from "./chunk-3RIQ36LH.js";
+import {
+  SUMMARY_FIELDS,
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  gh_author_association
+} from "./chunk-DM6I4PYD.js";
+import {
+  open_issue_schema
+} from "./chunk-34DND4BA.js";
+import {
+  AUTO_OK_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  read_json_listing
+} from "./chunk-NAZ753DE.js";
+
+// scripts/auto-ok/auto-ok-author.ts
+function shared_author_of(row) {
+  return { ...gh_author_association.author_of(row), is_shared: true };
+}
+async function with_trust(issue) {
+  const author = shared_author_of(issue);
+  return { ...issue, author_trusted: await gh_author_association.is_trusted(author) };
+}
+async function with_author_trust(issues) {
+  return await Promise.all(issues.map(async (issue) => await with_trust(issue)));
+}
+function is_author_trusted(issue) {
+  return issue.author_trusted === true;
+}
+async function is_child_trusted(child, repo) {
+  const author = shared_author_of(child);
+  return await gh_author_association.is_trusted(
+    child.repo === repo ? author : { ...author, login: void 0 }
+  );
+}
+async function untrusted_child_keys(children, repo) {
+  const open = children.filter((child) => child.state === "OPEN");
+  const trusted = await Promise.all(open.map(async (child) => await is_child_trusted(child, repo)));
+  const untrusted = open.filter((_, index) => trusted[index] !== true);
+  return new Set(untrusted.map((child) => epic_graph.key_of(child)));
+}
+var auto_ok_author = { is_author_trusted, untrusted_child_keys, with_author_trust };
+
+// scripts/epic/epic-bundle-gaps.ts
+function backlog_gap(cutoff, limit) {
+  const cause = cutoff_cause(cutoff, `hit its ${String(limit)}-issue cap`);
+  if (cause === void 0) return void 0;
+  return `\u26A0 The backlog listing ${cause}; older issues were not considered.`;
+}
+function epic_gap(cutoff, limit) {
+  const cause = cutoff_cause(cutoff, `hit its ${String(limit)}-epic cap`);
+  if (cause === void 0) return void 0;
+  return `\u26A0 The epic listing ${cause}; an epic past it was not considered.`;
+}
+function is_membership_established(cutoff = "none") {
+  return cutoff === "none";
+}
+var UNCONFIRMED_MEMBERSHIP_LINE = "Could not confirm which epic already tracks these \u2014 do not place this issue in one.";
+var UNCONFIRMED_MEMBERSHIP_REASON = "the epics were not read in full, so an epic already tracking one of these may never have been seen";
+function unconfirmed_membership(related) {
+  return [
+    UNCONFIRMED_MEMBERSHIP_LINE,
+    `  ${UNCONFIRMED_MEMBERSHIP_REASON}`,
+    `  Related: ${related}`
+  ];
+}
+var epic_bundle_gaps = {
+  backlog_gap,
+  epic_gap,
+  is_membership_established,
+  UNCONFIRMED_MEMBERSHIP_LINE,
+  unconfirmed_membership
+};
+
+// scripts/auto-ok/auto-ok-cli.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var EXCLUDE_FLAG = "--exclude";
+var EXCLUDE_SEPARATOR = ",";
+var EXCLUDE_PAIR_SIZE = 2;
+var USAGE = `Usage: josh auto-ok:next [${EXCLUDE_FLAG} <issue-number>[,<issue-number>...]]...`;
+var NONE_TOKEN = "none";
+var LISTING_LIMIT = 200;
+var UNREADABLE_MESSAGE = `Could not read the \`${AUTO_OK_LABEL}\` listing. That is not "nothing is opted in" \u2014 check \`gh auth status\` and ask again.`;
+var UNEXPECTED_SHAPE_MESSAGE = `Read the \`${AUTO_OK_LABEL}\` listing but could not parse it. That is not "nothing is opted in" \u2014 the rows came back in a shape this command does not recognize, so check the fields it asks for and the REST field mapping in \`scripts/gh/git-gh-issue-rest.ts\` rather than your authentication.`;
+var BLOCKERS_UNREADABLE_MESSAGE = `Could not read the \`${AUTO_OK_LABEL}\` listing, though the same listing reads once the blocker relations are dropped from it \u2014 so it is reading the relations that failed, not your authentication. That is one \`dependencies/blocked_by\` request per opted-in issue declaring a blocker: either this GitHub host does not serve issue dependencies, or those requests are being rate limited. Ask again, and check the host if it persists.`;
+var TRUNCATED_BY_LIMIT = `hit the ${String(LISTING_LIMIT)}-issue cap`;
+var TRUNCATED_WITH_ANSWER = "; the answer below is opted in, but it may not be the highest-priority one.";
+var TRUNCATED_WITHOUT_ANSWER = ", and every issue in it was excluded \u2014 an opted-in issue older than the cut may still be runnable.";
+function truncated_cause(cutoff) {
+  return cutoff_cause(cutoff, TRUNCATED_BY_LIMIT);
+}
+var NONE_OPTED_IN_MESSAGE = `No open issue carries \`${AUTO_OK_LABEL}\`.`;
+var EPICS_UNREADABLE_MESSAGE = `Could not read the epic listing, so which issues an epic already tracks is unknown. That is not "no epic tracks anything" \u2014 an opted-in child would be handed back outside its epic's order, so no answer is given. Check \`gh auth status\` and ask again.`;
+var CLOSED_STATE = "CLOSED";
+var NO_CUTOFF = "none";
+function parse_issue_number(value) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) return void 0;
+  return parsed;
+}
+function parse_exclude(value) {
+  if (value === void 0) return void 0;
+  const parsed = value.split(EXCLUDE_SEPARATOR).map((entry) => parse_issue_number(entry.trim()));
+  return parsed.every((entry) => entry !== void 0) ? parsed : void 0;
+}
+function parse_pair(argv, index) {
+  if (argv[index] !== EXCLUDE_FLAG) return void 0;
+  return parse_exclude(argv[index + 1]);
+}
+function parse_options(argv, usage = USAGE) {
+  const exclude = [];
+  for (let index = 0; index < argv.length; index += EXCLUDE_PAIR_SIZE) {
+    const parsed = parse_pair(argv, index);
+    if (parsed === void 0) return { usage };
+    exclude.push(...parsed);
+  }
+  return exclude.length === 0 ? {} : { exclude };
+}
+function parse_listing(raw, is_capped) {
+  const read = read_json_listing(raw, open_issue_schema);
+  if (read.kind !== "read") return { kind: read.kind };
+  return {
+    kind: "read",
+    issues: read.rows,
+    cutoff: cutoff_of(read.rows.length, LISTING_LIMIT, is_capped)
+  };
+}
+async function reads_without_blocked_by() {
+  const probe = await git_gh_command.issue_list_by_label_summary(AUTO_OK_LABEL, LISTING_LIMIT, {
+    json_fields: SUMMARY_FIELDS
+  });
+  return probe.json !== void 0;
+}
+async function classify_failed_read() {
+  if (!await reads_without_blocked_by()) return { kind: "unreadable" };
+  const retry = await git_gh_command.issue_list_by_label_summary(AUTO_OK_LABEL, LISTING_LIMIT);
+  return retry.json === void 0 ? { kind: "blockers_unreadable" } : parse_listing(retry.json, retry.is_capped);
+}
+async function fetch_opted_in() {
+  const { json, is_capped, is_unchanged } = await git_gh_command.issue_list_by_label_summary(
+    AUTO_OK_LABEL,
+    LISTING_LIMIT
+  );
+  const read = json === void 0 ? await classify_failed_read() : parse_listing(json, is_capped);
+  if (read.kind !== "read") return read;
+  const issues = await auto_ok_author.with_author_trust(read.issues);
+  await issue_sample_prime.prime(issues.map((issue) => issue.body));
+  return { ...read, issues, is_unchanged: is_unchanged === true };
+}
+function is_page_complete(blocked_by) {
+  const nodes = blocked_by?.nodes ?? [];
+  return (blocked_by?.totalCount ?? nodes.length) <= nodes.length;
+}
+function is_closed(blocker) {
+  return epic_issue.normalize_state(blocker.state ?? "") === CLOSED_STATE;
+}
+function is_unblocked(issue) {
+  if (!is_page_complete(issue.blockedBy)) return false;
+  return (issue.blockedBy?.nodes ?? []).every((blocker) => is_closed(blocker));
+}
+async function read_open_epics() {
+  try {
+    return await epic_index.fetch_epics(LISTING_LIMIT);
+  } catch {
+    return void 0;
+  }
+}
+async function fetch_tracking(count) {
+  if (count === 0) return { kind: "read", index: /* @__PURE__ */ new Map(), cutoff: NO_CUTOFF };
+  const open_epics = await read_open_epics();
+  if (open_epics === void 0) return { kind: "epics_unreadable" };
+  return {
+    kind: "read",
+    index: epic_index.build_tracking_index(open_epics.epics),
+    cutoff: open_epics.cutoff
+  };
+}
+function is_ready(issue, options) {
+  return !issue_publication_state.is_pending(issue.body) && auto_ok_author.is_author_trusted(issue) && is_unblocked(issue) && issue_not_before.is_due(issue.body, options.now ?? Date.now());
+}
+function is_runnable(issue, tracked, exclude, options = {}) {
+  if (tracked.has(issue.number)) return false;
+  return !exclude.includes(issue.number) && is_ready(issue, options);
+}
+function pick_next(issues, tracked = /* @__PURE__ */ new Map(), exclude = [], options = {}) {
+  return git_next_issues.order(issues).find((issue) => is_runnable(issue, tracked, exclude, options));
+}
+function none_reason(count) {
+  if (count === 0) return NONE_OPTED_IN_MESSAGE;
+  return `All ${String(count)} open \`${AUTO_OK_LABEL}\` issue(s) are excluded \u2014 tracked by an opted-in epic, an epic itself, already in progress, parked, filed by an author without write access (waiting on a person), blocked by an open issue, not due until its start time, or the one just merged.`;
+}
+function truncation_note(cutoff, has_answer) {
+  const cause = truncated_cause(cutoff);
+  if (cause === void 0) return void 0;
+  const tail = has_answer ? TRUNCATED_WITH_ANSWER : TRUNCATED_WITHOUT_ANSWER;
+  return `\u26A0 The listing ${cause}, so the oldest \`${AUTO_OK_LABEL}\` issues are not in it${tail}`;
+}
+function warn_gaps(context, has_answer) {
+  const note = truncation_note(context.cutoff, has_answer);
+  if (note !== void 0) console.error(note);
+  const epic_note = epic_bundle_gaps.epic_gap(context.epic_cutoff, LISTING_LIMIT);
+  if (epic_note !== void 0) console.error(epic_note);
+}
+function report(context) {
+  const { issues } = context;
+  const next = pick_next(issues, context.tracked, context.exclude, context);
+  warn_gaps(context, next !== void 0);
+  if (next === void 0) {
+    console.error(none_reason(issues.length));
+    console.info(NONE_TOKEN);
+    return SUCCESS_EXIT_CODE;
+  }
+  console.error(session_cite.issue(next.number, next.title));
+  console.info(String(next.number));
+  return SUCCESS_EXIT_CODE;
+}
+async function answer(read, exclude) {
+  const tracking = await fetch_tracking(read.issues.length);
+  if (tracking.kind !== "read") {
+    console.error(EPICS_UNREADABLE_MESSAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return report({
+    issues: read.issues,
+    cutoff: read.cutoff,
+    tracked: epic_index.withheld_children(tracking.index, read.issues),
+    epic_cutoff: tracking.cutoff,
+    exclude
+  });
+}
+var READ_FAILURE_MESSAGES = {
+  unreadable: UNREADABLE_MESSAGE,
+  unexpected_shape: UNEXPECTED_SHAPE_MESSAGE,
+  blockers_unreadable: BLOCKERS_UNREADABLE_MESSAGE
+};
+async function run(argv) {
+  const options = parse_options(argv);
+  if (options.usage !== void 0) {
+    console.error(options.usage);
+    return FAILURE_EXIT_CODE;
+  }
+  const read = await fetch_opted_in();
+  if (read.kind !== "read") {
+    console.error(READ_FAILURE_MESSAGES[read.kind]);
+    return FAILURE_EXIT_CODE;
+  }
+  return await answer(read, options.exclude);
+}
+var auto_ok_cli = {
+  USAGE,
+  NONE_TOKEN,
+  LISTING_LIMIT,
+  UNREADABLE_MESSAGE,
+  UNEXPECTED_SHAPE_MESSAGE,
+  BLOCKERS_UNREADABLE_MESSAGE,
+  EPICS_UNREADABLE_MESSAGE,
+  TRUNCATED_WITH_ANSWER,
+  TRUNCATED_WITHOUT_ANSWER,
+  NONE_OPTED_IN_MESSAGE,
+  truncated_cause,
+  parse_options,
+  fetch_opted_in,
+  fetch_tracking,
+  is_runnable,
+  pick_next,
+  truncation_note,
+  run
+};
+
+export {
+  auto_ok_author,
+  epic_bundle_gaps,
+  auto_ok_cli
+};