@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/hooks/chunk-ALY5AW75.js

@@ -0,0 +1,1953 @@
+import {
+  core_weights,
+  direct_launch,
+  package_version_schema,
+  pnpm_reach,
+  project_checks,
+  resolve_local_bin,
+  resolve_package_bin,
+  unit_worker_share
+} from "./chunk-Z6W64J64.js";
+import {
+  ESLINT_RELATED_CACHE_FILE,
+  ESLINT_RELATED_CACHE_FLAGS,
+  PRETTIER_RELATED_CACHE_FLAGS,
+  changed_paths,
+  find_package_directory,
+  package_manifest,
+  poll,
+  process_owner_schema
+} from "./chunk-NP6BVTR3.js";
+import {
+  file_reader,
+  lane_ledger_write,
+  lane_paths,
+  process_identity
+} from "./chunk-NFTDYUN3.js";
+import {
+  MS_PER_SECOND,
+  PLATFORM_TEMP_ROOT,
+  PROBE_TIMEOUT_MS,
+  SUITE_TIMEOUT_MS,
+  atomic_write,
+  execa,
+  external_exports,
+  git_command,
+  git_common_directory,
+  json_value,
+  stamp_file
+} from "./chunk-RWVA2SFN.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/lint/lint-related-scope.ts
+import path3 from "node:path";
+
+// scripts/git/changed-file-scope.ts
+import path2 from "node:path";
+var UNREADABLE_REASON = "the changed files could not be read";
+var LISTED_FILE_LIMIT = 10;
+async function repository_root_or_cwd() {
+  try {
+    return await git_command.repository_root();
+  } catch {
+    return process.cwd();
+  }
+}
+async function read_changed_files(root) {
+  try {
+    const relative_paths = await changed_paths.read_changed_paths(false);
+    return relative_paths.map((relative) => path2.join(root, relative));
+  } catch {
+    return void 0;
+  }
+}
+function select_files(paths2, inputs) {
+  return paths2.filter(
+    (file_path) => inputs.is_selectable(file_path) && inputs.is_present(file_path)
+  );
+}
+function all_scope(reason) {
+  return { mode: "all", files: [], reason };
+}
+function resolve_scope(paths2, inputs) {
+  if (paths2 === void 0) return all_scope(UNREADABLE_REASON);
+  const files = select_files(paths2, inputs);
+  if (files.length === 0) return all_scope(inputs.nothing_reason);
+  return { mode: "related", files, reason: `${String(files.length)} changed file(s)` };
+}
+function format_file_list(files, root) {
+  const listed = files.slice(0, LISTED_FILE_LIMIT).map((file) => `  - ${path2.relative(root, file)}`);
+  const hidden = files.length - listed.length;
+  if (hidden > 0) listed.push(`  \u2026 and ${String(hidden)} more`);
+  return listed.join("\n");
+}
+function describe_scope(scope, root, vocabulary) {
+  if (scope.mode === "all") {
+    return `${vocabulary.label}: ${scope.reason} \u2014 ${vocabulary.fallback_suffix}.`;
+  }
+  return `${vocabulary.label}: ${scope.reason} \u2014 ${vocabulary.narrowed_suffix}.
+${format_file_list(scope.files, root)}`;
+}
+var ARGV_START = 2;
+var FLAG_PREFIX = "-";
+function is_flag(argument) {
+  return argument.startsWith(FLAG_PREFIX);
+}
+function explicit_files_of(command_arguments) {
+  return command_arguments.filter((argument) => !is_flag(argument));
+}
+function flags_of(command_arguments) {
+  return command_arguments.filter((argument) => is_flag(argument));
+}
+async function resolve_command_scope(request) {
+  const explicit_files = explicit_files_of(request.command_arguments);
+  if (explicit_files.length === 0) {
+    return resolve_scope(await read_changed_files(request.root), request.inputs);
+  }
+  return resolve_scope(
+    explicit_files.map((file) => path2.resolve(file)),
+    request.inputs
+  );
+}
+function report_unusable_arguments(command_arguments, scope, label) {
+  const narrowed = new Set(scope.files);
+  const unusable = explicit_files_of(command_arguments).filter(
+    (file) => !narrowed.has(path2.resolve(file))
+  );
+  if (unusable.length === 0) return;
+  process.stdout.write(`${label}: ignored \u2014 not a file this check reads: ${unusable.join(" ")}
+`);
+}
+var changed_file_scope = {
+  ARGV_START,
+  LISTED_FILE_LIMIT,
+  UNREADABLE_REASON,
+  describe_scope,
+  flags_of,
+  format_file_list,
+  is_flag,
+  read_changed_files,
+  report_unusable_arguments,
+  repository_root_or_cwd,
+  resolve_command_scope,
+  resolve_scope,
+  select_files
+};
+
+// scripts/lint/lint-related-scope.ts
+var LINTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".svelte",
+  ".vue",
+  ".md",
+  ".mdx",
+  ".json",
+  ".jsonc",
+  ".json5",
+  ".yaml",
+  ".yml",
+  ".css",
+  ".scss",
+  ".less",
+  ".html",
+  ".graphql",
+  ".gql"
+]);
+var NOTHING_LINTABLE_REASON = "no changed file is one prettier or eslint reads";
+var COMMAND_NAME = "lint:related";
+var COMMAND_LABEL = `josh ${COMMAND_NAME}`;
+var VOCABULARY = {
+  label: COMMAND_LABEL,
+  fallback_suffix: "checking the whole tree instead",
+  narrowed_suffix: "checking only them"
+};
+var PRETTIER_ARGS = ["exec", "prettier", "--check", "--ignore-unknown"];
+var ESLINT_ARGS = ["exec", "eslint"];
+var ESLINT_SCOPED_FLAGS = ["--no-warn-ignored"];
+function is_lintable(file_path) {
+  return LINTABLE_EXTENSIONS.has(path3.extname(file_path));
+}
+function scope_inputs(is_present) {
+  return { is_present, is_selectable: is_lintable, nothing_reason: NOTHING_LINTABLE_REASON };
+}
+function describe_scope2(scope, root) {
+  return changed_file_scope.describe_scope(scope, root, VOCABULARY);
+}
+var RELATED_CACHES = {
+  eslint_file: ESLINT_RELATED_CACHE_FILE,
+  eslint_flags: ESLINT_RELATED_CACHE_FLAGS,
+  prettier_flags: PRETTIER_RELATED_CACHE_FLAGS
+};
+function prettier_arguments(files, caches = RELATED_CACHES, directory = process.cwd()) {
+  const targets = project_checks.prettier_targets(directory, files);
+  return [...PRETTIER_ARGS, ...targets, ...caches.prettier_flags];
+}
+function eslint_arguments(files, caches = RELATED_CACHES) {
+  return [...ESLINT_ARGS, ...files, ...caches.eslint_flags, ...ESLINT_SCOPED_FLAGS];
+}
+var lint_related_scope = {
+  COMMAND_LABEL,
+  NOTHING_LINTABLE_REASON,
+  RELATED_CACHES,
+  describe_scope: describe_scope2,
+  eslint_arguments,
+  is_lintable,
+  prettier_arguments,
+  scope_inputs
+};
+
+// scripts/lib/buffered-process.ts
+import { existsSync as existsSync2 } from "node:fs";
+var { PNPM } = pnpm_reach;
+var FORCE_COLOR = "1";
+function is_pnpm_missing(result, cwd) {
+  return pnpm_reach.is_not_found(result) && existsSync2(cwd ?? process.cwd());
+}
+function unfinished_reason(result, cwd) {
+  if (result.exitCode !== void 0) return [];
+  const reason = [result.shortMessage ?? ""];
+  if (is_pnpm_missing(result, cwd)) reason.push(pnpm_reach.NOT_ON_PATH_NOTICE);
+  return reason;
+}
+function collect_output(all, reason) {
+  return [all, ...reason].filter((part) => part !== "").join("\n");
+}
+function child_environment() {
+  const environment = { ...process.env };
+  if (environment["NO_COLOR"] === void 0) environment["FORCE_COLOR"] = FORCE_COLOR;
+  else delete environment["FORCE_COLOR"];
+  return environment;
+}
+async function run_buffered_launch(launch, options) {
+  const started_at = performance.now();
+  const result = await execa(launch.file, [...launch.args], {
+    env: options.environment ?? child_environment(),
+    extendEnv: false,
+    all: true,
+    reject: false,
+    ...options.cwd !== void 0 && { cwd: options.cwd },
+    timeout: options.timeout_ms ?? SUITE_TIMEOUT_MS
+  });
+  return {
+    output: collect_output(result.all, unfinished_reason(result, options.cwd)),
+    exit_code: result.exitCode,
+    elapsed_ms: performance.now() - started_at
+  };
+}
+async function run_buffered_process(command_args, options = {}) {
+  return await run_buffered_launch({ file: PNPM, args: command_args }, options);
+}
+async function run_buffered_direct(pnpm_arguments, options = {}) {
+  const launch = direct_launch(options.cwd ?? process.cwd(), pnpm_arguments);
+  return await run_buffered_launch(launch, options);
+}
+function is_process_failed(result) {
+  return result.exit_code !== 0;
+}
+var buffered_process = {
+  child_environment,
+  is_process_failed,
+  run_buffered_direct,
+  run_buffered_process
+};
+
+// scripts/josh/josh-logic.ts
+import { existsSync as existsSync4 } from "node:fs";
+import path8 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 path5 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-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 path4 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 ? path4.basename(checkout) : `${path4.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/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),
+    memory_supported: process.platform === "darwin" || process.platform === "linux",
+    total_mb: totalmem() / BYTES_PER_MB
+  };
+}
+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-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 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(path5.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 = path5.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_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, path5.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 path6 from "node:path";
+import { pathToFileURL } from "node:url";
+var BUNDLED_COMMAND_DIRECTORY = path6.join("dist", "commands");
+
+// scripts/josh/run-github-prerequisite.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path7 from "node:path";
+
+// scripts/josh/josh-logic.ts
+var TSX_BIN = "tsx";
+var TSX_PACKAGE = "tsx";
+var PACKAGE_DIR = find_package_directory(path8.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(existsSync4) ?? 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`;
+
+// scripts/lint/import-graph.ts
+import path11 from "node:path";
+
+// scripts/gate/input-fingerprint.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import path9 from "node:path";
+var ABSENT = "absent";
+function of_content(content) {
+  return stamp_file.digest(content);
+}
+function of_entries(entries) {
+  return of_content([...entries].toSorted((left, right) => left.localeCompare(right)).join("\n"));
+}
+function of_file(file_path) {
+  try {
+    return of_content(readFileSync2(file_path));
+  } catch {
+    return ABSENT;
+  }
+}
+function of_files(root, relatives) {
+  const sorted = [...new Set(relatives)].toSorted((left, right) => left.localeCompare(right));
+  return Object.fromEntries(
+    sorted.map((relative) => [relative, of_file(path9.join(root, relative))])
+  );
+}
+var input_fingerprint = { ABSENT, of_entries, of_file, of_files };
+
+// scripts/lint/import-graph-store.ts
+import { existsSync as existsSync5 } from "node:fs";
+import path10 from "node:path";
+var STORE_VERSION = 1;
+var STORE_NAME = `import-graph.v${String(STORE_VERSION)}.json`;
+var ENVIRONMENT_FILES = ["package.json", "pnpm-lock.yaml"];
+var EXTENSION = /(?:\.d)?\.[^./]+$/u;
+var INDEX = "index";
+var stored_dependency = external_exports.tuple([external_exports.string(), external_exports.boolean()]);
+var stored_file = external_exports.object({
+  hash: external_exports.string(),
+  all: external_exports.array(stored_dependency).optional(),
+  runtime: external_exports.array(stored_dependency).optional()
+});
+var stored_graph = external_exports.object({
+  version: external_exports.literal(STORE_VERSION),
+  environment: external_exports.string(),
+  files: external_exports.record(external_exports.string(), stored_file)
+});
+function store_path(root) {
+  const common = git_common_directory.repository(root);
+  return common === void 0 ? void 0 : path10.join(common, git_common_directory.STATE_DIRECTORY, STORE_NAME);
+}
+function environment_of(root, config_files) {
+  const relatives = [...config_files.map((file) => path10.relative(root, file)), ...ENVIRONMENT_FILES];
+  const digests = Object.entries(input_fingerprint.of_files(root, relatives));
+  return input_fingerprint.of_entries(digests.map(([file, digest2]) => `${file}:${digest2}`));
+}
+function open(root, config_files) {
+  return {
+    root,
+    environment: environment_of(root, config_files),
+    file_path: store_path(root),
+    files: void 0,
+    seeded: /* @__PURE__ */ new Set(),
+    memo: { all: /* @__PURE__ */ new Map(), runtime: /* @__PURE__ */ new Map() },
+    unresolved: { all: /* @__PURE__ */ new Set(), runtime: /* @__PURE__ */ new Set() },
+    content_hashes: /* @__PURE__ */ new Map()
+  };
+}
+function remember(store, name, file, references) {
+  const found = references.filter((dependency) => dependency !== void 0);
+  if (found.length < references.length) store.unresolved[name].add(file);
+  store.memo[name].set(file, found);
+  return found;
+}
+function content_hash(store, file) {
+  const known = store.content_hashes.get(file);
+  if (known !== void 0) return known;
+  const computed = input_fingerprint.of_file(file);
+  store.content_hashes.set(file, computed);
+  return computed;
+}
+function read_files(store) {
+  const text = store.file_path === void 0 ? void 0 : file_reader.read_if_readable(store.file_path);
+  const stored = text === void 0 ? void 0 : json_value.parse_with(text, stored_graph);
+  return stored?.environment === store.environment ? stored.files : {};
+}
+function files_of(store) {
+  store.files ??= read_files(store);
+  return store.files;
+}
+function module_stem(file) {
+  const stem = file.replace(EXTENSION, "");
+  return path10.basename(stem) === INDEX ? path10.dirname(stem) : stem;
+}
+function added_stems(store, universe) {
+  const files = files_of(store);
+  const added = universe.filter((file) => !Object.hasOwn(files, path10.relative(store.root, file)));
+  return new Set(added.map((file) => module_stem(file)));
+}
+function rebased(store, stored) {
+  return stored.map(([file, external]) => ({ file: path10.join(store.root, file), external }));
+}
+function is_standing(dependency, seeding) {
+  return existsSync5(dependency.file) && !seeding.added.has(module_stem(dependency.file));
+}
+function stored_edges(store, name, file, seeding) {
+  const entry = seeding.files[path10.relative(store.root, file)];
+  const stored = entry?.hash === content_hash(store, file) ? entry[name] : void 0;
+  if (stored === void 0) return void 0;
+  const dependencies = rebased(store, stored);
+  return dependencies.every((dependency) => is_standing(dependency, seeding)) ? dependencies : void 0;
+}
+function seed(store, name, universe) {
+  if (store.seeded.has(name)) return [];
+  store.seeded.add(name);
+  const seeding = { files: files_of(store), added: added_stems(store, universe) };
+  const memo = store.memo[name];
+  return universe.filter((file) => {
+    const stored = stored_edges(store, name, file, seeding);
+    if (stored !== void 0 && !memo.has(file)) memo.set(file, stored);
+    return stored === void 0;
+  });
+}
+function entry_of(store, name, file) {
+  const dependencies = store.memo[name].get(file);
+  if (dependencies === void 0 || store.unresolved[name].has(file)) return void 0;
+  const hash = content_hash(store, file);
+  const known = files_of(store)[path10.relative(store.root, file)];
+  const entry = known?.hash === hash ? { ...known } : { hash };
+  entry[name] = dependencies.map((dependency) => [
+    path10.relative(store.root, dependency.file),
+    dependency.external
+  ]);
+  return entry;
+}
+function write(store, file_path) {
+  const files = Object.entries(files_of(store)).filter(
+    ([file]) => existsSync5(path10.join(store.root, file))
+  );
+  const graph = {
+    version: STORE_VERSION,
+    environment: store.environment,
+    files: Object.fromEntries(files)
+  };
+  atomic_write.replace_file(file_path, JSON.stringify(graph));
+}
+function keep(store, name, missing) {
+  if (missing.length === 0 || store.file_path === void 0) return;
+  const files = files_of(store);
+  for (const file of missing) {
+    const entry = entry_of(store, name, file);
+    if (entry !== void 0) files[path10.relative(store.root, file)] = entry;
+  }
+  write(store, store.file_path);
+}
+var import_graph_store = { content_hash, keep, open, remember, seed, store_path };
+
+// scripts/test/test-inputs.ts
+var GLOBALS = /* @__PURE__ */ new Set([
+  "undefined",
+  "NaN",
+  "Infinity",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "BigInt",
+  "Symbol",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "JSON",
+  "RegExp",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "Promise",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite"
+]);
+var UNSAFE = /* @__PURE__ */ new Set([
+  "process",
+  "global",
+  "globalThis",
+  "eval",
+  "Function",
+  "require",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "vi",
+  "vitest",
+  "inject",
+  "provide",
+  "toMatchSnapshot",
+  "toMatchFileSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "matchSnapshot"
+]);
+function is_property(typescript, node) {
+  const { parent } = node;
+  return typescript.isPropertyAccessExpression(parent) && parent.name === node || (typescript.isPropertyAssignment(parent) || typescript.isMethodDeclaration(parent)) && parent.name === node;
+}
+function is_unsafe_syntax(typescript, node) {
+  return [
+    typescript.isNamespaceImport(node),
+    typescript.isElementAccessExpression(node),
+    node.kind === typescript.SyntaxKind.ThisKeyword,
+    typescript.isMetaProperty(node)
+  ].includes(true);
+}
+function is_dynamic_import(typescript, node) {
+  return typescript.isCallExpression(node) && node.expression.kind === typescript.SyntaxKind.ImportKeyword;
+}
+function is_unknown_identifier(typescript, node, checker) {
+  if (UNSAFE.has(node.text)) return true;
+  return !is_property(typescript, node) && checker.getSymbolAtLocation(node) === void 0 && !GLOBALS.has(node.text);
+}
+function is_unknown(typescript, node, checker) {
+  if (is_unsafe_syntax(typescript, node) || is_dynamic_import(typescript, node)) return true;
+  if (!typescript.isIdentifier(node)) return false;
+  return is_unknown_identifier(typescript, node, checker);
+}
+function is_closed(typescript, file, content) {
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest, true);
+  const host = typescript.createCompilerHost({});
+  host.getSourceFile = (name) => name === file ? source : void 0;
+  const program = typescript.createProgram([file], { noLib: true, noResolve: true }, host);
+  const checker = program.getTypeChecker();
+  function unknown(node) {
+    if (typescript.isTypeNode(node)) return false;
+    return is_unknown(typescript, node, checker) || typescript.forEachChild(node, unknown) === true;
+  }
+  return program.getSyntacticDiagnostics(source).length === 0 && !unknown(source);
+}
+var test_inputs = { is_closed };
+
+// scripts/lint/type-only-imports.ts
+function declaration_of(typescript, statement) {
+  if (typescript.isImportDeclaration(statement)) return statement;
+  if (typescript.isExportDeclaration(statement)) return statement;
+  return void 0;
+}
+function is_type_only(typescript, declaration) {
+  if (typescript.isExportDeclaration(declaration)) return declaration.isTypeOnly;
+  return declaration.importClause?.phaseModifier === typescript.SyntaxKind.TypeKeyword;
+}
+function type_only_position(typescript, source, statement) {
+  const declaration = declaration_of(typescript, statement);
+  if (declaration === void 0 || !is_type_only(typescript, declaration)) return void 0;
+  const specifier = declaration.moduleSpecifier;
+  if (specifier === void 0 || !typescript.isStringLiteral(specifier)) return void 0;
+  return specifier.getStart(source);
+}
+function runtime_specifiers(typescript, file, content) {
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
+  const type_only = new Set(
+    source.statements.map((statement) => type_only_position(typescript, source, statement))
+  );
+  return typescript.preProcessFile(content, true, true).importedFiles.filter((reference) => !type_only.has(reference.pos)).map((reference) => reference.fileName);
+}
+function strings(typescript, file) {
+  const content = file_reader.read_if_readable(file) ?? "";
+  const source = typescript.createSourceFile(file, content, typescript.ScriptTarget.Latest);
+  const found = [];
+  function visit(node) {
+    if (typescript.isStringLiteralLike(node) || typescript.isTemplateLiteralToken(node)) {
+      found.push(node.text);
+    }
+    typescript.forEachChild(node, visit);
+  }
+  visit(source);
+  return found;
+}
+var type_only_imports = { runtime_specifiers, strings };
+
+// scripts/lint/import-test-inputs.ts
+var DECLARATION_EXTENSION = /\.d\.[cm]?ts$/u;
+var TYPESCRIPT_EXTENSION = /\.[cm]?tsx?$/u;
+var JAVASCRIPT_EXTENSIONS = ["js", "jsx", "mjs", "cjs"];
+function is_runtime_source(typescript, file) {
+  if (DECLARATION_EXTENSION.test(file)) return false;
+  if (!TYPESCRIPT_EXTENSION.test(file)) return true;
+  return JAVASCRIPT_EXTENSIONS.every(
+    (extension) => !typescript.sys.fileExists(file.replace(TYPESCRIPT_EXTENSION, () => `.${extension}`))
+  );
+}
+function dependencies_of(typescript, resolve, file, content) {
+  const specifiers = type_only_imports.runtime_specifiers(typescript, file, content);
+  const dependencies = specifiers.filter((name) => name !== "vitest").map((name) => name.startsWith(".") ? resolve(name, file) : void 0);
+  if (dependencies.some((dependency) => dependency === void 0 || dependency.external)) {
+    return void 0;
+  }
+  return dependencies.flatMap((dependency) => dependency?.file ?? []);
+}
+function read_source(typescript, resolve, file) {
+  if (!is_runtime_source(typescript, file)) return void 0;
+  const content = file_reader.read_if_readable(file);
+  if (content === void 0 || !test_inputs.is_closed(typescript, file, content)) return void 0;
+  return dependencies_of(typescript, resolve, file, content);
+}
+function unvisited(file, reached, read) {
+  return reached.has(file) ? [] : read(file);
+}
+function closure(file, read) {
+  const reached = /* @__PURE__ */ new Set();
+  const pending = [file];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    const dependencies = unvisited(current, reached, read);
+    if (dependencies === void 0) return void 0;
+    reached.add(current);
+    pending.push(...dependencies);
+  }
+  return [...reached];
+}
+function create(typescript, resolve) {
+  const cache = /* @__PURE__ */ new Map();
+  function read(file) {
+    if (!cache.has(file)) cache.set(file, read_source(typescript, resolve, file));
+    return cache.get(file);
+  }
+  return (file) => closure(file, read);
+}
+var import_test_inputs2 = { create };
+
+// scripts/lint/import-graph.ts
+var TSCONFIG = "tsconfig.json";
+var NODE_MODULES = "node_modules";
+var MODULE_STATEMENT = /^(?:import|export)\b/mu;
+var GLOBAL_DECLARATION = /^declare (?:global|module|namespace)\b/mu;
+async function load_typescript() {
+  try {
+    const module = await import("typescript");
+    return module.default;
+  } catch {
+    return void 0;
+  }
+}
+function parsed_config(typescript, root) {
+  const config_file = path11.join(root, TSCONFIG);
+  if (!typescript.sys.fileExists(config_file)) return void 0;
+  const source = typescript.readJsonConfigFile(config_file, typescript.sys.readFile);
+  const parsed = typescript.parseJsonSourceFileConfigFileContent(
+    source,
+    typescript.sys,
+    root,
+    void 0,
+    config_file
+  );
+  return {
+    options: parsed.options,
+    file_names: parsed.fileNames,
+    config_files: [config_file, ...source.extendedSourceFiles ?? []]
+  };
+}
+function is_installed(file) {
+  return file.split(path11.sep).includes(NODE_MODULES);
+}
+function as_dependency(file, external) {
+  if (file === void 0) return void 0;
+  return { file, external: external === true && is_installed(file) };
+}
+function relative_to(specifier, file) {
+  return { file: path11.resolve(path11.dirname(file), specifier), external: false };
+}
+function resolve_module(context, specifier, file) {
+  const { typescript, options, resolution_cache } = context;
+  const resolved = typescript.resolveModuleName(
+    specifier,
+    file,
+    options,
+    typescript.sys,
+    resolution_cache
+  ).resolvedModule;
+  if (resolved !== void 0) {
+    return as_dependency(resolved.resolvedFileName, resolved.isExternalLibraryImport);
+  }
+  if (!specifier.startsWith(".")) return void 0;
+  return relative_to(specifier, file);
+}
+function resolve_type(resolver, name, file) {
+  const { typescript, options } = resolver;
+  const resolved = typescript.resolveTypeReferenceDirective(
+    name,
+    file,
+    options,
+    typescript.sys
+  ).resolvedTypeReferenceDirective;
+  return as_dependency(resolved?.resolvedFileName, resolved?.isExternalLibraryImport);
+}
+function references_of(context, file, content) {
+  const processed = context.typescript.preProcessFile(content, true, true);
+  return [
+    ...processed.importedFiles.map(
+      (reference) => resolve_module(context, reference.fileName, file)
+    ),
+    ...processed.referencedFiles.map((reference) => relative_to(reference.fileName, file)),
+    ...processed.typeReferenceDirectives.map(
+      (reference) => resolve_type(context, reference.fileName, file)
+    )
+  ];
+}
+function direct_dependencies(context, file) {
+  const known = context.store.memo.all.get(file);
+  if (known !== void 0) return known;
+  const references = references_of(context, file, file_reader.read_if_readable(file) ?? "");
+  return import_graph_store.remember(context.store, "all", file, references);
+}
+function runtime_dependencies(context, file) {
+  const known = context.store.memo.runtime.get(file);
+  if (known !== void 0) return known;
+  const content = file_reader.read_if_readable(file) ?? "";
+  const references = type_only_imports.runtime_specifiers(context.typescript, file, content).map((specifier) => resolve_module(context, specifier, file));
+  return import_graph_store.remember(context.store, "runtime", file, references);
+}
+function is_ambient(file) {
+  const content = file_reader.read_if_readable(file) ?? "";
+  return GLOBAL_DECLARATION.test(content) || !MODULE_STATEMENT.test(content);
+}
+function ambient_of(resolver, root, config) {
+  const config_file = path11.join(root, TSCONFIG);
+  const declarations = [
+    ...config.file_names.filter((file) => is_ambient(file)),
+    ...config.config_files
+  ].map((file) => ({ file, external: false }));
+  const types = resolver.typescript.getAutomaticTypeDirectiveNames(resolver.options, resolver.typescript.sys).map((name) => resolve_type(resolver, name, config_file)).filter((dependency) => dependency !== void 0);
+  return [...declarations, ...types];
+}
+function is_unvisited(dependency, start, reached) {
+  return dependency.file !== start && !reached.has(dependency.file);
+}
+function join(dependencies, start, reached) {
+  const next = dependencies.filter((dependency) => is_unvisited(dependency, start, reached));
+  for (const dependency of next) reached.set(dependency.file, dependency);
+  return next.filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function reachable(context, file) {
+  const reached = /* @__PURE__ */ new Map();
+  const pending = [file, ...join(context.ambient, file, reached)];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    pending.push(...join(direct_dependencies(context, current), file, reached));
+  }
+  return reached;
+}
+function token_of(context, dependency) {
+  const name = path11.relative(context.root, dependency.file);
+  if (dependency.external) return name;
+  return `${name}:${import_graph_store.content_hash(context.store, dependency.file)}`;
+}
+function closure_hash(context, file) {
+  const tokens = [...reachable(context, file).values()].map(
+    (dependency) => token_of(context, dependency)
+  );
+  return input_fingerprint.of_entries(tokens);
+}
+function closure2(context, file) {
+  return [...reachable(context, file).values()].filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function imports(context, file, content) {
+  const dependencies = content === void 0 ? direct_dependencies(context, file) : references_of(context, file, content).filter((dependency) => dependency !== void 0);
+  return dependencies.filter((dependency) => !dependency.external).map((dependency) => dependency.file);
+}
+function append(map, key, value) {
+  const known = map.get(key);
+  if (known === void 0) map.set(key, [value]);
+  else known.push(value);
+}
+function reverse_edges(context, universe, edges) {
+  const reverse = /* @__PURE__ */ new Map();
+  const missing = import_graph_store.seed(context.store, edges.name, universe);
+  for (const file of universe) {
+    for (const dependency of edges.of(context, file)) {
+      append(reverse, dependency.file, file);
+    }
+  }
+  import_graph_store.keep(context.store, edges.name, missing);
+  return reverse;
+}
+function importers(context, files, universe, edges) {
+  const reverse = reverse_edges(context, universe, edges);
+  const reached = new Set(files);
+  const pending = [...files];
+  for (let current = pending.pop(); current !== void 0; current = pending.pop()) {
+    const next = (reverse.get(current) ?? []).filter((file) => !reached.has(file));
+    for (const file of next) reached.add(file);
+    pending.push(...next);
+  }
+  return reached;
+}
+function project_module(context, specifier, file) {
+  const dependency = resolve_module(context, specifier, file);
+  if (dependency === void 0) return void 0;
+  const relative = path11.relative(context.root, dependency.file);
+  return relative.startsWith(`..${path11.sep}`) || path11.isAbsolute(relative) ? void 0 : dependency;
+}
+function graph_of(context) {
+  return {
+    // Type-checker suffixes need not select the source the runner executes.
+    test_inputs: context.options.moduleSuffixes === void 0 ? import_test_inputs2.create(
+      context.typescript,
+      (specifier, file) => project_module(context, specifier, file)
+    ) : void 0,
+    closure: (file) => closure2(context, file),
+    closure_hash: (file) => closure_hash(context, file),
+    imports: (file, content) => imports(context, file, content),
+    importers: (files, universe) => importers(context, files, universe, { name: "all", of: direct_dependencies }),
+    runtime_importers: (files, universe) => importers(context, files, universe, { name: "runtime", of: runtime_dependencies }),
+    strings: (file) => type_only_imports.strings(context.typescript, file)
+  };
+}
+async function create2(root) {
+  const typescript = await load_typescript();
+  if (typescript === void 0) return void 0;
+  const parsed = parsed_config(typescript, root);
+  if (parsed === void 0) return void 0;
+  return graph_of({
+    root,
+    typescript,
+    options: parsed.options,
+    resolution_cache: typescript.createModuleResolutionCache(root, (name) => name, parsed.options),
+    ambient: ambient_of({ typescript, options: parsed.options }, root, parsed),
+    store: import_graph_store.open(root, parsed.config_files)
+  });
+}
+var import_graph = { create: create2 };
+
+export {
+  toolchain_inputs,
+  buffered_process,
+  run_board_usage_rusage,
+  core_admission,
+  machine_capacity,
+  held_mark,
+  core_budget,
+  resolve_tsx_runner,
+  input_fingerprint,
+  import_graph,
+  changed_file_scope,
+  lint_related_scope
+};