@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-43DU7DYZ.js

@@ -0,0 +1,540 @@
+import {
+  bounded_pool
+} from "./chunk-EBVS2LKX.js";
+import {
+  run_startup
+} from "./chunk-RV7EQIE4.js";
+import {
+  token_shape
+} from "./chunk-AQ3PMSXK.js";
+import {
+  gh_api
+} from "./chunk-QVOFWFWC.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  get_exit_code,
+  has_timed_out
+} from "./chunk-B5HP6T4L.js";
+import {
+  COMMAND_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-exec.ts
+import { execa as execa2, execaSync } from "execa";
+
+// scripts/gh/gh-call-kind.ts
+var API = "api";
+var GRAPHQL = "graphql";
+var RATE_LIMIT = "GET rate_limit";
+var GH_PREFIX = "gh ";
+var DEFAULT_METHOD = "GET";
+var BODY_METHOD = "POST";
+var OWNER_REPO = ["repos", "{o}", "{r}"];
+var NUMBER = /^\d+$/u;
+var SHA = /^[\da-f]{7,40}$/u;
+var { METHOD_FLAGS, FIELD_FLAGS: BODY_FLAGS, API_VALUE_TAKING_FLAGS: VALUE_FLAGS } = gh_api;
+var NAME_AFTER = /* @__PURE__ */ new Map([
+  ["commits", "{ref}"],
+  ["branches", "{branch}"],
+  ["heads", "{branch}"],
+  ["labels", "{label}"],
+  ["compare", "{range}"]
+]);
+function placeholder_of(segment, previous = "") {
+  const named = NAME_AFTER.get(previous);
+  if (named !== void 0) return named;
+  if (NUMBER.test(segment)) return "{n}";
+  return SHA.test(segment) ? "{sha}" : segment;
+}
+function normalized(path) {
+  const [bare = ""] = path.replace(/^\//u, "").split("?", 1);
+  const segments = bare.split("/");
+  const is_repo = segments[0] === OWNER_REPO[0];
+  return segments.map(
+    (segment, index) => is_repo && index < OWNER_REPO.length ? OWNER_REPO[index] : placeholder_of(segment, segments[index - 1])
+  ).join("/");
+}
+function of_api(path, method = DEFAULT_METHOD) {
+  const bare = normalized(path);
+  return bare === GRAPHQL ? GRAPHQL : `${method.toUpperCase()} ${bare}`;
+}
+function path_of(arguments_) {
+  const rest = arguments_.slice(1);
+  return rest.find(
+    (argument, index) => !argument.startsWith("-") && !VALUE_FLAGS.has(rest[index - 1] ?? "")
+  ) ?? "";
+}
+function method_of(arguments_) {
+  const flag = arguments_.findIndex((argument) => METHOD_FLAGS.has(argument));
+  if (flag !== -1) return arguments_[flag + 1] ?? DEFAULT_METHOD;
+  return arguments_.some((argument) => BODY_FLAGS.has(argument)) ? BODY_METHOD : DEFAULT_METHOD;
+}
+function of(arguments_) {
+  const [subcommand = "", action = ""] = arguments_;
+  if (subcommand === API) return of_api(path_of(arguments_), method_of(arguments_));
+  const named = action.startsWith("-") ? [subcommand] : [subcommand, action];
+  return `${GH_PREFIX}${named.join(" ")}`.trimEnd();
+}
+function class_of(kind) {
+  if (kind === GRAPHQL) return "graphql";
+  if (kind === RATE_LIMIT) return "free";
+  return kind.startsWith(GH_PREFIX) ? "gh" : "rest";
+}
+var gh_call_kind = { of, of_api, class_of };
+
+// scripts/gh/gh-request-tally.ts
+var STATE_KEY = /* @__PURE__ */ Symbol.for("josh.gh-request-tally");
+function is_state(value) {
+  return typeof value === "object" && value !== null && Reflect.has(value, "endpoints");
+}
+function shared_state() {
+  const existing = Reflect.get(globalThis, STATE_KEY);
+  if (is_state(existing)) return existing;
+  const state = {
+    tally: { calls: 0, not_modified: 0 },
+    endpoints: /* @__PURE__ */ new Map(),
+    core: { read: void 0, start: void 0 }
+  };
+  Reflect.set(globalThis, STATE_KEY, state);
+  return state;
+}
+var { tally, endpoints, core } = shared_state();
+function watch_core(read) {
+  core.read = async () => {
+    try {
+      return await read();
+    } catch {
+      return void 0;
+    }
+  };
+}
+function endpoint_of(kind) {
+  const count = endpoints.get(kind) ?? { calls: 0, not_modified: 0 };
+  endpoints.set(kind, count);
+  return count;
+}
+function snapshot() {
+  const entries = [...endpoints].map(([kind, count]) => [kind, { ...count }]);
+  return { ...tally, endpoints: Object.fromEntries(entries) };
+}
+function count_call(kind) {
+  run_startup.metric("api", gh_call_kind.class_of(kind));
+  if (core.read !== void 0) core.start ??= core.read();
+  tally.calls += 1;
+  endpoint_of(kind).calls += 1;
+}
+function count_not_modified(kind) {
+  tally.not_modified += 1;
+  endpoint_of(kind).not_modified += 1;
+}
+function to_delta(start, end) {
+  if (start === void 0 || start.reset_ms !== end?.reset_ms) return void 0;
+  return end.used - start.used;
+}
+async function core_delta() {
+  if (core.read === void 0 || core.start === void 0) return void 0;
+  const [start, end] = await Promise.all([core.start, core.read()]);
+  return to_delta(start, end);
+}
+function reset() {
+  tally.calls = 0;
+  tally.not_modified = 0;
+  endpoints.clear();
+  core.read = void 0;
+  core.start = void 0;
+}
+var gh_request_tally = {
+  watch_core,
+  count_call,
+  count_not_modified,
+  snapshot,
+  core_delta,
+  reset
+};
+
+// scripts/gh/git-gh-check.ts
+import { execa } from "execa";
+var GH_NOT_INSTALLED_MSG = "gh CLI is not installed. Install it from https://cli.github.com/";
+var gh_check = {};
+async function run_gh_check() {
+  try {
+    await execa("gh", ["--version"], { timeout: COMMAND_TIMEOUT_MS });
+  } catch {
+    delete gh_check.promise;
+    throw new Error(GH_NOT_INSTALLED_MSG);
+  }
+}
+async function check_gh_installed() {
+  gh_check.promise ??= run_gh_check();
+  await gh_check.promise;
+}
+
+// scripts/git/parse-json-array.ts
+function parse_json_loose(raw_json) {
+  return json_value.parse_or_undefined(raw_json);
+}
+function parse_json_array_or_undefined(raw_json, element_schema) {
+  const value = parse_json_loose(raw_json);
+  if (!Array.isArray(value)) return void 0;
+  return element_schema.array().parse(value);
+}
+function read_json_listing(raw_json, element_schema) {
+  try {
+    const rows = parse_json_array_or_undefined(raw_json, element_schema);
+    return rows === void 0 ? { kind: "unreadable" } : { kind: "read", rows };
+  } catch {
+    return { kind: "unexpected_shape" };
+  }
+}
+function parse_json_array_safe(raw_json, element_schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === void 0) return [];
+  return element_schema.array().parse(value);
+}
+function parse_json_object_or_undefined(raw_json, schema) {
+  const value = parse_json_loose(raw_json);
+  if (value === void 0) return void 0;
+  return schema.parse(value);
+}
+var parse_json = {
+  parse_json_object_or_undefined
+};
+
+// scripts/gh/git-gh-failure.ts
+import { z } from "zod";
+var error_document_schema = z.object({ status: z.union([z.string(), z.number()]).optional() }).catch({});
+var GH_FAILURE_FIELD = "gh_failure";
+function has_stdout_field(error) {
+  return error instanceof Error && "stdout" in error && typeof error.stdout === "string";
+}
+function has_gh_failure(error) {
+  return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
+}
+function parse_response_status(stdout) {
+  const document = parse_json.parse_json_object_or_undefined(stdout, error_document_schema);
+  if (document?.status === void 0) return void 0;
+  const status = Number(document.status);
+  return Number.isSafeInteger(status) ? status : void 0;
+}
+function classify_stdout(stdout) {
+  return { status: parse_response_status(stdout) };
+}
+function attach(error, failure) {
+  Object.defineProperty(error, GH_FAILURE_FIELD, {
+    value: failure,
+    enumerable: false,
+    configurable: true
+  });
+  return error;
+}
+function failure_of(error) {
+  return has_gh_failure(error) ? error.gh_failure : void 0;
+}
+function body_of(error) {
+  const cause = error instanceof Error ? error.cause : void 0;
+  return has_stdout_field(cause) ? cause.stdout : void 0;
+}
+var gh_failure = { attach, body_of, classify_stdout, failure_of, parse_response_status };
+
+// scripts/gh/git-gh-retry.ts
+import { setTimeout as delay } from "node:timers/promises";
+var FIRST_RETRY_DELAY_MS = 2e3;
+var SECOND_RETRY_DELAY_MS = 5e3;
+var RETRY_DELAYS_MS = [FIRST_RETRY_DELAY_MS, SECOND_RETRY_DELAY_MS];
+var MAX_ATTEMPTS = RETRY_DELAYS_MS.length + 1;
+var SERVER_ERROR_FLOOR = 500;
+var GH_AUTH_REQUIRED_EXIT_CODE = 4;
+var SPENT_NOTE = "gh: request failed transiently on every attempt";
+var SUMMARY_STATUS_PATTERN = /\(HTTP (?<status>\d{3})\)/u;
+var DEFAULT_HOOKS = {
+  wait: async (milliseconds) => {
+    await delay(milliseconds);
+  },
+  note: (text) => {
+    process.stderr.write(`${text}
+`);
+  }
+};
+function summary_status(error) {
+  const { status } = SUMMARY_STATUS_PATTERN.exec(error.message)?.groups ?? {};
+  return status === void 0 ? void 0 : Number(status);
+}
+function has_answer(spawn_error) {
+  if (!(spawn_error instanceof Error) || !("stdout" in spawn_error)) return false;
+  return typeof spawn_error.stdout === "string" && spawn_error.stdout.trim().length > 0;
+}
+function is_transient_status(status, spawn_error, is_read) {
+  if (is_read && has_timed_out(spawn_error)) return true;
+  if (status === void 0) return !has_answer(spawn_error);
+  return status >= SERVER_ERROR_FLOOR;
+}
+function is_final_spawn(spawn_error, is_read) {
+  return !is_read && has_timed_out(spawn_error) || get_exit_code(spawn_error) === GH_AUTH_REQUIRED_EXIT_CODE;
+}
+function is_transient_request(error, is_read) {
+  const failure = gh_failure.failure_of(error);
+  if (failure === void 0 || !(error instanceof Error)) return false;
+  const status = failure.status ?? summary_status(error);
+  return !is_final_spawn(error.cause, is_read) && is_transient_status(status, error.cause, is_read);
+}
+function is_transient(error) {
+  return is_transient_request(error, false);
+}
+function first_line(error) {
+  return error_text.message_of(error).split("\n", 1)[0] ?? "";
+}
+function retry_note(error, attempt, wait_ms) {
+  const ordinal = `${String(attempt)}/${String(MAX_ATTEMPTS)}`;
+  return `gh: request failed transiently (attempt ${ordinal}: ${first_line(error)}) \u2014 retrying in ${String(wait_ms)} ms`;
+}
+function retry_delay(error, attempt, is_read) {
+  return is_transient_request(error, is_read) ? RETRY_DELAYS_MS[attempt - 1] : void 0;
+}
+function spent_note(message) {
+  return `${SPENT_NOTE} (${message})`;
+}
+function note_spent(error, attempt, hooks, is_read) {
+  if (attempt === MAX_ATTEMPTS && is_transient_request(error, is_read)) {
+    hooks.note(spent_note(first_line(error)));
+  }
+}
+async function retry_request(request, hooks, attempt, is_read) {
+  try {
+    return await request();
+  } catch (error) {
+    const wait_ms = retry_delay(error, attempt, is_read);
+    if (wait_ms === void 0) {
+      note_spent(error, attempt, hooks, is_read);
+      throw error;
+    }
+    hooks.note(retry_note(error, attempt, wait_ms));
+    await hooks.wait(wait_ms);
+    return await retry_request(request, hooks, attempt + 1, is_read);
+  }
+}
+async function with_retry(request, hooks = DEFAULT_HOOKS, attempt = 1) {
+  return await retry_request(request, hooks, attempt, false);
+}
+async function with_read_retry(request, hooks = DEFAULT_HOOKS) {
+  return await retry_request(request, hooks, 1, true);
+}
+var gh_retry = {
+  MAX_ATTEMPTS,
+  RETRY_DELAYS_MS,
+  is_transient,
+  spent_note,
+  with_retry,
+  with_read_retry
+};
+
+// scripts/gh/git-gh-spawn-width.ts
+var GH_SPAWN_CONCURRENCY = 8;
+
+// scripts/gh/git-gh-exec.ts
+var BODY_FROM_STDIN = "-";
+var GH_REQUEST_TIMEOUT_MS = 6e4;
+function to_timeout_option(timeout_ms) {
+  return { timeout: timeout_ms ?? GH_REQUEST_TIMEOUT_MS };
+}
+function direct_environment() {
+  const removed = agent_session_environment.removed_proxy_environment();
+  return Object.keys(removed).length > 0 ? { env: removed } : {};
+}
+function to_spawn_options(timeout_ms, cwd) {
+  return {
+    ...to_timeout_option(timeout_ms),
+    ...direct_environment(),
+    ...cwd !== void 0 && { cwd }
+  };
+}
+var GH_REQUEST_TIMEOUT_MESSAGE = "gh request timed out";
+function has_stderr_field(error) {
+  return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
+}
+function to_timeout_prefix(error) {
+  return has_timed_out(error) ? `${GH_REQUEST_TIMEOUT_MESSAGE}: ` : "";
+}
+function to_gh_error(error) {
+  const stderr = has_stderr_field(error) ? error.stderr.trim() : "";
+  const stdout = has_stdout_field(error) ? error.stdout.trim() : "";
+  const summary = stderr.length > 0 ? stderr : error_text.message_of(error);
+  const detail = stdout.length > 0 ? `${summary}
+${stdout}` : summary;
+  return gh_failure.attach(
+    new Error(`${to_timeout_prefix(error)}${detail}`, { cause: error }),
+    gh_failure.classify_stdout(stdout)
+  );
+}
+var gh_slots = bounded_pool.limiter(GH_SPAWN_CONCURRENCY);
+async function spawn_gh_command(arguments_, timeout_ms, cwd) {
+  await check_gh_installed();
+  const options = to_spawn_options(timeout_ms, cwd);
+  gh_request_tally.count_call(gh_call_kind.of(arguments_));
+  try {
+    const { stdout } = await execa2("gh", arguments_, options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+async function exec_gh_command(arguments_, timeout_ms, cwd) {
+  return await gh_slots.run(async () => await spawn_gh_command(arguments_, timeout_ms, cwd));
+}
+async function spawn_gh_command_with_stdin(input) {
+  await check_gh_installed();
+  const options = { input: input.stdin_body, ...to_spawn_options(input.timeout_ms, input.cwd) };
+  gh_request_tally.count_call(gh_call_kind.of(input.args));
+  try {
+    const { stdout } = await execa2("gh", input.args, options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+async function exec_gh_command_with_stdin(input) {
+  return await gh_slots.run(async () => await spawn_gh_command_with_stdin(input));
+}
+var STATUS_LINE_PATTERN = /^HTTP\/[\d.]+ (?<status>\d{3})\b/u;
+function parse_status_line(output) {
+  const { status } = STATUS_LINE_PATTERN.exec(output)?.groups ?? {};
+  return status === void 0 ? void 0 : Number(status);
+}
+function status_of_failure(error) {
+  return has_stdout_field(error) ? parse_status_line(error.stdout) : void 0;
+}
+async function spawn_gh_api_status(path, timeout_ms) {
+  const options = to_spawn_options(timeout_ms);
+  try {
+    await check_gh_installed();
+    gh_request_tally.count_call(gh_call_kind.of_api(path));
+    const { stdout } = await execa2("gh", ["api", "--include", "--silent", path], options);
+    return parse_status_line(stdout);
+  } catch (error) {
+    return status_of_failure(error);
+  }
+}
+async function exec_gh_api_status(path, timeout_ms) {
+  return await gh_slots.run(async () => await spawn_gh_api_status(path, timeout_ms));
+}
+function exec_gh_api_status_sync(path, timeout_ms) {
+  const options = to_spawn_options(timeout_ms);
+  gh_request_tally.count_call(gh_call_kind.of_api(path));
+  try {
+    const { stdout } = execaSync("gh", ["api", "--include", "--silent", path], options);
+    return parse_status_line(stdout);
+  } catch (error) {
+    return status_of_failure(error);
+  }
+}
+var METHOD_FLAG = "--method";
+var INPUT_FLAG = "--input";
+var PAGINATE_FLAG = "--paginate";
+var SLURP_FLAG = "--slurp";
+var JQ_FLAG = "--jq";
+var ALLOW_ESCAPES_FLAG = "--allow-escape-sequences";
+function optional_flag(flag, value) {
+  return value === void 0 ? [] : [flag, value];
+}
+function refuse_credential_body(request) {
+  if (request.body !== void 0) {
+    token_shape.refuse(token_shape.decoded(request.body), `The gh api ${request.path} body`);
+  }
+}
+function to_gh_api_args(request) {
+  const body_args = request.body === void 0 ? [] : [INPUT_FLAG, BODY_FROM_STDIN];
+  const paginate_args = request.should_paginate === true ? [PAGINATE_FLAG] : [];
+  const slurp_args = request.should_slurp === true ? [SLURP_FLAG] : [];
+  const escape_args = request.should_allow_escapes === true ? [ALLOW_ESCAPES_FLAG] : [];
+  return [
+    "api",
+    request.path,
+    ...optional_flag(METHOD_FLAG, request.method),
+    ...body_args,
+    ...paginate_args,
+    ...slurp_args,
+    ...escape_args,
+    ...optional_flag(JQ_FLAG, request.jq_filter)
+  ];
+}
+async function send_gh_api(request) {
+  const args = to_gh_api_args(request);
+  if (request.body === void 0) {
+    return await exec_gh_command(args, request.timeout_ms, request.cwd);
+  }
+  return await exec_gh_command_with_stdin({
+    args,
+    stdin_body: request.body,
+    timeout_ms: request.timeout_ms,
+    cwd: request.cwd
+  });
+}
+async function exec_gh_api(request) {
+  refuse_credential_body(request);
+  if (request.should_retry === false) return await send_gh_api(request);
+  return await gh_retry.with_retry(async () => await send_gh_api(request));
+}
+async function exec_gh_api_uncounted(request) {
+  const options = to_spawn_options(request.timeout_ms, request.cwd);
+  try {
+    const { stdout } = await execa2("gh", to_gh_api_args(request), options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+function exec_gh_api_sync(request) {
+  refuse_credential_body(request);
+  const body_option = request.body === void 0 ? {} : { input: request.body };
+  const options = { ...body_option, ...to_spawn_options(request.timeout_ms, request.cwd) };
+  const gh_arguments = to_gh_api_args(request);
+  gh_request_tally.count_call(gh_call_kind.of(gh_arguments));
+  try {
+    const { stdout } = execaSync("gh", gh_arguments, options);
+    return stdout.trimEnd();
+  } catch (error) {
+    throw to_gh_error(error);
+  }
+}
+function read_gh_api_sync(request) {
+  try {
+    return exec_gh_api_sync(request);
+  } catch {
+    return void 0;
+  }
+}
+var git_gh_exec = {
+  direct_environment,
+  exec_gh_command,
+  exec_gh_command_with_stdin,
+  exec_gh_api,
+  exec_gh_api_uncounted,
+  exec_gh_api_sync,
+  read_gh_api_sync,
+  exec_gh_api_status,
+  exec_gh_api_status_sync,
+  parse_status_line
+};
+
+export {
+  gh_call_kind,
+  gh_request_tally,
+  parse_json_array_or_undefined,
+  read_json_listing,
+  parse_json_array_safe,
+  parse_json_object_or_undefined,
+  parse_json,
+  has_stdout_field,
+  gh_failure,
+  gh_retry,
+  GH_SPAWN_CONCURRENCY,
+  has_stderr_field,
+  git_gh_exec
+};

package/dist/commands/chunk-43H725LG.js

@@ -0,0 +1,132 @@
+import {
+  process_directories,
+  process_linux
+} from "./chunk-NZ45KOLL.js";
+import {
+  lane_reap
+} from "./chunk-ON4IKRGS.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-residents.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import path from "node:path";
+
+// scripts/lane/process-lane-marks.ts
+import { spawnSync } from "node:child_process";
+var PS_COMMAND = "/bin/ps";
+var LISTING_ARGUMENTS = ["-A", "-ww", "-o", "pid=,command="];
+var ENVIRONMENT_FLAG = "-E";
+var LISTING_BUFFER_BYTES = 67108864;
+var PID_LINE = /^\s*(?<pid>\d+) (?<command>.*)$/u;
+var APPLICATION_BUNDLE = ".app/Contents/";
+var LISTING_PLATFORMS = /* @__PURE__ */ new Set(["darwin"]);
+var MARK = new RegExp(String.raw`(?:^|\s)${lane_child_marker.KEY}=(?<issue>\d+)(?=\s|$)`, "u");
+function command_lines(printed) {
+  const groups = printed.split("\n").map((line) => PID_LINE.exec(line)?.groups);
+  return new Map(
+    groups.filter((group) => group !== void 0).map((group) => [Number(group["pid"]), group["command"] ?? ""])
+  );
+}
+function environment_of(command, with_environment) {
+  if (command === void 0 || command.includes(APPLICATION_BUNDLE)) return void 0;
+  return with_environment.startsWith(command) ? with_environment.slice(command.length) : void 0;
+}
+function mark_of(command, with_environment) {
+  const environment = environment_of(command, with_environment);
+  return environment === void 0 ? void 0 : MARK.exec(environment)?.groups?.["issue"];
+}
+function parse(plain, with_environment) {
+  const commands = command_lines(plain);
+  const marks = [...command_lines(with_environment)].map(
+    ([pid, line]) => [pid, mark_of(commands.get(pid), line)]
+  );
+  return new Map(marks.filter((pair) => pair[1] !== void 0));
+}
+function listing(arguments_) {
+  const result = spawnSync(PS_COMMAND, arguments_, {
+    encoding: "utf8",
+    maxBuffer: LISTING_BUFFER_BYTES,
+    timeout: PROBE_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return result.error === void 0 && result.status === 0 ? result.stdout : void 0;
+}
+function darwin_marks() {
+  const plain = listing(LISTING_ARGUMENTS);
+  const with_environment = listing([ENVIRONMENT_FLAG, ...LISTING_ARGUMENTS]);
+  if (plain === void 0 || with_environment === void 0) return void 0;
+  return parse(plain, with_environment);
+}
+function list_all(platform = process.platform) {
+  if (platform === "linux") return process_linux.marks();
+  return LISTING_PLATFORMS.has(platform) ? darwin_marks() : /* @__PURE__ */ new Map();
+}
+var process_lane_marks = { list_all, parse };
+
+// scripts/lane/lane-residents.ts
+var GROUP_ARGUMENTS = ["-o", "pid=,pgid=", "-p"];
+var PID_SEPARATOR = ",";
+var PAIR_LENGTH = 2;
+function parse_groups(printed) {
+  const pairs = printed.split("\n").map((line) => line.trim().split(/\s+/u).map(Number)).filter((pair) => pair.length === PAIR_LENGTH && pair.every((id) => Number.isSafeInteger(id)));
+  return new Map(pairs.map(([pid = 0, group = 0]) => [pid, group]));
+}
+function groups_of(pids) {
+  const result = spawnSync2(lane_reap.PS_COMMAND, [...GROUP_ARGUMENTS, pids.join(PID_SEPARATOR)], {
+    encoding: "utf8",
+    timeout: PROBE_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return parse_groups(result.stdout);
+}
+var SYSTEM_PROBES = {
+  directories: () => process_directories.list_all(),
+  marks: () => process_lane_marks.list_all(),
+  own: () => lane_reap.own_ancestry(),
+  groups_of,
+  terminate: (pid) => lane_reap.SYSTEM_PROBES.terminate(pid)
+};
+function outside_own_group(candidates, probes) {
+  if (candidates.length === 0) return candidates;
+  const groups = probes.groups_of([process.pid, ...candidates]);
+  const own_group = groups.get(process.pid);
+  return candidates.filter((pid) => own_group === void 0 || groups.get(pid) !== own_group);
+}
+function lane_processes(lane, directories, marks) {
+  const root = path.dirname(lane.directory);
+  const within = [...directories].filter(([, cwd]) => process_directories.lane_of(cwd, root) === lane.issue).map(([pid]) => pid);
+  const marked = [...marks].filter(([, issue]) => issue === lane.issue).map(([pid]) => pid);
+  return [.../* @__PURE__ */ new Set([...within, ...marked])];
+}
+function residents(lane, probes = SYSTEM_PROBES) {
+  const directories = probes.directories();
+  const marks = probes.marks();
+  if (directories === void 0 || marks === void 0) return void 0;
+  const own = probes.own();
+  const candidates = lane_processes(lane, directories, marks).filter((pid) => !own.has(pid));
+  return outside_own_group(candidates, probes);
+}
+function end_residents(lane, spared, probes = SYSTEM_PROBES) {
+  return residents(lane, probes)?.filter((pid) => !spared.includes(pid)).filter((pid) => probes.terminate(pid));
+}
+function residents_sentence(ended, cited) {
+  if (ended === void 0) {
+    return `Could not read which processes still run from the lane for ${cited} (lsof or ps failed); none of them was ended.`;
+  }
+  if (ended.length === 0) return void 0;
+  return `Terminated ${String(ended.length)} process(es) still running from the lane for ${cited}: ${ended.join(", ")}.`;
+}
+function report(ended, cited) {
+  const sentence = residents_sentence(ended, cited);
+  if (sentence !== void 0) console.error(sentence);
+}
+var lane_residents = { end_residents, parse_groups, report, residents, residents_sentence };
+
+export {
+  lane_residents
+};