@joshuafolkken/kit 1.2116.0 → 1.3000.0

package/dist/commands/chunk-QS5USD4T.js

@@ -0,0 +1,540 @@
+import {
+  lane_await
+} from "./chunk-WWC5L3AO.js";
+import {
+  lane_ledger
+} from "./chunk-XYAK53TK.js";
+import {
+  run_board_usage_rusage
+} from "./chunk-FCINBCKB.js";
+import {
+  machine_capacity
+} from "./chunk-KXHXMERX.js";
+import {
+  lane_registry
+} from "./chunk-LRS2OS5J.js";
+import {
+  run_event_stream_emit
+} from "./chunk-34LAULSC.js";
+import {
+  run_event_stream
+} from "./chunk-NSAVEXVR.js";
+import {
+  lane_ledger_write
+} from "./chunk-I63RNFFR.js";
+import {
+  MS_PER_MINUTE,
+  MS_PER_SECOND,
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-load.ts
+import { loadavg } from "node:os";
+import { execa as execa2 } from "execa";
+
+// scripts/lane/lane-process-load.ts
+import { execa } from "execa";
+var { load_builtin, rusage_reader } = run_board_usage_rusage;
+var PS_ARGUMENTS = ["-A", "-o", "pid=,rss=,%cpu=,args="];
+var PS_ENVIRONMENT = { LC_ALL: "C" };
+var FIELD_SEPARATOR = /\s+/u;
+var KB_PER_MB = 1024;
+var BYTES_PER_MB = KB_PER_MB * KB_PER_MB;
+var TOP_KINDS = 5;
+var OTHER_KIND = "other";
+var RESIDENT_APPS = ["Google Chrome.app", "Visual Studio Code.app"];
+var RESIDENT_APPS_VARIABLE = "JOSH_LANE_RESIDENT_APPS";
+var NAME_SEPARATOR = ",";
+var KIND_PATTERNS = [
+  ["vscode", /Visual Studio Code|Code Helper|\.vscode\/extensions\//u],
+  ["vitest", /vitest/u],
+  ["eslint", /eslint/u],
+  ["tsc", /\btsc\b|svelte-check|typescript/u],
+  ["cspell", /cspell/u],
+  ["prettier", /prettier/u],
+  ["playwright", /playwright/u],
+  ["chrome", /Google Chrome/u],
+  ["chromium", /chromium|headless_shell/iu],
+  ["claude", /(?:^|\/)claude(?:\s|$)|@anthropic-ai\/claude-code\//u],
+  ["josh", /josh(?:-ready)?\.[jt]s|\btsx\b|(?<!\.)\bpnpm\b/u],
+  ["node", /\bnode\b/u]
+];
+function kind_of(command_line) {
+  return KIND_PATTERNS.find(([, pattern]) => pattern.test(command_line))?.[0] ?? OTHER_KIND;
+}
+function line_of(line) {
+  const [pid, rss, cpu, ...command] = line.trim().split(FIELD_SEPARATOR);
+  const reading = { pid: Number(pid), cpu_percent: Number(cpu), rss_mb: Number(rss) / KB_PER_MB };
+  if (command.length === 0 || Number.isNaN(reading.pid + reading.cpu_percent + reading.rss_mb)) {
+    return void 0;
+  }
+  return { command_line: command.join(" "), ...reading };
+}
+function footprint_mb_of(footprint, pid) {
+  const footprint_bytes = footprint?.(pid)?.footprint_bytes;
+  return footprint_bytes === void 0 ? void 0 : footprint_bytes / BYTES_PER_MB;
+}
+function process_of(line, footprint) {
+  const reading = line_of(line);
+  if (reading === void 0) return void 0;
+  return {
+    kind: kind_of(reading.command_line),
+    cpu_percent: reading.cpu_percent,
+    rss_mb: reading.rss_mb,
+    footprint_mb: footprint_mb_of(footprint, reading.pid)
+  };
+}
+function resident_apps(value = process.env[RESIDENT_APPS_VARIABLE]) {
+  if (value === void 0) return RESIDENT_APPS;
+  return value.split(NAME_SEPARATOR).map((name) => name.trim()).filter((name) => name.length > 0);
+}
+function is_resident(reading, names) {
+  return reading !== void 0 && names.some((name) => reading.command_line.includes(name));
+}
+function resident_mb(listing, names) {
+  if (names.length === 0) return void 0;
+  const readings = listing.split("\n").map((line) => line_of(line));
+  const resident = readings.filter((reading) => is_resident(reading, names));
+  return Math.round(resident.reduce((total, reading) => total + reading.rss_mb, 0));
+}
+function add_reading(total, reading) {
+  total.cpu_percent += reading.cpu_percent;
+  total.rss_mb += reading.rss_mb;
+  total.count += 1;
+  if (reading.footprint_mb !== void 0) {
+    total.footprint_mb = (total.footprint_mb ?? 0) + reading.footprint_mb;
+  }
+}
+function add_line(totals, line, footprint) {
+  const reading = process_of(line, footprint);
+  if (reading === void 0) return;
+  const { kind } = reading;
+  const total = totals.get(kind) ?? { kind, cpu_percent: 0, rss_mb: 0, count: 0 };
+  add_reading(total, reading);
+  totals.set(kind, total);
+}
+function rounded(total) {
+  const { footprint_mb, ...rest } = total;
+  const kind = {
+    ...rest,
+    cpu_percent: Math.round(rest.cpu_percent),
+    rss_mb: Math.round(rest.rss_mb)
+  };
+  return footprint_mb === void 0 ? kind : { ...kind, footprint_mb: Math.round(footprint_mb) };
+}
+function by_weight(left, right) {
+  return right.cpu_percent - left.cpu_percent || right.rss_mb - left.rss_mb;
+}
+function summarize(listing, footprint) {
+  const totals = /* @__PURE__ */ new Map();
+  for (const line of listing.split("\n")) add_line(totals, line, footprint);
+  return [...totals.values()].map((total) => rounded(total)).toSorted(by_weight).slice(0, TOP_KINDS);
+}
+async function read(names = resident_apps(), footprint = rusage_reader(process.platform, load_builtin)) {
+  try {
+    const { stdout } = await execa("ps", PS_ARGUMENTS, {
+      env: PS_ENVIRONMENT,
+      timeout: PROBE_TIMEOUT_MS
+    });
+    return { processes: summarize(stdout, footprint), resident_mb: resident_mb(stdout, names) };
+  } catch {
+    return void 0;
+  }
+}
+var lane_process_load = {
+  RESIDENT_APPS,
+  TOP_KINDS,
+  kind_of,
+  read,
+  resident_apps,
+  resident_mb,
+  summarize
+};
+
+// scripts/lane/lane-load.ts
+function count_working(lanes, is_running = lane_await.is_process_running_default) {
+  return lanes.filter((lane) => !lane.is_stranded && is_running(lane.issue)).length;
+}
+async function read_lanes() {
+  try {
+    return count_working(await lane_registry.list_lanes());
+  } catch {
+    return void 0;
+  }
+}
+function rounded2(megabytes) {
+  return megabytes === void 0 ? void 0 : Math.round(megabytes);
+}
+var CLOCK_SYSCTL_NAMES = ["hw.tbfrequency", "machdep.wake_abstime", "machdep.wake_conttime"];
+var SLEEP_SYSCTL_NAMES = [...CLOCK_SYSCTL_NAMES, "kern.boottime", "kern.waketime"];
+var SYSCTL_LINE = /^(?<name>[\w.]+): (?<value>\d+)$/gmu;
+var SYSCTL_TIME = /^kern\.(?<name>boottime|waketime): \{ sec = (?<seconds>\d+)/gmu;
+function parse_times(stdout) {
+  const times = new Map(
+    Array.from(stdout.matchAll(SYSCTL_TIME), (match) => [
+      match.groups?.["name"],
+      Number(match.groups?.["seconds"]) * MS_PER_SECOND
+    ])
+  );
+  return { booted_ms: times.get("boottime"), woke_ms: times.get("waketime") };
+}
+function parse_slept_ms(stdout) {
+  const values = new Map(
+    Array.from(stdout.matchAll(SYSCTL_LINE), (match) => [
+      match.groups?.["name"],
+      Number(match.groups?.["value"])
+    ])
+  );
+  const [frequency = 0, awake = 0, total = 0] = CLOCK_SYSCTL_NAMES.map((name) => values.get(name));
+  if ([frequency, awake, total].includes(0)) return void 0;
+  return Math.round((total - awake) / frequency * MS_PER_SECOND);
+}
+async function read_host_sleep() {
+  if (process.platform !== "darwin") return {};
+  const { stdout } = await execa2("sysctl", SLEEP_SYSCTL_NAMES, {
+    reject: false,
+    timeout: PROBE_TIMEOUT_MS
+  });
+  return { slept_ms: parse_slept_ms(stdout), ...parse_times(stdout) };
+}
+async function sample(at) {
+  const [memory, lanes, reading, host_sleep] = await Promise.all([
+    machine_capacity.read_memory(),
+    read_lanes(),
+    lane_process_load.read(),
+    read_host_sleep()
+  ]);
+  const [load = 0] = loadavg();
+  return {
+    kind: "load",
+    at,
+    load,
+    available_mb: rounded2(memory.available_mb),
+    swapped_mb: rounded2(memory.swapped_mb),
+    lanes,
+    processes: reading?.processes,
+    resident_mb: reading?.resident_mb,
+    ...host_sleep
+  };
+}
+var lane_load = {
+  count_working,
+  parse_slept_ms,
+  parse_times,
+  sample
+};
+
+// scripts/lane/lane-sleep.ts
+var { EVENT_KIND } = run_event_stream;
+var GAP_INTERVALS = 3;
+function gap_of(last_ms, now_ms, interval_ms) {
+  if (now_ms - last_ms <= interval_ms * GAP_INTERVALS) return void 0;
+  return { from_ms: last_ms + interval_ms, to_ms: now_ms };
+}
+function event_of(span) {
+  const elapsed_ms2 = span.to_ms - span.from_ms;
+  const minutes = (elapsed_ms2 / MS_PER_MINUTE).toFixed(1);
+  return {
+    at: new Date(span.to_ms).toISOString(),
+    kind: EVENT_KIND.SLEEP,
+    text: `host slept ${minutes} min`,
+    elapsed_ms: elapsed_ms2
+  };
+}
+async function record(span, events_path) {
+  const target = events_path ?? await run_event_stream_emit.stream_target();
+  if (target === void 0) return;
+  run_event_stream.append_event(target, event_of(span));
+}
+function spans(events) {
+  return events.filter((event) => event.kind === EVENT_KIND.SLEEP).map((event) => {
+    const to_ms = Date.parse(event.at);
+    return { from_ms: to_ms - (event.elapsed_ms ?? 0), to_ms };
+  });
+}
+var lane_sleep = { gap_of, record, spans };
+
+// scripts/lane/lane-sampler.ts
+var SAMPLE_INTERVAL_MS = 6e4;
+async function take(context = {}) {
+  const at = new Date(context.now_ms ?? Date.now()).toISOString();
+  const entry = await lane_load.sample(at);
+  await lane_ledger_write.record(entry, context.ledger_path);
+  return entry;
+}
+async function newest_load(ledger_path) {
+  const path = ledger_path ?? await lane_ledger.target();
+  if (path === void 0) return void 0;
+  return lane_ledger.read_entries(path).findLast((entry) => entry.kind === lane_ledger.KIND.LOAD);
+}
+function counter_growth(previous, current) {
+  if (previous.booted_ms !== current.booted_ms) return 0;
+  return (current.slept_ms ?? 0) - (previous.slept_ms ?? Infinity);
+}
+function sleep_since(previous, current) {
+  if (previous === void 0) return void 0;
+  const slept_ms = counter_growth(previous, current);
+  if (slept_ms < SAMPLE_INTERVAL_MS) return void 0;
+  const to_ms = Math.min(Date.parse(current.at), current.woke_ms ?? Infinity);
+  return { from_ms: Math.max(Date.parse(previous.at), to_ms - slept_ms), to_ms };
+}
+async function take_quietly(context) {
+  try {
+    await take(context);
+  } catch {
+  }
+}
+async function record_quietly(span, context) {
+  try {
+    await lane_sleep.record(span, context.events_path);
+  } catch {
+  }
+}
+async function take_first(context) {
+  try {
+    const previous = await newest_load(context.ledger_path);
+    const slept = sleep_since(previous, await take(context));
+    if (slept !== void 0) await record_quietly(slept, context);
+  } catch {
+  }
+}
+function start(context = {}) {
+  let last_ms = Date.now();
+  void take_first(context);
+  const timer = setInterval(() => {
+    const now_ms = Date.now();
+    const slept = lane_sleep.gap_of(last_ms, now_ms, SAMPLE_INTERVAL_MS);
+    last_ms = now_ms;
+    if (slept !== void 0) void record_quietly(slept, context);
+    void take_quietly(context);
+  }, SAMPLE_INTERVAL_MS).unref();
+  return () => {
+    clearInterval(timer);
+  };
+}
+var lane_sampler = {
+  SAMPLE_INTERVAL_MS,
+  start,
+  take
+};
+
+// scripts/lane/lane-tail-stats.ts
+var OVERRUN_LANE_MINUTES = 40;
+var TAIL_PERCENTILE = 90;
+var WHOLE_PERCENT = 100;
+function is_overrun(minutes) {
+  return minutes > OVERRUN_LANE_MINUTES;
+}
+function overrun_count(minutes) {
+  return minutes.filter((value) => is_overrun(value)).length;
+}
+function tail_minutes(minutes) {
+  if (minutes.length === 0) return void 0;
+  const sorted = minutes.toSorted((left, right) => left - right);
+  const rank = Math.ceil(TAIL_PERCENTILE / WHOLE_PERCENT * sorted.length);
+  return sorted[rank - 1];
+}
+var lane_tail_stats = { is_overrun, OVERRUN_LANE_MINUTES, overrun_count, tail_minutes };
+
+// scripts/lane/lane-stats.ts
+var MS_PER_HOUR = 36e5;
+var ACTIVE_GAP_MS = MS_PER_HOUR;
+var MS_PER_DAY = 864e5;
+var MB_PER_GB = 1024;
+var HALF = 2;
+var MIN_RATE_GAP_MS = lane_sampler.SAMPLE_INTERVAL_MS / HALF;
+var DECIMALS = 1;
+var DAY_DIGITS = 3;
+var MISSING = "\u2014";
+var CELL_SEPARATOR = " | ";
+var COLUMNS = [
+  "JOSH_LANE_LIMIT",
+  "period (days)",
+  "merges",
+  "merges / hour",
+  "effective lanes",
+  "lane median (min)",
+  `lanes over ${String(lane_tail_stats.OVERRUN_LANE_MINUTES)} min`,
+  "lane p90 (min)",
+  "gate median (min)",
+  "gate max (min)",
+  "load peak",
+  "load mean",
+  "swapped peak (GB/h)",
+  "swapped mean (GB/h)",
+  "free memory min (GB)",
+  "free memory mean (GB)",
+  "load samples"
+];
+function window_of(period_days, now_ms) {
+  return { since_ms: now_ms - period_days * MS_PER_DAY, until_ms: now_ms };
+}
+function days_of(window) {
+  return String(Number(((window.until_ms - window.since_ms) / MS_PER_DAY).toPrecision(DAY_DIGITS)));
+}
+function in_window(entries, window) {
+  return entries.filter((entry) => {
+    const at = Date.parse(entry.at);
+    return at >= window.since_ms && at <= window.until_ms;
+  });
+}
+function is_gate(entry) {
+  return entry.kind === "gate";
+}
+function is_merge(entry) {
+  return entry.kind === "merge";
+}
+function is_dispatch(entry) {
+  return entry.kind === "dispatch";
+}
+function is_load(entry) {
+  return entry.kind === "load";
+}
+function is_number(value) {
+  return value !== void 0;
+}
+function mean(values) {
+  if (values.length === 0) return void 0;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function median(values) {
+  if (values.length === 0) return void 0;
+  const sorted = values.toSorted((left, right) => left - right);
+  const middle = Math.floor(sorted.length / HALF);
+  return sorted.length % HALF === 0 ? mean(sorted.slice(middle - 1, middle + 1)) : sorted[middle];
+}
+function peak(values) {
+  return values.length === 0 ? void 0 : Math.max(...values);
+}
+function lowest(values) {
+  return values.length === 0 ? void 0 : Math.min(...values);
+}
+function is_working(sample2) {
+  return (sample2.lanes ?? 0) > 0;
+}
+function sample_pairs(samples) {
+  const sorted = samples.toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+  return sorted.slice(1).map((next, index) => ({ sample: sorted[index] ?? next, next }));
+}
+function elapsed_ms({ sample: sample2, next }) {
+  return Date.parse(next.at) - Date.parse(sample2.at);
+}
+function sum_hours(gaps) {
+  const active = gaps.filter((gap) => gap <= ACTIVE_GAP_MS).reduce((sum, gap) => sum + gap, 0);
+  return active > 0 ? active / MS_PER_HOUR : void 0;
+}
+function gap_hours(entries) {
+  const instants = entries.filter((entry) => entry.kind === "merge" || is_gate(entry)).map((entry) => Date.parse(entry.at)).toSorted((left, right) => left - right);
+  return sum_hours(
+    instants.slice(1).map((instant, index) => instant - (instants[index] ?? instant))
+  );
+}
+function sampled_hours(samples) {
+  const gaps = sample_pairs(samples).filter(({ sample: sample2 }) => is_working(sample2)).map((pair) => elapsed_ms(pair));
+  return sum_hours(gaps);
+}
+function swap_rate(pair) {
+  const swapped = machine_capacity.swapped_between(pair.sample.swapped_mb, pair.next.swapped_mb);
+  const elapsed = elapsed_ms(pair);
+  const is_one_interval = elapsed >= MIN_RATE_GAP_MS && elapsed <= ACTIVE_GAP_MS;
+  if (swapped === void 0 || !is_one_interval) return void 0;
+  return swapped / MB_PER_GB / (elapsed / MS_PER_HOUR);
+}
+function active_hours(entries) {
+  const samples = entries.filter(is_load);
+  return samples.some((sample2) => is_working(sample2)) ? sampled_hours(samples) : gap_hours(entries);
+}
+function gigabytes(megabytes) {
+  return megabytes === void 0 ? void 0 : megabytes / MB_PER_GB;
+}
+function cell(value) {
+  return value === void 0 ? MISSING : value.toFixed(DECIMALS);
+}
+function throughput_cells(entries) {
+  const merges = entries.filter((entry) => entry.kind === "merge").length;
+  const hours = active_hours(entries);
+  const lanes = entries.filter(is_load).filter(is_working).map((entry) => entry.lanes);
+  const per_hour = hours === void 0 ? void 0 : merges / hours;
+  return [String(merges), cell(per_hour), cell(mean(lanes))];
+}
+function dispatched_before(dispatches, merge) {
+  const merged_at = Date.parse(merge.at);
+  const starts = dispatches.filter((dispatch) => dispatch.issue === merge.issue).map((dispatch) => Date.parse(dispatch.at)).filter((at) => at <= merged_at);
+  return peak(starts);
+}
+function lane_minutes(dispatches, merge) {
+  const start2 = dispatched_before(dispatches, merge);
+  return start2 === void 0 ? void 0 : (Date.parse(merge.at) - start2) / MS_PER_MINUTE;
+}
+function merge_minutes(entries, period) {
+  const dispatches = entries.filter(is_dispatch);
+  return period.filter((entry) => is_merge(entry)).map((merge) => lane_minutes(dispatches, merge)).filter(is_number);
+}
+function lane_cells(entries, period) {
+  const minutes = merge_minutes(entries, period);
+  return [
+    cell(median(minutes)),
+    String(lane_tail_stats.overrun_count(minutes)),
+    cell(lane_tail_stats.tail_minutes(minutes))
+  ];
+}
+function gate_cells(entries) {
+  const minutes = entries.filter(is_gate).filter((entry) => entry.is_reused !== true).map((entry) => entry.elapsed_ms / MS_PER_MINUTE);
+  return [cell(median(minutes)), cell(peak(minutes))];
+}
+function swap_cells(samples) {
+  const pairs = sample_pairs(samples);
+  const rates = pairs.map((pair) => swap_rate(pair)).filter(is_number);
+  const working_rates = pairs.filter(({ sample: sample2 }) => is_working(sample2)).map((pair) => swap_rate(pair)).filter(is_number);
+  return [cell(peak(rates)), cell(mean(working_rates))];
+}
+function load_cells(samples) {
+  const working = samples.filter(is_working);
+  const free = samples.map((sample2) => sample2.available_mb).filter(is_number);
+  const working_free = working.map((sample2) => sample2.available_mb).filter(is_number);
+  return [
+    cell(peak(samples.map((sample2) => sample2.load))),
+    cell(mean(working.map((sample2) => sample2.load))),
+    ...swap_cells(samples),
+    cell(gigabytes(lowest(free))),
+    cell(gigabytes(mean(working_free))),
+    String(samples.length)
+  ];
+}
+function to_row(cells) {
+  return `| ${cells.join(CELL_SEPARATOR)} |`;
+}
+function header() {
+  return [to_row(COLUMNS), to_row(COLUMNS.map(() => "---"))].join("\n");
+}
+function row(entries, window, label) {
+  const period = in_window(entries, window);
+  return to_row([
+    label.limit,
+    days_of(window),
+    ...throughput_cells(period),
+    ...lane_cells(entries, period),
+    ...gate_cells(period),
+    ...load_cells(period.filter(is_load))
+  ]);
+}
+var lane_stats = {
+  COLUMNS,
+  MISSING,
+  header,
+  in_window,
+  mean,
+  median,
+  merge_minutes,
+  peak,
+  row,
+  to_row,
+  window_of
+};
+
+export {
+  lane_sleep,
+  lane_sampler,
+  lane_tail_stats,
+  lane_stats
+};

package/dist/commands/chunk-QVOFWFWC.js

@@ -0,0 +1,134 @@
+import {
+  git_argv
+} from "./chunk-G6BXCWPH.js";
+
+// scripts/rules/gh-api.ts
+var GH_FLAGS = String.raw`(?:-{1,2}[\w-]+(?:[= ][^\s]+)?\s+)*`;
+var GH_API_COMMAND = new RegExp(String.raw`^gh\s+${GH_FLAGS}api\s`, "u");
+var GH_COMMAND = "gh";
+var METHOD_FLAGS = /* @__PURE__ */ new Set(["-X", "--method"]);
+var ATTACHED_METHOD = /^(?:-X=?|--method=)([A-Za-z]+)$/u;
+var FIELD_FLAGS = /* @__PURE__ */ new Set(["-f", "-F", "--field", "--raw-field", "--input"]);
+var ATTACHED_FIELD = /^(?:-[fF].|--(?:raw-field|field|input)=)/u;
+var QUOTES = /['"]/gu;
+var FLAG_PREFIX = "-";
+var NEXT = 1;
+var READ_METHOD = "GET";
+var API_VALUE_TAKING_FLAGS = /* @__PURE__ */ new Set([
+  "-R",
+  "--repo",
+  ...METHOD_FLAGS,
+  ...FIELD_FLAGS,
+  "-H",
+  "--header",
+  "-q",
+  "--jq",
+  "-t",
+  "--template",
+  "--hostname",
+  "-p",
+  "--preview",
+  "--cache"
+]);
+var INCLUDE_CLUSTER = /^-i+(?=[A-Za-z])/u;
+var REPO_PATH = /repos\/([^/\s'"?]+)\/([^/\s'"?]+)/u;
+var OWNER_GROUP = 1;
+var REPO_GROUP = 2;
+var OWNER_PLACEHOLDERS = /* @__PURE__ */ new Set(["{owner}", ":owner"]);
+function is_gh_api(segment) {
+  return GH_API_COMMAND.test(segment);
+}
+function flags_of(segment) {
+  const words = (git_argv.arguments_of(segment, GH_COMMAND) ?? []).map(
+    (word) => word.replace(INCLUDE_CLUSTER, "-")
+  );
+  let has_value_pending = false;
+  return words.map((word, index) => [word, words[index + NEXT] ?? ""]).filter(([word]) => {
+    if (has_value_pending) {
+      has_value_pending = false;
+      return false;
+    }
+    has_value_pending = API_VALUE_TAKING_FLAGS.has(word);
+    return word.startsWith(FLAG_PREFIX);
+  });
+}
+function method_value(flag, next) {
+  if (METHOD_FLAGS.has(flag)) return next.replaceAll(QUOTES, "");
+  return ATTACHED_METHOD.exec(flag)?.[1];
+}
+function method_of(segment) {
+  const methods = flags_of(segment).map(([flag, next]) => method_value(flag, next));
+  return methods.findLast((method) => method !== void 0)?.toUpperCase();
+}
+function is_field_flag(flag) {
+  return FIELD_FLAGS.has(flag) || ATTACHED_FIELD.test(flag);
+}
+function is_read(segment) {
+  const method = method_of(segment);
+  if (method !== void 0) return method === READ_METHOD;
+  return flags_of(segment).every(([flag]) => !is_field_flag(flag));
+}
+function is_write(segment) {
+  return !is_read(segment);
+}
+var INPUT_FLAG = "--input";
+var READS_FILE_FLAGS = /* @__PURE__ */ new Set(["-F", "--field"]);
+var ATTACHED_PARTS = /^(-[fF]|--(?:raw-field|field|input))=?(.+)$/u;
+var ATTACHED_FLAG_GROUP = 1;
+var ATTACHED_VALUE_GROUP = 2;
+var FILE_PREFIX = "@";
+var STANDARD_INPUT = "-";
+var FIELD_KEY_END = "=";
+function field_parts(flag, next) {
+  if (FIELD_FLAGS.has(flag)) return [flag, next];
+  const match = ATTACHED_PARTS.exec(flag);
+  if (match === null) return void 0;
+  return [String(match[ATTACHED_FLAG_GROUP]), String(match[ATTACHED_VALUE_GROUP])];
+}
+function field_value(value) {
+  return value.slice(value.indexOf(FIELD_KEY_END) + NEXT);
+}
+function file_path(flag, value) {
+  if (flag === INPUT_FLAG) return value;
+  const sent = field_value(value);
+  if (!READS_FILE_FLAGS.has(flag) || !sent.startsWith(FILE_PREFIX)) return void 0;
+  return sent.slice(FILE_PREFIX.length);
+}
+function field_source(flag, raw) {
+  const value = raw.replaceAll(QUOTES, "");
+  const path = file_path(flag, value);
+  if (path === void 0) return { kind: "text", value: field_value(value) };
+  return path === STANDARD_INPUT ? void 0 : { kind: "file", value: path };
+}
+function field_sources(segment) {
+  return flags_of(segment).flatMap(([flag, next]) => {
+    const parts = field_parts(flag, next);
+    const source = parts === void 0 ? void 0 : field_source(...parts);
+    return source === void 0 ? [] : [source];
+  });
+}
+function repo_target(segment) {
+  const match = REPO_PATH.exec(segment);
+  if (match === null) return void 0;
+  return { owner: match[OWNER_GROUP] ?? "", repo: match[REPO_GROUP] ?? "" };
+}
+function is_owner_placeholder(owner) {
+  return OWNER_PLACEHOLDERS.has(owner);
+}
+var gh_api = {
+  API_VALUE_TAKING_FLAGS,
+  FIELD_FLAGS,
+  GH_FLAGS,
+  METHOD_FLAGS,
+  field_sources,
+  is_gh_api,
+  is_owner_placeholder,
+  is_read,
+  is_write,
+  method_of,
+  repo_target
+};
+
+export {
+  gh_api
+};