@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-ZCHZU6NX.js

@@ -1,799 +0,0 @@
-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
-};