@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-XZQHP4JR.js

@@ -0,0 +1,145 @@
+import {
+  run_step_section_table
+} from "./chunk-KMVJKK43.js";
+import {
+  entry_read_set
+} from "./chunk-45RCSJGE.js";
+import {
+  document_section
+} from "./chunk-NDWZTWXV.js";
+
+// scripts/document/read-set-trim.ts
+function subtract(left, right) {
+  return { bytes: left.bytes - right.bytes, tokens: left.tokens - right.tokens };
+}
+function skill_text(root) {
+  const path = entry_read_set.document_path(root, entry_read_set.SKILL_FILE);
+  return document_section.read_optional(path) ?? "";
+}
+function section_cost(text, heading) {
+  return entry_read_set.cost_of(document_section.section(text, heading)?.text ?? "");
+}
+function unused_skill_cost(root, sections) {
+  const text = skill_text(root);
+  return entry_read_set.total(sections.map((heading) => section_cost(text, heading)));
+}
+function reduce_skill(file, saving) {
+  if (file.file !== entry_read_set.SKILL_FILE) return file;
+  return { file: file.file, cost: subtract(file.cost, saving) };
+}
+var HEADING_JOINER = '" + "';
+function printed_cost(root, row, printed) {
+  const printed_headings = printed.filter((one) => one.file === row.file).map((one) => one.heading);
+  if (printed_headings.length === 0) return row;
+  const named = row.heading === "" ? [] : row.heading.split(HEADING_JOINER);
+  const headings = [.../* @__PURE__ */ new Set([...named, ...printed_headings])];
+  const text = document_section.read_optional(entry_read_set.document_path(root, row.file)) ?? "";
+  return {
+    file: row.file,
+    heading: headings.join(HEADING_JOINER),
+    cost: entry_read_set.total(headings.map((heading) => section_cost(text, heading))),
+    is_resolved: headings.every((heading) => document_section.section(text, heading) !== void 0)
+  };
+}
+function point_of_use_rows(root, base, spec) {
+  return base.point_of_use.filter((one) => !spec.skipped_point_of_use.has(one.file)).map((one) => printed_cost(root, one, spec.printed_sections ?? []));
+}
+function costed(root, spec) {
+  const base = entry_read_set.costed(root, spec.base_entry, spec.reached_point_of_use);
+  const saving = unused_skill_cost(root, spec.unused_skill_sections);
+  return {
+    ...base,
+    entry: spec.label,
+    files: base.files.map((file) => reduce_skill(file, saving)),
+    point_of_use: point_of_use_rows(root, base, spec),
+    whole: subtract(base.whole, saving),
+    scoped: subtract(base.scoped, saving)
+  };
+}
+var read_set_trim = { costed };
+
+// scripts/document/lane-child-read-set.ts
+var LANE_CHILD = "lane-child";
+var SKIPPED_POINT_OF_USE = /* @__PURE__ */ new Set([
+  "backlogrun-child.md",
+  "backlogrun-lanes.md",
+  "backlogrun-progress.md",
+  "backlogrun-steps.md",
+  "delegation.md",
+  "issue-scout.md",
+  "latest-gate.md",
+  "progress-watcher.md",
+  "retrospective.md"
+]);
+var REACHED_POINT_OF_USE = /* @__PURE__ */ new Set(["backlogrun-park.md", "pre-gate-cut.md"]);
+function printed_sections() {
+  const rows = [
+    run_step_section_table.CUT,
+    run_step_section_table.RESUME,
+    run_step_section_table.ENTRY
+  ].map((key) => run_step_section_table.GOVERNING_SECTIONS.get(key));
+  return rows.filter((found) => found !== void 0).map((found) => ({ file: found.document, heading: found.heading }));
+}
+function costed2(root) {
+  return read_set_trim.costed(root, {
+    base_entry: LANE_CHILD,
+    label: LANE_CHILD,
+    unused_skill_sections: [],
+    skipped_point_of_use: SKIPPED_POINT_OF_USE,
+    reached_point_of_use: REACHED_POINT_OF_USE,
+    printed_sections: printed_sections()
+  });
+}
+var lane_child_read_set = {
+  LANE_CHILD,
+  REACHED_POINT_OF_USE,
+  SKIPPED_POINT_OF_USE,
+  costed: costed2
+};
+
+// scripts/document/backlogrun-parent-read-set.ts
+var BACKLOGRUN = "backlogrun";
+var UNUSED_SKILL_SECTIONS = [
+  "3. What stays resident, and what is read from here"
+];
+var SKIPPED_POINT_OF_USE2 = /* @__PURE__ */ new Set([
+  "background-commands.md",
+  "chain-rule.md",
+  "fullrun.md"
+]);
+var PARENT_STEP_KEYS = [
+  "backlog:next",
+  "run:merge",
+  "run:carry",
+  run_step_section_table.PROGRESS,
+  run_step_section_table.RETROSPECTIVE
+];
+function printed_sections2() {
+  return PARENT_STEP_KEYS.map((key) => run_step_section_table.GOVERNING_SECTIONS.get(key)).filter((found) => found !== void 0).map((found) => ({ file: found.document, heading: found.heading }));
+}
+var REACHED_POINT_OF_USE2 = /* @__PURE__ */ new Set([
+  "retrospective.md",
+  "backlogrun-recovery.md"
+]);
+function costed3(root) {
+  return read_set_trim.costed(root, {
+    base_entry: BACKLOGRUN,
+    label: BACKLOGRUN,
+    unused_skill_sections: UNUSED_SKILL_SECTIONS,
+    skipped_point_of_use: SKIPPED_POINT_OF_USE2,
+    reached_point_of_use: REACHED_POINT_OF_USE2,
+    printed_sections: printed_sections2()
+  });
+}
+var backlogrun_parent_read_set = {
+  BACKLOGRUN,
+  REACHED_POINT_OF_USE: REACHED_POINT_OF_USE2,
+  UNUSED_SKILL_SECTIONS,
+  costed: costed3,
+  printed_sections: printed_sections2
+};
+
+export {
+  lane_child_read_set,
+  backlogrun_parent_read_set
+};

package/dist/commands/chunk-YDVFQL3G.js

@@ -0,0 +1,23 @@
+import {
+  split_assess
+} from "./chunk-OYGNL5RO.js";
+
+// scripts/issue/issue-fold.ts
+var FOLD = "fold";
+var SEPARATE = "separate";
+var NO_FOLD_NEEDED = "no-fold-needed";
+var UNDETERMINED = "undetermined";
+var MIN_CANDIDATES = 2;
+function separable_verdict(size_verdict) {
+  if (size_verdict === void 0) return UNDETERMINED;
+  return size_verdict === split_assess.SPLIT_VERDICT ? SEPARATE : FOLD;
+}
+function fold_verdict(candidate_count, is_separable, size_verdict) {
+  if (candidate_count < MIN_CANDIDATES) return NO_FOLD_NEEDED;
+  return is_separable ? separable_verdict(size_verdict) : FOLD;
+}
+var issue_fold = { FOLD, SEPARATE, NO_FOLD_NEEDED, UNDETERMINED, MIN_CANDIDATES, fold_verdict };
+
+export {
+  issue_fold
+};

package/dist/commands/chunk-YFD46GB2.js

@@ -0,0 +1,45 @@
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  issue_label_schema
+} from "./chunk-34DND4BA.js";
+import {
+  IN_PROGRESS_LABEL,
+  label_name_of
+} from "./chunk-QQBMVC5W.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+
+// scripts/followup/git-followup-label.ts
+import { z } from "zod";
+var labels_read_schema = z.object({ labels: z.array(issue_label_schema).optional() });
+function unreadable_error(issue_number) {
+  return new Error(
+    `gh api answered no readable labels for issue ${session_cite.issue(issue_number)}`
+  );
+}
+async function read_label_names(issue_number) {
+  const raw = await git_gh_command.issue_get_labels_and_body(issue_number);
+  if (raw === void 0) throw unreadable_error(issue_number);
+  const parsed = parse_json_object_or_undefined(raw, labels_read_schema);
+  if (parsed === void 0) throw unreadable_error(issue_number);
+  return (parsed.labels ?? []).map((label) => label.name);
+}
+async function strip_in_progress(issue_number) {
+  if (issue_number === void 0) return;
+  const stored = label_name_of(await read_label_names(issue_number), IN_PROGRESS_LABEL);
+  if (stored === void 0) return;
+  await git_gh_command.issue_remove_label(issue_number, stored);
+}
+var git_followup_label = {
+  strip_in_progress
+};
+
+export {
+  git_followup_label
+};

package/dist/commands/chunk-YJMOFRL7.js

@@ -0,0 +1,269 @@
+import {
+  lane_plan_wait,
+  lane_plan_wait_until
+} from "./chunk-G4UVY3TO.js";
+import {
+  lane_plan_probe,
+  lane_plan_size
+} from "./chunk-NV6Y4U37.js";
+import {
+  trusted_measure
+} from "./chunk-NWMY2QJJ.js";
+import {
+  run_hold_cli
+} from "./chunk-IQMMYORJ.js";
+import {
+  backlog_plan_comment
+} from "./chunk-IC5XLIE2.js";
+import {
+  auto_ok_cli
+} from "./chunk-N2EE7MMH.js";
+import {
+  measure_declaration
+} from "./chunk-2GJ3WJVT.js";
+import {
+  lane_plan_wait_event
+} from "./chunk-54ZLBLLE.js";
+import {
+  lane_yield
+} from "./chunk-SIPHEZXP.js";
+import {
+  backlog_overlap,
+  lane_plan
+} from "./chunk-JUQN3OXG.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  line_budget
+} from "./chunk-QFIKPGMC.js";
+
+// scripts/lane/lane-plan-check.ts
+import path from "node:path";
+
+// scripts/lane/lane-plan-premise.ts
+function listed_premises(issue, issues) {
+  const listed = issues?.find((candidate) => candidate.number === issue);
+  return listed === void 0 ? void 0 : measure_declaration.premises(listed.body ?? "").length;
+}
+function measured(declaration, run) {
+  if (run.kind === "failed") return { holds: false, value: `failed (${run.message})` };
+  const verdict = measure_declaration.judge(declaration, run.output);
+  const value = "value" in verdict ? String(verdict.value) : verdict.kind;
+  return { holds: verdict.kind === "pass", value };
+}
+function checked(declaration, source) {
+  const result = measured(declaration, trusted_measure.run_command(declaration.command, source));
+  const line = `${measure_declaration.format(declaration)} measured ${result.value}`;
+  console.error(`premise: ${line}`);
+  return result.holds ? void 0 : line;
+}
+async function failed_premises(issue, issues) {
+  const listed = listed_premises(issue, issues);
+  if (listed === 0) return [];
+  const read = await trusted_measure.read_trusted_body(String(issue));
+  if (read.kind === "refused") return listed === void 0 ? [] : [`not re-run: ${read.reason}`];
+  return measure_declaration.premises(read.body).flatMap((declaration) => checked(declaration, read) ?? []);
+}
+async function stop_text(issue, issues) {
+  const failed = await failed_premises(issue, issues);
+  if (failed.length === 0) return void 0;
+  return `premise: ${session_cite.issue(issue)}'s premises do not hold (${failed.join("; ")}), so the lane stops before implementing: park it with these values (backlogrun-park.md \u2192 "park and continue").`;
+}
+var lane_plan_premise = { stop_text };
+
+// scripts/lane/lane-plan-check.ts
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var YIELD_EXIT_CODE = 2;
+var SPLIT_EXIT_CODE = 3;
+var PREMISE_EXIT_CODE = 4;
+var RELEASE_FLAG = "--release";
+var NEAR_CAP_HEADROOM = 20;
+function plan_of(argv, now) {
+  const [issue = "", ...paths] = argv;
+  const claims = [...backlog_overlap.path_claims(paths)];
+  if (!issue_number_shape.is_issue_number(issue) || claims.length === 0) return void 0;
+  return { issue: Number(issue), paths: claims, planned_at: now.toISOString() };
+}
+async function give_back(plan, clash, directory, at) {
+  const overlap = lane_plan_probe.overlap_text(plan.issue, clash);
+  lane_plan.record({ ...plan, yielded: true, waits_until: void 0 }, directory);
+  await lane_yield.record_yield(plan.issue, overlap, at);
+  await run_hold_cli.run([RELEASE_FLAG, String(plan.issue)]);
+  console.error(
+    `${overlap}, so it gives its lane back: end the session now, with no edit \u2014 \`run:merge\` closes the lane, and the issue is offered again once that lane ends.`
+  );
+  console.info("yield");
+  return YIELD_EXIT_CODE;
+}
+function clear_answer() {
+  console.info("clear");
+  return SUCCESS_EXIT_CODE;
+}
+function clear(plan, directory) {
+  lane_plan_probe.record_cleared(plan, directory);
+  return clear_answer();
+}
+function unread() {
+  console.error(auto_ok_cli.UNREADABLE_MESSAGE);
+  console.info("wait");
+  return FAILURE_EXIT_CODE;
+}
+function split(plan, over) {
+  console.error(lane_plan_size.refusal_text(plan.issue, over));
+  console.info("split");
+  return SPLIT_EXIT_CODE;
+}
+async function note(plan, over) {
+  const files = plan.paths.filter((file) => !test_declared_logic.is_test_file(file)).length;
+  const lines = over.reason === "lines" ? over.measured : 0;
+  await lane_ledger_write.record_split_notice({
+    issue: plan.issue,
+    files,
+    lines,
+    reason: over.reason
+  });
+}
+function is_dispatched(plan) {
+  return lane_child_marker.marked_issue() === String(plan.issue);
+}
+function is_split(plan, over) {
+  return over !== void 0 && !is_dispatched(plan) && !lane_plan_size.is_waived(plan, over);
+}
+function is_repeat(plan, directory) {
+  return is_dispatched(plan) && lane_plan.read(plan.issue, directory) !== void 0;
+}
+async function refusal(plan, over, directory) {
+  if (over === void 0 || is_repeat(plan, directory)) return void 0;
+  if (!is_dispatched(plan)) await note(plan, over);
+  if (is_split(plan, over)) return split(plan, over);
+  console.error(lane_plan_size.waiver_text(plan.issue, over));
+  return void 0;
+}
+async function warn_near_cap(plan, directory) {
+  const paths = plan.paths.map((file) => path.resolve(directory, file));
+  const budgets = await line_budget.budgets_for(paths, directory);
+  for (const { file_path, budget } of budgets) {
+    if (budget === void 0 || budget.headroom > NEAR_CAP_HEADROOM) continue;
+    console.error(
+      `near cap: ${path.relative(directory, file_path)} (${String(budget.headroom)} lines left)`
+    );
+  }
+}
+function sized_of(plan, issues) {
+  const is_judged = issues !== void 0 && lane_plan_size.declares(plan.issue, issues);
+  return is_judged ? { ...plan, sized: true } : plan;
+}
+function held(plan, clash, until) {
+  console.error(
+    `${lane_plan_probe.overlap_text(plan.issue, clash)}; this lane was dispatched first and holds commits, so it keeps its seat until ${until}: run this \`lane:plan\` again now \u2014 it waits inside, and answers \`clear\` once that lane ends, or \`yield\` past the deadline.`
+  );
+  console.info("wait");
+  return FAILURE_EXIT_CODE;
+}
+async function is_free(plan, directory) {
+  const issues = await lane_plan_probe.opted_in();
+  const running = issues === void 0 ? void 0 : lane_plan_probe.running_of(issues);
+  return running !== void 0 && lane_plan_probe.clash_among(plan, running, directory) === void 0;
+}
+async function settle(plan, clash, directory) {
+  const until = await lane_plan_wait_until.until(plan, clash.holder);
+  if (until === void 0) return await give_back(plan, clash, directory, "summary");
+  const waiting = { ...plan, waits_until: until };
+  lane_plan.record(waiting, directory);
+  const until_ms = Date.parse(until);
+  const end = await lane_plan_wait_event.timed(
+    { issue: plan.issue, holder: clash.holder },
+    async () => await lane_plan_wait.hold(until_ms, async () => await is_free(waiting, directory))
+  );
+  if (end === "free") return clear(waiting, directory);
+  return end === "expired" ? await give_back(waiting, clash, directory, "summary") : held(waiting, clash, until);
+}
+async function premise_stop(plan, issues, directory) {
+  if (lane_plan.read(plan.issue, directory) !== void 0) return void 0;
+  const stop = await lane_plan_premise.stop_text(plan.issue, issues);
+  if (stop === void 0) return void 0;
+  console.error(stop);
+  console.info("premise");
+  return PREMISE_EXIT_CODE;
+}
+async function check_plan(plan, directory) {
+  await warn_near_cap(plan, directory);
+  const issues = await lane_plan_probe.opted_in();
+  const refused = await refusal(plan, await lane_plan_probe.oversize_of(plan, issues, directory), directory) ?? await premise_stop(plan, issues, directory);
+  if (refused !== void 0) return refused;
+  const sized = sized_of(plan, issues);
+  lane_plan.record(sized, directory);
+  const found = lane_plan_probe.probe(sized, issues, directory);
+  if (lane_plan_probe.is_unread(found)) return unread();
+  return found === void 0 ? clear(sized, directory) : await settle(sized, found, directory);
+}
+async function probe_answer(plan, directory) {
+  const issues = await lane_plan_probe.opted_in();
+  const over = await lane_plan_probe.oversize_of(plan, issues, directory);
+  if (is_split(plan, over)) return split(plan, over);
+  const found = lane_plan_probe.probe(plan, issues, directory);
+  if (lane_plan_probe.is_unread(found)) return unread();
+  if (found === void 0) return clear_answer();
+  console.error(`${lane_plan_probe.overlap_text(plan.issue, found)}.`);
+  console.info("yield");
+  return YIELD_EXIT_CODE;
+}
+function placed(plan, directory) {
+  const recorded = lane_plan.read(plan.issue, directory);
+  if (recorded === void 0) return plan;
+  return {
+    ...plan,
+    size_approval: recorded.size_approval,
+    single: plan.single ?? recorded.single,
+    planned_at: recorded.planned_at,
+    yielded: recorded.yielded,
+    waits_until: recorded.waits_until,
+    sized: lane_plan.is_sized(recorded)
+  };
+}
+async function entry_plan(issue, issues, directory) {
+  const own = issues.filter((candidate) => candidate.number === issue);
+  const declared = await backlog_plan_comment.declared_of(own, directory);
+  const plan = plan_of([String(issue), ...declared.get(issue) ?? []], /* @__PURE__ */ new Date());
+  return plan === void 0 ? void 0 : placed(plan, directory);
+}
+async function entry_yield(issue, issues, directory) {
+  const plan = await entry_plan(issue, issues, directory);
+  const running = lane_plan_probe.running_of(issues);
+  const found = plan === void 0 ? void 0 : lane_plan_probe.clash_among(plan, running, directory);
+  if (plan === void 0 || found === void 0) return false;
+  await give_back(plan, found, directory, "entry");
+  return true;
+}
+async function yield_at_entry(issue, directory = process.cwd()) {
+  const issues = await lane_plan_probe.opted_in();
+  return issues === void 0 ? false : await entry_yield(issue, issues, directory);
+}
+var lane_plan_check = {
+  PREMISE_EXIT_CODE,
+  SPLIT_EXIT_CODE,
+  YIELD_EXIT_CODE,
+  check_plan,
+  placed,
+  plan_of,
+  probe_answer,
+  yield_at_entry
+};
+
+export {
+  lane_plan_check
+};

package/dist/commands/chunk-YPCMBQYP.js

@@ -0,0 +1,88 @@
+import {
+  with_page_size
+} from "./chunk-FZYFGHRY.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.js";
+import {
+  GH_API_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/propagate/propagate-publish.ts
+var VERSIONS_PAGE_SIZE = 100;
+var NAMES_JQ = "[.[] | .name]";
+var DEFAULT_TIMEOUT_MS = 6e5;
+var DEFAULT_INTERVAL_MS = 15e3;
+var UNREADABLE_THRESHOLD = 3;
+function is_version_published(published_versions, target_version) {
+  return published_versions.includes(target_version);
+}
+function should_keep_waiting(now_ms, deadline_ms) {
+  return now_ms < deadline_ms;
+}
+function finish(state, version, attempts) {
+  return { state, version, attempts };
+}
+function fetch_published_versions(versions_endpoint) {
+  const endpoint = with_page_size(versions_endpoint, VERSIONS_PAGE_SIZE);
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: endpoint,
+    jq_filter: NAMES_JQ,
+    timeout_ms: GH_API_TIMEOUT_MS
+  });
+  if (stdout === void 0) return void 0;
+  return json_value.parse_array(stdout)?.filter((name) => typeof name === "string");
+}
+var WAIT_DEFAULTS = {
+  timeout_ms: DEFAULT_TIMEOUT_MS,
+  interval_ms: DEFAULT_INTERVAL_MS,
+  fetch_versions: fetch_published_versions,
+  sleep: poll.sleep,
+  now: Date.now
+};
+function resolve_wait_options(options) {
+  return { ...WAIT_DEFAULTS, ...options };
+}
+function probe_state(versions, target_version, consecutive_failures) {
+  if (versions === void 0) {
+    return consecutive_failures >= UNREADABLE_THRESHOLD ? "unreadable" : void 0;
+  }
+  return is_version_published(versions, target_version) ? "published" : void 0;
+}
+function probe_once(resolved, versions_endpoint, target_version, progress) {
+  progress.attempts += 1;
+  const versions = resolved.fetch_versions(versions_endpoint);
+  progress.failures = versions === void 0 ? progress.failures + 1 : 0;
+  const state = probe_state(versions, target_version, progress.failures);
+  return state === void 0 ? {} : { state };
+}
+async function wait_for_publish(versions_endpoint, target_version, options = {}) {
+  const resolved = resolve_wait_options(options);
+  const deadline = resolved.now() + resolved.timeout_ms;
+  const progress = { attempts: 0, failures: 0 };
+  const state = await poll.wait_for(
+    () => {
+      if (!should_keep_waiting(resolved.now(), deadline)) return "timed_out";
+      return probe_once(resolved, versions_endpoint, target_version, progress).state;
+    },
+    { interval_ms: resolved.interval_ms, sleeper: resolved.sleep }
+  );
+  return finish(state, target_version, progress.attempts);
+}
+var propagate_publish = {
+  UNREADABLE_THRESHOLD,
+  is_version_published,
+  should_keep_waiting,
+  fetch_published_versions,
+  wait_for_publish
+};
+
+export {
+  propagate_publish
+};

package/dist/commands/chunk-YR5RS4YT.js

@@ -0,0 +1,38 @@
+import {
+  lane_await
+} from "./chunk-YSDBY2G7.js";
+import {
+  PROCESS_NONE
+} from "./chunk-L7GYJHDX.js";
+import {
+  run_hold
+} from "./chunk-NQ4D2XZY.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/lane/lane-vacant.ts
+async function has_no_commits(lane) {
+  try {
+    const base = await git_command.default_branch_reference();
+    return await git_command.commit_count_beyond(base, lane.branch) === 0;
+  } catch {
+    return false;
+  }
+}
+function is_occupied(lane) {
+  return lane.is_stranded || lane_await.process_trace_default(lane.issue) !== PROCESS_NONE;
+}
+async function is_vacant(lane) {
+  if (is_occupied(lane) || await run_hold.is_tree_dirty(lane.directory)) return false;
+  return await has_no_commits(lane);
+}
+async function vacant_issues(lanes) {
+  const answers = await Promise.all(lanes.map(async (lane) => await is_vacant(lane)));
+  return lanes.filter((_lane, index) => answers[index] === true).map((lane) => lane.issue);
+}
+var lane_vacant = { is_vacant, vacant_issues };
+
+export {
+  lane_vacant
+};