@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-TROCFVCU.js

@@ -0,0 +1,45 @@
+import {
+  review_comment_round
+} from "./chunk-2OEXY4GM.js";
+import {
+  review_finding_ledger
+} from "./chunk-KVURNO74.js";
+import {
+  observation_ledger_home
+} from "./chunk-QXBOECGL.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+
+// scripts/review/review-record.ts
+async function has_comment_record(issue, read) {
+  try {
+    const lines = await read(issue);
+    return review_finding_ledger.has_issue_record(lines.join("\n"), issue);
+  } catch {
+    return false;
+  }
+}
+async function is_recorded(content, issue, read) {
+  if (review_finding_ledger.has_issue_record(content, issue)) return true;
+  return await has_comment_record(issue, read);
+}
+async function check(issue, root = observation_ledger_home.ledger_root(), read_comment_lines = review_comment_round.issue_lines) {
+  const content = await observation_ledger_home.read(root);
+  if (content === void 0) return { status: "not-required" };
+  if (await is_recorded(content, issue, read_comment_lines)) return { status: "ok", issue };
+  return { status: "missing", issue };
+}
+var MISSING_REASON = "No review round is recorded for this issue, so there is no evidence `/code-review` ran. A round whose findings are never recorded leaves the recurrence ledger blind, which is indistinguishable from a round nobody reviewed \u2014 so an unrecorded round is refused (joshuafolkken/kit#2343).";
+var REMEDY = "Record the round with `pnpm josh review:record --issue <N> [<category>:<severity>:<file> ...]` \u2014 a clean round is a call with no findings, which records one zero-finding line \u2014 then reissue the merge.";
+function refusal_message(issue) {
+  return [MISSING_REASON, `Issue: ${session_cite.issue(issue)}`, REMEDY].join("\n");
+}
+var review_record = {
+  check,
+  refusal_message
+};
+
+export {
+  review_record
+};

package/dist/commands/chunk-TTTZZN7F.js

@@ -0,0 +1,269 @@
+import {
+  lane_plan_wait,
+  lane_plan_wait_until
+} from "./chunk-MK4CARBI.js";
+import {
+  lane_plan_probe,
+  lane_plan_size
+} from "./chunk-4GUGC4IW.js";
+import {
+  trusted_measure
+} from "./chunk-GNTTGRCX.js";
+import {
+  run_hold_cli
+} from "./chunk-GWTBIGYC.js";
+import {
+  backlog_plan_comment
+} from "./chunk-MRW2WYJS.js";
+import {
+  auto_ok_cli
+} from "./chunk-RFIOZTXY.js";
+import {
+  measure_declaration
+} from "./chunk-34JJYCIY.js";
+import {
+  lane_plan_wait_event
+} from "./chunk-DDOS32JU.js";
+import {
+  lane_yield
+} from "./chunk-GZL6ISVM.js";
+import {
+  backlog_overlap,
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  test_declared_logic
+} from "./chunk-7HCPRVMB.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.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-TUBBESHU.js

@@ -0,0 +1,85 @@
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/hooks/check-commit-message.ts
+import { readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var PARENT_SEGMENT = "..";
+var COMMIT_MESSAGE_FILE_NAME = "COMMIT_EDITMSG";
+var FALLBACK_GIT_DIRECTORY = ".git";
+function is_inside(directory, resolved_path) {
+  const relative = path.relative(directory, resolved_path);
+  return relative !== "" && !relative.startsWith(PARENT_SEGMENT) && !path.isAbsolute(relative);
+}
+function is_safe_commit_message_path(file_path, git_directories) {
+  const resolved = path.resolve(file_path);
+  return git_directories.some((directory) => is_inside(directory, resolved)) || is_inside(os.tmpdir(), resolved);
+}
+function default_commit_message_path(git_directories) {
+  return path.join(git_directories[0] ?? FALLBACK_GIT_DIRECTORY, COMMIT_MESSAGE_FILE_NAME);
+}
+async function get_commit_message() {
+  const FILE_INDEX = 2;
+  const commit_message_file = process.argv.at(FILE_INDEX);
+  const git_directories = await git_command.git_directories();
+  const message_path = commit_message_file ?? default_commit_message_path(git_directories);
+  if (commit_message_file !== void 0 && !is_safe_commit_message_path(commit_message_file, git_directories)) {
+    throw new Error(
+      `Commit message file must be inside a git directory or the system temp dir: ${commit_message_file}`
+    );
+  }
+  try {
+    return readFileSync(message_path, "utf8").trim();
+  } catch (error) {
+    throw new Error(`Failed to read commit message file: ${message_path}`, { cause: error });
+  }
+}
+function extract_issue_number(branch_name) {
+  const branch_pattern = /^(\d+)-[\da-z-]+$/u;
+  const match = branch_pattern.exec(branch_name);
+  return match?.[1];
+}
+function create_error_message(issue_number, branch, message) {
+  const reference = issue_cite.plain_for("github", issue_number);
+  return `\u{1F6AB} Error: Commit message must include ${reference}
+   Current branch: ${branch}
+   Commit message: ${message}
+   Please include ${reference} in your commit message
+`;
+}
+async function check_commit_message() {
+  const current_branch = await git_command.branch();
+  const issue_number = extract_issue_number(current_branch);
+  if (issue_number === void 0) {
+    return {
+      success: true,
+      message: `\u2705 Branch format check passed: '${current_branch}' (no issue number required)`
+    };
+  }
+  const commit_message = await get_commit_message();
+  if (!commit_message.includes(issue_cite.plain_for("github", issue_number))) {
+    return {
+      success: false,
+      message: create_error_message(issue_number, current_branch, commit_message)
+    };
+  }
+  return {
+    success: true,
+    message: `\u2705 Commit message check passed: Found ${issue_cite.plain_for("github", issue_number)}`
+  };
+}
+async function run_check() {
+  const result = await check_commit_message();
+  console.info(result.message);
+  return result.success ? 0 : 1;
+}
+
+export {
+  extract_issue_number,
+  run_check
+};

package/dist/commands/chunk-TVZIFZZN.js

@@ -0,0 +1,62 @@
+import {
+  git_gh_command,
+  git_pr_checks
+} from "./chunk-NRULNBYI.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+
+// scripts/gh/git-pr-merge-checked.ts
+var MAX_HEAD_MOVES = 3;
+var NO_CHECKED_HEAD_MESSAGE = "The merge gate answered without the head commit it checked, so there is no commit to bind the merge to";
+var HEAD_MOVED_NOTE = "The pull request head moved after its checks passed \u2014 waiting on the new head";
+var HEAD_KEPT_MOVING_MESSAGE = `The pull request head moved after its checks passed ${String(MAX_HEAD_MOVES)} times, so it was not merged`;
+function checked_head(snapshot) {
+  if (snapshot.head_sha === void 0) throw new Error(NO_CHECKED_HEAD_MESSAGE);
+  return snapshot.head_sha;
+}
+async function try_merge(input, snapshot) {
+  const head_sha = checked_head(snapshot);
+  await input.before_merge?.(head_sha);
+  try {
+    await git_gh_command.pr_merge(input.branch_name, head_sha);
+    return true;
+  } catch (error) {
+    if (!git_gh_command.is_head_moved(error)) throw error;
+    return false;
+  }
+}
+async function merge_checked(input) {
+  const progress = { snapshot: input.checked ?? await input.wait_for_green() };
+  const is_merged = await poll.poll_until(
+    async () => {
+      if (await try_merge(input, progress.snapshot)) return true;
+      console.info(HEAD_MOVED_NOTE);
+      Object.assign(progress, { snapshot: await input.wait_for_green() });
+      return false;
+    },
+    {
+      attempts: MAX_HEAD_MOVES,
+      interval_ms: 0,
+      sleeper: async () => {
+        await Promise.resolve();
+      }
+    }
+  );
+  if (is_merged) return;
+  throw new Error(HEAD_KEPT_MOVING_MESSAGE);
+}
+async function merge_when_green(branch_name) {
+  async function wait_for_green() {
+    return await git_pr_checks.wait_for_pr_success(branch_name);
+  }
+  await merge_checked({ branch_name, wait_for_green });
+}
+var git_pr_merge_checked = {
+  merge_checked,
+  merge_when_green
+};
+
+export {
+  git_pr_merge_checked
+};

package/dist/commands/chunk-TXRWAL63.js

@@ -0,0 +1,144 @@
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  git_gh_exec
+} from "./chunk-43DU7DYZ.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/merge/run-merge-usage-limit.ts
+var KIND = run_event_stream.EVENT_KIND.USAGE_LIMIT;
+var RESUMES_AT = /resumes at (\S+)$/u;
+function stop_text(child, reset_ms, limit) {
+  return `${issue_cite.plain_for("program", child)} ${limit} \u2014 resumes at ${new Date(reset_ms).toISOString()}`;
+}
+async function record(child, reset_ms, limit = "usage limit") {
+  await run_event_stream_emit.emit(KIND, stop_text(child, reset_ms, limit));
+}
+function time_of(text) {
+  const parsed = Date.parse(RESUMES_AT.exec(text)?.[1] ?? "");
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function resume_ms(events) {
+  const newest = events.findLast((event) => event.kind === KIND);
+  return newest === void 0 ? void 0 : time_of(newest.text);
+}
+function held_until(events, now_ms) {
+  const ahead = events.filter((event) => event.kind === KIND).map((event) => time_of(event.text) ?? 0).filter((reset_ms) => reset_ms > now_ms);
+  return ahead.length === 0 ? void 0 : Math.max(...ahead);
+}
+function held_count(events, now_ms) {
+  return events.filter((event) => event.kind === KIND && (time_of(event.text) ?? 0) > now_ms).length;
+}
+async function is_held(now_ms) {
+  return held_until(await run_event_stream_emit.current_events(), now_ms) !== void 0;
+}
+var run_merge_usage_limit = { held_count, held_until, is_held, record, resume_ms };
+
+// scripts/gh/gh-core-rate-limit.ts
+import { z } from "zod";
+var FRESH_MS = 3e4;
+var core_schema = z.object({
+  used: z.number().int().nonnegative(),
+  remaining: z.number().int().nonnegative(),
+  limit: z.number().int().positive(),
+  reset: z.number().int().nonnegative()
+});
+var resources_schema = z.object({
+  core: core_schema,
+  graphql: core_schema.optional().catch(void 0)
+});
+var CORE_REQUEST = { path: "rate_limit", jq_filter: ".resources.core", should_retry: false };
+var RESOURCES_REQUEST = {
+  path: "rate_limit",
+  jq_filter: ".resources | {core, graphql}",
+  should_retry: false
+};
+async function read_with(exec, request, schema) {
+  try {
+    return json_value.parse_with(await exec(request), schema);
+  } catch {
+    return void 0;
+  }
+}
+function kept_reader(request, schema) {
+  const kept = /* @__PURE__ */ new Map();
+  return async function read(exec) {
+    const now_ms = Date.now();
+    const entry = kept.get(exec);
+    if (entry !== void 0 && now_ms - entry.at_ms < FRESH_MS) return entry.value;
+    const value = await read_with(exec, request, schema);
+    if (value !== void 0) kept.set(exec, { at_ms: now_ms, value });
+    return value;
+  };
+}
+var read_kept_core = kept_reader(CORE_REQUEST, core_schema);
+var read_kept_resources = kept_reader(RESOURCES_REQUEST, resources_schema);
+async function read_parsed(exec) {
+  return await read_with(exec, CORE_REQUEST, core_schema);
+}
+function limit_of(core) {
+  return { remaining: core.remaining, limit: core.limit, reset_ms: core.reset * MS_PER_SECOND };
+}
+async function read_core(exec = git_gh_exec.exec_gh_api) {
+  const core = await read_kept_core(exec);
+  return core === void 0 ? void 0 : limit_of(core);
+}
+async function read_resources(exec = git_gh_exec.exec_gh_api) {
+  const resources = await read_kept_resources(exec);
+  if (resources === void 0) return void 0;
+  const { core, graphql } = resources;
+  return { core: limit_of(core), graphql: graphql === void 0 ? void 0 : limit_of(graphql) };
+}
+async function read_usage(exec = git_gh_exec.exec_gh_api_uncounted) {
+  const core = await read_parsed(exec);
+  if (core === void 0) return void 0;
+  return { used: core.used, reset_ms: core.reset * MS_PER_SECOND };
+}
+async function read_allowance(exec = git_gh_exec.exec_gh_api_uncounted) {
+  const core = await read_parsed(exec);
+  if (core === void 0) return void 0;
+  return { used: core.used, remaining: core.remaining, reset_ms: core.reset * MS_PER_SECOND };
+}
+var gh_core_rate_limit = { read_allowance, read_core, read_resources, read_usage };
+
+// scripts/run/merge/run-merge-token.ts
+var MERGE_TOKEN = {
+  // The hand-off check after a merge: the parent's context is over its threshold.
+  OVER: "over",
+  // The child's own ending: it stopped before its commit for a person to look at.
+  HUMAN_REVIEW: "human-review",
+  // Matches the `busy` verdict `run:carry` emits for a refused count, so callers see one vocabulary.
+  BUSY: "busy",
+  // A failed child could not be parked.
+  STOP: "stop",
+  // The environment is down. `run:merge` no longer emits it — an outage or an authentication failure
+  // holds launches instead (joshuafolkken/kit#7078) — so it is only ever read, ending the loop.
+  ENVIRONMENT: "environment",
+  // The child's state could not be read; re-read before deciding.
+  RETRY: "retry",
+  // The child's cut was resumed in its own lane: the parent awaits that lane again, and offers no child
+  // in its place.
+  RESUMED: "resumed"
+};
+function is_control_stop(read) {
+  return !read.is_offer && read.token === MERGE_TOKEN.STOP;
+}
+var run_merge_token = { MERGE_TOKEN, is_control_stop };
+
+export {
+  gh_core_rate_limit,
+  run_merge_token,
+  run_merge_usage_limit
+};