@agentdocumentformat/cli 0.7.8 → 0.8.0

package/dist/chunks/chunk-JVPZIMXW.mjs

@@ -0,0 +1,976 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  testSeamsAllowed
+} from "./chunk-WVTPPOKK.mjs";
+import {
+  getUserDataPath
+} from "./chunk-PAK5JCO2.mjs";
+
+// src/main/runtime/agent-lease.ts
+import { execFile } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { promises as fsp, readFileSync, unlinkSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import { homedir, hostname as osHostname, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+var AGENT_LEASED_CODE = "agent_leased", DEFAULT_DAEMON_PORT = 7385, PROBE_TIMEOUT_MS = 1500, PARTIAL_WRITE_GRACE_MS = 2e3, ACQUIRE_BUDGET_MS = 5e3, MAX_SOCKET_PATH = 100, TRANSIENT_FS_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]), UNUSABLE_DIR_MEMO_MS = 6e4, TAKEOVER_LOCK_TTL_MS = 1e4, TAKEOVER_LOCK_WAIT_MS = 2e3, TAKEOVER_LOCK_REPROBE_MS = 250, TAKEOVER_LOCK_SUSPECT_MS = 500, DIR_MODE = 448, FILE_MODE = 384;
+function leaseDir(env = process.env) {
+  if (env.ADF_LEASE_DIR) return resolve(env.ADF_LEASE_DIR);
+  let base;
+  return process.platform === "darwin" ? base = join(homedir(), "Library", "Application Support") : process.platform === "win32" ? base = env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local") : base = env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), join(base, "adf", "leases");
+}
+async function canonicalLeasePath(filePath) {
+  let abs = resolve(filePath);
+  try {
+    return stripLongPathPrefix(await fsp.realpath(abs));
+  } catch {
+    return stripLongPathPrefix(abs);
+  }
+}
+function leaseKeyForCanonicalPath(canonicalPath, platform = process.platform) {
+  let norm = canonicalPath;
+  return platform === "win32" ? norm = norm.replace(/\//g, "\\").toLowerCase() : platform === "darwin" && (norm = norm.normalize("NFC").toLowerCase()), createHash("sha256").update(norm).digest("hex");
+}
+function stripLongPathPrefix(p) {
+  return process.platform !== "win32" ? p : p.startsWith("\\\\?\\UNC\\") ? `\\\\${p.slice(8)}` : p.startsWith("\\\\?\\") ? p.slice(4) : p;
+}
+function agentNameOf(path) {
+  return (path.split(/[\\/]/).pop() ?? path).replace(/\.adf$/i, "");
+}
+function samePath(a, b, platform = process.platform) {
+  let norm = (p) => {
+    let abs = platform === "darwin" ? resolve(p).normalize("NFC") : resolve(p);
+    return platform === "linux" ? abs : abs.toLowerCase();
+  };
+  return norm(a) === norm(b);
+}
+function agentLeasedMessage(record, ownSettingsPath, otherMachine = !1, check = {}) {
+  let name = agentNameOf(record.path), h = record.holder, text;
+  if (otherMachine)
+    text = `${name} is already running on another machine (${h.hostname || "unknown host"}, pid ${h.pid}) that shares this lease folder. Stop it there, then start it here.`;
+  else if (h.kind === "daemon") {
+    let url = h.controlUrl && !/^http:\/\/(127\.0\.0\.1|localhost):7385\/?$/.test(h.controlUrl) ? h.controlUrl : null, target = url ? ` --url ${url}` : "";
+    text = `${name} is already running in the ADF daemon (pid ${h.pid}${url ? `, ${url}` : ""}). Stop it there with "adf${target} stop ${name}", or stop that daemon with "adf daemon stop", then start it here.`;
+  } else
+    text = `${name} is already running in another ADF Studio (pid ${h.pid}). Stop the agent there or quit that Studio, then start it here.`;
+  return ownSettingsPath && h.settingsPath && !samePath(ownSettingsPath, h.settingsPath) && (text += ` That process uses the settings file ${h.settingsPath}.`), otherMachine || (check.unconfirmedLeaseFile ? text += ` ADF cannot confirm that pid ${h.pid} is still that process: it recorded no endpoint to check. If no ADF Studio or daemon runs ${name}, delete the lease file ${check.unconfirmedLeaseFile} and start it again.` : check.noAnswerFrom && (text += ` ADF could not confirm it: ${check.noAnswerFrom} did not answer the check, which a busy daemon also does. Wait a moment and try again; "adf daemon status" shows whether that daemon runs.`)), text;
+}
+function agentIdLeasedMessage(path, agentId, record, ownProcess, otherMachine = !1) {
+  let h = record.holder, where = ownProcess ? h.kind === "daemon" ? "in this ADF daemon" : "in this ADF Studio" : otherMachine ? `on another machine (${h.hostname || "unknown host"}, pid ${h.pid}) that shares this lease folder` : h.kind === "daemon" ? `in the ADF daemon (pid ${h.pid}${h.controlUrl ? `, ${h.controlUrl}` : ""})` : `in another ADF Studio (pid ${h.pid})`;
+  return `${agentNameOf(path)} was not started: ${path} has the agent id ${agentId}, and ${record.path} with the same id is already running ${where}. The two files are copies of one agent; running both would answer its timers and messages twice and poll its Telegram bot twice. Stop the running copy first, or keep only one of the two files.`;
+}
+function describeHolder(h) {
+  return `${h.kind === "daemon" ? "the ADF daemon" : "ADF Studio"} pid ${h.pid}`;
+}
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function errCode(err) {
+  return err?.code;
+}
+var MACHINE_ID_ATTEMPT_TIMEOUTS_MS = [3e3, 1e4], MACHINE_ID_RETRY_MS = 15e3, MACHINE_ID_WAIT_MS = 3e3, machineIdReader = readMachineId, machineIdRetryMs = MACHINE_ID_RETRY_MS, machineIdWaitMs = MACHINE_ID_WAIT_MS, machineIdLookup = null;
+function machineId() {
+  let cached = machineIdLookup;
+  if (cached && (cached.failedAt === null || Date.now() - cached.failedAt < machineIdRetryMs)) return cached.promise;
+  let entry = { promise: Promise.resolve(null), failedAt: null };
+  return entry.promise = lookupMachineId().then((outcome) => ("failed" in outcome && (entry.failedAt = Date.now()), "id" in outcome ? outcome.id : null)), machineIdLookup = entry, entry.promise;
+}
+function machineIdLookupFailed() {
+  return machineIdLookup?.failedAt != null;
+}
+function machineIdWithin(waitMs = machineIdWaitMs) {
+  let lookup = machineId(), timer, waited = new Promise((resolve2) => {
+    timer = setTimeout(() => resolve2(null), waitMs), timer.unref?.();
+  });
+  return Promise.race([lookup, waited]).finally(() => clearTimeout(timer));
+}
+async function lookupMachineId() {
+  let lastError = null;
+  for (let timeoutMs of MACHINE_ID_ATTEMPT_TIMEOUTS_MS)
+    try {
+      let id = (await machineIdReader(timeoutMs))?.trim().toLowerCase() || null;
+      return id ? { id } : (console.warn("[AgentLease] This machine has no machine id (e.g. no /etc/machine-id in a container); this process's records carry none, and records of other runtimes are judged by this machine's pids"), { none: !0 });
+    } catch (err) {
+      lastError = err;
+    }
+  return console.warn(`[AgentLease] Could not read this machine's id (${lastError instanceof Error ? lastError.message : String(lastError)}); asked again after ${Math.ceil(machineIdRetryMs / 1e3)} s. Until then this process's records carry no machine id and records of other runtimes are judged by this machine's pids`), { failed: !0 };
+}
+function run(cmd, args, timeoutMs) {
+  return new Promise((ok, fail) => {
+    try {
+      execFile(cmd, args, { timeout: timeoutMs, windowsHide: !0, encoding: "utf-8" }, (err, stdout) => err ? fail(err) : ok(stdout));
+    } catch (err) {
+      fail(err);
+    }
+  });
+}
+async function readMachineId(timeoutMs) {
+  if (process.env.ADF_MACHINE_ID && testSeamsAllowed()) return process.env.ADF_MACHINE_ID;
+  if (process.platform === "linux") {
+    for (let file of ["/etc/machine-id", "/var/lib/dbus/machine-id"])
+      try {
+        let id = (await fsp.readFile(file, "utf-8")).trim();
+        if (id) return id;
+      } catch {
+      }
+    return null;
+  }
+  if (process.platform === "darwin")
+    return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(await run("ioreg", ["-rd1", "-c", "IOPlatformExpertDevice"], timeoutMs))?.[1] ?? null;
+  if (process.platform === "win32") {
+    let reg = join(process.env.SystemRoot ?? "C:\\Windows", "System32", "reg.exe");
+    return /MachineGuid\s+REG_SZ\s+(\S+)/i.exec(await run(reg, ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"], timeoutMs))?.[1] ?? null;
+  }
+  return null;
+}
+async function fromOtherMachine(record) {
+  if (!record.machineId) return !1;
+  let ours = await machineIdWithin();
+  return !!ours && record.machineId !== ours;
+}
+async function leaseHolderElsewhere(leases, filePath) {
+  if (!leases) return null;
+  try {
+    if (await leases.isHeld(filePath)) return null;
+    let canonical = await canonicalLeasePath(filePath), raw;
+    try {
+      raw = await fsp.readFile(join(leases.dir, `${leaseKeyForCanonicalPath(canonical)}.json`), "utf-8");
+    } catch {
+      return null;
+    }
+    let record = JSON.parse(raw);
+    if (record?.v !== 1 || typeof record.holder?.pid != "number" || typeof record.holder.runtimeId != "string" || record.holder.runtimeId === leases.runtimeId) return null;
+    let liveness = await holderLiveness(record.holder, leases.dir);
+    return liveness.alive ? agentLeasedMessage(record, void 0, liveness.otherMachine) : null;
+  } catch (err) {
+    return console.warn(`[AgentLease] Lease check of ${agentNameOf(filePath)} failed:`, err), null;
+  }
+}
+async function openHereOrLeasedElsewhere(leases, filePath, openHere) {
+  for (let p of openHere) if (samePath(p, filePath)) return !0;
+  return await leases.isHeld(filePath) ? !0 : await leaseHolderElsewhere(leases, filePath) !== null;
+}
+async function pidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return !1;
+  try {
+    process.kill(pid, 0);
+  } catch (err) {
+    return errCode(err) === "EPERM";
+  }
+  if (process.platform === "linux")
+    try {
+      let stat = await fsp.readFile(`/proc/${pid}/stat`, "utf-8");
+      if (stat.slice(stat.lastIndexOf(")") + 2).startsWith("Z")) return !1;
+    } catch {
+    }
+  return !0;
+}
+function probeEndpoint(endpoint, timeoutMs = PROBE_TIMEOUT_MS) {
+  return new Promise((resolveProbe) => {
+    let settled = !1, sock = null, done = (result) => {
+      settled || (settled = !0, clearTimeout(timer), sock?.destroy(), resolveProbe(result));
+    }, timer = setTimeout(() => done("unknown"), timeoutMs);
+    try {
+      sock = createConnection(endpoint);
+    } catch {
+      done("unknown");
+      return;
+    }
+    sock.once("connect", () => done("connected")), sock.once("error", (err) => {
+      let code = errCode(err);
+      done(code === "ECONNREFUSED" ? "refused" : code === "ENOENT" ? "missing" : "unknown");
+    });
+  });
+}
+function trustedEndpoint(holder, dir) {
+  let { endpoint, runtimeId } = holder;
+  return !endpoint || !/^[0-9a-f]{16}$/.test(runtimeId) ? null : process.platform === "win32" ? endpoint === pipeName(runtimeId) ? endpoint : null : endpoint === join(dir, "hosts", `${runtimeId}.sock`) || endpoint === join(tmpdir(), `adf-runtime-${runtimeId}.sock`) ? endpoint : null;
+}
+function probeProvesDead(endpoint, probe, dir) {
+  return probe === "refused" ? !0 : probe !== "missing" ? !1 : process.platform === "win32" || dirname(endpoint) === join(dir, "hosts");
+}
+function pipeName(runtimeId) {
+  return `\\\\.\\pipe\\adf-runtime-${runtimeId}`;
+}
+async function fetchDaemonPid(controlUrl) {
+  try {
+    let res = await fetch(`${controlUrl.replace(/\/+$/, "")}/version`, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
+    if (!res.ok) return null;
+    let body = await res.json();
+    return typeof body.pid == "number" ? body.pid : null;
+  } catch {
+    return null;
+  }
+}
+async function holderLiveness(holder, dir = leaseDir()) {
+  if (await fromOtherMachine(holder)) return { alive: !0, otherMachine: !0, reason: "held on another machine" };
+  if (!await pidAlive(holder.pid)) return { alive: !1, reason: `pid ${holder.pid} is not running` };
+  let endpoint = trustedEndpoint(holder, dir);
+  if (endpoint) {
+    let probe = await probeEndpoint(endpoint);
+    return probe === "connected" ? { alive: !0, reason: "endpoint answered" } : probeProvesDead(endpoint, probe, dir) ? { alive: !1, reason: `pid ${holder.pid} now belongs to another program` } : { alive: !0, reason: `pid ${holder.pid} is running (endpoint ${probe})` };
+  }
+  if (holder.kind === "daemon" && holder.controlUrl) {
+    let pid = await fetchDaemonPid(holder.controlUrl);
+    return pid !== null && pid !== holder.pid ? { alive: !1, reason: `${holder.controlUrl} is served by pid ${pid}, not ${holder.pid}` } : pid === holder.pid ? { alive: !0, reason: `${holder.controlUrl} is served by pid ${pid}` } : { alive: !0, noAnswer: !0, reason: `pid ${holder.pid} is running; ${holder.controlUrl} did not answer` };
+  }
+  return !holder.endpoint && !holder.controlUrl ? { alive: !0, unconfirmed: !0, reason: `pid ${holder.pid} is running` } : { alive: !0, reason: `pid ${holder.pid} is running` };
+}
+function parseRecord(raw) {
+  try {
+    let rec = JSON.parse(raw);
+    return rec?.v !== 1 || typeof rec.path != "string" || typeof rec.holder?.pid != "number" || typeof rec.holder.runtimeId != "string" ? null : rec;
+  } catch {
+    return null;
+  }
+}
+async function readLease(file) {
+  try {
+    let [raw, st] = await Promise.all([fsp.readFile(file, "utf-8"), fsp.stat(file)]);
+    return { raw, record: parseRecord(raw), mtimeMs: st.mtimeMs };
+  } catch (err) {
+    if (errCode(err) === "ENOENT") return null;
+    throw err;
+  }
+}
+async function writeAtomic(file, data) {
+  let tmp = `${file}.${process.pid}-${randomBytes(4).toString("hex")}.tmp`;
+  await fsp.writeFile(tmp, data, { mode: FILE_MODE });
+  for (let attempt = 0; ; attempt++)
+    try {
+      await fsp.rename(tmp, file);
+      return;
+    } catch (err) {
+      let code = errCode(err);
+      if (attempt < 5 && code && TRANSIENT_FS_CODES.has(code)) {
+        await delay(20 * (attempt + 1));
+        continue;
+      }
+      throw await fsp.rm(tmp, { force: !0 }).catch(() => {
+      }), err;
+    }
+}
+async function unlockTakeover(lock) {
+  for (let attempt = 0; attempt < 200; attempt++)
+    try {
+      await fsp.rm(lock, { force: !0 });
+      return;
+    } catch (err) {
+      let code = errCode(err);
+      if (!code || !TRANSIENT_FS_CODES.has(code)) break;
+      await delay(5);
+    }
+  console.warn(`[AgentLease] Could not remove the takeover lock ${lock}; it expires after ${TAKEOVER_LOCK_TTL_MS / 1e3}s`);
+}
+var exitHookRegistries = /* @__PURE__ */ new Set(), exitHookInstalled = !1;
+function inferKind() {
+  return !!process.versions.electron && process.env.ELECTRON_RUN_AS_NODE !== "1" && process.type === "browser" ? "studio-embedded" : "daemon";
+}
+function defaultControlUrl(env) {
+  let port = Number(env.ADF_DAEMON_PORT) || DEFAULT_DAEMON_PORT, host = env.ADF_DAEMON_HOST ?? "127.0.0.1";
+  return (host === "0.0.0.0" || host === "::" || host === "localhost") && (host = "127.0.0.1"), `http://${host.includes(":") ? `[${host}]` : host}:${port}`;
+}
+var AgentLeaseRegistry = class {
+  dir;
+  runtimeId = randomBytes(8).toString("hex");
+  startedAt = Date.now();
+  info;
+  held = /* @__PURE__ */ new Map();
+  chains = /* @__PURE__ */ new Map();
+  probes = /* @__PURE__ */ new Set();
+  /** abs path → target, for paths whose realpath resolved. */
+  targetCache = /* @__PURE__ */ new Map();
+  endpoint = null;
+  server = null;
+  ready = null;
+  hostEntryWritten = !1;
+  clientMode = null;
+  generation = 0;
+  pid;
+  hostnameOverride;
+  machineIdValue = null;
+  machineIdOverride;
+  /** Pending retry of a failed machine id lookup (scheduleMachineIdRetry). */
+  machineIdRetry = null;
+  takeoverLockTtlMs;
+  beforeTakeoverReplace;
+  sweepEntries;
+  /** Containers this runtime uses, written into its host record. */
+  containers = [];
+  /** The lease dir refused writes: remembered so every start does not stall on it. */
+  unusable = null;
+  constructor(opts = {}) {
+    this.dir = opts.dir ?? leaseDir(), this.pid = opts.pid ?? process.pid, this.hostnameOverride = opts.hostname, this.machineIdOverride = opts.machineId, this.takeoverLockTtlMs = opts.takeoverLockTtlMs ?? TAKEOVER_LOCK_TTL_MS, this.beforeTakeoverReplace = opts.beforeTakeoverReplace, this.sweepEntries = opts.sweepDeadEntries ?? !0;
+    let kind = opts.kind ?? inferKind();
+    this.info = {
+      kind,
+      settingsPath: opts.settingsPath ?? process.env.ADF_DAEMON_SETTINGS ?? join(getUserDataPath(), "adf-settings.json"),
+      version: opts.version ?? process.env.npm_package_version ?? null,
+      mode: opts.mode ?? (kind === "daemon" ? "daemon" : "embedded"),
+      controlUrl: opts.controlUrl ?? (kind === "daemon" ? defaultControlUrl(process.env) : void 0)
+    };
+  }
+  /**
+   * Who this process is, for lease and host records. Composition roots call
+   * it at boot (Studio embedded: registerAllIpcHandlers; daemon: its index)
+   * and it (re)writes the host entry.
+   */
+  configure(info) {
+    return this.info = {
+      ...this.info,
+      ...Object.fromEntries(Object.entries(info).filter(([, v]) => v !== void 0))
+    }, info.kind && !info.mode && (this.info.mode = info.kind === "daemon" ? "daemon" : "embedded"), info.kind === "studio-embedded" && !info.controlUrl && delete this.info.controlUrl, this.ensureReady(!0);
+  }
+  /** Register a host's view of the agents it runs or is starting. Returns the unregister function. */
+  addHostedPathsProbe(probe) {
+    return this.probes.add(probe), () => {
+      this.probes.delete(probe);
+    };
+  }
+  holder() {
+    return {
+      kind: this.info.kind,
+      pid: this.pid,
+      runtimeId: this.runtimeId,
+      hostname: this.hostnameOverride ?? osHostname(),
+      machineId: this.machineIdValue,
+      settingsPath: this.info.settingsPath,
+      startedAt: this.startedAt,
+      version: this.info.version,
+      endpoint: this.endpoint,
+      ...(this.info.kind === "daemon" || this.clientMode) && this.info.controlUrl ? { controlUrl: this.info.controlUrl } : {}
+    };
+  }
+  /**
+   * Take the lease for `filePath` before preparing the agent. Re-entrant
+   * within the process. The caller MUST keep the path visible to its probe
+   * from before this call until it no longer runs the agent, and call
+   * reconcile() when it stops (or fails to start).
+   */
+  async acquire(filePath, opts = {}) {
+    let target = await this.target(filePath), agentId = opts.agentId ?? null, { result, fresh } = await this.withKey(target.key, async () => {
+      let heldBefore = this.held.has(target.key);
+      return { result: await this.acquireLocked(target, agentId), fresh: !heldBefore };
+    });
+    if (!result.ok || result.unprotected || !agentId) return result;
+    let generation = this.held.get(target.key)?.generation, conflict = await this.agentIdConflict(target, agentId);
+    return conflict ? (fresh && await this.withKey(target.key, async () => {
+      this.held.get(target.key)?.generation === generation && await this.releaseLocked(target.key);
+    }), conflict) : result;
+  }
+  /** Release every held lease no probe lists. Never throws. */
+  async reconcile() {
+    if (this.held.size !== 0)
+      try {
+        let paths = [];
+        for (let probe of [...this.probes])
+          try {
+            for (let p of probe()) paths.push(p);
+          } catch (err) {
+            console.error("[AgentLease] Hosted-paths probe failed; nothing released:", err);
+            return;
+          }
+        let generations = new Map([...this.held].map(([key, h]) => [key, h.generation])), hosted = /* @__PURE__ */ new Set();
+        for (let p of paths) hosted.add((await this.target(p)).key);
+        for (let [key, generation] of generations)
+          hosted.has(key) || await this.withKey(key, async () => {
+            this.held.get(key)?.generation === generation && await this.releaseLocked(key);
+          });
+      } catch (err) {
+        console.error("[AgentLease] Reconcile failed:", err);
+      }
+  }
+  /**
+   * The agent file moved (rename while held). Hosts update their own path
+   * maps first, then call this: the lease moves to the new path's key.
+   */
+  async rekey(oldPath, newPath) {
+    let oldKey = await this.findHeldKey(oldPath);
+    if (!oldKey) return null;
+    let target = await this.target(newPath), previous = this.held.get(oldKey);
+    if (target.key === oldKey)
+      return this.withKey(oldKey, async () => {
+        let entry = this.held.get(oldKey);
+        if (!entry) return null;
+        entry.record = { ...entry.record, path: target.canonical };
+        try {
+          await writeAtomic(entry.file, JSON.stringify(entry.record, null, 2));
+        } catch (err) {
+          console.warn(`[AgentLease] Could not update the lease of ${agentNameOf(target.canonical)}:`, err);
+        }
+        return { ok: !0, leaseFile: entry.file };
+      });
+    let result = await this.withKey(target.key, () => this.acquireLocked(target, previous.record.agentId));
+    return result.ok || console.warn(`[AgentLease] Rename of ${agentNameOf(previous.record.path)}: ${result.message}`), await this.withKey(oldKey, () => this.releaseLocked(oldKey)), result;
+  }
+  /**
+   * Record the agent id in a lease taken before the file was opened (a
+   * daemon load and a background start acquire first, then read the
+   * config), then check it as acquire() does: a refusal when another live
+   * holder runs that agent id from another file, else null. No-op (null)
+   * when this process does not hold the lease. Never throws.
+   */
+  async noteAgentId(filePath, agentId) {
+    try {
+      let target = await this.target(filePath);
+      return await this.withKey(target.key, async () => {
+        let entry = this.held.get(target.key);
+        return entry ? (entry.record.agentId === agentId || (entry.record = { ...entry.record, agentId }, await writeAtomic(entry.file, JSON.stringify(entry.record, null, 2))), !0) : !1;
+      }) ? await this.agentIdConflict(target, agentId) : null;
+    } catch (err) {
+      return console.warn(`[AgentLease] Could not record the agent id in the lease of ${agentNameOf(filePath)}:`, err), null;
+    }
+  }
+  /** True when this process holds the lease for `filePath`. */
+  async isHeld(filePath) {
+    return this.held.has((await this.target(filePath)).key);
+  }
+  /** Canonical paths of the agents this process holds leases for. */
+  heldPaths() {
+    return [...this.held.values()].map((h) => h.record.path);
+  }
+  /**
+   * Studio in local/remote mode runs no agents, so it is not a host; it
+   * records itself as a client so `adf daemon start` knows the running
+   * Studio is not a conflict.
+   */
+  registerClient(mode, info = {}) {
+    return this.clientMode = mode, info.settingsPath && (this.info.settingsPath = info.settingsPath), info.version !== void 0 && (this.info.version = info.version), info.controlUrl ? this.info.controlUrl = info.controlUrl : delete this.info.controlUrl, this.ensureReady(!0);
+  }
+  /** Test / shutdown helper: release everything, remove host entries, close the endpoint. */
+  async close() {
+    await this.ready?.catch(() => {
+    }), this.machineIdRetry && clearTimeout(this.machineIdRetry), this.machineIdRetry = null;
+    for (let key of [...this.held.keys()]) await this.withKey(key, () => this.releaseLocked(key));
+    await this.removeOwnEntries();
+    let server = this.server;
+    this.server = null, this.endpoint = null, this.ready = null, this.hostEntryWritten = !1, server && await new Promise((r) => server.close(() => r())), exitHookRegistries.delete(this);
+  }
+  // --- internals -----------------------------------------------------------
+  async target(filePath) {
+    let abs = resolve(filePath), cached = this.targetCache.get(abs);
+    if (cached) return cached;
+    let canonical, resolved = !0;
+    try {
+      canonical = stripLongPathPrefix(await fsp.realpath(abs));
+    } catch {
+      canonical = stripLongPathPrefix(abs), resolved = !1;
+    }
+    let key = leaseKeyForCanonicalPath(canonical), target = { key, canonical, file: join(this.dir, `${key}.json`) };
+    return resolved && this.targetCache.set(abs, target), target;
+  }
+  async findHeldKey(path) {
+    let key = (await this.target(path)).key;
+    if (this.held.has(key)) return key;
+    let abs = resolve(path);
+    for (let [k, h] of this.held) {
+      if (samePath(h.record.path, abs)) return k;
+      for (let [raw, t] of this.targetCache)
+        if (t.key === k && samePath(raw, abs)) return k;
+    }
+    return null;
+  }
+  withKey(key, fn) {
+    let run2 = (this.chains.get(key) ?? Promise.resolve()).then(fn, fn), tail = run2.catch(() => {
+    });
+    return this.chains.set(key, tail), tail.then(() => {
+      this.chains.get(key) === tail && this.chains.delete(key);
+    }), run2;
+  }
+  async acquireLocked(target, agentId) {
+    await this.ensureReady(!1);
+    let name = agentNameOf(target.canonical), own = this.held.get(target.key);
+    if (own)
+      return own.generation = ++this.generation, await this.verifyOwn(target, own), { ok: !0, leaseFile: target.file };
+    if (this.unusable && Date.now() - this.unusable.at < UNUSABLE_DIR_MEMO_MS)
+      return this.unprotected(name, target, this.unusable.reason, !1);
+    let record = { v: 1, path: target.canonical, agentId, holder: this.holder(), acquiredAt: Date.now() }, body = JSON.stringify(record, null, 2), deadline = Date.now() + ACQUIRE_BUDGET_MS, won = async () => {
+      let entry = { file: target.file, record, generation: ++this.generation };
+      this.held.set(target.key, entry), this.unusable = null, this.installExitHook();
+      let id = this.machineIdValue;
+      return id && record.holder.machineId !== id && await this.stampLease(entry, id), { ok: !0, leaseFile: target.file };
+    }, lastError = null;
+    try {
+      await fsp.mkdir(this.dir, { recursive: !0, mode: DIR_MODE });
+    } catch (err) {
+      return this.unprotected(name, target, err instanceof Error ? err.message : String(err), !0);
+    }
+    for (; Date.now() < deadline; ) {
+      try {
+        return await fsp.writeFile(target.file, body, { flag: "wx", mode: FILE_MODE }), await won();
+      } catch (err) {
+        let code = errCode(err);
+        if (code !== "EEXIST") {
+          if (lastError = err, code && TRANSIENT_FS_CODES.has(code) && await this.dirWritable()) {
+            await delay(20);
+            continue;
+          }
+          return this.unprotected(name, target, err instanceof Error ? err.message : String(err), !0);
+        }
+      }
+      let existing;
+      try {
+        existing = await readLease(target.file);
+      } catch (err) {
+        lastError = err, await delay(50);
+        continue;
+      }
+      if (!existing) continue;
+      if (!existing.record) {
+        let age = Date.now() - existing.mtimeMs;
+        if (age < PARTIAL_WRITE_GRACE_MS) {
+          await delay(Math.min(250, PARTIAL_WRITE_GRACE_MS - age + 10));
+          continue;
+        }
+        if (console.warn(`[AgentLease] ${name}: replacing an unreadable lease file ${target.file}`), await this.takeOver(target.file, existing.raw, body)) return await won();
+        continue;
+      }
+      let holder = existing.record.holder;
+      if (holder.runtimeId === this.runtimeId)
+        return this.held.set(target.key, { file: target.file, record: existing.record, generation: ++this.generation }), { ok: !0, leaseFile: target.file };
+      let liveness = await holderLiveness(holder, this.dir);
+      if (liveness.alive)
+        return {
+          ok: !1,
+          code: AGENT_LEASED_CODE,
+          leaseFile: target.file,
+          record: existing.record,
+          message: agentLeasedMessage(existing.record, this.info.settingsPath, liveness.otherMachine, {
+            ...liveness.unconfirmed ? { unconfirmedLeaseFile: target.file } : {},
+            ...liveness.noAnswer && holder.controlUrl ? { noAnswerFrom: holder.controlUrl } : {}
+          })
+        };
+      if (console.warn(`[AgentLease] ${name}: replacing a stale lease held by ${describeHolder(holder)} (${liveness.reason})`), await this.takeOver(target.file, existing.raw, body)) return await won();
+    }
+    let reason = lastError instanceof Error ? lastError.message : "the lease file kept changing";
+    console.error(`[AgentLease] ${name}: could not take the lease (${reason})`);
+    let placeholder = { ...record, holder: { ...record.holder, pid: 0 } };
+    return {
+      ok: !1,
+      code: AGENT_LEASED_CODE,
+      leaseFile: target.file,
+      record: placeholder,
+      message: `${name} could not be started: its lease file ${target.file} could not be read or replaced (${reason}). If no other ADF Studio or daemon runs this agent, delete that file and start it again.`
+    };
+  }
+  /**
+   * The lease is keyed by path, so a copied or restored `.adf` (same agent
+   * id, another file) got its own lease, and two runtimes, or one runtime
+   * twice, ran one agent: both answered its timers and both polled its
+   * Telegram bot (W5-D3). Checked after our path lease is written: two
+   * hosts starting two copies at once each see the other's lease (at worst
+   * both refuse; never both run). Another holder's lease that is stale or
+   * unreadable is ignored here; whoever starts its path replaces it.
+   */
+  async agentIdConflict(target, agentId) {
+    for (let [key, h] of this.held)
+      if (key !== target.key && h.record.agentId === agentId)
+        return this.agentIdRefusal(target, agentId, h.file, h.record, !0);
+    let names;
+    try {
+      names = await fsp.readdir(this.dir);
+    } catch {
+      return null;
+    }
+    for (let name of names) {
+      let m = /^([0-9a-f]{64})\.json$/.exec(name);
+      if (!m || m[1] === target.key || this.held.has(m[1])) continue;
+      let file = join(this.dir, name), record = null;
+      try {
+        record = (await readLease(file))?.record ?? null;
+      } catch {
+        continue;
+      }
+      if (!record || record.agentId !== agentId || record.holder.runtimeId === this.runtimeId) continue;
+      let liveness = await holderLiveness(record.holder, this.dir);
+      if (liveness.alive)
+        return this.agentIdRefusal(target, agentId, file, record, !1, liveness.otherMachine);
+    }
+    return null;
+  }
+  agentIdRefusal(target, agentId, leaseFile, record, ownProcess, otherMachine = !1) {
+    let message = agentIdLeasedMessage(target.canonical, agentId, record, ownProcess, otherMachine);
+    return console.warn(`[AgentLease] ${message}`), { ok: !1, code: AGENT_LEASED_CODE, leaseFile, record, message };
+  }
+  /** Can a fresh file be created in the lease dir? Tells a delete-pending lease from an unusable dir. */
+  async dirWritable() {
+    let probe = join(this.dir, `.${this.runtimeId}-${randomBytes(4).toString("hex")}.probe`);
+    try {
+      return await fsp.writeFile(probe, "", { flag: "wx", mode: FILE_MODE }), await fsp.rm(probe, { force: !0 }), !0;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * The lease dir refused a write: proceed without a lease and say so. The
+   * dir is remembered as unusable for a minute (`remember`), so the next
+   * starts skip it instead of retrying.
+   */
+  unprotected(name, target, reason, remember) {
+    let message = `Agent leases unavailable: ${this.dir} cannot be written (${reason}). ${name} runs without protection against a second ADF Studio or daemon on this machine running it.`;
+    return remember && (this.unusable = { reason, at: Date.now() }, console.error(`[AgentLease] ${message}`)), { ok: !0, leaseFile: target.file, unprotected: message };
+  }
+  /** Our lease file should exist and name us. Recreate it if it was deleted. */
+  async verifyOwn(target, own) {
+    try {
+      let current = await readLease(own.file);
+      current ? current.record && current.record.holder.runtimeId !== this.runtimeId && console.warn(`[AgentLease] ${agentNameOf(target.canonical)}: lease file now names ${describeHolder(current.record.holder)} while this process runs the agent`) : (await fsp.mkdir(this.dir, { recursive: !0, mode: DIR_MODE }), await fsp.writeFile(own.file, JSON.stringify(own.record, null, 2), { flag: "wx", mode: FILE_MODE }), console.warn(`[AgentLease] ${agentNameOf(target.canonical)}: lease file was missing; recreated`));
+    } catch (err) {
+      console.warn(`[AgentLease] ${agentNameOf(target.canonical)}: could not verify the lease:`, err);
+    }
+  }
+  /**
+   * Replace a lease judged stale (its bytes were `expectedRaw`) with ours,
+   * under the takeover lock. Under the lock the lease is re-read: it is
+   * removed only if it still holds exactly those bytes, and ours is written
+   * exclusively (a plain acquirer that slipped in wins; the caller then
+   * re-evaluates). Returns true when our lease was written.
+   */
+  async takeOver(file, expectedRaw, body) {
+    let lock = `${file}.takeover`;
+    if (!await this.lockTakeover(lock)) return !1;
+    try {
+      let current = null;
+      try {
+        current = await fsp.readFile(file, "utf-8");
+      } catch (err) {
+        if (errCode(err) !== "ENOENT") return !1;
+      }
+      if (current !== null && current !== expectedRaw) return !1;
+      await this.beforeTakeoverReplace?.();
+      try {
+        current = await fsp.readFile(file, "utf-8");
+      } catch (err) {
+        if (errCode(err) !== "ENOENT") return !1;
+        current = null;
+      }
+      if (current !== null && current !== expectedRaw) return !1;
+      current !== null && await fsp.rm(file, { force: !0 });
+      for (let attempt = 0; ; attempt++)
+        try {
+          return await fsp.writeFile(file, body, { flag: "wx", mode: FILE_MODE }), !0;
+        } catch (err) {
+          let code = errCode(err);
+          if (code === "EEXIST") return !1;
+          if (!code || !TRANSIENT_FS_CODES.has(code) || attempt >= 20) throw err;
+          await delay(10);
+        }
+    } catch (err) {
+      return console.warn(`[AgentLease] Takeover of ${file} failed:`, err instanceof Error ? err.message : err), !1;
+    } finally {
+      await unlockTakeover(lock);
+    }
+  }
+  /**
+   * Create `<lease>.takeover` exclusively. A lock left by a crash (its pid
+   * gone, or older than the TTL, while the critical section takes
+   * milliseconds) is removed.
+   */
+  async lockTakeover(lock) {
+    let deadline = Date.now() + TAKEOVER_LOCK_WAIT_MS, judged = /* @__PURE__ */ new Map();
+    for (; Date.now() < deadline; ) {
+      try {
+        return await fsp.writeFile(lock, JSON.stringify({ pid: this.pid, runtimeId: this.runtimeId, endpoint: this.endpoint, machineId: this.machineIdValue, at: Date.now() }), { flag: "wx", mode: FILE_MODE }), !0;
+      } catch (err) {
+        let code = errCode(err);
+        if (code && TRANSIENT_FS_CODES.has(code)) {
+          await delay(5);
+          continue;
+        }
+        if (code !== "EEXIST") return !1;
+      }
+      try {
+        let st = await fsp.stat(lock), age = Date.now() - st.mtimeMs;
+        if (age > TAKEOVER_LOCK_SUSPECT_MS) {
+          let raw = await fsp.readFile(lock, "utf-8"), last = judged.get(raw), fresh = last && (last.state !== "live" || Date.now() - last.at < TAKEOVER_LOCK_REPROBE_MS), state = fresh ? last.state : await this.lockHolderState(raw);
+          if (fresh || judged.set(raw, { state, at: Date.now() }), state === "dead" || state === "unknown" && age > this.takeoverLockTtlMs) {
+            await fsp.readFile(lock, "utf-8") === raw && (console.warn(`[AgentLease] Removing a takeover lock left by a ${state === "dead" ? "crashed" : "stuck"} process: ${lock}`), await fsp.rm(lock, { force: !0 }));
+            continue;
+          }
+        }
+      } catch {
+      }
+      await delay(5 + Math.floor(Math.random() * 15));
+    }
+    return !1;
+  }
+  /**
+   * Who holds a takeover lock: 'dead' (pid gone, endpoint missing or
+   * refusing) is removed; 'live' (anything else while the pid runs,
+   * including a probe timeout) never expires; 'unknown' (no readable pid,
+   * e.g. a crash between create and write) waits for the TTL.
+   */
+  async lockHolderState(raw) {
+    let holder;
+    try {
+      holder = JSON.parse(raw);
+    } catch {
+      return "unknown";
+    }
+    let pid = Number(holder.pid), rec = {
+      pid,
+      runtimeId: typeof holder.runtimeId == "string" ? holder.runtimeId : "",
+      endpoint: typeof holder.endpoint == "string" ? holder.endpoint : null,
+      machineId: typeof holder.machineId == "string" ? holder.machineId : null
+    };
+    if (!Number.isInteger(pid) || pid <= 0) return "unknown";
+    if (await fromOtherMachine(rec)) return "live";
+    if (!await pidAlive(pid)) return "dead";
+    let endpoint = trustedEndpoint(rec, this.dir);
+    if (!endpoint) return "live";
+    let probe = await probeEndpoint(endpoint);
+    return probeProvesDead(endpoint, probe, this.dir) ? "dead" : "live";
+  }
+  async releaseLocked(key) {
+    let entry = this.held.get(key);
+    if (entry) {
+      this.held.delete(key);
+      try {
+        let current = await readLease(entry.file);
+        if (!current) return;
+        if (current.record && current.record.holder.runtimeId !== this.runtimeId) {
+          console.warn(`[AgentLease] ${agentNameOf(entry.record.path)}: lease now names ${describeHolder(current.record.holder)}; left in place`);
+          return;
+        }
+        await fsp.rm(entry.file, { force: !0 });
+      } catch (err) {
+        console.error(`[AgentLease] Could not release the lease of ${agentNameOf(entry.record.path)}:`, err);
+      }
+    }
+  }
+  installExitHook() {
+    exitHookRegistries.add(this), !exitHookInstalled && (exitHookInstalled = !0, process.once("exit", () => {
+      for (let reg of exitHookRegistries) reg.releaseAllSync();
+    }));
+  }
+  /** Process exit: synchronous by necessity. Removes only files that still name us. */
+  releaseAllSync() {
+    for (let entry of this.held.values()) this.unlinkIfOwnSync(entry.file);
+    this.held.clear(), this.hostEntryWritten && this.unlinkIfOwnSync(this.entryFile());
+  }
+  unlinkIfOwnSync(file) {
+    try {
+      let rec = JSON.parse(readFileSync(file, "utf-8"));
+      (rec.holder?.runtimeId ?? rec.runtimeId) === this.runtimeId && unlinkSync(file);
+    } catch {
+    }
+  }
+  entryFile() {
+    return join(this.dir, this.clientMode ? "clients" : "hosts", `${this.pid}.json`);
+  }
+  /** This runtime's host record (`hosts/<pid>.json`). */
+  get hostEntryFile() {
+    return this.entryFile();
+  }
+  /**
+   * services/compute-users.ts: record the containers this runtime uses in
+   * its host record. Rejects when the record cannot be written.
+   */
+  setContainers(names) {
+    this.containers = [...new Set(names)].sort();
+    let run2 = this.ensureReady(!1).then(() => this.writeEntryOrThrow());
+    return this.ready = run2.catch(() => {
+    }), run2;
+  }
+  /** Refresh the host record's mtime (compute-users heartbeat). Rejects when it is gone. */
+  async touchEntry() {
+    let now = /* @__PURE__ */ new Date();
+    await fsp.utimes(this.entryFile(), now, now);
+  }
+  ensureReady(rewriteEntry) {
+    if (this.ready)
+      rewriteEntry && (this.ready = this.ready.then(() => this.writeEntry()));
+    else {
+      let lookup;
+      this.ready = this.startEndpoint().then(async () => {
+        if (this.machineIdOverride !== void 0) {
+          this.machineIdValue = this.machineIdOverride;
+          return;
+        }
+        lookup = machineId(), this.machineIdValue = await machineIdWithin();
+      }).then(() => this.writeEntry()).then(() => this.scheduleMachineIdRetry(lookup));
+    }
+    return this.ready;
+  }
+  /**
+   * The machine id was not read when the host record was first written: wait
+   * for the lookup still running (`pending`), else, after a failed lookup,
+   * ask again every MACHINE_ID_RETRY_MS (15 s), and once read rewrite the
+   * host record and every lease this process holds. A platform with no
+   * machine id at all is not asked again. A record without a machine id is judged
+   * by the reader's own pids, so a runtime on another machine sharing the
+   * lease folder could take a live agent from this one.
+   */
+  scheduleMachineIdRetry(pending) {
+    if (this.machineIdValue || this.machineIdOverride !== void 0 || this.machineIdRetry || !this.ready) return;
+    let settle = (lookup) => {
+      lookup.then(async (id) => {
+        if (!(!this.ready || this.machineIdValue)) {
+          if (!id) {
+            machineIdLookupFailed() && this.scheduleMachineIdRetry();
+            return;
+          }
+          this.machineIdValue = id, await this.stampMachineId(id);
+        }
+      });
+    };
+    if (pending) {
+      settle(pending);
+      return;
+    }
+    this.machineIdRetry = setTimeout(() => {
+      this.machineIdRetry = null, settle(machineId());
+    }, machineIdRetryMs), this.machineIdRetry.unref?.();
+  }
+  /** Write `id` into the host record and into every held lease that still names this runtime. */
+  async stampMachineId(id) {
+    this.ready && await this.ensureReady(!0);
+    let leases = 0;
+    for (let [key, entry] of [...this.held])
+      await this.withKey(key, async () => {
+        this.held.get(key) === entry && await this.stampLease(entry, id) && leases++;
+      });
+    console.log(`[AgentLease] Read this machine's id late; added it to the host record and ${leases} held lease(s)`);
+  }
+  /**
+   * Rewrite one held lease with machine id `id`. The caller holds the key's
+   * chain. The read and the write run under the lease's takeover lock, and
+   * only a lease that still names this runtime is rewritten: a taker that
+   * judged it stale and replaced it keeps its own.
+   */
+  async stampLease(entry, id) {
+    let lock = `${entry.file}.takeover`;
+    try {
+      if (!await this.lockTakeover(lock)) return !1;
+    } catch (err) {
+      return console.warn(`[AgentLease] ${agentNameOf(entry.record.path)}: could not add the machine id to its lease:`, err instanceof Error ? err.message : err), !1;
+    }
+    try {
+      let current = await readLease(entry.file);
+      if (!current?.record || current.record.holder.runtimeId !== this.runtimeId) return !1;
+      let record = { ...current.record, holder: { ...current.record.holder, machineId: id } };
+      return await writeAtomic(entry.file, JSON.stringify(record, null, 2)), entry.record = record, !0;
+    } catch (err) {
+      return console.warn(`[AgentLease] ${agentNameOf(entry.record.path)}: could not add the machine id to its lease:`, err instanceof Error ? err.message : err), !1;
+    } finally {
+      await unlockTakeover(lock);
+    }
+  }
+  async startEndpoint() {
+    let endpoint;
+    process.platform === "win32" ? endpoint = pipeName(this.runtimeId) : (endpoint = join(this.dir, "hosts", `${this.runtimeId}.sock`), endpoint.length > MAX_SOCKET_PATH && (endpoint = join(tmpdir(), `adf-runtime-${this.runtimeId}.sock`)));
+    try {
+      process.platform !== "win32" && await fsp.mkdir(join(this.dir, "hosts"), { recursive: !0, mode: DIR_MODE });
+      let server = createServer((socket) => {
+        socket.on("error", () => {
+        }), socket.end(`${JSON.stringify({ pid: process.pid, runtimeId: this.runtimeId })}
+`);
+      });
+      await new Promise((ok, fail) => {
+        server.once("error", fail), server.listen(endpoint, () => {
+          server.off("error", fail), ok();
+        });
+      }), server.on("error", (err) => console.error("[AgentLease] Endpoint error:", err)), server.unref(), this.server = server, this.endpoint = endpoint;
+    } catch (err) {
+      console.warn(`[AgentLease] Could not listen on ${endpoint}; leases fall back to pid checks:`, err instanceof Error ? err.message : err);
+    }
+  }
+  async writeEntry() {
+    try {
+      await this.writeEntryOrThrow();
+    } catch (err) {
+      console.warn(`[AgentLease] Could not write the runtime host entry in ${this.dir}:`, err instanceof Error ? err.message : err);
+    }
+  }
+  async writeEntryOrThrow() {
+    let kind = this.clientMode ? "studio-client" : this.info.kind, other = join(this.dir, this.clientMode ? "hosts" : "clients", `${this.pid}.json`);
+    this.unlinkIfOwnSync(other);
+    let entry = {
+      v: 1,
+      ...this.holder(),
+      kind,
+      mode: this.clientMode ?? this.info.mode,
+      ...this.clientMode ? {} : { containers: this.containers }
+    };
+    await fsp.mkdir(join(this.dir, this.clientMode ? "clients" : "hosts"), { recursive: !0, mode: DIR_MODE }), await writeAtomic(this.entryFile(), JSON.stringify(entry, null, 2)), this.hostEntryWritten = !0, this.installExitHook(), this.sweepEntries && sweepDeadEntries(this.dir, this.pid).catch(() => {
+    });
+  }
+  async removeOwnEntries() {
+    for (let sub of ["hosts", "clients"]) this.unlinkIfOwnSync(join(this.dir, sub, `${this.pid}.json`));
+    this.hostEntryWritten = !1;
+  }
+};
+function parseHostRecord(raw) {
+  try {
+    let record = JSON.parse(raw);
+    return record?.v !== 1 || typeof record.pid != "number" || typeof record.runtimeId != "string" || record.containers !== void 0 && !(Array.isArray(record.containers) && record.containers.every((c) => typeof c == "string")) ? null : record;
+  } catch {
+    return null;
+  }
+}
+async function readEntries(dir) {
+  let names;
+  try {
+    names = await fsp.readdir(dir);
+  } catch {
+    return [];
+  }
+  let out = [];
+  for (let name of names) {
+    if (!/^\d+\.json$/.test(name)) continue;
+    let file = join(dir, name);
+    try {
+      let raw = await fsp.readFile(file, "utf-8"), record = parseHostRecord(raw);
+      record && out.push({ file, raw, record });
+    } catch {
+    }
+  }
+  return out;
+}
+async function sweepDeadEntries(dir, ownPid) {
+  for (let sub of ["hosts", "clients"])
+    for (let { file, raw, record } of await readEntries(join(dir, sub)))
+      if (record.pid !== ownPid && !(await holderLiveness(record, dir)).alive)
+        try {
+          await fsp.readFile(file, "utf-8") === raw && await fsp.rm(file, { force: !0 });
+        } catch {
+        }
+}
+async function listRuntimeHosts(dir = leaseDir()) {
+  return listEntries(dir, "hosts");
+}
+async function listStudioClients(dir = leaseDir()) {
+  return listEntries(dir, "clients");
+}
+async function listEntries(dir, sub) {
+  let entries = await readEntries(join(dir, sub));
+  return Promise.all(entries.map(async ({ record }) => ({
+    ...record,
+    alive: record.pid === process.pid ? !0 : (await holderLiveness(record, dir)).alive
+  })));
+}
+var processRegistry = null;
+function processAgentLeases() {
+  return processRegistry ??= new AgentLeaseRegistry(), processRegistry;
+}
+
+export {
+  AGENT_LEASED_CODE,
+  leaseDir,
+  fromOtherMachine,
+  leaseHolderElsewhere,
+  openHereOrLeasedElsewhere,
+  pidAlive,
+  trustedEndpoint,
+  holderLiveness,
+  AgentLeaseRegistry,
+  parseHostRecord,
+  listRuntimeHosts,
+  listStudioClients,
+  processAgentLeases
+};