@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-SWHN7TNT.js

@@ -0,0 +1,59 @@
+import {
+  npm_acquisition
+} from "./chunk-6OUQZC6V.js";
+import {
+  KIT_PACKAGE_NAME
+} from "./chunk-PBOS7MTW.js";
+import {
+  shell_quote
+} from "./chunk-W2IA2LV3.js";
+import {
+  PACKAGE_DIR
+} from "./chunk-3CCGKX7Y.js";
+
+// scripts/version/upgrade-shell-command.ts
+import path from "node:path";
+var STEP_SEPARATOR = " && ";
+function update_scope_flag(is_local) {
+  return is_local ? "-D" : "-g";
+}
+function update_argv(latest, is_local, config) {
+  const registry = !is_local && config.package_name === KIT_PACKAGE_NAME ? ["--config.@joshuafolkken:registry=https://registry.npmjs.org/"] : [];
+  return [
+    "pnpm",
+    "add",
+    update_scope_flag(is_local),
+    ...registry,
+    `${config.package_name}@${latest}`
+  ];
+}
+function format_update_command(latest, is_local, config) {
+  return update_argv(latest, is_local, config).join(" ");
+}
+function needs_migration(is_local, package_name, root) {
+  return is_local && package_name === KIT_PACKAGE_NAME && !npm_acquisition.is_project_npm(root);
+}
+function build_upgrade_command(latest, is_local, config, root = process.cwd()) {
+  const steps = [update_argv(latest, is_local, config)];
+  if (needs_migration(is_local, config.package_name, root)) {
+    steps.unshift(["node", path.join(PACKAGE_DIR, "dist/registry-migrate.mjs"), latest]);
+  }
+  if (is_local) steps.push(["node_modules/.bin/tsx", config.fix_gh_packages_path]);
+  return {
+    text: steps.map((step) => step.map((argument) => shell_quote.word(argument)).join(" ")).join(STEP_SEPARATOR),
+    steps
+  };
+}
+function shell_upgrade_command(command) {
+  return { text: command, steps: [["sh", "-c", command]] };
+}
+function build_upgrade_shell_command(latest, is_local, config) {
+  return build_upgrade_command(latest, is_local, config).text;
+}
+
+export {
+  format_update_command,
+  build_upgrade_command,
+  shell_upgrade_command,
+  build_upgrade_shell_command
+};

package/dist/commands/chunk-T5D3BW3D.js

@@ -0,0 +1,85 @@
+import {
+  git_grep_hits
+} from "./chunk-EWBEYTVS.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+
+// scripts/run/run-prep-locate.ts
+var BACKTICKED = /`([^`\n]+)`/gu;
+var JOSH_PREFIX = /^(?:pnpm\s+)?josh\s+(\S+)/u;
+var LINE_SUFFIX = /(?::\d+)+$/u;
+var NAME_CHARACTERS = /^[\w@./:-]+$/u;
+var NAME_SEPARATOR = /[./:_-]/u;
+var MIN_TARGET_LENGTH = 3;
+var MAX_TARGETS = 10;
+var MAX_FILES_PER_TARGET = 3;
+var INDENT = "  ";
+var HIT_SEPARATOR = "  ";
+var NO_MATCH = " \u2014 no match in code";
+var SEARCH_FAILED = " \u2014 git grep failed; not searched";
+var FILE_PATHSPEC = ":(glob)**/";
+var FILE_HIT = { line: "1", excerpt: "(file named in the issue)" };
+var NO_TARGETS = "(no backticked path or identifier in the issue)";
+var CODE_PATHS = [
+  "*.ts",
+  "*.js",
+  "*.svelte",
+  ":(exclude)*.test.ts",
+  ":(exclude)*.e2e.ts",
+  ":(exclude)*.snap"
+];
+function to_target(span) {
+  const josh = JOSH_PREFIX.exec(span);
+  return josh?.[1] ?? span.trim().replace(LINE_SUFFIX, "");
+}
+function is_name(target) {
+  if (target.length < MIN_TARGET_LENGTH || target.includes("://")) return false;
+  return NAME_CHARACTERS.test(target) && NAME_SEPARATOR.test(target);
+}
+function names_of(text) {
+  const targets = [...text.matchAll(BACKTICKED)].map((match) => to_target(match[1] ?? ""));
+  return [...new Set(targets.filter((target) => is_name(target)))];
+}
+function extract_targets(text) {
+  return names_of(text).slice(0, MAX_TARGETS);
+}
+function format_target(located) {
+  if (located.has_failed) return `${located.target}${SEARCH_FAILED}`;
+  if (located.hits.length === 0) return `${located.target}${NO_MATCH}`;
+  const lines = located.hits.map(
+    (hit) => `${INDENT}${hit.path}:${hit.line}${HIT_SEPARATOR}${hit.excerpt}`
+  );
+  return [located.target, ...lines].join("\n");
+}
+function format_locations(located) {
+  if (located.length === 0) return NO_TARGETS;
+  return located.map((entry) => format_target(entry)).join("\n");
+}
+async function grep(target) {
+  const { hits, has_failed } = await git_grep_hits.search(target, ["-m", "1"], CODE_PATHS);
+  return { target, hits: hits.slice(0, MAX_FILES_PER_TARGET), has_failed };
+}
+async function find_files(target) {
+  try {
+    const stdout = await git_spawn.read(["ls-files", "--", `${FILE_PATHSPEC}${target}`]);
+    const paths = stdout.split("\n").filter((path) => path !== "");
+    return paths.slice(0, MAX_FILES_PER_TARGET).map((path) => ({ path, ...FILE_HIT }));
+  } catch {
+    return [];
+  }
+}
+async function find(target) {
+  const files = await find_files(target);
+  if (files.length > 0) return { target, hits: files, has_failed: false };
+  return await grep(target);
+}
+async function locate(text) {
+  const located = await Promise.all(extract_targets(text).map(async (target) => await find(target)));
+  return format_locations(located);
+}
+var run_prep_locate = { extract_targets, locate, names_of };
+
+export {
+  run_prep_locate
+};

package/dist/commands/chunk-T76CS2AQ.js

@@ -0,0 +1,307 @@
+import {
+  base_tree
+} from "./chunk-H6TBBVC2.js";
+import {
+  resolve_tsx_runner
+} from "./chunk-4NIHTEGD.js";
+import {
+  release_approval_prune
+} from "./chunk-G6H2TOAA.js";
+import {
+  toolchain_inputs
+} from "./chunk-TUIFS5E7.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  import_graph
+} from "./chunk-JZOTCPX2.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn
+} from "./chunk-LZNACCHR.js";
+import {
+  git_location_environment
+} from "./chunk-B77ZMVHS.js";
+import {
+  file_reader
+} from "./chunk-ZNX2LJCQ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// tools/metrics/metrics-ratchet.ts
+import { z } from "zod";
+var NEWLINE = "\n";
+var JSON_INDENT = "	";
+var GROWTH_PRECISION = 100;
+var metrics_schema = z.object({
+  scripts: z.object({
+    files: z.number(),
+    code_lines: z.number(),
+    comment_lines: z.number(),
+    comment_ratio: z.number()
+  }),
+  rules: z.object({ files: z.number(), lines: z.number() }),
+  guards: z.number(),
+  ai_cost: z.object({ resident_bytes: z.number(), on_demand_bytes: z.number() }),
+  prose: z.object({ long_paragraphs: z.number(), excess_bold: z.number() })
+});
+var approval_schema = z.object({
+  reason: z.string(),
+  date: z.string(),
+  growth: z.record(z.string(), z.number())
+});
+function parse_metrics(text) {
+  const parsed = metrics_schema.safeParse(json_value.parse_or_undefined(text));
+  return parsed.success ? parsed.data : void 0;
+}
+function parse_approval(text) {
+  const parsed = approval_schema.safeParse(json_value.parse_or_undefined(text));
+  return parsed.success ? parsed.data : void 0;
+}
+function approval_text(approval) {
+  return `${JSON.stringify(approval, void 0, JSON_INDENT)}${NEWLINE}`;
+}
+function fresh_approvals(current, base) {
+  return [...current].filter(([name, text]) => base.get(name) !== text).flatMap(([, text]) => parse_approval(text) ?? []);
+}
+function ratcheted(metrics) {
+  return [
+    ["scripts.code_lines", metrics.scripts.code_lines],
+    ["scripts.comment_ratio", metrics.scripts.comment_ratio],
+    ["rules.lines", metrics.rules.lines],
+    ["guards", metrics.guards],
+    ["ai_cost.resident_bytes", metrics.ai_cost.resident_bytes],
+    ["ai_cost.on_demand_bytes", metrics.ai_cost.on_demand_bytes],
+    ["prose.long_paragraphs", metrics.prose.long_paragraphs],
+    ["prose.excess_bold", metrics.prose.excess_bold]
+  ];
+}
+function growth_between(base, current) {
+  return Math.round((current - base) * GROWTH_PRECISION) / GROWTH_PRECISION;
+}
+function approved_growth(approvals, name) {
+  return Math.max(0, ...approvals.map((approval) => approval.growth[name] ?? 0));
+}
+function changes(base, current, approvals) {
+  const before = new Map(ratcheted(base));
+  return ratcheted(current).map(([name, value]) => {
+    const base_value = before.get(name) ?? value;
+    const growth = growth_between(base_value, value);
+    return { name, base: base_value, current: value, growth };
+  }).filter((change) => change.growth !== 0).map((change) => ({ ...change, approved: approved_growth(approvals, change.name) }));
+}
+function settled_kind(changed, grown) {
+  if (grown > 0) return "approved";
+  return changed > 0 ? "shrank" : "unchanged";
+}
+function compare(base, current, approvals) {
+  const changed = changes(base, current, approvals);
+  const grown = changed.filter((change) => change.growth > 0);
+  const regressions = grown.filter((change) => change.growth > change.approved);
+  if (regressions.length > 0) return { kind: "regressed", regressions };
+  return { kind: settled_kind(changed.length, grown.length) };
+}
+function accept(base, current, reason, date) {
+  const grown = changes(base, current, []).filter((change) => change.growth > 0);
+  if (grown.length === 0) return void 0;
+  return {
+    reason,
+    date,
+    growth: Object.fromEntries(grown.map((change) => [change.name, change.growth]))
+  };
+}
+function own_approval(name, current, base) {
+  const text = current.get(name);
+  if (text === void 0 || base.get(name) === text) return void 0;
+  const approval = parse_approval(text);
+  return approval !== void 0 && approval.reason.trim().length > 0 ? approval : void 0;
+}
+function refresh(approval, base, current, date) {
+  const past = changes(base, current, [approval]).filter(
+    (change) => Object.hasOwn(approval.growth, change.name) && change.growth > change.approved
+  );
+  if (past.length === 0) return void 0;
+  const regrown = Object.fromEntries(past.map((change) => [change.name, change.growth]));
+  return { ...approval, date, growth: { ...approval.growth, ...regrown } };
+}
+function render_regression(change) {
+  const values = `merge-base ${String(change.base)} \u2192 current ${String(change.current)}`;
+  return `  ${change.name}  ${values} (+${String(change.growth)}, approved +${String(change.approved)})`;
+}
+function render_regressions(regressions, commit) {
+  return [
+    `josh metrics: ${String(regressions.length)} total(s) grew past the merge-base ${commit}:`,
+    ...regressions.map((change) => render_regression(change)),
+    'Bring them back down, or record the reason they grew: pnpm josh metrics --accept --reason "<why>"'
+  ].join(NEWLINE);
+}
+var metrics_ratchet = {
+  accept,
+  approval_text,
+  compare,
+  fresh_approvals,
+  own_approval,
+  parse_approval,
+  parse_metrics,
+  refresh,
+  render_regressions
+};
+
+// tools/metrics/metrics-base.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { existsSync, mkdirSync, readdirSync as readdirSync2, writeFileSync } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import { execa } from "execa";
+
+// tools/metrics/metrics-base-cache.ts
+import { readdirSync } from "node:fs";
+import path from "node:path";
+import { z as z2 } from "zod";
+var CACHE_PREFIX = "josh-metrics-base-";
+var KEY_SEPARATOR = "\n";
+var SOURCE_EXTENSION = ".ts";
+var TEST_MARKER = ".test.";
+var SOURCE_DIRECTORIES = ["scripts", "tools"];
+var COMMAND_SCRIPT = path.join("tools", "metrics", "metrics-command.ts");
+var approval_schema2 = z2.tuple([z2.string(), z2.string()]);
+var record_schema = z2.object({ stdout: z2.string(), approvals: z2.array(approval_schema2) });
+function sources_in(root, directory) {
+  try {
+    return readdirSync(path.join(root, directory), { recursive: true, encoding: "utf8" }).filter((name) => name.endsWith(SOURCE_EXTENSION) && !name.includes(TEST_MARKER)).map((name) => path.join(root, directory, name));
+  } catch {
+    return [];
+  }
+}
+function sorted(files) {
+  return [...files].toSorted((left, right) => left.localeCompare(right));
+}
+function ruler_files(root) {
+  const universe = SOURCE_DIRECTORIES.flatMap((directory) => sources_in(root, directory));
+  const forward = import_graph.build_forward(universe, root);
+  return sorted(import_graph.reachable(path.join(root, COMMAND_SCRIPT), forward));
+}
+function ruler_part(root, file) {
+  return `${path.relative(root, file)}${KEY_SEPARATOR}${file_reader.read_if_readable(file) ?? ""}`;
+}
+function ruler_digest(root) {
+  const parts = ruler_files(root).map((file) => ruler_part(root, file));
+  return stamp_file.digest([...parts, toolchain_inputs.digest(root)].join(KEY_SEPARATOR));
+}
+function cache_path(commit, root) {
+  return stamp_file.stamp_path(CACHE_PREFIX, `${commit}${KEY_SEPARATOR}${ruler_digest(root)}`);
+}
+function read(commit, root) {
+  const text = stamp_file.read_stamp_text(cache_path(commit, root));
+  return text === void 0 ? void 0 : record_schema.safeParse(json_value.parse_or_undefined(text)).data;
+}
+function write(commit, root, reading) {
+  try {
+    stamp_file.replace_stamp(cache_path(commit, root), reading);
+  } catch {
+  }
+}
+var metrics_base_cache = { cache_path, read, ruler_files, write };
+
+// tools/metrics/metrics-base.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../tools/metrics/metrics-base.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var BASE_VARIABLE = "JOSH_METRICS_BASE";
+var COMMIT_PEEL = "^{commit}";
+var { APPROVAL_DIRECTORY } = release_approval_prune;
+var APPROVAL_EXTENSION = ".json";
+var TREE_PREFIX = "josh-metrics-base-";
+var JSON_FLAG = "--json";
+var COMMAND_SCRIPT2 = fileURLToPath(new URL("metrics-command.ts", __josh_source_url));
+var RULER_ROOT = fileURLToPath(new URL("../..", __josh_source_url));
+async function resolve_commit() {
+  const named = process.env[BASE_VARIABLE] ?? "";
+  if (named.length === 0) return await change_base.resolved_through_merge();
+  try {
+    return await git_spawn.read(["rev-parse", "--verify", `${named}${COMMIT_PEEL}`]);
+  } catch {
+    throw new Error(`josh metrics: ${BASE_VARIABLE}=${named} names no commit in this checkout`);
+  }
+}
+function approval_texts(root) {
+  const directory = path2.join(root, APPROVAL_DIRECTORY);
+  if (!existsSync(directory)) return /* @__PURE__ */ new Map();
+  return new Map(
+    readdirSync2(directory).flatMap((name) => {
+      const text = file_reader.read_if_readable(path2.join(directory, name));
+      return text === void 0 ? [] : [[name, text]];
+    })
+  );
+}
+function approval_name(issue) {
+  return `${String(issue)}${APPROVAL_EXTENSION}`;
+}
+function write_approval(root, issue, approval) {
+  const file = path2.join(APPROVAL_DIRECTORY, approval_name(issue));
+  mkdirSync(path2.join(root, APPROVAL_DIRECTORY), { recursive: true });
+  writeFileSync(path2.join(root, file), metrics_ratchet.approval_text(approval));
+  return file;
+}
+async function is_at(commit) {
+  const head = await git_spawn.read(["rev-parse", "HEAD"]);
+  const status = await git_command.status();
+  return head === commit && status.trim().length === 0;
+}
+async function measure_in(tree) {
+  const runner = resolve_tsx_runner();
+  const { stdout } = await execa(
+    runner.executable,
+    [...runner.leading_arguments, COMMAND_SCRIPT2, JSON_FLAG],
+    { cwd: tree, env: git_location_environment.location_free_environment(), extendEnv: true }
+  );
+  return stdout;
+}
+async function measure_base(commit) {
+  return await base_tree.with_tree(TREE_PREFIX, commit, async ({ tree }) => ({
+    stdout: await measure_in(tree),
+    approvals: [...approval_texts(tree)]
+  }));
+}
+function reading_of(cached) {
+  const metrics = metrics_ratchet.parse_metrics(cached.stdout);
+  return metrics === void 0 ? void 0 : { metrics, approvals: new Map(cached.approvals) };
+}
+function cached_reading(commit) {
+  const cached = metrics_base_cache.read(commit, RULER_ROOT);
+  return cached === void 0 ? void 0 : reading_of(cached);
+}
+async function read2(commit, current) {
+  if (await is_at(commit)) return current;
+  const hit = cached_reading(commit);
+  if (hit !== void 0) return hit;
+  const measured = await measure_base(commit);
+  const reading = reading_of(measured);
+  if (reading === void 0) throw new Error("josh metrics: the merge-base printed no totals");
+  metrics_base_cache.write(commit, RULER_ROOT, measured);
+  return reading;
+}
+var metrics_base = {
+  APPROVAL_DIRECTORY,
+  BASE_VARIABLE,
+  JSON_FLAG,
+  approval_name,
+  approval_texts,
+  read: read2,
+  resolve_commit,
+  write_approval
+};
+
+export {
+  metrics_ratchet,
+  metrics_base
+};

package/dist/commands/chunk-TBIX42IT.js

@@ -0,0 +1,144 @@
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  git_gh_exec
+} from "./chunk-NAZ753DE.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
+};