@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-ZCHZU6NX.js

@@ -0,0 +1,799 @@
+import {
+  machine_capacity
+} from "./chunk-XDR2BRDL.js";
+import {
+  unit_worker_share
+} from "./chunk-B73IIRMS.js";
+import {
+  process_owner_schema
+} from "./chunk-HLUS2M3D.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  core_weights
+} from "./chunk-ENFPR7J2.js";
+import {
+  MS_PER_SECOND
+} from "./chunk-WPAQUMHC.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gate/core-budget.ts
+import { randomUUID } from "node:crypto";
+import { readdirSync } from "node:fs";
+import { availableParallelism } from "node:os";
+import path2 from "node:path";
+
+// 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_memory_held(key, reservations, budget) {
+  const placement = place(key, reservations);
+  if (placement === void 0) return false;
+  if (placement.own.reservation.is_unit === true && budget.memory_pressured !== true) return false;
+  return !fits([...placement.running, placement.own], {
+    cores: Infinity,
+    memory_mb: budget.memory_mb
+  });
+}
+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;
+}
+function is_admitted(key, reservations, budget) {
+  const placement = place(key, reservations);
+  if (placement === void 0 || is_memory_held(key, reservations, budget)) 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_memory_held,
+  is_too_narrow,
+  ledger_load,
+  narrowed_weight,
+  sum_load,
+  with_grant
+};
+
+// 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-reservation.ts
+import { z } from "zod";
+
+// 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 path 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 ? path.basename(checkout) : `${path.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: z.number(),
+  claimed_at: z.number(),
+  memory_mb: z.number().optional(),
+  admitted_at: z.number().optional(),
+  is_unit: z.boolean().optional(),
+  is_strict_admission: z.boolean().optional(),
+  is_memory_pending: z.boolean().optional(),
+  is_priority: z.boolean().optional(),
+  granted: z.number().optional(),
+  command: z.string().optional(),
+  checkout: z.string().optional(),
+  lane: z.string().optional(),
+  lanes_root: z.string().optional(),
+  wait_reason: z.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-budget-poll.ts
+function check_measurement(command, reading) {
+  if (reading.memory_supported === true && !Number.isFinite(reading.available_mb)) {
+    throw new Error(`${command}: memory measurement failed; admission refused`);
+  }
+}
+function check_capacity(command, requested, total_mb) {
+  if (total_mb === void 0) return;
+  if (requested > total_mb) {
+    throw new Error(
+      `${command}: requested ${String(requested)} MB exceeds physical memory ${String(total_mb)} MB`
+    );
+  }
+}
+function check_memory(context, reading) {
+  const requested = context.fields.memory_mb ?? 0;
+  if (requested === 0) return;
+  const command = context.fields.command ?? "a step";
+  const minimum = context.fields.is_unit === true ? requested / Math.max(1, context.fields.weight) : requested;
+  check_measurement(command, reading);
+  check_capacity(command, minimum, reading.total_mb);
+}
+async function current_reading(context, reservations) {
+  const reading = await context.read_machine();
+  const ledger = core_admission.ledger_load(reservations, context.now());
+  check_memory(context, reading);
+  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 { budget: machine_capacity.machine_budget(context.budget, mean, ledger), reading };
+}
+function admit(context, decision) {
+  const admitted_at = context.now();
+  const { granted, overflow, reason, budget, reading } = decision;
+  core_reservation.write_reservation(context.target, { ...context.fields, admitted_at, granted });
+  return {
+    overflow,
+    granted,
+    waited_ms: admitted_at - context.fields.claimed_at,
+    decision: { reason, budget, reading }
+  };
+}
+function mark_waiting(context, reason) {
+  const previous = context.fields.wait_reason;
+  if (previous === reason) return;
+  context.fields = { ...context.fields, wait_reason: reason };
+  core_reservation.write_reservation(context.target, context.fields);
+  if (previous === void 0) context.report(core_wait.wait_line(context.fields.command, reason));
+}
+function spent_reason(context, reservations, budget) {
+  const now = context.now();
+  if (now >= context.deadline) return "cpu-deadline";
+  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) ? "cpu-unrelieved" : void 0;
+}
+function overflow_reason(context, reservations, budget) {
+  if (context.fields.is_strict_admission === true || core_admission.is_memory_held(context.key, reservations, budget)) {
+    return void 0;
+  }
+  return spent_reason(context, reservations, budget);
+}
+function overflow_of(context, reservations, decision) {
+  const held = core_admission.with_grant(context.key, reservations, decision.granted);
+  const overflow = {
+    waited_ms: context.now() - context.fields.claimed_at,
+    ledger: core_admission.sum_load(held),
+    budget: decision.budget
+  };
+  return admit(context, { ...decision, overflow });
+}
+function fit_reason(context, reservations, budget) {
+  const requested = context.fields.memory_mb ?? 0;
+  if (context.fields.is_unit === true && requested > budget.memory_mb) {
+    return "unit-memory-narrowing";
+  }
+  const strict = { ...budget, busy_excess: 0, is_overloaded: true };
+  return core_admission.is_admitted(context.key, reservations, strict) ? "budget-fit" : "cpu-first-waiter";
+}
+async function poll_admission(context, reservations) {
+  const { budget, reading } = await current_reading(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, {
+      budget,
+      reading,
+      granted,
+      reason: fit_reason(context, reservations, budget)
+    });
+  }
+  const overflow = overflow_reason(context, reservations, budget);
+  if (overflow !== void 0) {
+    return overflow_of(context, reservations, { budget, reading, granted, reason: overflow });
+  }
+  mark_waiting(context, reason);
+  return void 0;
+}
+var core_budget_poll = { poll_admission };
+
+// 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 request_fields(claim2, admission) {
+  return {
+    requested_cores: claim2.weight,
+    granted_cores: admission?.granted ?? claim2.weight,
+    memory_mb: claim2.memory_mb ?? 0,
+    wait_reason: claim2.wait_reason,
+    admission_waited_ms: admission?.waited_ms
+  };
+}
+function admission_fields(claim2, admission) {
+  const decision = admission?.decision;
+  if (decision === void 0) return {};
+  return {
+    ...request_fields(claim2, admission),
+    admission_reason: decision.reason,
+    overflow: admission?.overflow !== void 0,
+    budget_cores: decision.budget.cores,
+    budget_memory_mb: Number.isFinite(decision.budget.memory_mb) ? decision.budget.memory_mb : void 0,
+    available_mb: decision.reading.available_mb,
+    busy_cores: decision.reading.busy_cores,
+    memory_pressured: decision.reading.memory_pressured
+  };
+}
+function should_record(claim2, admission) {
+  return claim2.wait_reason !== void 0 || admission?.decision !== void 0;
+}
+function wait_of2(claim2, now, admission) {
+  if (!should_record(claim2, admission)) return void 0;
+  const waited_ms = claim2.wait_reason === void 0 ? 0 : now - claim2.claimed_at;
+  const wait = {
+    command: claim2.command ?? UNNAMED_COMMAND,
+    waited_ms,
+    ...admission_fields(claim2, admission)
+  };
+  return claim2.lane === void 0 ? wait : { ...wait, issue: Number(claim2.lane) };
+}
+async function record_admitted(claim2, now, sink = to_ledger, admission) {
+  const wait = wait_of2(claim2, now, admission);
+  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/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 readdirSync(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(path2.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 poll_admission2(context) {
+  try {
+    return await core_budget_poll.poll_admission(context, live_reservations(context.directory));
+  } catch (error) {
+    sweep_marker(context.target);
+    throw error;
+  }
+}
+async function await_admission(context) {
+  const admission = await poll.wait_for(async () => await poll_admission2(context), {
+    interval_ms: context.poll_interval_ms,
+    sleeper: context.sleep
+  });
+  await core_wait_record.record_admitted(
+    context.fields,
+    context.now(),
+    context.record_wait,
+    admission
+  );
+  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 = path2.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 ?? availableParallelism()),
+    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_admission2(context);
+  if (admission === void 0) return void 0;
+  await core_wait_record.record_admitted(
+    context.fields,
+    context.now(),
+    context.record_wait,
+    admission
+  );
+  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, path2.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
+};
+
+export {
+  core_admission,
+  core_priority,
+  core_wait,
+  held_mark,
+  core_budget
+};