@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-BJQDQAQU.js

@@ -0,0 +1,167 @@
+import {
+  test_related_pins
+} from "./chunk-HE5S4XRE.js";
+import {
+  direct_importers
+} from "./chunk-7GICNM73.js";
+import {
+  test_pinned_logic
+} from "./chunk-I36PDO6I.js";
+import {
+  test_pinned_reach
+} from "./chunk-PTJ6X3QK.js";
+import {
+  related_scope
+} from "./chunk-QA44M56F.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/test/test-related-cap.ts
+import { existsSync } from "node:fs";
+import path2 from "node:path";
+
+// scripts/test/test-related-imports.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+function is_loading(typescript, node, source) {
+  if (!typescript.isCallExpression(node)) return false;
+  return node.expression.kind === typescript.SyntaxKind.ImportKeyword || node.expression.getText(source) === "require";
+}
+function signature(typescript, file, content) {
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
+  const declarations = [];
+  function visit(node) {
+    if (typescript.isImportDeclaration(node) || typescript.isExportDeclaration(node) || is_loading(typescript, node, source)) {
+      declarations.push(node.getText(source));
+    }
+    typescript.forEachChild(node, visit);
+  }
+  visit(source);
+  return JSON.stringify(declarations);
+}
+async function is_stable(root, file, comparison) {
+  if (path.extname(file) === ".svelte") return false;
+  try {
+    const before = await git_spawn.read(["-C", root, "show", `${comparison.base}:${file}`]);
+    const current = readFileSync(path.join(root, file), "utf8");
+    return signature(comparison.typescript, file, before) === signature(comparison.typescript, file, current);
+  } catch {
+    return false;
+  }
+}
+async function compare(root, files) {
+  try {
+    const base = await change_base.resolved_through_merge();
+    if (base === void 0) return files.map(() => false);
+    const { default: typescript } = await import("typescript");
+    return await Promise.all(
+      files.map(async (file) => await is_stable(root, file, { base, typescript }))
+    );
+  } catch {
+    return files.map(() => false);
+  }
+}
+async function stable_files(root, files) {
+  if (files.length === 0) return [];
+  const stable = await compare(root, files);
+  const retained = files.filter((_file, index) => stable[index] !== true);
+  if (retained.length > 0) {
+    process.stdout.write(
+      `josh test:related: keeping full reach (imports changed or unknown): ${retained.join(", ")}
+`
+    );
+  }
+  return files.filter((_file, index) => stable[index] === true);
+}
+var test_related_imports = { stable_files };
+
+// scripts/test/test-related-cap.ts
+var NO_CAP = { importers: /* @__PURE__ */ new Map(), over_cap: [] };
+function reach_sum(counts) {
+  return counts.reduce((sum, reached) => sum + reached.count, 0);
+}
+function over_cap_of(counts, max_tests = test_pinned_logic.MAX_TEST_FILES) {
+  const widest = counts.toSorted((first, second) => second.count - first.count);
+  const fits = widest.findIndex((_, index) => reach_sum(widest.slice(index)) <= max_tests);
+  const narrowed = fits === -1 ? widest : widest.slice(0, fits);
+  return narrowed.map((reached) => reached.file);
+}
+function candidates_of(root, files, narrowed) {
+  return files.filter(
+    (file) => related_scope.is_relatable(file) && !test_declared_logic.is_test_file(file) && !narrowed.has(file) && existsSync(path2.join(root, file))
+  );
+}
+async function relative_counts(root, files, read_counts) {
+  if (files.length === 0) return [];
+  const counts = await read_counts(files.map((file) => path2.join(root, file)));
+  return (counts ?? []).map((reached) => ({ ...reached, file: path2.relative(root, reached.file) }));
+}
+async function read_over_cap(root, files, read_counts) {
+  return over_cap_of(await relative_counts(root, files, read_counts));
+}
+async function direct_of(root, over_cap) {
+  const stable = await test_related_imports.stable_files(root, over_cap);
+  const importers = await direct_importers.importers_of(root, stable);
+  const narrowed = [...importers].filter(([, tests]) => tests.length > 0);
+  return narrowed.map(([file, tests]) => [file, test_related_pins.with_pins(file, tests)]);
+}
+async function split_of(root, files) {
+  const shared = direct_importers.every_test_imports_of(files);
+  const stable = await test_related_imports.stable_files(root, shared);
+  const every_test = await direct_importers.every_test_importers(root, stable);
+  return [every_test, candidates_of(root, files, every_test)];
+}
+async function capped_importers(root, files, is_whole, read_counts = test_pinned_reach.reached_test_counts) {
+  if (is_whole) return NO_CAP;
+  const [every_test, candidates] = await split_of(root, files);
+  const over_cap = await read_over_cap(root, candidates, read_counts);
+  const capped = await direct_of(root, over_cap);
+  return { importers: new Map([...every_test, ...capped]), over_cap: capped.map(([file]) => file) };
+}
+async function hubs_of(root, files, read_counts = test_pinned_reach.reached_test_counts) {
+  const [, candidates] = await split_of(root, files);
+  const counts = await relative_counts(root, candidates, read_counts);
+  return counts.flatMap((reached) => over_cap_of([reached]));
+}
+function capped_test_count(capped) {
+  const tests = capped.over_cap.flatMap((file) => capped.importers.get(file) ?? []);
+  return new Set(tests).size;
+}
+function hub_of(over_cap, own) {
+  return over_cap.find((file) => own.includes(file));
+}
+function over_cap_line(capped, own) {
+  const { over_cap } = capped;
+  if (over_cap.length === 0) return void 0;
+  const { COMMAND_LABEL } = related_scope;
+  const cap = String(test_pinned_logic.MAX_TEST_FILES);
+  const ran = String(capped_test_count(capped));
+  const hub = hub_of(over_cap, own);
+  const hub_part = hub === void 0 ? "" : `, hub ${hub}`;
+  return `${COMMAND_LABEL}: ${String(over_cap.length)} over cap (${cap} test files)${hub_part} \u2014 ${ran} test files run, the rest unchecked: ${over_cap.join(", ")}`;
+}
+function report_over_cap(capped, own) {
+  const line = over_cap_line(capped, own);
+  if (line !== void 0) process.stdout.write(`${line}
+`);
+}
+var test_related_cap = {
+  NO_CAP,
+  capped_importers,
+  hub_of,
+  hubs_of,
+  over_cap_line,
+  over_cap_of,
+  report_over_cap
+};
+
+export {
+  test_related_cap
+};

package/dist/commands/chunk-BU3WIUDD.js

@@ -0,0 +1,230 @@
+import {
+  behavior_change_lint
+} from "./chunk-2FD3N3OX.js";
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+import {
+  issue_label_schema
+} from "./chunk-34DND4BA.js";
+import {
+  BUGFIX_LABEL,
+  BUG_LABEL,
+  ENHANCEMENT_LABEL,
+  INTERRUPT_ROUTE_LABEL,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  git_gh_exec,
+  parse_json
+} from "./chunk-NAZ753DE.js";
+import {
+  bounded_pool
+} from "./chunk-EBVS2LKX.js";
+
+// scripts/issue/defect-rate.ts
+var DEFECT_DECLARATION_LINE = issue_body_keys.line("kind", "bug");
+var DEFECT_LABELS = [BUG_LABEL, BUGFIX_LABEL, INTERRUPT_ROUTE_LABEL];
+var DEFAULT_WINDOW_DAYS = 14;
+var BASELINE_RATE = 0.73;
+var MS_PER_DAY = 864e5;
+var ISO_DATE_LENGTH = 10;
+var RATE_DIGITS = 2;
+function window_start(now_ms, days) {
+  return new Date(now_ms - days * MS_PER_DAY).toISOString().slice(0, ISO_DATE_LENGTH);
+}
+function filed_query(repo, since) {
+  return `repo:${repo} is:issue created:>=${since}`;
+}
+function completed_query(repo, since) {
+  return `repo:${repo} is:issue is:closed reason:completed label:${ENHANCEMENT_LABEL} closed:>=${since}`;
+}
+function is_defect(issue) {
+  return markdown_section.has_line(issue.body, DEFECT_DECLARATION_LINE) || DEFECT_LABELS.some((label) => has_label_name(issue.labels, label));
+}
+function is_enhancement(issue) {
+  return has_label_name(issue.labels, ENHANCEMENT_LABEL);
+}
+function kind_of(issue) {
+  if (is_defect(issue)) return "defect";
+  return behavior_change_lint.is_target(issue.body) ? "mechanism" : "other";
+}
+function measure(input) {
+  return {
+    days: input.days,
+    since: input.since,
+    defects: input.filed.filter((issue) => is_defect(issue)).length,
+    enhancements: input.completed.filter((issue) => is_enhancement(issue)).length,
+    is_capped: input.is_capped
+  };
+}
+function rate_of(result) {
+  if (result.enhancements === 0) return void 0;
+  return result.defects / result.enhancements;
+}
+function is_above_baseline(result) {
+  const rate = rate_of(result);
+  return rate !== void 0 && rate > BASELINE_RATE;
+}
+function rate_text(result) {
+  const rate = rate_of(result);
+  if (rate === void 0) return "n/a (no enhancement completed in the window)";
+  return `${rate.toFixed(RATE_DIGITS)} (${String(result.defects)} / ${String(result.enhancements)})`;
+}
+var defect_rate = {
+  BASELINE_RATE,
+  DEFAULT_WINDOW_DAYS,
+  DEFECT_DECLARATION_LINE,
+  completed_query,
+  filed_query,
+  is_above_baseline,
+  is_defect,
+  kind_of,
+  measure,
+  rate_of,
+  rate_text,
+  window_start
+};
+
+// scripts/issue/issue-search.ts
+import { z } from "zod";
+var PER_PAGE = "100";
+var FIRST_PAGE = 1;
+var SECOND_PAGE = 2;
+var SEARCH_RESULT_CEILING = 1e3;
+var PAGE_CONCURRENCY = 4;
+var WINDOW_READ_LIMIT = 15;
+var MS_PER_SECOND = 1e3;
+var MS_PER_DAY2 = 864e5;
+var SPLIT_DIVISOR = 2;
+function skips_pages(first, should_split) {
+  return should_split && first.total_count > SEARCH_RESULT_CEILING;
+}
+var search_item_schema = z.object({
+  number: z.number().optional(),
+  title: z.string().optional(),
+  state: z.string().optional(),
+  body: z.string().nullish(),
+  labels: z.array(issue_label_schema)
+});
+var search_page_schema = z.object({
+  total_count: z.number(),
+  incomplete_results: z.boolean(),
+  items: z.array(search_item_schema)
+});
+function search_path(query, page = FIRST_PAGE) {
+  const parameters = new URLSearchParams({ q: query, per_page: PER_PAGE });
+  if (page !== FIRST_PAGE) parameters.set("page", String(page));
+  return `search/issues?${parameters.toString()}`;
+}
+function page_count(first) {
+  return Math.ceil(Math.min(first.total_count, SEARCH_RESULT_CEILING) / Number(PER_PAGE));
+}
+async function read_page(query, page) {
+  const raw = await git_gh_exec.exec_gh_api({ path: search_path(query, page) });
+  return parse_json.parse_json_object_or_undefined(raw, search_page_schema);
+}
+async function read_pages(query, should_split = false) {
+  const first = await read_page(query, FIRST_PAGE);
+  if (first === void 0) return void 0;
+  if (skips_pages(first, should_split)) return [first];
+  const rest_numbers = Array.from(
+    { length: Math.max(page_count(first) - FIRST_PAGE, 0) },
+    (_value, index) => index + SECOND_PAGE
+  );
+  const rest = await bounded_pool.bounded_map(
+    rest_numbers,
+    PAGE_CONCURRENCY,
+    async (page) => await read_page(query, page)
+  );
+  return rest.every((page) => page !== void 0) ? [first, ...rest] : void 0;
+}
+function to_issue(item) {
+  return {
+    number: item.number ?? 0,
+    title: item.title ?? "",
+    state: item.state ?? "",
+    body: item.body ?? "",
+    labels: item.labels.map((label) => label.name)
+  };
+}
+function to_result(pages) {
+  const issues = pages.flatMap((page) => page.items.map((item) => to_issue(item)));
+  const total = pages[0]?.total_count ?? 0;
+  const is_incomplete = pages.some((page) => page.incomplete_results);
+  const numbers = issues.map((issue) => issue.number).filter((number) => number > 0);
+  const has_duplicates = new Set(numbers).size !== numbers.length;
+  return { issues, is_capped: is_incomplete || total !== issues.length || has_duplicates };
+}
+function window_query(window) {
+  const original_start = Date.parse(window.qualifier.split(">=").at(-1) ?? "");
+  if (window.is_open && window.start === original_start) return window.query;
+  const start = new Date(window.start).toISOString().replace(".000Z", "Z");
+  const end = new Date(window.end - MS_PER_SECOND).toISOString().replace(".000Z", "Z");
+  const range = window.is_open ? `>=${start}` : `${start}..${end}`;
+  return window.query.replace(
+    window.qualifier,
+    () => `${window.qualifier.split(":", 1)[0] ?? ""}:${range}`
+  );
+}
+function merge_windows(results, total) {
+  const issues = results.flatMap((result) => result.issues);
+  const unique = new Map(issues.map((issue) => [issue.number, issue]));
+  const is_capped = results.some((result) => result.is_capped) || unique.size !== total || unique.size !== issues.length;
+  return { issues: [...unique.values()], is_capped };
+}
+async function split_window(window, budget, total, read) {
+  const middle = Math.floor((window.start + window.end) / SPLIT_DIVISOR / MS_PER_SECOND) * MS_PER_SECOND;
+  const left = await read({ ...window, end: middle, is_open: false }, budget);
+  if (left === void 0) return void 0;
+  const right = await read({ ...window, start: middle }, budget);
+  return right === void 0 ? void 0 : merge_windows([left, right], total);
+}
+function can_split(first, window) {
+  return !first.incomplete_results && first.total_count > SEARCH_RESULT_CEILING && window.end - window.start > MS_PER_SECOND;
+}
+async function read_window(window, budget) {
+  if (budget.remaining === 0) return { issues: [], is_capped: true };
+  budget.remaining -= 1;
+  const pages = await read_pages(window_query(window), true);
+  if (pages === void 0) return void 0;
+  const result = to_result(pages);
+  const [first] = pages;
+  if (first === void 0 || !can_split(first, window)) return result;
+  return await split_window(window, budget, first.total_count, read_window);
+}
+async function search(query) {
+  try {
+    const pages = await read_pages(query);
+    return pages === void 0 ? void 0 : to_result(pages);
+  } catch {
+    return void 0;
+  }
+}
+function rate_qualifier(query) {
+  return /\b(?:created|closed):>=\d{4}-\d{2}-\d{2}\b/u.exec(query)?.[0];
+}
+async function search_complete(query, now_ms = Date.now()) {
+  const qualifier = rate_qualifier(query);
+  if (qualifier === void 0) return await search(query);
+  const start = Date.parse(qualifier.split(">=").at(-1) ?? "");
+  const now = (Math.floor(now_ms / MS_PER_DAY2) + 1) * MS_PER_DAY2;
+  const end = Math.max(now, start + MS_PER_SECOND);
+  try {
+    return await read_window(
+      { query, qualifier, start, end, is_open: true },
+      { remaining: WINDOW_READ_LIMIT }
+    );
+  } catch {
+    return void 0;
+  }
+}
+var issue_search = { search, search_complete, search_path };
+
+export {
+  defect_rate,
+  issue_search
+};

package/dist/commands/chunk-C2WXQPF3.js

@@ -0,0 +1,34 @@
+import {
+  markdown_section
+} from "./chunk-UYHREBT7.js";
+import {
+  issue_body_keys
+} from "./chunk-4DNAAFF4.js";
+
+// scripts/issue/reproduction-measure.ts
+var REPRODUCTION_HEADING = issue_body_keys.heading("reproduction");
+var COMMAND_SPAN = /`[^`]+`/u;
+var PLACEHOLDER_SPAN = /`<[^`]*>`/gu;
+var FENCE_LINE = /^\s*(?:```|~~~)/u;
+var FENCE_PAIR = 2;
+function has_command_line(lines) {
+  const first_fence = lines.findIndex((line) => FENCE_LINE.test(line));
+  const open_lines = first_fence === -1 ? lines : lines.slice(0, first_fence);
+  return open_lines.some((line) => COMMAND_SPAN.test(line.replaceAll(PLACEHOLDER_SPAN, "")));
+}
+function has_output_block(lines) {
+  return lines.filter((line) => FENCE_LINE.test(line)).length >= FENCE_PAIR;
+}
+function parse_reproduction(body, heading = REPRODUCTION_HEADING) {
+  const lines = markdown_section.section_lines(body, heading);
+  return { has_command: has_command_line(lines), has_output: has_output_block(lines) };
+}
+function has_command_output(body, heading = REPRODUCTION_HEADING) {
+  const reproduction = parse_reproduction(body, heading);
+  return reproduction.has_command && reproduction.has_output;
+}
+var reproduction_measure = { has_command_output };
+
+export {
+  reproduction_measure
+};

package/dist/commands/chunk-C3V6H6TW.js

@@ -0,0 +1,183 @@
+import {
+  run_retrospective
+} from "./chunk-33N7SBIU.js";
+import {
+  latest_scope_cli
+} from "./chunk-BVUL57IX.js";
+import {
+  git_stash
+} from "./chunk-5KEESWMC.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/run/run-step.ts
+var CLOSED = "CLOSED";
+var IMPLEMENT = "implement";
+var HUMAN_REVIEW = "human-review";
+var UPDATE_DEPS = "update-deps";
+var ALREADY_DONE = "already-done";
+var KEEP_WORK = "keep-work";
+var WAIT = "wait";
+var STOP = "stop";
+var UNKNOWN = "unknown";
+var VOCABULARY = [
+  IMPLEMENT,
+  HUMAN_REVIEW,
+  UPDATE_DEPS,
+  ALREADY_DONE,
+  KEEP_WORK,
+  WAIT,
+  STOP,
+  UNKNOWN
+];
+var RETROSPECTIVE_COMMAND = "pnpm josh retrospective";
+function closed_verdict(input) {
+  return input.has_changes ? KEEP_WORK : ALREADY_DONE;
+}
+function pre_verdict(input) {
+  if (input.state === void 0) return UNKNOWN;
+  if (input.state === CLOSED) return closed_verdict(input);
+  if (input.latest_scope === latest_scope_cli.REQUIRED_SCOPE) return UPDATE_DEPS;
+  if (input.is_human_review) return HUMAN_REVIEW;
+  return IMPLEMENT;
+}
+function verdict(token) {
+  return { kind: "verdict", line: token };
+}
+function command(line) {
+  return { kind: "command", line };
+}
+function merge_command(issue_number) {
+  return command(`pnpm josh run:merge ${issue_number}`);
+}
+var KIND = run_event_stream.EVENT_KIND;
+var OFFER_BACKLOG = "pnpm josh backlog:next";
+var EVENT_ACTIONS = {
+  [KIND.PR_OPENED]: () => command("pnpm josh followup"),
+  // `ship --review` asks `review:round2 --record` itself and reuses a recorded round 1, so a run past
+  // round 1 hands the rest of the region to it rather than to the hand-run round-2 steps.
+  [KIND.REVIEW_ROUND]: () => command("pnpm josh ship --review"),
+  [KIND.MERGE]: merge_command,
+  [KIND.OUTAGE]: merge_command,
+  [KIND.PARK]: () => command(OFFER_BACKLOG),
+  // The child was released; `backlog:drive` holds the next launch until the limit resets.
+  [KIND.USAGE_LIMIT]: () => command(OFFER_BACKLOG),
+  [KIND.CUT]: (issue_number) => command(`pnpm josh run:cut --resume ${issue_number}`),
+  // A stall is undispatched ready work with a free lane, so its next step is exactly a park's: offer
+  // the backlog. The detector only reports the stall; reading it here as a dispatch is what turns the
+  // report into the action that resolves it.
+  [KIND.STALL]: () => command(OFFER_BACKLOG),
+  // The post-implementation region is with a detached ship supervisor: nothing
+  // is the agent's until the supervisor stops or the issue closes, which the terminal read answers.
+  [KIND.SHIP_LAUNCH]: () => verdict(WAIT),
+  // The supervisor stopped at a failed stage and handed control back — the next step is reading the
+  // report it stopped on, which names the stage and why.
+  [KIND.SHIP_STOP]: (issue_number) => command(`pnpm josh ship --log ${issue_number}`)
+};
+var PARENT_ONLY_EVENTS = /* @__PURE__ */ new Set([KIND.MERGE, KIND.OUTAGE, KIND.USAGE_LIMIT]);
+function stop_action(input) {
+  return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(STOP);
+}
+function drain_action(input) {
+  return run_retrospective.is_owed(input) ? command(RETROSPECTIVE_COMMAND) : verdict(WAIT);
+}
+var HAND_OFF_COMMAND = "pnpm josh run:carry --cut";
+function can_hand_off(input) {
+  if (input.is_lane_child || input.is_at_cut_cap) return false;
+  return input.carry_kind === "carried" && !input.has_completion_callback;
+}
+function child_launch_action(input) {
+  return can_hand_off(input) ? command(HAND_OFF_COMMAND) : verdict(WAIT);
+}
+var FULL_INPUT_ACTIONS = {
+  [KIND.STOP]: stop_action,
+  [KIND.DRAIN]: drain_action,
+  [KIND.CHILD_LAUNCH]: child_launch_action,
+  // A person's restart re-dispatched the child, so the parent's position is a launch's.
+  [KIND.RESTART]: child_launch_action
+};
+function event_action(event, issue_number, is_lane_child) {
+  if (is_lane_child && PARENT_ONLY_EVENTS.has(event)) return verdict(STOP);
+  return EVENT_ACTIONS[event]?.(issue_number) ?? verdict(UNKNOWN);
+}
+var IMPLEMENTATION_POSITIONS = /* @__PURE__ */ new Set([KIND.PLAN, KIND.RESUME]);
+function is_pre_implementation(last_event) {
+  return last_event === void 0 || IMPLEMENTATION_POSITIONS.has(last_event);
+}
+function pre_implementation_action(input) {
+  return verdict(pre_verdict(input));
+}
+function owes_merge(input) {
+  return input.is_merge_owed && input.carry_kind === "carried" && !input.is_lane_child;
+}
+function closed_action(input) {
+  if (owes_merge(input)) return merge_command(input.issue_number);
+  if (closed_verdict(input) === ALREADY_DONE) return verdict(ALREADY_DONE);
+  const message = git_stash.work_message(input.issue_number, ALREADY_DONE);
+  return {
+    kind: "decide",
+    line: `decide: ${session_cite.issue(input.issue_number)} is closed but this tree holds uncommitted work \u2014 keep it with \`pnpm josh stash:push "${message}"\` | carry it into a new issue`
+  };
+}
+function is_handed_off_parent(input) {
+  return input.is_handed_off && input.carry_kind === "carried" && !input.is_lane_child;
+}
+function carry_terminal_action(input) {
+  if (input.carry_kind === "unreadable") return verdict(UNKNOWN);
+  if (is_handed_off_parent(input)) return verdict(STOP);
+  return void 0;
+}
+function terminal_action(input) {
+  const carry_action = carry_terminal_action(input);
+  if (carry_action !== void 0) return carry_action;
+  if (input.state === void 0) return verdict(UNKNOWN);
+  if (input.state === CLOSED) return closed_action(input);
+  return void 0;
+}
+var RETROSPECTIVE_POSITIONS = /* @__PURE__ */ new Set([KIND.DRAIN, KIND.STOP]);
+function is_retrospective_position(input) {
+  return RETROSPECTIVE_POSITIONS.has(input.last_event ?? "") && run_retrospective.is_owed(input);
+}
+function driving_action(input) {
+  if (is_retrospective_position(input)) return command(RETROSPECTIVE_COMMAND);
+  return input.is_at_cut_cap ? verdict(WAIT) : command(HAND_OFF_COMMAND);
+}
+function parent_action(input) {
+  if (input.is_lane_child) return verdict(UNKNOWN);
+  const terminal = carry_terminal_action(input);
+  if (terminal !== void 0) return terminal;
+  return input.is_driving ? driving_action(input) : verdict(UNKNOWN);
+}
+function next_action(input) {
+  const terminal = terminal_action(input);
+  if (terminal !== void 0) return terminal;
+  if (is_pre_implementation(input.last_event)) return pre_implementation_action(input);
+  const event = input.last_event ?? "";
+  const full_input_action = FULL_INPUT_ACTIONS[event];
+  if (full_input_action !== void 0) return full_input_action(input);
+  return event_action(event, input.issue_number, input.is_lane_child);
+}
+var run_step = {
+  ALREADY_DONE,
+  HAND_OFF_COMMAND,
+  HUMAN_REVIEW,
+  IMPLEMENT,
+  KEEP_WORK,
+  RETROSPECTIVE_COMMAND,
+  STOP,
+  UNKNOWN,
+  UPDATE_DEPS,
+  VOCABULARY,
+  WAIT,
+  next_action,
+  parent_action,
+  pre_verdict
+};
+
+export {
+  run_step
+};