@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/hooks/chunk-IURJANNZ.js

@@ -1,1082 +0,0 @@
-import {
-  core_weights,
-  package_version_schema,
-  resolve_local_bin,
-  resolve_package_bin,
-  unit_worker_share
-} from "./chunk-AO4TOV4V.js";
-import {
-  find_package_directory,
-  package_manifest,
-  poll,
-  process_owner_schema
-} from "./chunk-G5WSPYJ6.js";
-import {
-  lane_ledger_write,
-  lane_paths,
-  process_identity
-} from "./chunk-FOW4B7OQ.js";
-import {
-  MS_PER_SECOND,
-  PLATFORM_TEMP_ROOT,
-  PROBE_TIMEOUT_MS,
-  execa,
-  external_exports,
-  json_value,
-  stamp_file
-} from "./chunk-CY3ADSDR.js";
-
-// scripts/gate/toolchain-inputs.ts
-import { createHash } from "node:crypto";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import path from "node:path";
-var PACKAGE_FILES = [
-  "package.json",
-  "pnpm-lock.yaml",
-  "pnpm-workspace.yaml",
-  "package-lock.json",
-  "yarn.lock",
-  "bun.lock",
-  "bun.lockb",
-  ".npmrc",
-  "node_modules/.modules.yaml"
-];
-var CONFIG_ENTRIES = [
-  /^eslint\.config\.[cm]?[jt]s$/u,
-  /^tsconfig(?:\.[\w-]+)?\.json$/u
-];
-var CONFIG_DIRECTORIES = /* @__PURE__ */ new Set(["eslint", "tsconfig"]);
-var TEST_MARKER = ".test.";
-var SEPARATOR = "/";
-var DIGEST_ALGORITHM = "sha256";
-function by_code_unit(left, right) {
-  if (left === right) return 0;
-  return left < right ? -1 : 1;
-}
-function to_posix(relative) {
-  return relative.split(path.sep).join(SEPARATOR);
-}
-function is_config_entry(name) {
-  return CONFIG_ENTRIES.some((entry) => entry.test(name));
-}
-function is_config_module(relative) {
-  const [top = ""] = relative.split(SEPARATOR, 1);
-  return CONFIG_DIRECTORIES.has(top) && !path.basename(relative).includes(TEST_MARKER);
-}
-function is_input(relative) {
-  const posix = to_posix(relative);
-  if (PACKAGE_FILES.includes(posix)) return true;
-  return is_config_entry(posix) || is_config_module(posix);
-}
-function modules_under(root, directory) {
-  const absolute = path.join(root, directory);
-  if (!existsSync(absolute)) return [];
-  return readdirSync(absolute, { recursive: true, withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => to_posix(path.relative(root, path.join(entry.parentPath, entry.name)))).filter((relative) => is_config_module(relative));
-}
-function paths(root) {
-  const present = PACKAGE_FILES.filter((relative) => existsSync(path.join(root, relative)));
-  const entries = readdirSync(root).filter((name) => is_config_entry(name));
-  const modules = [...CONFIG_DIRECTORIES].flatMap((directory) => modules_under(root, directory));
-  return [...present, ...entries, ...modules].toSorted(by_code_unit);
-}
-function read_or_empty(file) {
-  try {
-    return readFileSync(file);
-  } catch {
-    return new Uint8Array();
-  }
-}
-function digest(root) {
-  const hash = createHash(DIGEST_ALGORITHM);
-  for (const relative of paths(root)) {
-    hash.update(`${relative}\0`).update(read_or_empty(path.join(root, relative))).update("\0");
-  }
-  return hash.digest("hex");
-}
-var toolchain_inputs = { digest, is_input, PACKAGE_FILES, paths };
-
-// scripts/run/board/run-board-usage-rusage.ts
-var PROC_LIBRARY = "/usr/lib/libproc.dylib";
-var SYSTEM_LIBRARY = "/usr/lib/libSystem.B.dylib";
-var RUSAGE_INFO_V2 = 2;
-var RUSAGE_INFO_V2_BYTES = 160;
-var USER_TIME_OFFSET = 16;
-var SYSTEM_TIME_OFFSET = 24;
-var CHILD_USER_TIME_OFFSET = 96;
-var CHILD_SYSTEM_TIME_OFFSET = 104;
-var PHYS_FOOTPRINT_OFFSET = 72;
-var TIME_OFFSETS = [
-  USER_TIME_OFFSET,
-  SYSTEM_TIME_OFFSET,
-  CHILD_USER_TIME_OFFSET,
-  CHILD_SYSTEM_TIME_OFFSET
-];
-var TIMEBASE_BYTES = 8;
-var DENOM_OFFSET = 4;
-var NS_PER_MS = 1e6;
-var EXPERIMENTAL_WARNING = "ExperimentalWarning";
-var DARWIN = "darwin";
-var PROC_PID_RUSAGE = {
-  proc_pid_rusage: { arguments: ["int32", "int32", "buffer"], return: "int32" }
-};
-var MACH_TIMEBASE_INFO = {
-  mach_timebase_info: { arguments: ["buffer"], return: "int32" }
-};
-function cpu_ms_of(buffer, timebase) {
-  const ticks = TIME_OFFSETS.reduce(
-    (sum, offset) => sum + Number(buffer.readBigUInt64LE(offset)),
-    0
-  );
-  return ticks * timebase.numer / timebase.denom / NS_PER_MS;
-}
-function quiet_ffi(load) {
-  const emit_warning = process.emitWarning;
-  process.emitWarning = function quiet(warning, ...rest) {
-    if (rest[0] !== EXPERIMENTAL_WARNING) Reflect.apply(emit_warning, process, [warning, ...rest]);
-  };
-  try {
-    return load("node:ffi");
-  } finally {
-    process.emitWarning = emit_warning;
-  }
-}
-function timebase_of(ffi) {
-  const buffer = Buffer.alloc(TIMEBASE_BYTES);
-  ffi.dlopen(SYSTEM_LIBRARY, MACH_TIMEBASE_INFO).functions.mach_timebase_info(buffer);
-  return { numer: buffer.readUInt32LE(0), denom: buffer.readUInt32LE(DENOM_OFFSET) };
-}
-function reader_of(ffi) {
-  const timebase = timebase_of(ffi);
-  const { proc_pid_rusage } = ffi.dlopen(PROC_LIBRARY, PROC_PID_RUSAGE).functions;
-  const buffer = Buffer.alloc(RUSAGE_INFO_V2_BYTES);
-  return function read(pid) {
-    if (proc_pid_rusage(pid, RUSAGE_INFO_V2, buffer) !== 0) return void 0;
-    const footprint_bytes = Number(buffer.readBigUInt64LE(PHYS_FOOTPRINT_OFFSET));
-    return { cpu_ms: cpu_ms_of(buffer, timebase), footprint_bytes };
-  };
-}
-function load_builtin(id) {
-  return process.getBuiltinModule(id);
-}
-function rusage_reader(platform, load) {
-  if (platform !== DARWIN) return void 0;
-  try {
-    const ffi = quiet_ffi(load);
-    return ffi === void 0 ? void 0 : reader_of(ffi);
-  } catch {
-    return void 0;
-  }
-}
-var run_board_usage_rusage = { cpu_ms_of, load_builtin, quiet_ffi, rusage_reader };
-
-// scripts/josh/josh-logic.ts
-import { existsSync as existsSync3 } from "node:fs";
-import path6 from "node:path";
-import { fileURLToPath } from "node:url";
-
-// scripts/gate/core-budget.ts
-import { randomUUID } from "node:crypto";
-import { readdirSync as readdirSync2 } from "node:fs";
-import { availableParallelism as availableParallelism2 } from "node:os";
-import path3 from "node:path";
-
-// scripts/gate/busy-average.ts
-var AVERAGE_WINDOW_MS = 3e3;
-function with_reading(samples, reading, ledger_cores, now) {
-  const kept = samples.filter((sample) => now - sample.at < AVERAGE_WINDOW_MS);
-  const { busy_cores } = reading;
-  if (busy_cores === void 0) return kept;
-  return [...kept, { at: now, external_cores: Math.max(0, busy_cores - ledger_cores), busy_cores }];
-}
-function mean_busy(samples) {
-  if (samples.length === 0) return void 0;
-  let total = 0;
-  for (const sample of samples) total += sample.busy_cores;
-  return total / samples.length;
-}
-function averaged(reading, samples, ledger_cores) {
-  if (reading.busy_cores === void 0 || samples.length === 0) return reading;
-  let total = 0;
-  for (const sample of samples) total += sample.external_cores;
-  return { ...reading, busy_cores: ledger_cores + total / samples.length };
-}
-var EASE_CORES = 1;
-function with_ease(ease, busy_cores, now) {
-  if (busy_cores === void 0) return ease;
-  if (ease === void 0 || busy_cores <= ease.level - EASE_CORES) {
-    return { level: busy_cores, eased_at: now };
-  }
-  return ease;
-}
-function is_unrelieved(ease, now, window_ms) {
-  return ease !== void 0 && now - ease.eased_at >= window_ms;
-}
-var busy_average = {
-  AVERAGE_WINDOW_MS,
-  averaged,
-  is_unrelieved,
-  mean_busy,
-  with_ease,
-  with_reading
-};
-
-// scripts/gate/core-budget-timing.ts
-var POLL_INTERVAL_MS = 50;
-var WAIT_CAP_MS = 12e4;
-var EASE_WINDOW_MS = 3e4;
-async function default_sleep(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function resolve_cadence(options) {
-  return {
-    poll_interval_ms: options.poll_interval_ms ?? POLL_INTERVAL_MS,
-    wait_cap_ms: options.wait_cap_ms ?? WAIT_CAP_MS,
-    ease_window_ms: options.ease_window_ms ?? EASE_WINDOW_MS
-  };
-}
-function resolve_timing(options) {
-  return {
-    now: options.now ?? Date.now,
-    sleep: options.sleep ?? default_sleep,
-    ...resolve_cadence(options)
-  };
-}
-var core_budget_timing = { WAIT_CAP_MS, resolve_timing };
-
-// scripts/gate/core-admission.ts
-var RAMP_UP_MS = 3e4;
-var BYPASS_WINDOW_MS = 3e4;
-var WAIT_CAP_SHARE = 0.5;
-var HEAVIER_BYPASS_WINDOW_MS = core_budget_timing.WAIT_CAP_MS * WAIT_CAP_SHARE;
-var MIN_GRANT = 1;
-var NARROW_DIVISOR = 2;
-function priority_rank(reservation) {
-  return reservation.is_priority === true ? 0 : 1;
-}
-function compare_claim(left, right) {
-  const by_priority = priority_rank(left.reservation) - priority_rank(right.reservation);
-  if (by_priority !== 0) return by_priority;
-  const by_time = left.reservation.claimed_at - right.reservation.claimed_at;
-  return by_time === 0 ? left.key.localeCompare(right.key) : by_time;
-}
-function add_load(totals, reservation) {
-  totals.cores += reservation.granted ?? reservation.weight;
-  totals.memory_mb += reservation.memory_mb ?? 0;
-}
-function exceeds(totals, budget) {
-  return totals.cores > budget.cores || totals.memory_mb > budget.memory_mb;
-}
-function sum_load(reservations) {
-  const load = { cores: 0, memory_mb: 0 };
-  for (const entry of reservations) add_load(load, entry.reservation);
-  return load;
-}
-function is_waiting(entry) {
-  return entry.reservation.admitted_at === void 0;
-}
-function fits(entries, limit) {
-  return !exceeds(sum_load(entries), limit);
-}
-function place(key, reservations) {
-  const ordered = reservations.toSorted(compare_claim);
-  const index = ordered.findIndex((entry) => entry.key === key);
-  const own = ordered[index];
-  if (own === void 0) return void 0;
-  return {
-    own,
-    is_oldest: index === 0,
-    ahead: ordered.slice(0, index).filter((entry) => is_waiting(entry)),
-    running: ordered.filter((entry) => entry.key !== key && !is_waiting(entry))
-  };
-}
-function first_waiter_limit(budget) {
-  if (budget.is_overloaded === true) return budget;
-  return { cores: budget.cores + (budget.busy_excess ?? 0), memory_mb: budget.memory_mb };
-}
-function may_pass_waiter(own, waiter) {
-  const since_ms = own.claimed_at - waiter.claimed_at;
-  if (priority_rank(waiter) < priority_rank(own)) return false;
-  if (since_ms < BYPASS_WINDOW_MS) return true;
-  return waiter.weight > own.weight && since_ms < HEAVIER_BYPASS_WINDOW_MS;
-}
-function may_pass({ own, ahead, running }, budget) {
-  const is_passable = ahead.every((entry) => may_pass_waiter(own.reservation, entry.reservation));
-  return is_passable && fits([...running, own], budget);
-}
-function fits_in_order({ own, ahead, running }, budget) {
-  const limit = ahead.length === 0 ? first_waiter_limit(budget) : budget;
-  return fits([...running, ...ahead, own], limit);
-}
-function is_swap_stalled({ own, running }, budget) {
-  const needed_mb = sum_load([...running, own]).memory_mb;
-  return budget.memory_pressured === true && needed_mb > budget.memory_mb;
-}
-function is_swap_held(key, reservations, budget) {
-  const placement = place(key, reservations);
-  return placement !== void 0 && is_swap_stalled(placement, budget);
-}
-function runs_alone(placement, budget) {
-  if (!placement.is_oldest || placement.running.length > 0 || placement.own.reservation.is_strict_admission === true) {
-    return false;
-  }
-  return budget.is_overloaded !== true && !is_swap_stalled(placement, budget);
-}
-function is_admitted(key, reservations, budget) {
-  const placement = place(key, reservations);
-  if (placement === void 0) return false;
-  if (runs_alone(placement, budget)) return true;
-  return fits_in_order(placement, budget) || may_pass(placement, budget);
-}
-function mark_admitted(entries, key) {
-  const index = entries.findIndex((entry2) => entry2.key === key);
-  const entry = entries[index];
-  if (entry === void 0) return;
-  entries[index] = {
-    ...entry,
-    reservation: { ...entry.reservation, admitted_at: entry.reservation.claimed_at }
-  };
-}
-function admitted_keys(reservations, budget, memory_budget = Infinity) {
-  const limit = { cores: budget, memory_mb: memory_budget };
-  const ledger = [...reservations];
-  const admitted = /* @__PURE__ */ new Set();
-  for (const { key } of reservations.toSorted(compare_claim)) {
-    if (!is_admitted(key, ledger, limit)) continue;
-    admitted.add(key);
-    mark_admitted(ledger, key);
-  }
-  return admitted;
-}
-function is_ramped(reservation, now) {
-  const { admitted_at } = reservation;
-  return reservation.is_memory_pending !== true && admitted_at !== void 0 && now - admitted_at >= RAMP_UP_MS;
-}
-function ledger_load(reservations, now) {
-  const admitted = reservations.filter((entry) => entry.reservation.admitted_at !== void 0);
-  const ramped = admitted.filter((entry) => is_ramped(entry.reservation, now));
-  return { cores: sum_load(admitted).cores, memory_mb: sum_load(ramped).memory_mb };
-}
-function total_weight(reservations) {
-  return sum_load(reservations).cores;
-}
-function narrowed_weight(key, reservations, budget) {
-  const own = reservations.find((entry) => entry.key === key)?.reservation;
-  if (own?.is_unit !== true) return void 0;
-  const others = reservations.filter(
-    (entry) => entry.key !== key && entry.reservation.admitted_at !== void 0
-  );
-  const room = Math.max(MIN_GRANT, Math.floor(budget - total_weight(others)));
-  return room >= own.weight ? void 0 : room;
-}
-function is_too_narrow(key, reservations, granted) {
-  if (granted === void 0) return false;
-  const own = reservations.find((entry) => entry.key === key)?.reservation;
-  return own !== void 0 && granted * NARROW_DIVISOR < own.weight;
-}
-function with_grant(key, reservations, granted) {
-  if (granted === void 0) return [...reservations];
-  return reservations.map(
-    (entry) => entry.key === key ? { ...entry, reservation: { ...entry.reservation, granted } } : entry
-  );
-}
-function admitted_load(reservations, budget) {
-  const admitted = admitted_keys(reservations, budget);
-  return total_weight(reservations.filter((entry) => admitted.has(entry.key)));
-}
-function describe_memory(ledger, budget) {
-  if (!Number.isFinite(budget.memory_mb)) return "";
-  return ` and ${String(Math.round(ledger.memory_mb))} MB of memory against ${String(Math.round(budget.memory_mb))} MB`;
-}
-function describe_overflow(admission) {
-  const { overflow } = admission;
-  if (overflow === void 0) return void 0;
-  const { ledger, budget } = overflow;
-  const waited = String(Math.round(overflow.waited_ms / MS_PER_SECOND));
-  const cores = `the ledger held ${String(ledger.cores)} cores against a budget of ${String(budget.cores)}`;
-  return `started past the core budget after ${waited}s \u2014 ${cores}${describe_memory(ledger, budget)}`;
-}
-var core_admission = {
-  BYPASS_WINDOW_MS,
-  HEAVIER_BYPASS_WINDOW_MS,
-  RAMP_UP_MS,
-  admitted_keys,
-  admitted_load,
-  compare_claim,
-  describe_overflow,
-  is_admitted,
-  is_swap_held,
-  is_too_narrow,
-  ledger_load,
-  narrowed_weight,
-  sum_load,
-  with_grant
-};
-
-// scripts/gate/core-priority.ts
-var PRIORITY_KEY = "JOSH_CORE_PRIORITY";
-var PRIORITY_VALUE = "1";
-var PRIORITY_ENVIRONMENT = { [PRIORITY_KEY]: PRIORITY_VALUE };
-var UNMARKED_ENVIRONMENT = { [PRIORITY_KEY]: void 0 };
-function marker_field({ is_unit, is_suite }) {
-  const is_marked = process.env[PRIORITY_KEY] === PRIORITY_VALUE;
-  return is_marked && is_unit !== true && is_suite !== true ? true : void 0;
-}
-var core_priority = { PRIORITY_ENVIRONMENT, PRIORITY_KEY, UNMARKED_ENVIRONMENT, marker_field };
-
-// scripts/gate/core-wait.ts
-import path2 from "node:path";
-var WAIT_REASONS = ["cores", "cpu", "memory", "pressure"];
-var REASON_TEXT = {
-  cores: "not enough free cores",
-  cpu: "CPU saturated",
-  memory: "not enough free memory",
-  pressure: "memory under pressure"
-};
-function core_reason(key, reservations, budget) {
-  const declared = { cores: budget.cores + (budget.busy_excess ?? 0), memory_mb: Infinity };
-  return core_admission.is_admitted(key, reservations, declared) ? "cpu" : "cores";
-}
-function wait_reason(key, reservations, budget) {
-  const cores_only = { ...budget, memory_mb: Infinity };
-  if (!core_admission.is_admitted(key, reservations, cores_only)) {
-    return core_reason(key, reservations, budget);
-  }
-  return budget.memory_pressured === true ? "pressure" : "memory";
-}
-function hold_reason(key, reservations, budget, granted) {
-  if (!core_admission.is_admitted(key, reservations, budget)) {
-    return wait_reason(key, reservations, budget);
-  }
-  return core_admission.is_too_narrow(key, reservations, granted) ? "cpu" : void 0;
-}
-function is_outside_held(key, reservations, budget) {
-  const unloaded = {
-    ...budget,
-    cores: budget.cores + (budget.busy_excess ?? 0),
-    busy_excess: 0,
-    is_overloaded: false
-  };
-  const granted = core_admission.narrowed_weight(key, reservations, unloaded.cores);
-  return hold_reason(key, reservations, unloaded, granted) === void 0;
-}
-var SMALL_CLAIM_CORES = core_weights.CORE_WEIGHTS.lint;
-function unseen_cores(own, reservations, now) {
-  const fresh = reservations.filter((entry) => {
-    const { admitted_at } = entry.reservation;
-    if (admitted_at === void 0) return core_admission.compare_claim(entry, own) < 0;
-    return now - admitted_at < busy_average.AVERAGE_WINDOW_MS;
-  });
-  return core_admission.sum_load(fresh).cores;
-}
-function has_room(weight, budget, room, unseen) {
-  if (weight > SMALL_CLAIM_CORES || budget.is_overloaded === true) return false;
-  return room.busy_cores !== void 0 && room.busy_cores + unseen + weight <= room.cores;
-}
-function is_ledger_held_small(key, reservations, budget, room) {
-  const own = reservations.find((entry) => entry.key === key);
-  if (own === void 0) return false;
-  const unseen = unseen_cores(own, reservations, room.now);
-  if (!has_room(own.reservation.weight, budget, room, unseen)) return false;
-  return core_admission.is_admitted(key, reservations, { ...budget, cores: Infinity });
-}
-function is_held_in_vain(key, reservations, budget, room) {
-  if (is_outside_held(key, reservations, budget)) return true;
-  return is_ledger_held_small(key, reservations, budget, room);
-}
-function wait_line(command, reason) {
-  return `\u23F3 ${command ?? "a step"} waits for the core budget \u2014 ${REASON_TEXT[reason]}`;
-}
-function where_of(checkout) {
-  return {
-    checkout,
-    lane: lane_paths.lane_issue_of(checkout),
-    lanes_root: lane_paths.lanes_root_of(checkout)
-  };
-}
-function place_of(marker, home_root) {
-  const { checkout, lane, lanes_root } = marker;
-  if (checkout === void 0 || lanes_root === void 0 || lanes_root === home_root) {
-    return { lane, elsewhere: void 0 };
-  }
-  const name = lane === void 0 ? path2.basename(checkout) : `${path2.basename(lanes_root)}/${lane}`;
-  return { lane: void 0, elsewhere: name };
-}
-function wait_of(marker, now, home_root) {
-  const { command, wait_reason: reason } = marker;
-  if (reason === void 0 || marker.admitted_at !== void 0) return [];
-  return [{ command, ...place_of(marker, home_root), waited_ms: now - marker.claimed_at, reason }];
-}
-function waits_of(entries, now, home) {
-  const home_root = lane_paths.lanes_root_of(home);
-  return entries.flatMap((entry) => wait_of(entry.reservation, now, home_root)).toSorted((left, right) => right.waited_ms - left.waited_ms);
-}
-var core_wait = {
-  WAIT_REASONS,
-  hold_reason,
-  is_held_in_vain,
-  is_outside_held,
-  wait_line,
-  wait_reason,
-  waits_of,
-  where_of
-};
-
-// scripts/gate/core-reservation.ts
-var reservation_schema = process_owner_schema.extend({
-  weight: external_exports.number(),
-  claimed_at: external_exports.number(),
-  memory_mb: external_exports.number().optional(),
-  admitted_at: external_exports.number().optional(),
-  is_unit: external_exports.boolean().optional(),
-  is_strict_admission: external_exports.boolean().optional(),
-  is_memory_pending: external_exports.boolean().optional(),
-  is_priority: external_exports.boolean().optional(),
-  granted: external_exports.number().optional(),
-  command: external_exports.string().optional(),
-  checkout: external_exports.string().optional(),
-  lane: external_exports.string().optional(),
-  lanes_root: external_exports.string().optional(),
-  wait_reason: external_exports.enum(core_wait.WAIT_REASONS).optional()
-});
-function claim_fields(weight, claimed_at, options) {
-  const { memory_mb, command, is_unit, is_strict_admission, is_memory_pending } = options;
-  return {
-    weight,
-    claimed_at,
-    memory_mb,
-    command,
-    is_unit,
-    is_strict_admission,
-    is_memory_pending,
-    is_priority: core_priority.marker_field(options),
-    ...core_wait.where_of(options.checkout ?? process.cwd())
-  };
-}
-function read_reservation(source) {
-  const raw = stamp_file.read_stamp_text(source);
-  return raw === void 0 ? void 0 : json_value.parse_with(raw, reservation_schema);
-}
-function write_reservation(target, fields) {
-  stamp_file.replace_stamp(target, { ...process_identity.own_fields(), ...fields });
-}
-function transfer(handle, pid) {
-  const reservation = read_reservation(handle.target);
-  if (reservation === void 0) {
-    throw new Error("The admitted reservation disappeared before transfer");
-  }
-  stamp_file.replace_stamp(handle.target, {
-    ...reservation,
-    pid,
-    process_start: process_identity.read_start(pid),
-    is_memory_pending: false,
-    admitted_at: Date.now()
-  });
-}
-var core_reservation = { claim_fields, read_reservation, transfer, write_reservation };
-
-// scripts/gate/core-wait-record.ts
-var UNNAMED_COMMAND = "a step";
-async function to_ledger(wait) {
-  await lane_ledger_write.record_core_wait(wait);
-}
-function wait_of2(claim2, now) {
-  if (claim2.wait_reason === void 0) return void 0;
-  const wait = { command: claim2.command ?? UNNAMED_COMMAND, waited_ms: now - claim2.claimed_at };
-  return claim2.lane === void 0 ? wait : { ...wait, issue: Number(claim2.lane) };
-}
-async function record_admitted(claim2, now, sink = to_ledger) {
-  const wait = wait_of2(claim2, now);
-  if (wait !== void 0) await sink(wait);
-}
-var core_wait_record = { record_admitted, wait_of: wait_of2 };
-
-// scripts/gate/held-mark.ts
-var HELD_KEY = "JOSH_CORE_RESERVED";
-var HELD_VALUE = "1";
-var HELD_RESERVATION_KEY = "JOSH_CORE_RESERVATION";
-function is_held() {
-  return process.env[HELD_KEY] === HELD_VALUE;
-}
-function held_reservation() {
-  const key = process.env[HELD_RESERVATION_KEY] ?? "";
-  return key === "" ? void 0 : key;
-}
-function set_held_mark(value, reservation) {
-  process.env[HELD_KEY] = value;
-  process.env[HELD_RESERVATION_KEY] = reservation;
-}
-async function with_held_mark(run, reservation = "") {
-  const previous = process.env[HELD_KEY] ?? "";
-  const previous_reservation = process.env[HELD_RESERVATION_KEY] ?? "";
-  set_held_mark(HELD_VALUE, reservation);
-  try {
-    return await run();
-  } finally {
-    set_held_mark(previous, previous_reservation);
-  }
-}
-var held_mark = {
-  HELD_KEY,
-  HELD_RESERVATION_KEY,
-  HELD_VALUE,
-  held_reservation,
-  is_held,
-  with_held_mark
-};
-
-// scripts/gate/machine-capacity.ts
-import { readFile } from "node:fs/promises";
-import { availableParallelism, cpus, loadavg, totalmem } from "node:os";
-var SAMPLE_WINDOW_MS = 250;
-var OVERLOAD_FACTOR = 2;
-var BYTES_PER_MB = 1048576;
-var KB_PER_MB = 1024;
-var PERCENT = 100;
-var MEMINFO_PATH = "/proc/meminfo";
-var VMSTAT_PATH = "/proc/vmstat";
-var LINUX_AVAILABLE = /^MemAvailable:\s+(?<kb>\d+) kB/mu;
-var LINUX_SWAP_IN = /^pswpin (?<pages>\d+)$/mu;
-var LINUX_SWAP_OUT = /^pswpout (?<pages>\d+)$/mu;
-var PAGE_SIZE_ARGUMENTS = ["PAGESIZE"];
-var LEVEL_NAME = "kern.memorystatus_level";
-var SWAP_IN_NAME = "vm.compressor.swapper.swapins_total";
-var SWAP_OUT_NAME = "vm.compressor.swapper.swapouts_total";
-var COMPRESSED_NAME = "vm.compressor_input_bytes";
-var PAGE_SIZE_NAME = "hw.pagesize";
-var PRESSURE_NAME = "kern.memorystatus_vm_pressure_level";
-var PRESSURE_HOLD = 4;
-var SWAP_PRESSURE_MB = 16;
-var COMPRESSION_PRESSURE_MB = 64;
-var SYSCTL_ARGUMENTS = [
-  LEVEL_NAME,
-  SWAP_IN_NAME,
-  SWAP_OUT_NAME,
-  COMPRESSED_NAME,
-  PAGE_SIZE_NAME,
-  PRESSURE_NAME
-];
-var SYSCTL_LINE = /^(?<name>[\w.]+): (?<value>\d+)$/gmu;
-function cpu_times() {
-  let busy = 0;
-  let idle = 0;
-  for (const { times } of cpus()) {
-    busy += times.user + times.nice + times.sys + times.irq;
-    idle += times.idle;
-  }
-  return { busy, total: busy + idle };
-}
-function busy_share_between(before, after) {
-  const total = after.total - before.total;
-  if (total <= 0) return void 0;
-  return (after.busy - before.busy) / total;
-}
-function busy_cores_between(before, after, cores) {
-  const share = busy_share_between(before, after);
-  return share === void 0 ? void 0 : share * cores;
-}
-function sysctl_values(output) {
-  const values = [...output.matchAll(SYSCTL_LINE)].map(
-    (match) => [match.groups?.["name"] ?? "", Number(match.groups?.["value"])]
-  );
-  return new Map(values);
-}
-function swapped_pages(pages_in, pages_out) {
-  return pages_in === void 0 || pages_out === void 0 ? void 0 : pages_in + pages_out;
-}
-function mb_of(units, unit_bytes) {
-  if (units === void 0 || unit_bytes === void 0) return void 0;
-  return units * unit_bytes / BYTES_PER_MB;
-}
-function swapped_between(from, to) {
-  if (from === void 0 || to === void 0) return void 0;
-  return Math.max(0, to - from);
-}
-function parse_darwin_memory(output, total_bytes) {
-  const values = sysctl_values(output);
-  const level = values.get(LEVEL_NAME);
-  return {
-    available_mb: level === void 0 ? void 0 : level / PERCENT * (total_bytes / BYTES_PER_MB),
-    swapped_mb: mb_of(
-      swapped_pages(values.get(SWAP_IN_NAME), values.get(SWAP_OUT_NAME)),
-      values.get(PAGE_SIZE_NAME)
-    ),
-    pressure_level: values.get(PRESSURE_NAME),
-    compressed_mb: mb_of(values.get(COMPRESSED_NAME), 1)
-  };
-}
-function parse_linux_available(meminfo) {
-  const kb = LINUX_AVAILABLE.exec(meminfo)?.groups?.["kb"];
-  return kb === void 0 ? void 0 : Number(kb) / KB_PER_MB;
-}
-function pages_of(pattern, vmstat) {
-  const pages = pattern.exec(vmstat)?.groups?.["pages"];
-  return pages === void 0 ? void 0 : Number(pages);
-}
-function parse_linux_swapped(vmstat, page_bytes) {
-  const pages = swapped_pages(pages_of(LINUX_SWAP_IN, vmstat), pages_of(LINUX_SWAP_OUT, vmstat));
-  return mb_of(pages, page_bytes);
-}
-async function settled(read) {
-  try {
-    return await read();
-  } catch {
-    return void 0;
-  }
-}
-async function read_darwin_memory() {
-  const { stdout } = await execa("sysctl", SYSCTL_ARGUMENTS, {
-    reject: false,
-    timeout: PROBE_TIMEOUT_MS
-  });
-  return parse_darwin_memory(stdout, totalmem());
-}
-async function read_page_size() {
-  const { stdout } = await execa("getconf", PAGE_SIZE_ARGUMENTS, { timeout: PROBE_TIMEOUT_MS });
-  return stdout;
-}
-async function read_linux_memory() {
-  const [meminfo, vmstat, page_size] = await Promise.all([
-    settled(async () => await readFile(MEMINFO_PATH, "utf8")),
-    settled(async () => await readFile(VMSTAT_PATH, "utf8")),
-    settled(read_page_size)
-  ]);
-  const page_bytes = page_size === void 0 ? void 0 : Number(page_size);
-  return {
-    available_mb: meminfo === void 0 ? void 0 : parse_linux_available(meminfo),
-    swapped_mb: vmstat === void 0 || page_bytes === void 0 ? void 0 : parse_linux_swapped(vmstat, page_bytes),
-    pressure_level: void 0
-  };
-}
-var UNREAD_MEMORY = {
-  available_mb: void 0,
-  swapped_mb: void 0,
-  pressure_level: void 0
-};
-async function read_memory() {
-  if (process.platform === "darwin") return await settled(read_darwin_memory) ?? UNREAD_MEMORY;
-  return process.platform === "linux" ? await read_linux_memory() : UNREAD_MEMORY;
-}
-function is_unquoted() {
-  return cpus().length > 0 && cpus().length === availableParallelism();
-}
-async function default_sleep2(ms) {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function moved_over(from, to, limit) {
-  return (swapped_between(from, to) ?? 0) > limit;
-}
-function is_swapping(before, after) {
-  return moved_over(before?.swapped_mb, after.swapped_mb, SWAP_PRESSURE_MB);
-}
-function is_pressured(before, after) {
-  return (after.pressure_level ?? 0) >= PRESSURE_HOLD || is_swapping(before, after) || moved_over(before.compressed_mb, after.compressed_mb, COMPRESSION_PRESSURE_MB);
-}
-function pressured_available(after, before) {
-  if (after.available_mb === void 0) return void 0;
-  if (is_swapping(before, after)) return 0;
-  return (after.pressure_level ?? 0) >= PRESSURE_HOLD ? 0 : after.available_mb;
-}
-async function read_machine(sleep = default_sleep2) {
-  const before = cpu_times();
-  const [memory_before] = await Promise.all([read_memory(), sleep(SAMPLE_WINDOW_MS)]);
-  const memory_after = await read_memory();
-  const is_host = is_unquoted();
-  const busy_cores = is_host ? busy_cores_between(before, cpu_times(), cpus().length) : void 0;
-  return {
-    busy_cores,
-    run_queue: is_host ? loadavg()[0] : void 0,
-    available_mb: pressured_available(memory_after, memory_before),
-    memory_pressured: is_pressured(memory_before, memory_after)
-  };
-}
-async function read_sample() {
-  return { cpu: cpu_times(), memory: await read_memory(), total_mb: totalmem() / BYTES_PER_MB };
-}
-function external_cores(busy_cores, ledger_cores) {
-  if (busy_cores === void 0) return 0;
-  return Math.floor(Math.max(0, busy_cores - ledger_cores));
-}
-function is_overloaded(run_queue, ledger_cores, cores) {
-  if (run_queue === void 0) return false;
-  return run_queue - ledger_cores > cores * OVERLOAD_FACTOR;
-}
-function machine_budget(cores, reading, ledger) {
-  const busy_excess = external_cores(reading.busy_cores, ledger.cores);
-  return {
-    cores: Math.max(0, cores - busy_excess),
-    memory_mb: reading.available_mb === void 0 ? Infinity : reading.available_mb + ledger.memory_mb,
-    memory_pressured: reading.memory_pressured,
-    busy_excess,
-    is_overloaded: is_overloaded(reading.run_queue, ledger.cores, cores)
-  };
-}
-var machine_capacity = {
-  busy_cores_between,
-  busy_share_between,
-  COMPRESSION_PRESSURE_MB,
-  external_cores,
-  machine_budget,
-  parse_darwin_memory,
-  parse_linux_available,
-  parse_linux_swapped,
-  PRESSURE_HOLD,
-  pressured_available,
-  read_machine,
-  read_memory,
-  read_sample,
-  SWAP_PRESSURE_MB,
-  swapped_between
-};
-
-// scripts/gate/core-budget.ts
-var RESERVED_PREFIX = "josh-core-reserved-";
-var RESERVED_SUFFIX = ".json";
-var MIN_BUDGET = 1;
-var { claim_fields: claim_fields2, read_reservation: read_reservation2, write_reservation: write_reservation2 } = core_reservation;
-function marker_name(key) {
-  return `${RESERVED_PREFIX}${key}${RESERVED_SUFFIX}`;
-}
-function is_running(reservation) {
-  return process_identity.is_same_process(reservation.pid, reservation.process_start) !== false;
-}
-function sweep_marker(source) {
-  try {
-    stamp_file.remove_stamp(source);
-  } catch {
-  }
-}
-function live_reservation(source) {
-  const reservation = read_reservation2(source);
-  if (reservation === void 0) return void 0;
-  if (is_running(reservation)) return reservation;
-  sweep_marker(source);
-  return void 0;
-}
-function marker_files(directory) {
-  try {
-    return readdirSync2(directory).filter(
-      (name) => name.startsWith(RESERVED_PREFIX) && name.endsWith(RESERVED_SUFFIX)
-    );
-  } catch {
-    return [];
-  }
-}
-function live_reservations(directory = PLATFORM_TEMP_ROOT) {
-  return marker_files(directory).flatMap((name) => {
-    const reservation = live_reservation(path3.join(directory, name));
-    return reservation === void 0 ? [] : { key: name, reservation };
-  });
-}
-function normalize_budget(budget) {
-  return Number.isFinite(budget) ? Math.max(MIN_BUDGET, Math.floor(budget)) : MIN_BUDGET;
-}
-function report_wait(line) {
-  process.stderr.write(`${line}
-`);
-}
-async function current_budget(context, reservations) {
-  const reading = await context.read_machine();
-  const ledger = core_admission.ledger_load(reservations, context.now());
-  context.busy_samples = busy_average.with_reading(
-    context.busy_samples,
-    reading,
-    ledger.cores,
-    context.now()
-  );
-  const mean = busy_average.averaged(reading, context.busy_samples, ledger.cores);
-  context.ease = busy_average.with_ease(context.ease, mean.busy_cores, context.now());
-  return machine_capacity.machine_budget(context.budget, mean, ledger);
-}
-function admit(context, overflow, granted) {
-  const admitted_at = context.now();
-  write_reservation2(context.target, { ...context.fields, admitted_at, granted });
-  return { overflow, granted, waited_ms: admitted_at - context.fields.claimed_at };
-}
-function overflow_of(context, reservations, budget) {
-  return {
-    waited_ms: context.now() - context.fields.claimed_at,
-    ledger: core_admission.sum_load(reservations),
-    budget
-  };
-}
-function mark_waiting(context, reason) {
-  const previous = context.fields.wait_reason;
-  if (previous === reason) return;
-  context.fields = { ...context.fields, wait_reason: reason };
-  write_reservation2(context.target, context.fields);
-  if (previous === void 0) context.report(core_wait.wait_line(context.fields.command, reason));
-}
-function is_wait_spent(context, reservations, budget) {
-  if (context.fields.is_strict_admission === true || core_admission.is_swap_held(context.key, reservations, budget)) {
-    return false;
-  }
-  const now = context.now();
-  if (now >= context.deadline) return true;
-  const busy_cores = busy_average.mean_busy(context.busy_samples);
-  const room = { busy_cores, cores: context.budget, now };
-  return busy_average.is_unrelieved(context.ease, now, context.ease_window_ms) && core_wait.is_held_in_vain(context.key, reservations, budget, room);
-}
-async function poll_admission(context) {
-  const reservations = live_reservations(context.directory);
-  const budget = await current_budget(context, reservations);
-  const granted = core_admission.narrowed_weight(context.key, reservations, budget.cores);
-  const reason = core_wait.hold_reason(context.key, reservations, budget, granted);
-  if (reason === void 0) return admit(context, void 0, granted);
-  if (is_wait_spent(context, reservations, budget)) {
-    const held = core_admission.with_grant(context.key, reservations, granted);
-    return admit(context, overflow_of(context, held, budget), granted);
-  }
-  mark_waiting(context, reason);
-  return void 0;
-}
-async function await_admission(context) {
-  const admission = await poll.wait_for(async () => await poll_admission(context), {
-    interval_ms: context.poll_interval_ms,
-    sleeper: context.sleep
-  });
-  await core_wait_record.record_admitted(context.fields, context.now(), context.record_wait);
-  return admission;
-}
-function resolve_ports(options) {
-  return {
-    read_machine: options.read_machine ?? machine_capacity.read_machine,
-    report: options.report ?? report_wait,
-    record_wait: options.record_wait
-  };
-}
-function claim(weight, options = {}) {
-  const timing = core_budget_timing.resolve_timing(options);
-  const directory = options.directory ?? PLATFORM_TEMP_ROOT;
-  const claimed_at = timing.now();
-  const name = marker_name(randomUUID());
-  const target = path3.join(directory, name);
-  const fields = claim_fields2(weight, claimed_at, options);
-  write_reservation2(target, fields);
-  return {
-    ...timing,
-    key: name,
-    target,
-    directory,
-    budget: normalize_budget(options.budget ?? availableParallelism2()),
-    deadline: claimed_at + timing.wait_cap_ms,
-    fields,
-    busy_samples: [],
-    ...resolve_ports(options)
-  };
-}
-async function reserve(weight, options = {}) {
-  const context = claim(weight, options);
-  const admission = await await_admission(context);
-  return { target: context.target, admission };
-}
-async function poll_claim(context) {
-  const admission = await poll_admission(context);
-  if (admission === void 0) return void 0;
-  await core_wait_record.record_admitted(context.fields, context.now(), context.record_wait);
-  return { target: context.target, admission };
-}
-function budget_waits(directory = PLATFORM_TEMP_ROOT, now = Date.now(), home = process.cwd()) {
-  return core_wait.waits_of(live_reservations(directory), now, home);
-}
-function release(handle) {
-  sweep_marker(handle.target);
-}
-async function with_core_reservation(weight, run, options = {}) {
-  const handle = await reserve(weight, options);
-  try {
-    return await run(handle.admission, path3.basename(handle.target));
-  } finally {
-    release(handle);
-  }
-}
-function is_covered() {
-  return held_mark.is_held() || unit_worker_share.is_nested_run();
-}
-async function with_command_reservation(weight, run, options = {}) {
-  if (is_covered()) return await run();
-  return await with_core_reservation(
-    weight,
-    async (_admission, key) => await held_mark.with_held_mark(run, key),
-    options
-  );
-}
-function held_unit_claim(directory = PLATFORM_TEMP_ROOT) {
-  const key = held_mark.held_reservation();
-  if (key === void 0) return void 0;
-  const held = live_reservations(directory).find((entry) => entry.key === key);
-  return held?.reservation.is_unit === true ? held.reservation : void 0;
-}
-var core_budget = {
-  CORE_WEIGHTS: core_weights.CORE_WEIGHTS,
-  HELD_KEY: held_mark.HELD_KEY,
-  HELD_VALUE: held_mark.HELD_VALUE,
-  MEMORY_MB: core_weights.MEMORY_MB,
-  RESERVED_PREFIX,
-  admitted_keys: core_admission.admitted_keys,
-  admitted_load: core_admission.admitted_load,
-  budget_waits,
-  claim,
-  describe_overflow: core_admission.describe_overflow,
-  held_unit_claim,
-  is_covered,
-  is_held: held_mark.is_held,
-  live_reservations,
-  poll_claim,
-  release,
-  reserve,
-  transfer: core_reservation.transfer,
-  with_command_reservation,
-  with_core_reservation,
-  with_held_mark: held_mark.with_held_mark
-};
-
-// scripts/josh/josh-in-process.ts
-import { realpathSync } from "node:fs";
-import path4 from "node:path";
-import { pathToFileURL } from "node:url";
-var BUNDLED_COMMAND_DIRECTORY = path4.join("dist", "commands");
-
-// scripts/josh/run-github-prerequisite.ts
-import { existsSync as existsSync2 } from "node:fs";
-import path5 from "node:path";
-
-// scripts/josh/josh-logic.ts
-var TSX_BIN = "tsx";
-var TSX_PACKAGE = "tsx";
-var PACKAGE_DIR = find_package_directory(path6.dirname(fileURLToPath(import.meta.url)));
-function resolve_tsx_executable() {
-  const candidates = [
-    resolve_local_bin(PACKAGE_DIR, TSX_BIN),
-    resolve_local_bin(process.cwd(), TSX_BIN)
-  ];
-  return candidates.find(existsSync3) ?? TSX_BIN;
-}
-function resolve_tsx_cli_entry() {
-  for (const base_directory of [PACKAGE_DIR, process.cwd()]) {
-    const cli_entry = resolve_package_bin(base_directory, TSX_PACKAGE, TSX_BIN);
-    if (cli_entry !== void 0) return cli_entry;
-  }
-  return void 0;
-}
-function resolve_tsx_runner() {
-  const cli_entry = resolve_tsx_cli_entry();
-  if (cli_entry !== void 0) {
-    return { executable: process.execPath, leading_arguments: [cli_entry] };
-  }
-  return { executable: resolve_tsx_executable(), leading_arguments: [] };
-}
-function read_package_version() {
-  return package_manifest.read_manifest(PACKAGE_DIR, package_version_schema).version;
-}
-var HEADER = `josh v${read_package_version()} \u2014 Joshua Folkken's dev toolkit`;
-
-export {
-  toolchain_inputs,
-  run_board_usage_rusage,
-  machine_capacity,
-  resolve_tsx_runner
-};