@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-WWLCQREY.js

@@ -0,0 +1,225 @@
+import {
+  issue_observation_gate,
+  lane_early_push_count
+} from "./chunk-YJZAD4Z5.js";
+import {
+  issue_sample_gate
+} from "./chunk-CQUZ6TNQ.js";
+import {
+  git_closes_keyword
+} from "./chunk-J3TKZLHA.js";
+import {
+  git_gh_repo
+} from "./chunk-CTXJVMHW.js";
+import {
+  git_gh_pr_too_large,
+  read_pull
+} from "./chunk-5IHEBIPD.js";
+import {
+  lane_ledger
+} from "./chunk-2O64H5UJ.js";
+import {
+  git_gh_issue_rest
+} from "./chunk-TFYYXETQ.js";
+import {
+  gh_author_association
+} from "./chunk-5YTEMF4O.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  git_gh_exec,
+  parse_json,
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/issue/issue-closing-pr.ts
+import { z } from "zod";
+var LINE_SEPARATOR = "\n";
+var TIMELINE_FILTER = [
+  ".[]",
+  '| if .event == "cross-referenced" and .source.issue.pull_request != null',
+  'then {url: .source.issue.html_url, repo: .source.issue.repository.full_name, body: (.source.issue.body // ""), state: (if .source.issue.pull_request.merged_at != null then "merged" else .source.issue.state end)}',
+  'elif .event == "reopened" then {reopened: true}',
+  "else empty end"
+].join(" ");
+var reference_schema = z.object({
+  url: z.string(),
+  repo: z.string(),
+  body: z.string(),
+  state: z.enum(["open", "closed", "merged"]).default("merged")
+});
+var reopen_schema = z.object({ reopened: z.literal(true) });
+var row_schema = z.union([reference_schema, reopen_schema]);
+function is_reference(row) {
+  return "url" in row;
+}
+function parse_row(line) {
+  const row = parse_json_object_or_undefined(line, row_schema);
+  if (row === void 0) throw new Error("the issue timeline contains an unreadable row");
+  return row;
+}
+function parse_references(raw) {
+  const rows = raw.split(LINE_SEPARATOR).filter((line) => line.trim() !== "").map((line) => parse_row(line));
+  const last_reopen = rows.findLastIndex((row) => !is_reference(row));
+  return rows.slice(last_reopen + 1).filter((row) => is_reference(row));
+}
+function pick_closing_pr(references, issue, repo) {
+  return references.find(
+    (reference) => reference.repo === repo && reference.state === "merged" && git_closes_keyword.parse_closes_issue_number(reference.body) === issue
+  )?.url;
+}
+async function read_closing_result(issue) {
+  try {
+    const [raw, repo] = await Promise.all([
+      git_gh_exec.exec_gh_api({
+        path: `${git_gh_api_path.issue_api_path(issue)}/timeline?per_page=100`,
+        should_paginate: true,
+        jq_filter: TIMELINE_FILTER
+      }),
+      git_gh_repo.repo_get_canonical_name_with_owner()
+    ]);
+    if (repo === void 0) return { kind: "unreadable" };
+    return { kind: "read", url: pick_closing_pr(parse_references(raw), issue, repo) };
+  } catch {
+    return { kind: "unreadable" };
+  }
+}
+async function read_closing_pr(issue) {
+  const result = await read_closing_result(issue);
+  return result.kind === "read" ? result.url : void 0;
+}
+async function read_closing_number_result(issue) {
+  const result = await read_closing_result(String(issue));
+  if (result.kind === "unreadable") return result;
+  const number = result.url === void 0 ? void 0 : Number(result.url.slice(result.url.lastIndexOf("/") + 1));
+  return { kind: "read", number };
+}
+async function read_closing_number(issue) {
+  const result = await read_closing_number_result(issue);
+  return result.kind === "read" ? result.number : void 0;
+}
+var issue_closing_pr = {
+  read_closing_number,
+  read_closing_number_result,
+  read_closing_pr
+};
+
+// scripts/issue/issue-observation-prime.ts
+import { z as z2 } from "zod";
+var comment_schema = z2.object({
+  ...gh_author_association.author_fields_schema,
+  body: z2.string(),
+  html_url: z2.string()
+});
+async function read_ledger() {
+  const path = await lane_ledger.target();
+  return path === void 0 ? [] : lane_ledger.read_entries(path);
+}
+async function read(source) {
+  const path = `${git_gh_api_path.issues_api_path(source.repo)}/comments/${source.comment}`;
+  const raw = await git_gh_exec.exec_gh_api({ path });
+  const comment = parse_json.parse_json_object_or_undefined(raw, comment_schema);
+  if (comment?.html_url !== source.url) return void 0;
+  const author = { ...gh_author_association.author_of(comment), repo: source.repo };
+  return await gh_author_association.is_trusted(author) ? comment.body : void 0;
+}
+async function remember(source, read_source2) {
+  try {
+    issue_observation_gate.record(source.url, await read_source2(source));
+  } catch {
+    issue_observation_gate.record(source.url, void 0);
+  }
+}
+async function sample(sources, read_entries) {
+  if (sources.every((source) => source.ledger === void 0)) return;
+  let entries = [];
+  try {
+    entries = await read_entries();
+  } catch {
+  }
+  issue_observation_gate.record_sample(
+    lane_early_push_count.MULTI_SLOT_EARLY_PUSH,
+    lane_early_push_count.multi_slot_pushed(entries)
+  );
+}
+async function prime(bodies, read_source2 = read, read_entries = read_ledger) {
+  const sources = issue_observation_gate.sources(bodies);
+  const unique = new Map(sources.map((source) => [source.url, source]));
+  await Promise.all([
+    sample(sources, read_entries),
+    ...[...unique.values()].map(async (source) => {
+      await remember(source, read_source2);
+    })
+  ]);
+}
+var issue_observation_prime = { prime };
+
+// scripts/issue/issue-sample-prime.ts
+async function read_as_issue(pr) {
+  const json = await git_gh_exec.exec_gh_api({ path: git_gh_api_path.issue_api_path(String(pr)) });
+  const issue = git_gh_issue_rest.parse_rest_issue(json);
+  return { body: issue.body, merged_at: issue.pull_request?.merged_at };
+}
+async function read_fields(pr) {
+  try {
+    return await read_pull(pr);
+  } catch (error) {
+    if (!git_gh_pr_too_large.is_too_many_files(error)) throw error;
+    return await read_as_issue(pr);
+  }
+}
+async function read_source(pr) {
+  const pull = await read_fields(pr);
+  const closes = git_closes_keyword.parse_closes_issue_number(pull.body ?? void 0);
+  return {
+    merged_at: pull.merged_at ?? void 0,
+    closes: closes === void 0 ? void 0 : Number(closes)
+  };
+}
+async function read_closing_source(issue) {
+  const pr = await issue_closing_pr.read_closing_number(issue);
+  if (pr === void 0) return { merged_at: void 0, closes: issue };
+  const { merged_at } = await read_source(pr);
+  return { merged_at, closes: issue };
+}
+var DEFAULT_PORTS = {
+  pull: read_source,
+  closing: read_closing_source,
+  ledger_path: lane_ledger.target
+};
+function merges_of(path) {
+  return function merges() {
+    if (path === void 0) return [];
+    return lane_ledger.read_entries(path).filter((entry) => entry.kind === lane_ledger.KIND.MERGE);
+  };
+}
+async function remember2(condition, ports) {
+  const read2 = condition.via === "pull" ? ports.pull : ports.closing;
+  try {
+    issue_sample_gate.record(condition, await read2(condition.cited));
+  } catch {
+    issue_sample_gate.record(condition, void 0);
+  }
+}
+async function prime2(bodies, ports = DEFAULT_PORTS) {
+  await issue_observation_prime.prime(bodies);
+  const unread = issue_sample_gate.unread_of(bodies);
+  if (unread.length === 0) return;
+  issue_sample_gate.use_merges(merges_of(await ports.ledger_path()));
+  await Promise.all(
+    unread.map(async (condition) => {
+      await remember2(condition, ports);
+    })
+  );
+}
+var issue_sample_prime = {
+  prime: prime2,
+  read_closing: read_closing_source,
+  read_source
+};
+
+export {
+  issue_closing_pr,
+  issue_sample_prime
+};

package/dist/commands/chunk-WXLW7S4M.js

@@ -0,0 +1,71 @@
+import {
+  run_startup
+} from "./chunk-RV7EQIE4.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/josh/shared-cache.ts
+import { z } from "zod";
+var record_schema = z.object({
+  key: z.string(),
+  saved_at: z.number(),
+  value: z.unknown()
+});
+function slot_path(slot) {
+  return stamp_file.stamp_path(slot.prefix, git_common_directory.repository() ?? PROJECT_ROOT);
+}
+function is_fresh(saved_at, slot, now_ms) {
+  return saved_at <= now_ms && now_ms - saved_at < slot.ttl_ms;
+}
+function read_value(slot, key, now_ms) {
+  const raw = stamp_file.read_stamp_text(slot_path(slot));
+  const record = raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema);
+  return record?.key === key && is_fresh(record.saved_at, slot, now_ms) ? record.value : void 0;
+}
+function read(slot, key, schema, now_ms) {
+  const parsed = schema.safeParse(read_value(slot, key, now_ms));
+  run_startup.metric(
+    "cache",
+    parsed.success && parsed.data !== void 0 ? "hit" : "miss",
+    `${slot.prefix}:${key}`
+  );
+  return parsed.success ? parsed.data : void 0;
+}
+function write(slot, key, value, now_ms) {
+  try {
+    stamp_file.replace_stamp(slot_path(slot), { key, saved_at: now_ms, value });
+  } catch {
+  }
+}
+async function remember(request, compute, now_ms = Date.now()) {
+  const cached = read(request.slot, request.key, request.schema, now_ms);
+  if (cached !== void 0) return cached;
+  const value = await run_startup.phase(
+    `cache fill ${request.slot.prefix}`,
+    async () => {
+      run_startup.metric("cache", "fill", `${request.slot.prefix}:${request.key}`);
+      return await compute();
+    },
+    { edge_of: (result) => result === void 0 ? "failed" : "done" }
+  );
+  if (value !== void 0) write(request.slot, request.key, value, now_ms);
+  return value;
+}
+function clear(slot) {
+  stamp_file.remove_stamp(slot_path(slot));
+}
+var shared_cache = { clear, read, remember, write };
+
+export {
+  shared_cache
+};

package/dist/commands/chunk-WXXLJQBO.js

@@ -0,0 +1,67 @@
+import {
+  NEEDS_HUMAN_REVIEW_LABEL,
+  PLANNED_LABEL,
+  has_any_label,
+  has_label_name
+} from "./chunk-QQBMVC5W.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/issue/issue-state.ts
+import { z } from "zod";
+var NO_LABELS = "(none)";
+var LABEL_SEPARATOR = ", ";
+var STATE_LABEL = "state: ";
+var LABELS_LABEL = "labels: ";
+var HUMAN_REVIEW_LABEL_LINE = "human_review: ";
+var YES = "yes";
+var NO = "no";
+var ISSUE_LABEL = "issue: ";
+var HUMAN_REVIEW_LABELS = /* @__PURE__ */ new Set([NEEDS_HUMAN_REVIEW_LABEL]);
+var label_schema = z.looseObject({ name: z.string() });
+var issue_state_schema = z.looseObject({
+  state: z.string(),
+  labels: label_schema.array().optional()
+});
+function parse_issue_state(json) {
+  try {
+    const parsed = parse_json_object_or_undefined(json, issue_state_schema);
+    if (parsed === void 0) return void 0;
+    const labels = parsed.labels ?? [];
+    return {
+      state: parsed.state,
+      labels: labels.map((label) => label.name),
+      is_human_review: has_any_label(labels, HUMAN_REVIEW_LABELS)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function format_labels(labels) {
+  return labels.length === 0 ? NO_LABELS : labels.join(LABEL_SEPARATOR);
+}
+function format_issue_state(state) {
+  const human_review = `${HUMAN_REVIEW_LABEL_LINE}${state.is_human_review ? YES : NO}`;
+  return `${STATE_LABEL}${state.state}
+${LABELS_LABEL}${format_labels(state.labels)}
+${human_review}`;
+}
+function format_attributed_issue_state(issue_number, state) {
+  return `${ISSUE_LABEL}${issue_number}
+${format_issue_state(state)}`;
+}
+function is_planned(read) {
+  return read.kind === "state" && has_label_name(read.state.labels, PLANNED_LABEL);
+}
+var issue_state = {
+  is_planned,
+  NO_LABELS,
+  parse_issue_state,
+  format_issue_state,
+  format_attributed_issue_state
+};
+
+export {
+  issue_state
+};

package/dist/commands/chunk-X4LYH6Q4.js

@@ -0,0 +1,56 @@
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+
+// scripts/run/event/run-event-step.ts
+var TOTAL_STEPS = 8;
+var STEP_KIND = run_event_stream.EVENT_KIND.STEP;
+var STEP = {
+  UPDATE_DEPS: { number: 4, name: "update-deps" },
+  IMPLEMENT: { number: 5, name: "implement" },
+  GATE: { number: 6, name: "gate" },
+  FOLLOWUP: { number: 7, name: "followup" }
+};
+var WORD_SEPARATOR = " ";
+var WORDS_START = 1;
+var NAME_START = 3;
+function text_of(issue, step) {
+  const cite = issue_cite.plain_for("program", issue);
+  return `${cite} step ${String(step.number)}/${String(TOTAL_STEPS)} ${step.name}`;
+}
+function words_after(event, start) {
+  return event.text.split(WORD_SEPARATOR).slice(start).join(WORD_SEPARATOR);
+}
+function words_of(event) {
+  return words_after(event, WORDS_START);
+}
+function name_of(event) {
+  return words_after(event, NAME_START);
+}
+function is_step_of(event, issue) {
+  return event.kind === STEP_KIND && run_event_scope.issue_named(event) === issue;
+}
+function is_latest(events, issue, text) {
+  return events.findLast((event) => is_step_of(event, issue))?.text === text;
+}
+var STREAM_IO = {
+  read: run_event_stream_emit.all_events,
+  emit: run_event_stream_emit.emit
+};
+async function record(issue, step, io = STREAM_IO) {
+  const text = text_of(issue, step);
+  if (is_latest(await io.read(), issue, text)) return;
+  await io.emit(STEP_KIND, text);
+}
+var run_event_step = { STEP, name_of, record, text_of, words_of };
+
+export {
+  run_event_step
+};

package/dist/commands/chunk-XAEL24EG.js

@@ -0,0 +1,66 @@
+import {
+  git_gh_blocked_by_graphql
+} from "./chunk-LS7P324N.js";
+import {
+  git_gh_issue_graphql
+} from "./chunk-TFYYXETQ.js";
+import {
+  git_gh_transport
+} from "./chunk-LX2ENXHZ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/gh/git-gh-issue-alias-graphql.ts
+import { z } from "zod";
+var ALIAS_PREFIX = "issue";
+var rate_limit_schema = z.object({ cost: z.number(), remaining: z.number() });
+function alias_of(issue_number) {
+  return `${ALIAS_PREFIX}${String(issue_number)}`;
+}
+function query_of(issue_numbers, fields) {
+  const aliases = issue_numbers.map(
+    (issue_number) => `${alias_of(issue_number)}: issue(number: ${String(issue_number)}) { ${fields} }`
+  );
+  return `query($owner: String!, $name: String!) {
+	rateLimit { cost remaining }
+	repository(owner: $owner, name: $name) { ${aliases.join("\n")} }
+}`;
+}
+function response_schema_of(issue_schema) {
+  const repository_schema = z.record(z.string(), issue_schema.nullable());
+  const data_schema = z.looseObject({ rateLimit: rate_limit_schema, repository: repository_schema });
+  return z.looseObject({ data: data_schema });
+}
+async function query_chunk(issue_numbers, fields, issue_schema, variables) {
+  const json = await git_gh_transport.query({ query: query_of(issue_numbers, fields), variables });
+  if (json === void 0) return void 0;
+  return json_value.parse_with(json, response_schema_of(issue_schema))?.data;
+}
+function with_chunk(read, issue_numbers, data) {
+  if (data === void 0) return read;
+  const answered = issue_numbers.flatMap((issue_number) => {
+    const issue = data.repository[alias_of(issue_number)];
+    return issue === void 0 || issue === null ? [] : [[issue_number, issue]];
+  });
+  return {
+    answers: new Map([...read.answers, ...answered]),
+    cost: read.cost + data.rateLimit.cost,
+    remaining: data.rateLimit.remaining
+  };
+}
+async function read_aliased(issue_numbers, fields, issue_schema, repo) {
+  const variables = issue_numbers.length === 0 ? void 0 : git_gh_issue_graphql.repository_variables_of(repo);
+  let read = { answers: /* @__PURE__ */ new Map(), cost: 0, remaining: void 0 };
+  if (variables === void 0) return read;
+  const chunks = git_gh_blocked_by_graphql.chunks_of([...new Set(issue_numbers)]);
+  for (const chunk of chunks) {
+    read = with_chunk(read, chunk, await query_chunk(chunk, fields, issue_schema, variables));
+  }
+  return read;
+}
+var git_gh_issue_alias_graphql = { read_aliased };
+
+export {
+  git_gh_issue_alias_graphql
+};

package/dist/commands/chunk-XDR2BRDL.js

@@ -0,0 +1,216 @@
+import {
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/gate/machine-capacity.ts
+import { readFile } from "node:fs/promises";
+import { availableParallelism, cpus, loadavg, totalmem } from "node:os";
+import { execa } from "execa";
+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_sleep(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_sleep) {
+  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
+};
+
+export {
+  machine_capacity
+};