@scp-dev/broker 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,2514 @@
+// src/client.ts
+import {
+  PROTOCOL,
+  RelayError
+} from "@scp-dev/core";
+import { existsSync, readFileSync as readFileSync3 } from "fs";
+import { createConnection } from "net";
+import { dirname, join as join2 } from "path";
+import { setTimeout as sleep } from "timers/promises";
+
+// src/lock.ts
+import { randomBytes } from "crypto";
+import { closeSync, linkSync, openSync, readFileSync, renameSync, unlinkSync, writeSync } from "fs";
+import { uptime } from "os";
+var BrokerRunning = class extends Error {
+};
+var ATTEMPTS = 8;
+var BOOT_SLACK_S = 60;
+function readLock(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function holderAlive(content) {
+  const [pid, started] = content.split(":").map(Number);
+  if (pid === void 0 || !Number.isInteger(pid) || pid <= 0) return false;
+  if (started !== void 0 && Number.isFinite(started) && started < Date.now() / 1e3 - uptime() - BOOT_SLACK_S) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function clearStale(path, stale) {
+  const aside = `${path}.${process.pid}.${randomBytes(4).toString("hex")}`;
+  try {
+    renameSync(path, aside);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  try {
+    if (readLock(aside) !== stale) linkSync(aside, path);
+  } catch {
+  }
+  try {
+    unlinkSync(aside);
+  } catch {
+  }
+}
+var held = /* @__PURE__ */ new Set();
+var exitHook = false;
+function takeBrokerLock(path) {
+  const content = `${process.pid}:${Math.floor(Date.now() / 1e3)}`;
+  let holder;
+  for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
+    let fd;
+    try {
+      fd = openSync(path, "wx", 384);
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      holder = readLock(path);
+      if (holder === void 0) continue;
+      if (holderAlive(holder)) break;
+      clearStale(path, holder);
+      continue;
+    }
+    try {
+      writeSync(fd, content, 0);
+    } catch (error) {
+      unlinkSync(path);
+      throw error;
+    } finally {
+      closeSync(fd);
+    }
+    const lock = { path, content };
+    held.add(lock);
+    if (!exitHook) {
+      exitHook = true;
+      process.on("exit", () => {
+        for (const lock2 of held) releaseBrokerLock(lock2);
+      });
+    }
+    return lock;
+  }
+  const pid = holder?.split(":")[0] ?? "";
+  throw new BrokerRunning(`a relay broker already runs${/^\d+$/.test(pid) ? ` (pid ${pid})` : ""}`);
+}
+function brokerLockHeld(path) {
+  try {
+    const content = readLock(path);
+    return content !== void 0 && holderAlive(content);
+  } catch {
+    return void 0;
+  }
+}
+function releaseBrokerLock(lock) {
+  if (!held.delete(lock)) return;
+  try {
+    if (readLock(lock.path) === lock.content) unlinkSync(lock.path);
+  } catch {
+  }
+}
+
+// src/ndjson.ts
+var MAX_LINE = 256 * 1024;
+var NEWLINE = 10;
+var decoder = new TextDecoder();
+var encoder = new TextEncoder();
+var LineReader = class {
+  constructor(maxBytes) {
+    this.maxBytes = maxBytes;
+  }
+  maxBytes;
+  pending = Buffer.alloc(0);
+  /** bytes of a line that has not ended yet */
+  get buffered() {
+    return this.pending.length;
+  }
+  /** the complete lines so far; `tooLong` once a line passes the cap (lines before it still count) */
+  push(chunk) {
+    this.pending = this.pending.length ? Buffer.concat([this.pending, chunk]) : Buffer.from(chunk);
+    const lines = [];
+    for (let newline = this.pending.indexOf(NEWLINE); newline !== -1; newline = this.pending.indexOf(NEWLINE)) {
+      if (newline > this.maxBytes) return { lines, tooLong: true };
+      const line = decoder.decode(this.pending.subarray(0, newline));
+      this.pending = this.pending.subarray(newline + 1);
+      if (line.trim()) lines.push(line);
+    }
+    return { lines, tooLong: this.pending.length > this.maxBytes };
+  }
+};
+var BATCH = 64 * 1024;
+var LineWriter = class _LineWriter {
+  chunks = [];
+  static EMPTY = new Uint8Array(0);
+  head = 0;
+  queued = 0;
+  /** bytes waiting for the socket */
+  get pending() {
+    return this.queued;
+  }
+  push(value) {
+    this.pushBytes(encodeLine(value));
+  }
+  pushBytes(line) {
+    this.chunks.push(line);
+    this.queued += line.length;
+  }
+  flush(write) {
+    while (this.queued) {
+      const first = this.chunks[this.head];
+      let batch = first;
+      if (first.length < BATCH && this.head + 1 < this.chunks.length) {
+        const parts = [];
+        let size = 0;
+        for (let i = this.head; i < this.chunks.length && size < BATCH; i++) {
+          parts.push(this.chunks[i]);
+          size += this.chunks[i].length;
+        }
+        batch = Buffer.concat(parts, size);
+      }
+      const written = write(batch);
+      if (written <= 0) return;
+      this.consume(written);
+    }
+  }
+  consume(bytes) {
+    this.queued -= bytes;
+    while (bytes > 0) {
+      const first = this.chunks[this.head];
+      if (bytes < first.length) {
+        this.chunks[this.head] = first.subarray(bytes);
+        break;
+      }
+      bytes -= first.length;
+      this.chunks[this.head++] = _LineWriter.EMPTY;
+    }
+    if (this.head > 1024 || this.head === this.chunks.length) {
+      this.chunks = this.chunks.slice(this.head);
+      this.head = 0;
+    }
+  }
+};
+function encodeLine(value) {
+  return encoder.encode(`${JSON.stringify(value)}
+`);
+}
+
+// src/paths.ts
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import { chmodSync, lstatSync, mkdirSync, readFileSync as readFileSync2 } from "fs";
+import { homedir, hostname, userInfo } from "os";
+import { join } from "path";
+var runQuiet = (cmd) => {
+  const result = spawnSync(cmd[0], cmd.slice(1), { stdio: ["ignore", "pipe", "ignore"], timeout: 2e3 });
+  return { exitCode: result.status, stdout: result.stdout ?? "" };
+};
+function localHostName(run = runQuiet) {
+  try {
+    const result = run(["scutil", "--get", "LocalHostName"]);
+    return result.exitCode === 0 && result.stdout.toString().trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function systemHostname(platform = process.platform, local = localHostName, fallback = hostname) {
+  return platform === "darwin" && local() || fallback();
+}
+var host;
+function thisHostname() {
+  host ??= systemHostname();
+  return host;
+}
+function shortHostname(name = thisHostname()) {
+  return (name.split(".")[0] ?? "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-") || "unknown";
+}
+function relayDir(env = process.env) {
+  if (env.SCP_DIR) return env.SCP_DIR;
+  return join(env.XDG_STATE_HOME || join(env.HOME || homedir(), ".local", "state"), "scp");
+}
+function policyPath() {
+  return join(accountHome(), ".config", "scp", "policy.json");
+}
+var home;
+var verified = false;
+function accountHomeVerified() {
+  accountHome();
+  return verified;
+}
+function userDatabaseHome(uid, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (!(options.bun ?? typeof process.versions.bun === "string")) return userInfo().homedir || void 0;
+  const run = options.run ?? runQuiet;
+  if (platform === "darwin") {
+    const result2 = run(["dscacheutil", "-q", "user", "-a", "uid", String(uid)]);
+    return result2.exitCode === 0 && /^dir: (.+)$/m.exec(result2.stdout.toString())?.[1]?.trim() || void 0;
+  }
+  const entry = (text) => text.split("\n").find((line2) => line2.split(":")[2] === String(uid));
+  const result = run(["getent", "passwd", String(uid)]);
+  let line = result.exitCode === 0 ? entry(result.stdout.toString()) : void 0;
+  if (!line) {
+    try {
+      line = entry((options.passwd ?? (() => readFileSync2("/etc/passwd", "utf8")))());
+    } catch {
+    }
+  }
+  return line?.split(":")[5] || void 0;
+}
+function accountHome() {
+  if (home) return home;
+  try {
+    if (typeof process.getuid === "function") home = userDatabaseHome(process.getuid());
+    verified = Boolean(home);
+  } catch {
+  }
+  home ||= homedir();
+  return home;
+}
+var SUN_PATH_MAX = 100;
+function privateDir(path) {
+  mkdirSync(path, { recursive: true, mode: 448 });
+  const stat = lstatSync(path);
+  if (!stat.isDirectory() || typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+    throw new Error(`${path} is not a directory this user owns`);
+  }
+  chmodSync(path, 448);
+  return path;
+}
+function ownPrivateDir(path) {
+  const stat = lstatSync(path, { throwIfNoEntry: false });
+  return !!stat && stat.isDirectory() && (typeof process.getuid !== "function" || stat.uid === process.getuid()) && (stat.mode & 18) === 0;
+}
+function socketPath(dir) {
+  const inside = join(dir, "relay.sock");
+  if (Buffer.byteLength(inside) <= SUN_PATH_MAX) return inside;
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  const key = createHash("sha256").update(dir).digest("hex").slice(0, 12);
+  return join("/tmp", `scp-${uid}-${key}`, "relay.sock");
+}
+
+// src/socket.ts
+var END_GRACE_MS = 2e3;
+var Conn = class {
+  constructor(socket, data, handlers) {
+    this.socket = socket;
+    this.data = data;
+    socket.on("data", (chunk) => {
+      if (!this.ending) handlers.data(this, chunk);
+    });
+    socket.on("drain", () => handlers.drain(this));
+    socket.on("error", (error) => handlers.close(this, error));
+    socket.on("close", () => handlers.close(this));
+  }
+  socket;
+  data;
+  ending = false;
+  /** bytes the socket took but has not sent yet */
+  get unsent() {
+    return this.socket.writableLength;
+  }
+  /** takes all of `bytes`, or none while the socket waits to drain */
+  write(bytes) {
+    if (this.ending || this.socket.destroyed || this.socket.writableNeedDrain) return 0;
+    this.socket.write(bytes);
+    return bytes.length;
+  }
+  /** sends what was written, then closes once the peer does, or after a grace period; what the peer still sends is discarded */
+  end() {
+    if (this.ending || this.socket.destroyed) return;
+    this.ending = true;
+    this.socket.resume();
+    this.socket.end();
+    setTimeout(() => this.socket.destroy(), END_GRACE_MS).unref();
+  }
+  pause() {
+    if (!this.ending) this.socket.pause();
+  }
+  resume() {
+    this.socket.resume();
+  }
+};
+
+// src/client.ts
+var RelayClient = class _RelayClient {
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  reader = new LineReader(64 * 1024 * 1024);
+  writer = new LineWriter();
+  socket;
+  closedError;
+  listeners = [];
+  static connect(path) {
+    const client = new _RelayClient();
+    return new Promise((resolve, reject) => {
+      const socket = createConnection({ path });
+      socket.once("error", reject);
+      socket.once("connect", () => {
+        socket.off("error", reject);
+        client.socket = new Conn(socket, void 0, {
+          data: (_s, chunk) => client.onData(chunk),
+          drain: () => client.flush(),
+          close: (_s, error) => client.onClose(error ?? new Error("the relay broker closed the connection"))
+        });
+        resolve(client);
+      });
+    });
+  }
+  onNotification(fn) {
+    this.listeners.push(fn);
+  }
+  request(method, params = {}) {
+    if (this.closedError) return Promise.reject(this.closedError);
+    const id = this.nextId++;
+    const line = encodeLine({ jsonrpc: "2.0", id, method, params });
+    const bytes = line.length - 1;
+    if (bytes > MAX_LINE) {
+      return Promise.reject(
+        new RelayError(
+          "too_large",
+          `the request is ${bytes} bytes as JSON, over the broker's ${MAX_LINE} byte line limit (control characters count 6 bytes each once escaped)`
+        )
+      );
+    }
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.writer.pushBytes(line);
+      this.flush();
+    });
+  }
+  hello(hello) {
+    return this.request("hello", { protocol: PROTOCOL, capabilities: [], ...hello });
+  }
+  rules(endpoint) {
+    return this.request("rules", endpoint ? { endpoint } : {});
+  }
+  rulesSet(params) {
+    return this.request("rules_set", params);
+  }
+  rulesWiden(params) {
+    return this.request("rules_widen", params);
+  }
+  rulesLift(params) {
+    return this.request("rules_lift", params);
+  }
+  /** a `krt_` grant for a spawn: `env` holds SCP_GRANT, which is a secret */
+  grant(params) {
+    return this.request("grant", params);
+  }
+  /**
+   * the harness a spawn ran with `grant` exited: its endpoint goes done and offline, or a grant no one spent is revoked, and the spawner gets
+   * `output` back in the handback message, unless the harness never `started`
+   */
+  spawnExit(params) {
+    return this.request("spawn_exit", params);
+  }
+  /**
+   * a spawned worker that exited: its harness session id, the transcript its hooks named with it and its spawner's unread messages to it;
+   * with `take` and a session they are marked read, for a resume to carry them
+   */
+  spawnSteers(params) {
+    return this.request("spawn_steers", params);
+  }
+  /**
+   * at a stop: the spawned workers' unread messages, held for the hook to print, waiting up to `wait_s` while workers still run, none came,
+   * pushes are left and no prompt moved the `prompts` mark inject handed out; with `wait_s` above 0 and other workers still running, the
+   * broker gathers more of their results into the same push for up to ${LIMITS.pushGraceS} s, which may run past `wait_s`
+   */
+  stopWait(waitS = 0, prompts) {
+    return this.request("stop_wait", { wait_s: waitS, ...prompts !== void 0 ? { prompts } : {} });
+  }
+  group(params) {
+    return this.request("group", params);
+  }
+  admin(params) {
+    return this.request("admin", params);
+  }
+  async peers() {
+    return (await this.request("peers")).peers;
+  }
+  why(from, to) {
+    return this.request("why", { from, to });
+  }
+  close() {
+    this.socket.end();
+  }
+  flush() {
+    this.writer.flush((bytes) => this.socket.write(bytes));
+  }
+  onData(chunk) {
+    const { lines, tooLong } = this.reader.push(chunk);
+    this.dispatchLines(lines);
+    if (tooLong) this.fail(new Error("the relay broker sent a line over the size cap"));
+  }
+  dispatchLines(lines) {
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        this.fail(new Error("the relay broker sent a line that is not JSON"));
+        return;
+      }
+      const message = parsed;
+      if (message.method) {
+        for (const fn of this.listeners) fn(message.method, message.params);
+        continue;
+      }
+      const pending = message.id !== void 0 ? this.pending.get(message.id) : void 0;
+      if (!pending) continue;
+      this.pending.delete(message.id);
+      if (message.error) pending.reject(new RelayError(message.error.data?.code ?? "invalid_params", message.error.message, message.error.data?.retry_after));
+      else pending.resolve(message.result);
+    }
+  }
+  fail(error) {
+    this.onClose(error);
+    this.socket.end();
+  }
+  onClose(error) {
+    if (this.closedError) return;
+    this.closedError = error;
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+  }
+};
+var BrokerUnavailable = class extends Error {
+};
+function brokerLive(dir) {
+  const lock = join2(dir, "broker.lock");
+  const held2 = brokerLockHeld(lock);
+  if (held2 !== void 0) return held2;
+  let pid;
+  try {
+    pid = Number(readFileSync3(lock, "utf8").split(":")[0]);
+  } catch {
+    return false;
+  }
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function connectBroker(dir, start, timeoutMs = 5e3) {
+  const path = socketPath(dir);
+  const refuse = (code) => new BrokerUnavailable(`the sandbox blocks the relay socket (${code}); allow ${path} or run outside the sandbox`);
+  const owned = (client) => {
+    if (ownPrivateDir(dirname(path))) return client;
+    client.close();
+    throw new BrokerUnavailable(`${dirname(path)} is a link, not this user's, or writable by others; refusing the relay socket in it`);
+  };
+  const sandboxed = (error) => {
+    if (error instanceof BrokerUnavailable) throw error;
+    const code = error?.code;
+    if (code === "EPERM" || code === "EACCES") throw refuse(code);
+  };
+  try {
+    return owned(await RelayClient.connect(path));
+  } catch (error) {
+    sandboxed(error);
+    if (!start) throw new BrokerUnavailable(`no relay broker at ${path} (${error instanceof Error ? error.message : String(error)})`);
+    if (existsSync(path) && brokerLive(dir)) throw refuse(error?.code ?? "refused");
+  }
+  start();
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    await sleep(50);
+    try {
+      return owned(await RelayClient.connect(path));
+    } catch (error) {
+      sandboxed(error);
+      if (Date.now() >= deadline)
+        throw new BrokerUnavailable(`the relay broker did not start within ${timeoutMs} ms (${error instanceof Error ? error.message : String(error)})`);
+    }
+  }
+}
+
+// src/bridge.ts
+import {
+  findSecret,
+  matches,
+  newId,
+  PROTOCOL as PROTOCOL2,
+  RelayError as RelayError2,
+  XLIMITS
+} from "@scp-dev/core";
+import { HUB_LIMITS } from "@scp-dev/hub";
+var CONNECT_TIMEOUT_MS = 15e3;
+var MIRROR_FRAME_BYTES = HUB_LIMITS.frameBytes - 1024;
+var DEAD_LETTER_ATTEMPTS = 3;
+function remoteSend(core, to) {
+  const targets = Array.isArray(to) ? to : [to];
+  const remote = targets.filter((address) => core.isRemote(address)).length;
+  if (remote && remote !== targets.length)
+    throw new RelayError2("invalid_params", "a message goes to endpoints on this machine or on other machines, not both; send it twice");
+  return remote > 0;
+}
+function relaySocketUrl(origin) {
+  const url = new URL("/v1/relay/ws", origin);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url.toString();
+}
+function startBridge(options) {
+  const { core, onRemote: hooks, machine } = options;
+  const selectors2 = options.mirror ?? ["*"];
+  const minMs = options.backoff?.minMs ?? 1e3;
+  const maxMs = options.backoff?.maxMs ?? 6e4;
+  const forwardWaitMs = options.forwardWaitMs ?? 3e4;
+  const injectBackoffMs = options.injectBackoffMs ?? 1e3;
+  const Socket = options.webSocket ?? WebSocket;
+  const log = hooks.log ?? ((line) => console.error(line));
+  const encoder2 = new TextEncoder();
+  let token = options.token;
+  let ws = null;
+  let connected = false;
+  let ready = false;
+  let stopped = false;
+  let lastError = options.token ? null : options.tokenError ?? "no hub credential; the broker runs local-only";
+  let since = (/* @__PURE__ */ new Date()).toISOString();
+  let attempt = 0;
+  let account = null;
+  let revokedReason = null;
+  let retryTimer;
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  let waitingForLink = [];
+  let deliveries = Promise.resolve();
+  let ackedMax = 0;
+  const inflight = /* @__PURE__ */ new Set();
+  const injectFailures = /* @__PURE__ */ new Map();
+  const fromHub = /* @__PURE__ */ new WeakSet();
+  const setState = (up, error) => {
+    if (up !== connected || error !== lastError) since = (/* @__PURE__ */ new Date()).toISOString();
+    connected = up;
+    lastError = error;
+  };
+  function request(method, params = {}) {
+    const socket = ws;
+    if (socket?.readyState !== 1) return Promise.reject(new RelayError2("unavailable", "the hub is not connected"));
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      try {
+        socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+      } catch (error) {
+        pending.delete(id);
+        reject(new RelayError2("unavailable", `the hub connection failed (${error instanceof Error ? error.message : String(error)})`));
+      }
+    });
+  }
+  function fireAndForget(method, params) {
+    request(method, params).catch((error) => {
+      if (!(error instanceof RelayError2 && error.code === "unavailable"))
+        log(`relay bridge: ${method} failed: ${error instanceof Error ? error.message : String(error)}`);
+    });
+  }
+  function connect() {
+    if (stopped || !token) return;
+    let socket;
+    try {
+      socket = new Socket(relaySocketUrl(options.url), { headers: { Authorization: `Bearer ${token}` } });
+    } catch (error) {
+      setState(false, `cannot open the hub socket (${error instanceof Error ? error.message : String(error)})`);
+      return retry();
+    }
+    ws = socket;
+    revokedReason = null;
+    let handshakeError = null;
+    const timer = setTimeout(() => {
+      if (socket.readyState === 0) socket.close();
+    }, CONNECT_TIMEOUT_MS);
+    socket.addEventListener("open", () => {
+      clearTimeout(timer);
+      handshake(socket).catch((error) => {
+        if (ws !== socket) return;
+        const relay = error instanceof RelayError2 ? error : null;
+        if (relay && (relay.code === "unauthorized" || relay.code === "invalid_params")) {
+          stopped = true;
+          handshakeError = `the hub refused this bridge: ${relay.message}`;
+        } else if (relay?.code === "too_large") {
+          handshakeError = `the hub refused this bridge for now, retrying: ${relay.message}`;
+        } else {
+          handshakeError = `the handshake failed: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        socket.close(1e3, "handshake failed");
+      });
+    });
+    socket.addEventListener("message", (event) => onFrame(String(event.data)));
+    socket.addEventListener("error", () => {
+    });
+    socket.addEventListener("close", (event) => {
+      clearTimeout(timer);
+      if (ws !== socket) return;
+      ws = null;
+      ready = false;
+      const close = event;
+      const wasUp = connected;
+      for (const p of pending.values()) p.reject(new RelayError2("unavailable", "the hub connection closed"));
+      pending.clear();
+      const why = `${close.code}${close.reason ? ` ${close.reason}` : ""}`;
+      if (close.code === 1008) {
+        stopped = true;
+        setState(false, `revoked or unauthorized: ${revokedReason ?? (close.reason || "the hub closed the bridge")}`);
+      } else if (close.code === 4e3) {
+        stopped = true;
+        setState(false, `replaced: ${close.reason || "another bridge connected for this machine"}`);
+      } else if (close.code === 4001) {
+        setState(false, `the credential expired, reconnecting (${why})`);
+      } else {
+        setState(false, handshakeError ?? (wasUp ? `disconnected (${why})` : `cannot connect to ${options.url} (${why})`));
+      }
+      retry();
+    });
+  }
+  function retry() {
+    if (stopped) return;
+    const base = Math.min(maxMs, minMs * 2 ** Math.min(attempt, 16));
+    attempt++;
+    retryTimer = setTimeout(reconnect, base / 2 + Math.random() * (base / 2));
+  }
+  async function reconnect() {
+    if (options.credentials && !stopped) {
+      try {
+        token = await options.credentials() ?? token;
+      } catch (error) {
+        log(`relay bridge: the credential could not be read again: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    connect();
+  }
+  async function handshake(socket) {
+    const hello = await request("hello", { protocol: PROTOCOL2, machine, bridge: true });
+    account = hello.account;
+    core.setAliases([account]);
+    ready = true;
+    applyRemote(hello.endpoints, true);
+    await Promise.all(fullMirror().map((params) => request("mirror", params)));
+    await request("watch");
+    await request("subscribe", { after: cursor() });
+    if (ws !== socket) return;
+    attempt = 0;
+    setState(true, null);
+    for (const fn of waitingForLink.splice(0)) fn();
+  }
+  function applyRemote(views, full) {
+    const byMachine = /* @__PURE__ */ new Map();
+    for (const view of views) {
+      if (view.machine === machine) continue;
+      byMachine.set(view.machine, [...byMachine.get(view.machine) ?? [], view]);
+    }
+    if (full) {
+      for (const view of core.remoteViews()) if (view.machine !== account && !byMachine.has(view.machine)) byMachine.set(view.machine, []);
+    }
+    for (const [name, list] of byMachine) {
+      try {
+        core.mirror(name, list, { full });
+      } catch (error) {
+        log(`relay bridge: the endpoints of ${name} were not applied: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  function mirrored(view) {
+    if (view.kind === "system" || core.machineOf(view.id) !== null) return false;
+    const subject = {
+      handle: view.kind === "human" ? "" : view.address.slice(view.address.lastIndexOf("/") + 1),
+      harness: view.harness,
+      kind: view.kind,
+      labels: view.labels
+    };
+    return selectors2.some((selector) => matches(selector, subject));
+  }
+  function outward(view) {
+    const { title, ...scope } = core.mirrorScope(view.id);
+    return {
+      ...scope,
+      ...title === void 0 ? {} : { title: options.redact ? null : title },
+      address: view.address,
+      kind: view.kind,
+      harness: view.harness,
+      model: view.model,
+      cwd: options.redact ? null : view.cwd,
+      labels: view.labels,
+      status: view.status ? { state: view.status.state, note: options.redact ? "" : view.status.note } : null,
+      presence: view.presence,
+      last_seen: view.last_seen
+    };
+  }
+  function localViews() {
+    return core.list().filter(mirrored).map(outward);
+  }
+  function fullMirror() {
+    const frames = [[]];
+    let bytes = 0;
+    for (const view of localViews()) {
+      const size = encoder2.encode(JSON.stringify(view)).length + 1;
+      if (size > MIRROR_FRAME_BYTES)
+        throw new RelayError2("too_large", `${view.address} mirrors ${size} bytes, over the hub's ${MIRROR_FRAME_BYTES} byte frame`);
+      if (bytes + size > MIRROR_FRAME_BYTES) {
+        frames.push([]);
+        bytes = 0;
+      }
+      frames.at(-1).push(view);
+      bytes += size;
+    }
+    if (frames.length === 1) return [{ endpoints: frames[0], full: true }];
+    const id = newId("sync");
+    return frames.map((endpoints, i) => ({ endpoints, full: i === 0, sync: { id, part: i + 1, parts: frames.length } }));
+  }
+  function handleOf(endpoint) {
+    const view = core.whoami(endpoint);
+    if (!mirrored(view)) return null;
+    return view.kind === "human" ? "" : view.address.slice(view.address.lastIndexOf("/") + 1);
+  }
+  function localAddress(address) {
+    if (typeof address !== "string" || !account || !address.startsWith(`${account}/`)) return address;
+    const rest = address.slice(account.length + 1);
+    return rest.includes("/") ? `${core.user}/${rest}` : `${core.user}/${account}/${rest}`;
+  }
+  function cursor() {
+    return inflight.size ? Math.min(...inflight) - 1 : ackedMax;
+  }
+  function onFrame(text) {
+    let frame;
+    try {
+      frame = JSON.parse(text);
+    } catch {
+      log("relay bridge: the hub sent a frame that is not JSON");
+      return;
+    }
+    if (frame.method) return onNotification(frame.method, frame.params);
+    const waiter = frame.id !== void 0 ? pending.get(frame.id) : void 0;
+    if (!waiter) return;
+    pending.delete(frame.id);
+    if (!frame.error) return waiter.resolve(frame.result);
+    const error = new RelayError2(frame.error.data?.code ?? "unavailable", frame.error.message, frame.error.data?.retry_after);
+    fromHub.add(error);
+    waiter.reject(error);
+  }
+  function onNotification(method, params) {
+    switch (method) {
+      case "deliver": {
+        const seq = params.seq;
+        if (!Number.isInteger(seq)) return;
+        inflight.add(seq);
+        deliveries = deliveries.then(() => deliver(seq, params.endpoint, params.message));
+        return;
+      }
+      case "endpoints": {
+        if (typeof params.machine !== "string" || params.machine === machine) return;
+        try {
+          core.mirror(params.machine, params.endpoints, { full: params.full === true });
+        } catch (error) {
+          log(`relay bridge: the endpoints of ${params.machine} were not applied: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+      case "fleet":
+        return remoteFleet(params);
+      case "revoked":
+        revokedReason = typeof params.reason === "string" ? params.reason : null;
+        return;
+    }
+  }
+  async function deliver(seq, target, message) {
+    try {
+      let refused = null;
+      for (; ; ) {
+        try {
+          refused = inject(target, message);
+          break;
+        } catch (error) {
+          if (error instanceof RelayError2) {
+            refused = error.code;
+            break;
+          }
+          const attempts = (injectFailures.get(seq) ?? 0) + 1;
+          injectFailures.set(seq, attempts);
+          const why = error instanceof Error ? error.message : String(error);
+          log(`relay bridge: delivery ${seq} failed (attempt ${attempts} of ${DEAD_LETTER_ATTEMPTS}): ${why}`);
+          if (attempts >= DEAD_LETTER_ATTEMPTS) {
+            await settled("reject", { seq, code: "dead_letter" });
+            settle(seq);
+            core.record("dead_letter", null, typeof message?.id === "string" ? message.id : null, { seq, target: String(target), attempts, error: why });
+            return;
+          }
+          await new Promise((resolve) => setTimeout(resolve, injectBackoffMs * 2 ** (attempts - 1)));
+        }
+      }
+      if (refused !== null) {
+        await settled("reject", { seq, code: refused });
+        settle(seq);
+        return;
+      }
+      await settled("ack", { seqs: [seq] });
+      settle(seq);
+    } catch (error) {
+      if (error instanceof RelayError2 && error.code === "unavailable") return;
+      log(`relay bridge: delivery ${seq} failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  function inject(target, message) {
+    const endpoint = core.localTarget(target);
+    if ((hooks.policyError() ?? core.inboundRefusal(endpoint, message)) !== null) return "policy_refused";
+    if (core.admit(endpoint, message).duplicate) return null;
+    hooks.wake(endpoint);
+    hooks.fleet({
+      type: "message",
+      machine: message.from.machine ?? null,
+      id: message.id,
+      thread: message.thread,
+      kind: message.kind,
+      from: localAddress(message.from.address),
+      to: [core.addressOf(endpoint)],
+      hop: message.hop
+    });
+    return null;
+  }
+  async function settled(method, params) {
+    for (; ; ) {
+      try {
+        await request(method, params);
+        return;
+      } catch (error) {
+        if (!(error instanceof RelayError2 && error.code === "rate_limited")) throw error;
+        await new Promise((resolve) => setTimeout(resolve, (error.retryAfterS ?? 1) * 1e3));
+      }
+    }
+  }
+  function settle(seq) {
+    inflight.delete(seq);
+    injectFailures.delete(seq);
+    ackedMax = Math.max(ackedMax, seq);
+  }
+  function remoteFleet(event) {
+    if (event.machine === machine) return;
+    if (event.type === "message" && Array.isArray(event.to) && account && event.to.some((to) => typeof to === "string" && to.startsWith(`${account}/${machine}/`)))
+      return;
+    const local = {
+      ...event,
+      ...event.from !== void 0 ? { from: localAddress(event.from) } : {},
+      ...event.endpoint !== void 0 ? { endpoint: localAddress(event.endpoint) } : {}
+    };
+    if (Array.isArray(event.to)) local.to = event.to.map(localAddress);
+    if (event.type === "activity" && typeof event.machine === "string" && typeof event.endpoint === "string") {
+      try {
+        const proxy = core.remoteEndpoint(event.machine, event.endpoint.slice(event.endpoint.lastIndexOf("/") + 1));
+        const row = core.event(proxy, { kind: event.kind, tool: event.tool, summary: event.summary });
+        local.id = row.id;
+      } catch {
+      }
+    }
+    hooks.fleet(local);
+  }
+  function linkUp(ms) {
+    if (connected) return Promise.resolve(true);
+    if (stopped) return Promise.resolve(false);
+    return new Promise((resolve) => {
+      const done = (up) => {
+        clearTimeout(timer);
+        waitingForLink = waitingForLink.filter((fn) => fn !== onUp);
+        resolve(up);
+      };
+      const onUp = () => done(true);
+      const timer = setTimeout(() => done(false), ms);
+      waitingForLink.push(onUp);
+    });
+  }
+  function unavailable() {
+    return new RelayError2("unavailable", `the hub is not connected${lastError ? ` (${lastError})` : ""}; try again`, 5);
+  }
+  function crossAccount(params, targets) {
+    if (targets.length !== 1) throw new RelayError2("invalid_params", "a message to another account goes to exactly one endpoint: no lists, groups or tree:");
+    if (typeof params.body === "string") {
+      const bytes = new TextEncoder().encode(params.body).length;
+      if (bytes > XLIMITS.bodyBytes)
+        throw new RelayError2("too_large", `a message to another account is at most ${XLIMITS.bodyBytes} bytes; this one is ${bytes}`);
+    }
+    if (params.attachments?.length) throw new RelayError2("data_class_refused", "attachments stay in this account; send a reference instead");
+    if (params.data_class === "private") throw new RelayError2("data_class_refused", "a private message stays in this account");
+  }
+  async function forward(from, params, origin = {}) {
+    const sender = core.addressOf(from);
+    const targets = Array.isArray(params.to) ? params.to : [params.to];
+    if (targets.some((to) => core.foreignAccount(to) !== null)) crossAccount(params, targets);
+    for (const to of targets) {
+      core.scopeCheck(from, to, typeof params.reply_to === "string" ? params.reply_to : void 0);
+      const refusal = core.checkPolicy(sender, String(to));
+      if (refusal) throw new RelayError2("policy_refused", `${refusal} (${String(to)})`);
+    }
+    if (typeof params.body !== "string") throw new RelayError2("invalid_params", "body must be a string");
+    if (params.data_class === "private" && !options.privateOk) {
+      throw new RelayError2(
+        "data_class_refused",
+        "a private message stays on this machine; allow private messages in the bridge configuration to send them through the hub"
+      );
+    }
+    const secret = findSecret(params.body) ?? (params.attachments ?? []).map((a) => findSecret(String(a?.path))).find(Boolean) ?? null;
+    if (secret) throw new RelayError2("secret_refused", `the message looks like it carries a credential (${secret}); send a reference instead`);
+    const earlier = core.forwarded(from, params);
+    if (earlier) return earlier;
+    const handle = handleOf(from);
+    if (handle === null)
+      throw new RelayError2("policy_refused", `${sender} is not mirrored to the hub (the bridge's mirror selectors), so it can't message other machines`);
+    if (!connected) throw unavailable();
+    const clientId = params.client_id ?? newId("fwd");
+    const sent = { ...params, client_id: clientId, to: targets.map((to) => core.route(to)) };
+    delete sent.wait_s;
+    delete sent.attachments;
+    const deadline = Date.now() + forwardWaitMs;
+    for (let tries = 0; ; ) {
+      try {
+        const result = await request("forward", {
+          from: handle,
+          params: sent,
+          hop_floor: core.causalHop(from),
+          ...origin.tty === void 0 ? {} : { tty: origin.tty }
+        });
+        core.recordForward(from, { ...params, client_id: clientId }, result, origin);
+        return result;
+      } catch (error) {
+        if (!(error instanceof RelayError2 && error.code === "unavailable")) throw error;
+        if (fromHub.has(error)) {
+          const base = Math.min(maxMs, minMs * 2 ** tries++);
+          const wait = Math.max(base / 2 + Math.random() * (base / 2), (error.retryAfterS ?? 0) * 1e3);
+          if (Date.now() + wait >= deadline) throw error;
+          await new Promise((resolve) => setTimeout(resolve, wait));
+        } else if (!await linkUp(deadline - Date.now())) throw unavailable();
+      }
+    }
+  }
+  function changed(endpoint) {
+    if (!ready) return;
+    let view;
+    try {
+      view = core.whoami(endpoint);
+    } catch {
+      return;
+    }
+    if (mirrored(view)) fireAndForget("mirror", { endpoints: [outward(view)], full: false });
+  }
+  function resync() {
+    if (!ready) return;
+    let frames;
+    try {
+      frames = fullMirror();
+    } catch (error) {
+      return log(`relay bridge: mirror failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    for (const params of frames) fireAndForget("mirror", params);
+  }
+  function activity(endpoint, row) {
+    if (!ready) return;
+    const handle = handleOf(endpoint);
+    if (handle === null) return;
+    fireAndForget("event", { from: handle, kind: row.kind, tool: row.tool ?? void 0, summary: options.redact ? void 0 : row.summary ?? void 0 });
+  }
+  async function contacts() {
+    if (!connected) throw unavailable();
+    return (await request("list", { contacts: true })).contacts;
+  }
+  function status() {
+    return { enabled: true, machine, url: options.url, connected, last_error: lastError, since };
+  }
+  async function stop() {
+    stopped = true;
+    clearTimeout(retryTimer);
+    for (const fn of waitingForLink.splice(0)) fn();
+    const socket = ws;
+    ws = null;
+    connected = false;
+    ready = false;
+    for (const p of pending.values()) p.reject(new RelayError2("unavailable", "the bridge stopped"));
+    pending.clear();
+    if (socket && socket.readyState <= 1) socket.close(1e3, "the broker stopped");
+  }
+  connect();
+  return { forward, changed, resync, activity, contacts, status, stop };
+}
+
+// src/server.ts
+import { createHash as createHash2 } from "crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync2, lstatSync as lstatSync2, readFileSync as readFileSync5, realpathSync, rmdirSync, unlinkSync as unlinkSync2 } from "fs";
+import { createServer } from "net";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, isAbsolute, join as join3, sep } from "path";
+import { setTimeout as sleep2 } from "timers/promises";
+import {
+  BROKER_CAPABILITIES,
+  CLI_NAME,
+  LIMITS as LIMITS2,
+  parsePolicy,
+  PREAMBLE,
+  PROTOCOL as PROTOCOL3,
+  RelayError as RelayError4,
+  SERVER_FIELDS,
+  stripControl
+} from "@scp-dev/core";
+import { FederatedCore } from "@scp-dev/hub";
+
+// src/judge-gate.ts
+import { accessSync, constants, readFileSync as readFileSync4 } from "fs";
+import {
+  applyRedactions,
+  DEFAULT_JUDGE_BUDGET,
+  findSecret as findSecret2,
+  HttpJudgeClient,
+  JUDGE_PROMPT_VERSION,
+  judgeBoundary,
+  LIMITS,
+  mergeVerdicts,
+  newId as newId2,
+  newJudgeStats,
+  one,
+  RelayError as RelayError3,
+  runJudge,
+  sha256Hex,
+  VerdictCache
+} from "@scp-dev/core";
+var HELD_PER_SENDER = 100;
+var iso = (ms) => ms === null ? null : new Date(ms).toISOString();
+var JudgeGate = class {
+  constructor(o) {
+    this.o = o;
+    o.sql.all(
+      `CREATE TABLE IF NOT EXISTS judge_holds (id TEXT PRIMARY KEY, from_ep TEXT NOT NULL, params TEXT NOT NULL, origin TEXT NOT NULL, verdict TEXT NOT NULL,
+       created_at INTEGER NOT NULL, expires_at INTEGER NOT NULL, state TEXT NOT NULL, by TEXT, resolved_at INTEGER)`
+    );
+    o.sql.all(
+      `CREATE TABLE IF NOT EXISTS judge_sent (from_ep TEXT NOT NULL, client_id TEXT NOT NULL, fingerprint TEXT NOT NULL, result TEXT NOT NULL, created_at INTEGER NOT NULL,
+       PRIMARY KEY (from_ep, client_id))`
+    );
+    o.sql.all(`UPDATE judge_holds SET state = 'held' WHERE state = 'releasing'`);
+  }
+  o;
+  stats = newJudgeStats();
+  policy;
+  version = "";
+  client = null;
+  cache = new VerdictCache();
+  shadows = /* @__PURE__ */ new Set();
+  /** judged sends in the last hour per budget: `ep:<id>`, `tree:<root id>` and `*` for the whole broker */
+  spent = /* @__PURE__ */ new Map();
+  /** the policy's judge section; a model client only when its key is readable, else the prefilter alone */
+  configure(policy) {
+    this.policy = policy;
+    this.version = policy ? sha256Hex(JSON.stringify(policy)) : "";
+    this.client = null;
+    const model = policy?.model;
+    if (!policy || policy.mode === "off" || !model) return;
+    const key = this.keyReader(model);
+    if (!key) {
+      this.o.log(
+        `relay broker: the judge model's key (${model.key_env ? `key_env ${model.key_env}` : `key_file ${model.key_file}`}) is not readable; judging with the prefilter only`
+      );
+      return;
+    }
+    this.client = (this.o.client ?? ((m, k) => new HttpJudgeClient({ model: m.id, effort: m.effort, key: k })))(model, key);
+  }
+  keyReader(model) {
+    if (model.key_env) {
+      const name = model.key_env;
+      return this.o.env[name] ? async () => this.o.env[name] ?? "" : null;
+    }
+    const file = model.key_file;
+    try {
+      accessSync(file, constants.R_OK);
+    } catch {
+      return null;
+    }
+    return async () => readFileSync4(file, "utf8").trim();
+  }
+  /** resolves once every shadow judgement started so far finished */
+  async settled() {
+    await Promise.all([...this.shadows]);
+  }
+  /** a send or ask through the judge; an unjudged one goes straight to `deliver` */
+  async send(from, params, origin, deliver) {
+    const policy = this.policy;
+    const body = params.body;
+    if (!policy || policy.mode === "off" || typeof body !== "string" || new TextEncoder().encode(body).length > LIMITS.bodyBytes || findSecret2(body))
+      return deliver(from, params, origin);
+    const targets = Array.isArray(params.to) ? params.to : [params.to];
+    if (targets.some((to) => this.o.core.foreignAccount(to) !== null)) {
+      if (policy.mode === "enforce") {
+        this.o.core.auditJudge("judge_skipped", from, null, {
+          side: "local",
+          boundary: "other account",
+          prompt_version: JUDGE_PROMPT_VERSION,
+          categories: [],
+          sha256: sha256Hex(body),
+          verdict: "skipped",
+          reason: "other_account_judged_by_hub",
+          to: targets.map(String)
+        });
+      }
+      return deliver(from, params, origin);
+    }
+    if (policy.mode === "shadow") {
+      const result = await deliver(from, params, origin);
+      if (!result.duplicate) this.shadow(policy, from, params, origin, result.id);
+      return result;
+    }
+    const { groups, tree } = this.boundaries(policy, from, params, origin);
+    if (!groups.size) return deliver(from, params, origin);
+    const ttl = params.ttl_s ?? LIMITS.ttlDefaultS;
+    if (!Number.isInteger(ttl) || ttl < 1 || ttl > LIMITS.ttlMaxS) throw new RelayError3("invalid_params", `ttl_s must be 1 to ${LIMITS.ttlMaxS}`);
+    const seen = params.client_id === void 0 ? void 0 : this.seen(from, params);
+    if (seen) return seen;
+    const waiting = one(this.o.sql, `SELECT COUNT(*) AS n FROM judge_holds WHERE from_ep = ? AND state IN ('held', 'releasing')`, from).n;
+    if (waiting >= HELD_PER_SENDER)
+      throw new RelayError3("rate_limited", `${waiting} of your messages wait for review by your human; send more once they released or refused some`, 3600);
+    this.spend(policy, from, tree);
+    const verdict = await this.judge(policy, from, body, groups);
+    const detail = this.detail(verdict, body, groups);
+    switch (verdict.verdict) {
+      case "refuse":
+        this.o.core.auditJudge("judge_refuse", from, null, detail);
+        throw new RelayError3(
+          "judge_refused",
+          `the relay judge refused this message (local; ${verdict.categories.join(", ") || "no category"}): ${verdict.reason}`,
+          void 0,
+          {
+            side: "local",
+            categories: verdict.categories,
+            reason: verdict.reason
+          }
+        );
+      case "hold":
+        return this.hold(from, params, origin, verdict, groups, detail);
+      case "redact": {
+        const applied = applyRedactions(body, verdict.redactions);
+        const result = await deliver(from, { ...params, body: applied.text }, origin);
+        const redacted = { n: applied.n, kinds: applied.kinds };
+        this.o.core.auditJudge(verdict.source === "error" ? "judge_skipped" : "judge_redact", from, result.id, { ...detail, redacted });
+        return this.remember(from, params, { ...result, redacted });
+      }
+      case "pass": {
+        const result = await deliver(from, params, origin);
+        if (verdict.source === "error") this.o.core.auditJudge("judge_skipped", from, result.id, detail);
+        return this.remember(from, params, result);
+      }
+    }
+  }
+  /** an earlier judged send or waiting hold under the send's client_id: the same message is answered as before, another one refused as core refuses it */
+  seen(from, params) {
+    const clientId = params.client_id;
+    const held2 = one(
+      this.o.sql,
+      `SELECT id, params FROM judge_holds WHERE from_ep = ? AND json_extract(params, '$.client_id') = ? AND state IN ('held', 'releasing')`,
+      from,
+      clientId
+    );
+    const sent = held2 ? void 0 : one(
+      this.o.sql,
+      `SELECT fingerprint, result FROM judge_sent WHERE from_ep = ? AND client_id = ? AND created_at > ?`,
+      from,
+      clientId,
+      this.o.now() - LIMITS.idempotencyS * 1e3
+    );
+    const before = held2 ? fingerprint(JSON.parse(held2.params)) : sent?.fingerprint;
+    if (before === void 0) return void 0;
+    if (before !== fingerprint(params)) throw new RelayError3("invalid_params", `client_id ${clientId} was already used for a different message`);
+    return held2 ? heldResult(held2.id, params) : { ...JSON.parse(sent.result), duplicate: true };
+  }
+  remember(from, params, result) {
+    if (params.client_id !== void 0 && !result.duplicate) {
+      this.o.sql.all(
+        `INSERT OR REPLACE INTO judge_sent (from_ep, client_id, fingerprint, result, created_at) VALUES (?, ?, ?, ?, ?)`,
+        from,
+        params.client_id,
+        fingerprint(params),
+        JSON.stringify(result),
+        this.o.now()
+      );
+    }
+    return result;
+  }
+  /**
+   * a judged send counts before any model call against its sender's, its lineage tree's and the whole broker's budget, since refused and
+   * held sends never reach the send's own limits, and a new handle or a helper process must not bring a fresh budget
+   */
+  spend(policy, from, tree) {
+    const now = this.o.now();
+    const global = policy.budget ?? DEFAULT_JUDGE_BUDGET;
+    const budgets = [
+      [`ep:${from}`, LIMITS.pairPerMinute, LIMITS.pairPerHour, "from this endpoint"],
+      [`tree:${tree}`, LIMITS.pairPerMinute * 2, LIMITS.pairPerHour * 2, "from this lineage tree"],
+      ["*", global.per_minute, global.per_hour, "on this broker"]
+    ];
+    const recent = budgets.map(([key]) => (this.spent.get(key) ?? []).filter((at) => at > now - 36e5));
+    budgets.forEach(([key, perMinute, perHour, what], i) => {
+      for (const [limit, windowS] of [
+        [perMinute, 60],
+        [perHour, 3600]
+      ]) {
+        const inWindow = recent[i].filter((at) => at > now - windowS * 1e3);
+        if (inWindow.length >= limit) {
+          this.spent.set(key, recent[i]);
+          throw new RelayError3(
+            "rate_limited",
+            `${limit} judged messages ${what} in ${windowS} s`,
+            Math.max(1, Math.ceil((inWindow[0] + windowS * 1e3 - now) / 1e3))
+          );
+        }
+      }
+    });
+    for (const [i, [key]] of budgets.entries()) this.spent.set(key, [...recent[i], now]);
+  }
+  /** how many budgets are tracked (idle ones are evicted by the sweep) */
+  budgetKeys() {
+    return this.spent.size;
+  }
+  /** the held messages, newest first, without bodies */
+  holds(state) {
+    const rows = state ? this.o.sql.all(`SELECT * FROM judge_holds WHERE state = ? ORDER BY created_at DESC, rowid DESC LIMIT 200`, state) : this.o.sql.all(`SELECT * FROM judge_holds ORDER BY created_at DESC, rowid DESC LIMIT 200`);
+    return rows.map((row) => this.view(row));
+  }
+  /** one hold with its body and the judge's redactions while it waits */
+  show(id) {
+    const row = this.row(id);
+    const params = JSON.parse(row.params);
+    const verdict = JSON.parse(row.verdict);
+    return { ...this.view(row), ...typeof params.body === "string" ? { body: params.body } : {}, redactions: verdict.redactions };
+  }
+  /** delivers a held message as its sender, as stored or redacted: scope, policy and limits are checked again by the send itself */
+  async release(id, options, deliver) {
+    const row = one(
+      this.o.sql,
+      `UPDATE judge_holds SET state = 'releasing' WHERE id = ? AND state = 'held' AND expires_at > ? RETURNING *`,
+      id,
+      this.o.now()
+    );
+    if (!row) throw new RelayError3("not_found", `no held message ${id}`);
+    const params = JSON.parse(row.params);
+    const verdict = JSON.parse(row.verdict);
+    let sent = params;
+    let redacted;
+    if (options.redacted) {
+      const applied = applyRedactions(params.body, verdict.redactions);
+      if (!applied.n) {
+        this.o.sql.all(`UPDATE judge_holds SET state = 'held' WHERE id = ?`, id);
+        throw new RelayError3("invalid_params", `hold ${id} has no redactions: release it as it is or refuse it`);
+      }
+      sent = { ...params, body: applied.text };
+      redacted = { n: applied.n, kinds: applied.kinds };
+    }
+    let result;
+    try {
+      result = await deliver(row.from_ep, sent, JSON.parse(row.origin));
+    } catch (error) {
+      this.o.sql.all(`UPDATE judge_holds SET state = 'held' WHERE id = ?`, id);
+      throw error;
+    }
+    this.remember(row.from_ep, params, { ...result, ...redacted ? { redacted } : {} });
+    this.resolve(row, "released", options.by);
+    this.o.core.auditJudge("judge_override", row.from_ep, id, {
+      ...this.storedDetail(row, verdict),
+      by: options.by,
+      action: redacted ? "release_redacted" : "release",
+      ...redacted ? { redacted } : {}
+    });
+    this.tell(
+      row.from_ep,
+      `relay: your message held for review as ${id} was released by your human${redacted ? " with redactions" : ""} and delivered as ${result.id}`
+    );
+    return { ...result, ...redacted ? { redacted } : {} };
+  }
+  /** refuses a held message: it is never delivered, and its sender hears the human's reason */
+  refuse(id, reason, by) {
+    this.expire(this.o.now());
+    const row = one(this.o.sql, `SELECT * FROM judge_holds WHERE id = ? AND state = 'held'`, id);
+    if (!row) throw new RelayError3("not_found", `no held message ${id}`);
+    const verdict = JSON.parse(row.verdict);
+    this.resolve(row, "refused", by);
+    this.o.core.auditJudge("judge_override", row.from_ep, id, { ...this.storedDetail(row, verdict), by, action: "refuse", reason });
+    this.tell(row.from_ep, `relay: your message held for review as ${id} was refused by your human: ${reason}`);
+    return this.view(this.row(id));
+  }
+  /** expires holds past their message TTL (body purged, sender told) and drops resolved ones past the audit window */
+  sweep() {
+    const now = this.o.now();
+    this.expire(now);
+    this.o.sql.all(`DELETE FROM judge_holds WHERE state IN ('released', 'refused', 'expired') AND resolved_at <= ?`, now - LIMITS.auditKeepS * 1e3);
+    this.o.sql.all(`DELETE FROM judge_sent WHERE created_at <= ?`, now - LIMITS.idempotencyS * 1e3);
+    for (const [key, times] of this.spent) if (!times.length || times[times.length - 1] <= now - 36e5) this.spent.delete(key);
+  }
+  expire(now) {
+    for (const row of this.o.sql.all(`SELECT * FROM judge_holds WHERE state = 'held' AND expires_at <= ?`, now)) {
+      const verdict = JSON.parse(row.verdict);
+      this.resolve(row, "expired", null);
+      this.o.core.auditJudge("judge_expire", row.from_ep, row.id, this.storedDetail(row, verdict));
+      this.tell(row.from_ep, `relay: your message held for review as ${row.id} expired without review and was not delivered`);
+    }
+  }
+  /** the recipients by the boundary their message crosses; throws as send does for a target the sender cannot reach */
+  boundaries(policy, from, params, origin) {
+    const { sender, recipients, tree } = this.o.core.judgeSubjects(from, params, origin);
+    const groups = /* @__PURE__ */ new Map();
+    for (const recipient of recipients) {
+      const label = judgeBoundary(policy, sender, recipient);
+      if (label !== null) groups.set(label, [...groups.get(label) ?? [], recipient.address]);
+    }
+    return { groups, tree };
+  }
+  async judge(policy, from, body, groups) {
+    const verdicts = await Promise.all(
+      [...groups].map(
+        ([boundary, to]) => runJudge({
+          body,
+          side: "local",
+          boundary,
+          configVersion: this.version,
+          client: this.client,
+          cache: this.cache,
+          timeoutMs: policy.timeout_s * 1e3,
+          failMode: policy.fail,
+          ...this.client && policy.model ? { model: policy.model.id } : {},
+          from: this.o.core.addressOf(from),
+          to,
+          now: this.o.now,
+          stats: this.stats
+        })
+      )
+    );
+    return mergeVerdicts(verdicts);
+  }
+  shadow(policy, from, params, origin, ref) {
+    const task = (async () => {
+      try {
+        const { groups, tree } = this.boundaries(policy, from, params, origin);
+        if (!groups.size) return;
+        this.spend(policy, from, tree);
+        const body = params.body;
+        const verdict = await this.judge(policy, from, body, groups);
+        this.o.core.auditJudge("judge_shadow", from, ref, this.detail(verdict, body, groups));
+      } catch (error) {
+        this.o.log(`relay broker: a shadow judgement failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    })();
+    this.shadows.add(task);
+    void task.finally(() => this.shadows.delete(task));
+  }
+  hold(from, params, origin, verdict, groups, detail) {
+    const now = this.o.now();
+    const id = newId2("hold", now);
+    const stored = { ...params, client_id: params.client_id ?? id };
+    const to = [...groups.values()].flat();
+    const record = { ...verdict, boundary: [...groups.keys()].join(" | "), to };
+    this.o.sql.all(
+      `INSERT INTO judge_holds (id, from_ep, params, origin, verdict, created_at, expires_at, state) VALUES (?, ?, ?, ?, ?, ?, ?, 'held')`,
+      id,
+      from,
+      JSON.stringify(stored),
+      JSON.stringify(origin),
+      JSON.stringify(record),
+      now,
+      now + (params.ttl_s ?? LIMITS.ttlDefaultS) * 1e3
+    );
+    this.o.core.auditJudge("judge_hold", from, id, detail);
+    return heldResult(id, params);
+  }
+  detail(verdict, body, groups) {
+    return {
+      side: "local",
+      boundary: [...groups.keys()].join(" | "),
+      prompt_version: verdict.prompt_version,
+      categories: verdict.categories,
+      sha256: sha256Hex(body),
+      verdict: verdict.verdict,
+      source: verdict.source,
+      reason: verdict.reason,
+      to: [...groups.values()].flat(),
+      ...verdict.model ? { model: verdict.model } : {},
+      ...verdict.ms !== void 0 ? { ms: verdict.ms } : {}
+    };
+  }
+  storedDetail(row, verdict) {
+    const params = JSON.parse(row.params);
+    return {
+      side: "local",
+      boundary: verdict.boundary,
+      prompt_version: verdict.prompt_version,
+      categories: verdict.categories,
+      sha256: params.sha256 ?? sha256Hex(params.body ?? ""),
+      verdict: verdict.verdict,
+      to: verdict.to,
+      ...verdict.model ? { model: verdict.model } : {}
+    };
+  }
+  /** marks a hold resolved and purges its body and the judge's quotes of it */
+  resolve(row, state, by) {
+    const { body, ...params } = JSON.parse(row.params);
+    const verdict = JSON.parse(row.verdict);
+    const purged = { ...params, bytes: new TextEncoder().encode(body).length, sha256: sha256Hex(body) };
+    const kinds = { ...verdict, redactions: verdict.redactions.map((r) => ({ kind: r.kind })) };
+    this.o.sql.all(
+      `UPDATE judge_holds SET state = ?, by = ?, resolved_at = ?, params = ?, verdict = ? WHERE id = ?`,
+      state,
+      by,
+      this.o.now(),
+      JSON.stringify(purged),
+      JSON.stringify(kinds),
+      row.id
+    );
+  }
+  tell(endpoint, text) {
+    try {
+      this.o.core.judgeNotice(endpoint, text);
+      this.o.wake(endpoint);
+    } catch (error) {
+      if (!(error instanceof RelayError3)) throw error;
+    }
+  }
+  row(id) {
+    const row = one(this.o.sql, `SELECT * FROM judge_holds WHERE id = ?`, id);
+    if (!row) throw new RelayError3("not_found", `no held message ${id}`);
+    return row;
+  }
+  view(row) {
+    const params = JSON.parse(row.params);
+    const verdict = JSON.parse(row.verdict);
+    return {
+      id: row.id,
+      from: this.o.core.addressOf(row.from_ep),
+      to: verdict.to,
+      state: row.state,
+      created_at: iso(row.created_at),
+      expires_at: iso(row.expires_at),
+      categories: verdict.categories,
+      reason: verdict.reason,
+      boundary: verdict.boundary,
+      source: verdict.source,
+      bytes: params.bytes ?? new TextEncoder().encode(params.body ?? "").length,
+      by: row.by,
+      resolved_at: iso(row.resolved_at)
+    };
+  }
+};
+var fingerprint = (p) => sha256Hex(
+  JSON.stringify([
+    [p.to].flat().map(String).sort(),
+    p.body,
+    p.kind ?? "message",
+    p.thread ?? null,
+    p.reply_to ?? null,
+    p.data_class ?? "public",
+    (p.attachments ?? []).map((a) => a?.path).sort(),
+    p.mime ?? null,
+    p.ttl_s ?? LIMITS.ttlDefaultS,
+    p.require_reply ?? null
+  ])
+);
+function heldResult(id, params) {
+  return { id, thread: params.thread ?? "", hop: 0, deliveries: [], held: { hold_id: id, side: "local" } };
+}
+
+// src/sqlite.ts
+import { createRequire } from "module";
+var STATEMENT_CACHE = 512;
+var load = createRequire(import.meta.url);
+function bunDriver(path) {
+  const { Database } = load("bun:sqlite");
+  const db = new Database(path, { create: true });
+  return {
+    exec: (statement) => void db.run(statement),
+    all: (query, params) => db.query(query).all(...params),
+    close: () => db.close()
+  };
+}
+function nodeDriver(path) {
+  const { DatabaseSync } = load("node:sqlite");
+  const db = new DatabaseSync(path);
+  const statements = /* @__PURE__ */ new Map();
+  return {
+    exec: (statement) => db.exec(statement),
+    all: (query, params) => {
+      let statement = statements.get(query);
+      if (!statement) {
+        if (statements.size >= STATEMENT_CACHE) statements.clear();
+        statement = db.prepare(query);
+        statements.set(query, statement);
+      }
+      return statement.all(...params);
+    },
+    close: () => db.close()
+  };
+}
+function openDatabase(path) {
+  const driver = typeof process.versions.bun === "string" ? bunDriver(path) : nodeDriver(path);
+  let depth = 0;
+  return {
+    exec: (statement) => driver.exec(statement),
+    all: (query, ...params) => driver.all(query, params),
+    close: () => driver.close(),
+    transaction(fn) {
+      const savepoint = depth ? `tx_${depth}` : void 0;
+      driver.exec(savepoint ? `SAVEPOINT ${savepoint}` : "BEGIN IMMEDIATE");
+      depth++;
+      let result;
+      try {
+        result = fn();
+      } catch (error) {
+        depth--;
+        try {
+          if (savepoint) {
+            driver.exec(`ROLLBACK TO ${savepoint}`);
+            driver.exec(`RELEASE ${savepoint}`);
+          } else driver.exec("ROLLBACK");
+        } catch {
+        }
+        throw error;
+      }
+      depth--;
+      try {
+        driver.exec(savepoint ? `RELEASE ${savepoint}` : "COMMIT");
+      } catch (error) {
+        if (!savepoint)
+          try {
+            driver.exec("ROLLBACK");
+          } catch {
+          }
+        throw error;
+      }
+      return result;
+    }
+  };
+}
+
+// src/server.ts
+var SWEEP_MS = 10 * 6e4;
+var PRESENCE_MS = 6e4;
+var OBSERVER_METHODS = /* @__PURE__ */ new Set(["list", "snapshot", "watch", "log", "policy", "policy_check", "cloud_status"]);
+var SCOPE_METHODS = /* @__PURE__ */ new Set([
+  "rules",
+  "rules_set",
+  "rules_widen",
+  "rules_lift",
+  "grant",
+  "group",
+  "admin",
+  "peers",
+  "why",
+  "spawn_exit",
+  "spawn_steers",
+  "peek",
+  "peek_set",
+  "peek_who"
+]);
+var CHANGES_SCOPE = /* @__PURE__ */ new Set(["rules_set", "rules_widen", "rules_lift", "group"]);
+var ASK_RECHECK_MS = 1e3;
+var STOP_RECHECK_MS = 1e3;
+var TRANSIENT_METHODS = /* @__PURE__ */ new Set(["event", "status", "whoami", "inject", "injected", "peek_turn", "stop_wait", "prompted"]);
+var GRANT_UNBOUND = `a spawn-env grant binds only a new harness process: run the harness with it, or name the child (${CLI_NAME} spawn-env --name / --as)`;
+function workerResults(result) {
+  return result.messages.length - (result.others_shown ?? 0) + result.more;
+}
+function othersRunning(result) {
+  const senders = new Set(result.messages.slice(0, result.messages.length - (result.others_shown ?? 0)).map((m) => m.from.address));
+  return result.workers.filter((address) => !senders.has(address)).length + result.starting;
+}
+function running(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function hookOf(s) {
+  return { transient: s.data.transient === true, ...s.data.process ? { process: s.data.process } : {} };
+}
+async function startBroker(options) {
+  const dir = privateDir(options.dir);
+  const lock = takeBrokerLock(join3(dir, "broker.lock"));
+  const socket = socketPath(dir);
+  const connections = /* @__PURE__ */ new Set();
+  const waiters = /* @__PURE__ */ new Map();
+  const policyFile = options.policyPath ?? policyPath();
+  if (!options.policyPath && !accountHomeVerified())
+    (options.log ?? console.error)(`relay broker: the user database has no home for this account; the policy path ${policyFile} comes from HOME`);
+  let policyText;
+  let policyError = null;
+  const outboundCap = options.outboundCapBytes ?? 4 * 1024 * 1024;
+  const maxPending = options.maxPending ?? 32;
+  const partialLineMs = options.partialLineMs ?? 3e4;
+  const log = options.log ?? ((line) => console.error(line));
+  const idleMs = options.idleMs ?? 30 * 6e4;
+  let idleTimer;
+  let pending = 0;
+  let closing = false;
+  let stopping;
+  let resolveStopped;
+  const stopped = new Promise((resolve) => resolveStopped = resolve);
+  const previousUmask = process.umask(63);
+  let db;
+  let core;
+  let judge;
+  let bridge = null;
+  let listener;
+  try {
+    privateDir(dirname2(socket));
+    db = openDatabase(join3(dir, "relay.db"));
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA busy_timeout = 5000");
+    chmodSync2(join3(dir, "relay.db"), 384);
+    const sql = db;
+    const machine = options.machine ?? options.bridge?.machine;
+    core = new FederatedCore(sql, {
+      ...compact({ user: options.user, machine, now: options.now }),
+      hostname: shortHostname(),
+      hash: (value) => createHash2("sha256").update(value).digest("hex"),
+      transaction: (fn) => db.transaction(fn),
+      alive: running
+    });
+    core.migrate();
+    core.resetConnections();
+    core.sweep();
+    judge = new JudgeGate({ sql, core, now: options.now ?? Date.now, env: options.env ?? process.env, client: options.judgeClient, log, wake });
+    judge.sweep();
+    if (existsSync2(socket)) unlinkSync2(socket);
+    listener = createServer((raw) => {
+      const s = new Conn(
+        raw,
+        {
+          reader: new LineReader(MAX_LINE),
+          writer: new LineWriter(),
+          observer: false,
+          watching: false,
+          closed: false,
+          inFlight: 0,
+          queue: [],
+          queueHead: 0
+        },
+        { data: onData, drain: flush, close: (s2) => onClose(s2) }
+      );
+      if (closing) {
+        s.end();
+        return;
+      }
+      connections.add(s);
+      activity();
+    });
+    await new Promise((resolve, reject) => {
+      listener.once("error", reject);
+      listener.listen(socket, () => {
+        listener.off("error", reject);
+        resolve();
+      });
+    });
+    listener.on("error", (error) => log(`relay broker: the socket listener failed: ${error.message}`));
+    chmodSync2(socket, 384);
+  } catch (error) {
+    listener?.close();
+    db?.close();
+    releaseBrokerLock(lock);
+    throw error;
+  } finally {
+    process.umask(previousUmask);
+  }
+  const sweeper = setInterval(() => {
+    core.sweep();
+    judge.sweep();
+  }, SWEEP_MS);
+  const known = /* @__PURE__ */ new Map();
+  for (const view of localViews()) known.set(view.id, view.presence);
+  const presenceTimer = setInterval(() => {
+    const live = /* @__PURE__ */ new Set();
+    for (const view of localViews()) {
+      live.add(view.id);
+      if ((known.get(view.id) ?? "offline") !== view.presence) presenceChanged(view);
+    }
+    for (const id of known.keys()) if (!live.has(id)) known.delete(id);
+  }, options.presenceEveryMs ?? PRESENCE_MS);
+  if (options.bridge) {
+    bridge = startBridge({
+      ...options.bridge,
+      core,
+      onRemote: {
+        wake,
+        fleet: notifyFleet,
+        policyError: () => {
+          loadPolicy();
+          return policyError;
+        },
+        log
+      }
+    });
+  }
+  function activity() {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = void 0;
+    if (!closing && idleMs > 0 && connections.size === 0 && pending === 0) idleTimer = setTimeout(() => void stop(), idleMs);
+  }
+  function loadPolicy() {
+    let text;
+    try {
+      text = readFileSync5(policyFile, "utf8");
+    } catch (error) {
+      const code = error.code;
+      const dangling = code === "ENOENT" && lstatSync2(policyFile, { throwIfNoEntry: false }) !== void 0;
+      if (code !== "ENOENT" || dangling) {
+        policyText = void 0;
+        policyError = dangling ? `the relay policy at ${policyFile} is a link to a missing file; messages are refused until it is fixed` : `the relay policy at ${policyFile} cannot be read (${code ?? String(error)}); messages are refused until it is fixed`;
+        return;
+      }
+      text = null;
+    }
+    if (text === policyText) return;
+    policyText = text;
+    if (text === null) {
+      core.setPolicy(null);
+      judge.configure(void 0);
+      policyError = null;
+      bridge?.resync();
+      return;
+    }
+    try {
+      const policy = parsePolicy(JSON.parse(text));
+      core.setPolicy(policy);
+      judge.configure(policy.judge);
+      policyError = null;
+      bridge?.resync();
+    } catch (error) {
+      policyError = `the relay policy at ${policyFile} is invalid (${error instanceof Error ? error.message : String(error)}); messages are refused until it is fixed`;
+    }
+  }
+  function policyInfo() {
+    loadPolicy();
+    if (policyError) return { file: policyFile, state: "error", error: policyError };
+    return { file: policyFile, state: policyText === null ? "open" : "loaded" };
+  }
+  function brokerInfo() {
+    return { socket, dir, pid: process.pid, policy: policyInfo() };
+  }
+  function write(s, value) {
+    if (s.data.closed) return;
+    const line = encodeLine(value);
+    const queued = unread(s);
+    if (queued > 0 && queued + line.length > outboundCap) {
+      log(`relay broker: ended a connection with ${queued} bytes it did not read and a ${line.length} byte response`);
+      onClose(s);
+      s.end();
+      return;
+    }
+    s.data.writer.pushBytes(line);
+    flush(s);
+  }
+  function unread(s) {
+    return s.data.writer.pending + s.unsent;
+  }
+  function flush(s) {
+    if (!s.data.closed) s.data.writer.flush((bytes) => s.write(bytes));
+  }
+  function localViews() {
+    return core.list({ all: true }).filter((view) => core.machineOf(view.id) === null);
+  }
+  function presenceChanged(view) {
+    known.set(view.id, view.presence);
+    notifyFleet({ type: "presence", endpoint: view.address, presence: view.presence, harness: view.harness, labels: view.labels });
+    bridge?.changed(view.id);
+  }
+  function notifyFleet(event) {
+    const at = new Date((options.now ?? Date.now)()).toISOString();
+    let line;
+    const views = /* @__PURE__ */ new Map();
+    for (const s of connections) {
+      if (!s.data.watching || s.data.closed) continue;
+      const viewer = viewerOf(s);
+      let bytes;
+      if (viewer === void 0) bytes = line ??= encodeLine({ jsonrpc: "2.0", method: "fleet", params: { at, ...event } });
+      else {
+        let seen = views.get(viewer);
+        if (!seen) {
+          seen = core.visibleTo(viewer);
+          views.set(viewer, seen);
+        }
+        const shown = filterEvent(event, seen);
+        if (!shown) continue;
+        bytes = encodeLine({ jsonrpc: "2.0", method: "fleet", params: { at, ...shown } });
+      }
+      const queued = unread(s);
+      if (queued + bytes.length > outboundCap) {
+        s.data.watching = false;
+        s.data.writer.push({ jsonrpc: "2.0", method: "fleet", params: { at, type: "lagged", queued_bytes: queued } });
+      } else {
+        s.data.writer.pushBytes(bytes);
+      }
+      flush(s);
+    }
+  }
+  function filterEvent(event, seen) {
+    if (event.type === "message") {
+      const to = event.to.filter((address) => seen.has(address));
+      return seen.has(String(event.from)) && to.length ? { ...event, to } : null;
+    }
+    return typeof event.endpoint !== "string" || seen.has(event.endpoint) ? event : null;
+  }
+  function atTerminal(s) {
+    return s.data.human === true && s.data.tty === true;
+  }
+  function viewerOf(s) {
+    if (s.data.lineage) return s.data.lineage;
+    if (s.data.observer || s.data.human) return atTerminal(s) ? void 0 : core.humanId();
+    return s.data.endpoint;
+  }
+  function actorOf(s) {
+    if (s.data.lineage) return { kind: "endpoint", id: s.data.lineage, auth: s.data.own ? "self" : "lineage" };
+    if (s.data.observer || s.data.human) return { kind: "human", tty: atTerminal(s) };
+    return { kind: "endpoint", id: s.data.endpoint, auth: "session" };
+  }
+  function bindLineage(s, endpoint, params, own = false) {
+    s.data.endpoint = endpoint;
+    s.data.lineage = endpoint;
+    s.data.own = own;
+    s.data.brief = true;
+    s.data.cwd = typeof params.cwd === "string" ? params.cwd : void 0;
+    return {
+      endpoint: core.whoami(endpoint),
+      capabilities: BROKER_CAPABILITIES,
+      server_time: (/* @__PURE__ */ new Date()).toISOString(),
+      limits: LIMITS2,
+      preamble: PREAMBLE,
+      broker: brokerInfo()
+    };
+  }
+  function wake(endpoint) {
+    const set = waiters.get(endpoint);
+    if (!set) return;
+    waiters.delete(endpoint);
+    for (const fn of set) fn();
+  }
+  function waitFor(endpoint, ms, s) {
+    return new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(timer);
+        waiters.get(endpoint)?.delete(done);
+        resolve();
+      };
+      const timer = setTimeout(done, ms);
+      let set = waiters.get(endpoint);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        waiters.set(endpoint, set);
+      }
+      set.add(done);
+      if (s.data.closed) done();
+    });
+  }
+  async function gather(me, result, peek, s) {
+    const gathering = (r) => workerResults(r) > 0 && !r.more && !r.prompted && othersRunning(r) > 0;
+    const cap = Date.now() + LIMITS2.pushGraceS * 1e3;
+    let quiet = Date.now() + LIMITS2.pushQuietS * 1e3;
+    let results = workerResults(result);
+    while (gathering(result) && !s.data.closed && Date.now() < Math.min(quiet, cap)) {
+      await waitFor(me, Math.min(quiet, cap) - Date.now(), s);
+      if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+      result = core.stopWait(me, peek);
+      if (workerResults(result) > results) {
+        results = workerResults(result);
+        quiet = Date.now() + LIMITS2.pushQuietS * 1e3;
+      }
+    }
+  }
+  function onData(s, chunk) {
+    const { lines, tooLong } = s.data.reader.push(chunk);
+    for (const line of lines) s.data.queue.push(line);
+    pump(s);
+    if (tooLong) {
+      write(s, { jsonrpc: "2.0", id: null, error: { code: -32600, message: "request too large", data: { code: "too_large" } } });
+      s.end();
+      return;
+    }
+    if (!s.data.reader.buffered || lines.length) {
+      clearTimeout(s.data.lineTimer);
+      s.data.lineTimer = void 0;
+    }
+    if (s.data.reader.buffered && !s.data.lineTimer) armLineTimer(s);
+  }
+  function armLineTimer(s) {
+    if (partialLineMs <= 0) return;
+    s.data.lineTimer = setTimeout(() => {
+      s.data.lineTimer = void 0;
+      if (s.data.closed || !s.data.reader.buffered) return;
+      if (s.data.queueHead < s.data.queue.length) return armLineTimer(s);
+      write(s, { jsonrpc: "2.0", id: null, error: { code: -32600, message: "the request line was not finished in time", data: { code: "invalid_params" } } });
+      s.end();
+    }, partialLineMs);
+  }
+  function onClose(s) {
+    if (s.data.closed) return;
+    s.data.closed = true;
+    clearTimeout(s.data.lineTimer);
+    connections.delete(s);
+    if (s.data.endpoint && !closing && !s.data.transient && !s.data.lineage) {
+      const before = core.whoami(s.data.endpoint).presence;
+      const settled = core.disconnect(s.data.endpoint, { settle: !s.data.brief });
+      wake(s.data.endpoint);
+      const view = core.whoami(s.data.endpoint);
+      known.set(s.data.endpoint, view.presence);
+      if (!s.data.brief && view.presence !== before) notifyFleet({ type: "presence", endpoint: view.address, presence: view.presence });
+      if (settled) notifyFleet({ type: "status", endpoint: view.address, status: null });
+      if (!s.data.brief || view.presence !== before || settled) bridge?.changed(s.data.endpoint);
+    }
+    activity();
+  }
+  function pump(s) {
+    const data = s.data;
+    while (data.queueHead < data.queue.length && data.inFlight < maxPending && !data.closed) void handleLine(s, data.queue[data.queueHead++]);
+    if (data.queueHead === data.queue.length) {
+      data.queue = [];
+      data.queueHead = 0;
+      if (!data.closed) s.resume();
+    } else if (!data.closed) {
+      s.pause();
+    }
+  }
+  async function handleLine(s, line) {
+    s.data.inFlight++;
+    try {
+      await answer(s, line);
+    } catch (error) {
+      log(`relay broker: a request failed outside its handler: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+    } finally {
+      s.data.inFlight--;
+      pump(s);
+    }
+  }
+  function invalidRequest(s, id, message) {
+    write(s, { jsonrpc: "2.0", id, error: { code: -32600, message, data: { code: "invalid_params" } } });
+  }
+  async function answer(s, line) {
+    if (closing) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      write(s, { jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+      return;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return invalidRequest(s, null, "a request is a JSON object");
+    const request = parsed;
+    const hasId = "id" in request;
+    const id = request.id ?? null;
+    if (id !== null && typeof id !== "string" && typeof id !== "number") return invalidRequest(s, null, "a request id is a string or a number");
+    if (typeof request.method !== "string") return invalidRequest(s, id, "a request needs a method");
+    const params = request.params ?? {};
+    if (typeof params !== "object" || params === null || Array.isArray(params)) return invalidRequest(s, id, "params is an object");
+    pending++;
+    try {
+      const result = await dispatch(s, request.method, params);
+      if (hasId) write(s, { jsonrpc: "2.0", id, result });
+    } catch (error) {
+      if (!hasId || closing) return;
+      if (error instanceof RelayError4) {
+        const code = error.code === "method_not_found" ? -32601 : error.code === "invalid_params" ? -32602 : -32e3;
+        write(s, {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code,
+            message: error.message,
+            data: { ...error.detail, code: error.code, ...error.retryAfterS ? { retry_after: error.retryAfterS } : {} }
+          }
+        });
+      } else {
+        log(`relay broker: ${request.method} failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+        write(s, { jsonrpc: "2.0", id, error: { code: -32603, message: "internal error" } });
+      }
+    } finally {
+      pending--;
+      activity();
+    }
+  }
+  function endpointOf(s) {
+    if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+    if (!s.data.endpoint)
+      throw new RelayError4("unauthorized", s.data.observer ? "this connection only observes: say hello as an agent or the human" : "call hello first");
+    core.touch(s.data.endpoint);
+    return s.data.endpoint;
+  }
+  function waitSeconds(value) {
+    if (value === void 0) return 0;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new RelayError4("invalid_params", "wait_s must be a number of seconds");
+    return Math.min(value, LIMITS2.waitMaxS) * 1e3;
+  }
+  function checkAttachments(attachments, s) {
+    if (attachments === void 0) return void 0;
+    if (!Array.isArray(attachments)) throw new RelayError4("invalid_params", "attachments must be a list");
+    const tooWide = /* @__PURE__ */ new Set(["/", realOrSelf(homedir2()), realOrSelf(accountHome())]);
+    const roots = [s.data.cwd, ...options.roots ?? []].filter((r) => typeof r === "string" && isAbsolute(r)).map(realOrSelf).filter((r) => !tooWide.has(r));
+    return attachments.map((attachment) => {
+      if (attachment?.kind !== "path" || typeof attachment.path !== "string" || !isAbsolute(attachment.path)) {
+        throw new RelayError4("invalid_params", "an attachment is {kind: path, path: an absolute path}");
+      }
+      let real;
+      try {
+        real = realpathSync(attachment.path);
+      } catch {
+        throw new RelayError4("not_found", `no file at ${attachment.path}`);
+      }
+      if (!roots.some((root) => real === root || real.startsWith(root.endsWith(sep) ? root : root + sep))) {
+        throw new RelayError4("invalid_params", `${attachment.path} is outside the sender's working directory and the relay's allowed roots`);
+      }
+      return { kind: "path", path: real };
+    });
+  }
+  async function dispatch(s, method, params) {
+    if (method === "hello") {
+      if (s.data.endpoint || s.data.observer) throw new RelayError4("invalid_params", "hello was already called on this connection");
+      if (params.protocol !== PROTOCOL3) throw new RelayError4("invalid_params", `this broker speaks ${PROTOCOL3}`);
+      if (params.transient === true) {
+        if (params.human === true || params.observe === true || params.resume !== void 0) {
+          throw new RelayError4("invalid_params", "a hook connection claims an agent endpoint: transient does not go with human, observe or resume");
+        }
+        const before2 = new Map(core.list({ all: true }).map((view) => [view.id, view.presence]));
+        const { endpoint: endpoint2, subagent, created } = core.claim(params.claim ?? {}, { transient: true });
+        s.data.endpoint = endpoint2.id;
+        s.data.transient = true;
+        const key = params.claim?.process;
+        if (typeof key === "string") s.data.process = key;
+        if ((before2.get(endpoint2.id) ?? "offline") !== endpoint2.presence) presenceChanged(endpoint2);
+        return {
+          endpoint: endpoint2,
+          ...subagent ? { subagent, ...created ? { created } : {} } : {},
+          capabilities: BROKER_CAPABILITIES,
+          server_time: (/* @__PURE__ */ new Date()).toISOString(),
+          limits: LIMITS2,
+          preamble: PREAMBLE,
+          broker: brokerInfo()
+        };
+      }
+      if (params.observe === true) {
+        const self = params.self === void 0 ? null : core.placeLineage(params.self);
+        if (params.grant !== void 0) {
+          if (!core.grantBinds(params.grant, self)) throw new RelayError4("unauthorized", GRANT_UNBOUND);
+          return { ...bindLineage(s, self, params, true), grant_bound: true };
+        }
+        if (self) return bindLineage(s, self, params, true);
+        s.data.observer = true;
+        if (params.lineage !== void 0) s.data.lineage = core.placeLineage(params.lineage) ?? void 0;
+        return {
+          endpoint: null,
+          capabilities: BROKER_CAPABILITIES,
+          server_time: (/* @__PURE__ */ new Date()).toISOString(),
+          limits: LIMITS2,
+          preamble: PREAMBLE,
+          broker: brokerInfo()
+        };
+      }
+      const claim = params.claim;
+      if (params.human === true && params.resume === void 0 && params.lineage !== void 0) {
+        const placed = core.placeLineage(params.lineage);
+        if (placed) return bindLineage(s, placed, params);
+      } else if (params.human !== true && params.resume === void 0 && claim?.process === void 0 && typeof claim?.handle === "string") {
+        const placed = claim.lineage === void 0 ? null : core.placeLineage(claim.lineage, claim.handle);
+        if (placed && (claim.grant === void 0 || core.grantBinds(claim.grant, placed))) {
+          return bindLineage(s, placed, { cwd: claim.cwd, ...params }, params.self !== void 0 && core.placeLineage(params.self, claim.handle) === placed);
+        }
+      }
+      let token;
+      let endpoint;
+      const before = new Map(core.list({ all: true }).map((view) => [view.id, view]));
+      if (typeof params.resume === "string") endpoint = core.resume(params.resume);
+      else if (params.human === true) {
+        s.data.tty = params.tty === true;
+        endpoint = core.claimHuman(s.data.tty);
+      } else {
+        const claimed = core.claim(params.claim ?? {}, { self: params.self });
+        endpoint = claimed.endpoint;
+        token = claimed.token;
+      }
+      s.data.endpoint = endpoint.id;
+      s.data.human = endpoint.kind === "human";
+      s.data.brief = params.brief === true;
+      s.data.cwd = typeof params.cwd === "string" ? params.cwd : endpoint.cwd ?? void 0;
+      known.set(endpoint.id, endpoint.presence);
+      const was = before.get(endpoint.id);
+      const moved = (was?.presence ?? "offline") !== endpoint.presence || was !== void 0 && was.address !== endpoint.address;
+      if (!s.data.brief && moved) {
+        notifyFleet({ type: "presence", endpoint: endpoint.address, presence: endpoint.presence, harness: endpoint.harness, labels: endpoint.labels });
+      }
+      if (!s.data.brief || moved) bridge?.changed(endpoint.id);
+      return {
+        endpoint,
+        ...token ? { token } : {},
+        capabilities: BROKER_CAPABILITIES,
+        server_time: (/* @__PURE__ */ new Date()).toISOString(),
+        limits: LIMITS2,
+        preamble: PREAMBLE,
+        broker: brokerInfo()
+      };
+    }
+    if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+    if (s.data.observer && OBSERVER_METHODS.has(method)) return observe(s, method, params);
+    if (s.data.observer && SCOPE_METHODS.has(method) && (s.data.lineage || method === "why")) return scope(s, method, params);
+    if (s.data.transient && SCOPE_METHODS.has(method)) throw new RelayError4("scope_refused", "a hook connection cannot read or change scopes, groups or grants");
+    const me = endpointOf(s);
+    if (s.data.transient && !TRANSIENT_METHODS.has(method)) throw new RelayError4("unauthorized", "a hook connection only posts activity and status");
+    if (OBSERVER_METHODS.has(method)) return observe(s, method, params);
+    if (SCOPE_METHODS.has(method)) return scope(s, method, params);
+    switch (method) {
+      case "whoami":
+        return s.data.transient ? core.whoami(me) : { ...core.whoami(me), ...core.peekState(me) };
+      case "peek_turn":
+        if (!s.data.transient || !core.hookOwns(me, s.data.process))
+          throw new RelayError4("unauthorized", "only a hook of the endpoint's own harness process posts digest turns");
+        return core.peekTurn(me, { role: params.role, text: params.text });
+      case "send":
+      case "ask": {
+        for (const field of SERVER_FIELDS) if (field in params) throw new RelayError4("invalid_params", `${field} is set by the relay, not the sender`);
+        loadPolicy();
+        if (policyError) throw new RelayError4("policy_refused", policyError);
+        const attachments = checkAttachments(params.attachments, s);
+        const send = { ...params, ...attachments ? { attachments } : {} };
+        if (method === "ask") send.kind = "request";
+        const origin = s.data.tty === void 0 ? {} : { tty: s.data.tty, ...atTerminal(s) ? {} : { unverified: true } };
+        const result = await judge.send(me, send, origin, deliver);
+        if (method === "send" || result.held) return result;
+        return awaitReply(s, me, result.id, waitSeconds(params.wait_s), result);
+      }
+      case "holds":
+        return { holds: judge.holds(optional(reviewer(s, params), "state")) };
+      case "hold_show":
+        return judge.show(required(reviewer(s, params), "id"));
+      case "hold_release": {
+        const id = required(reviewer(s, params), "id");
+        loadPolicy();
+        if (policyError) throw new RelayError4("policy_refused", policyError);
+        return judge.release(id, { redacted: params.redacted === true, by: core.addressOf(me) }, deliver);
+      }
+      case "hold_refuse": {
+        const reason = required(reviewer(s, params), "reason");
+        if (reason.length > LIMITS2.noteChars) throw new RelayError4("invalid_params", `reason takes at most ${LIMITS2.noteChars} characters`);
+        return judge.refuse(required(params, "id"), stripControl(reason), core.addressOf(me));
+      }
+      case "ask_wait": {
+        if (typeof params.id !== "string") throw new RelayError4("invalid_params", "id is the request's message id");
+        return awaitReply(s, me, params.id, waitSeconds(params.wait_s));
+      }
+      case "inbox": {
+        const query = compact({ after: params.after, limit: params.limit });
+        const read = () => params.offer === true ? core.offer(me, query) : { messages: core.inbox(me, query) };
+        const deadline = Date.now() + waitSeconds(params.wait_s);
+        let page = read();
+        while (!page.messages.length && !s.data.closed && Date.now() < deadline) {
+          await waitFor(me, deadline - Date.now(), s);
+          if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+          page = read();
+        }
+        const { messages } = page;
+        return { ...page, next: messages.length ? messages[messages.length - 1].seq : query.after ?? 0 };
+      }
+      case "ack":
+        return { acked: core.ack(me, params.seqs) };
+      case "title": {
+        const view = core.title(me, params.text);
+        bridge?.changed(me);
+        return view;
+      }
+      case "status": {
+        core.status(me, params.state, params.note);
+        const view = core.whoami(me);
+        notifyFleet({ type: "status", endpoint: view.address, status: view.status });
+        bridge?.changed(me);
+        return view;
+      }
+      case "event": {
+        const row = core.event(me, params, hookOf(s));
+        notifyFleet({ type: "activity", ...row });
+        bridge?.activity(me, row);
+        const after = core.whoami(me);
+        if ((known.get(me) ?? "offline") !== after.presence) presenceChanged(after);
+        return row;
+      }
+      case "inject":
+        return core.inject(me, {
+          stop: params.stop === true,
+          count: params.count === true,
+          holdUnread: params.hold_unread === true,
+          directives: params.directives === true,
+          ...hookOf(s)
+        });
+      case "stop_wait": {
+        const waitMs = waitSeconds(params.wait_s);
+        const deadline = Date.now() + waitMs;
+        const options2 = { ...hookOf(s), ...typeof params.prompts === "number" ? { prompts: params.prompts } : {} };
+        const peek = { ...options2, peek: true };
+        let result = core.stopWait(me, peek);
+        const idle = (r) => !r.messages.length && !r.more && r.workers.length + r.starting > 0 && r.pushes_left > 0 && !r.prompted;
+        while (idle(result) && !s.data.closed && Date.now() < deadline) {
+          await waitFor(me, Math.min(STOP_RECHECK_MS, deadline - Date.now()), s);
+          if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+          result = core.stopWait(me, peek);
+        }
+        if (waitMs > 0) await gather(me, result, peek, s);
+        return core.stopWait(me, options2);
+      }
+      case "prompted": {
+        const prompted = core.prompted(me, hookOf(s));
+        if (prompted) wake(me);
+        return { prompted };
+      }
+      case "injected":
+        return {
+          injected: core.injected(params.seqs, params.hold, { endpoint: me, read: params.read, deferred: params.deferred === true }),
+          ...params.stop === true ? { held: core.stopHeld(me, hookOf(s)) } : {},
+          ...params.push === true ? { pushed: core.pushed(me, params.read, hookOf(s)) } : {},
+          ...params.nudged !== void 0 ? { nudged: core.nudged(me, params.nudged, hookOf(s)) } : {},
+          ...params.restated !== void 0 ? { restated: core.restated(me, params.restated, params.read, hookOf(s)) } : {},
+          ...params.preamble === true ? { briefed: core.briefed(me, hookOf(s)) } : {},
+          ...params.intro === true ? { introduced: core.introduced(me, hookOf(s)) } : {}
+        };
+      case "message":
+        return { message: core.delivered(me, params.id) ?? (params.member === true ? core.threadMessage(me, params.id) : null) };
+      case "receipts":
+        return core.receipts(me, params.id);
+    }
+    throw new RelayError4("method_not_found", `no method ${method}`);
+  }
+  const deliver = async (from, send, origin) => {
+    let result;
+    if (remoteSend(core, send.to)) {
+      if (!bridge)
+        throw new RelayError4("not_found", `no endpoint ${[send.to].flat().join(", ")}: this broker is not linked to a hub (${CLI_NAME} cloud enable)`);
+      result = await bridge.forward(from, send, origin);
+    } else {
+      result = core.send(from, send, origin);
+    }
+    if (!result.duplicate) {
+      for (const delivery of result.deliveries) wake(delivery.endpoint);
+      notifyFleet({
+        type: "message",
+        id: result.id,
+        thread: result.thread,
+        kind: send.kind ?? "message",
+        from: core.addressOf(from),
+        to: result.deliveries.map((d) => d.address),
+        hop: result.hop
+      });
+    }
+    return result;
+  };
+  function reviewer(s, params) {
+    if (!atTerminal(s)) throw new RelayError4("unauthorized", "only your human at a terminal reviews held messages");
+    return params;
+  }
+  function observe(s, method, params) {
+    const viewer = viewerOf(s);
+    switch (method) {
+      case "list":
+        if (params.contacts === true) {
+          if (!bridge) throw new RelayError4("unavailable", `this broker is not linked to a hub (${CLI_NAME} cloud enable), so it reaches no contacts`);
+          return bridge.contacts().then((contacts) => ({ contacts }));
+        }
+        return { endpoints: core.list({ ...params, viewer, peekable: viewer === void 0 }) };
+      case "snapshot":
+        return {
+          ...core.snapshot({ all: params.all === true, activity: typeof params.activity === "number" ? params.activity : void 0, viewer }),
+          broker: brokerInfo()
+        };
+      case "watch":
+        s.data.watching = true;
+        return { ...core.snapshot({ activity: 20, viewer }), broker: brokerInfo() };
+      case "log": {
+        return {
+          rows: core.log({
+            since: params.since,
+            limit: params.limit,
+            scope: params.scope === true,
+            judge: params.judge === true,
+            peek: params.peek === true,
+            viewer
+          })
+        };
+      }
+      case "policy": {
+        const info = policyInfo();
+        const text = actorOf(s).kind === "human" && info.state === "loaded" ? policyText : null;
+        return { ...info, policy: typeof text === "string" ? JSON.parse(text) : null };
+      }
+      case "policy_check": {
+        if (viewer !== void 0) core.why(actorOf(s), String(params.from), String(params.to));
+        const info = policyInfo();
+        if (info.error) return { allowed: false, reason: info.error, file: policyFile };
+        const reason = core.checkPolicy(String(params.from), String(params.to));
+        return { allowed: reason === null, reason, file: policyFile };
+      }
+      case "cloud_status":
+        return bridge?.status() ?? { enabled: false };
+    }
+    throw new RelayError4("method_not_found", `no method ${method}`);
+  }
+  function scope(s, method, params) {
+    const result = scopeCall(s, method, params);
+    if (CHANGES_SCOPE.has(method) && params.action !== "ls" && params.action !== "show") bridge?.resync();
+    return result;
+  }
+  function scopeCall(s, method, params) {
+    const actor = actorOf(s);
+    switch (method) {
+      case "rules":
+        return core.scopeView(actor, optional(params, "endpoint"));
+      case "rules_set":
+        return core.rulesSet(
+          actor,
+          compact({
+            endpoint: optional(params, "endpoint"),
+            in: selectors(params, "in"),
+            out: selectors(params, "out"),
+            scope: optional(params, "scope"),
+            allow: selectors(params, "allow")
+          })
+        );
+      case "rules_widen":
+        return core.rulesWiden(actor, compact({ endpoint: required(params, "endpoint"), in: selectors(params, "in"), out: selectors(params, "out") }));
+      case "rules_lift":
+        return core.rulesLift(actor, { endpoint: required(params, "endpoint"), cap: required(params, "cap") });
+      case "grant":
+        return core.grant(actor, params);
+      case "group":
+        return core.group(actor, params);
+      case "admin":
+        return core.admin(actor, params);
+      case "peers":
+        return { peers: core.peers(viewerOf(s) ?? s.data.endpoint, { unverified: !atTerminal(s) }) };
+      case "why":
+        return core.why(actor, required(params, "from"), required(params, "to"));
+      case "peek":
+        return core.peek(actor, { endpoint: params.endpoint, turns: params.turns, full: params.full });
+      case "peek_set":
+        return core.peekSet(actor, { ...compact({ endpoint: optional(params, "endpoint") }), level: params.level });
+      case "peek_who":
+        return core.peekWho(actor, compact({ endpoint: optional(params, "endpoint") }));
+      case "spawn_steers":
+        return core.spawnSteers(actor, { grant: params.grant, take: params.take === true });
+      case "spawn_exit": {
+        const { spawner, ...result } = core.spawnExit(
+          actor,
+          compact({
+            grant: params.grant,
+            code: params.code,
+            output: params.output,
+            stderr: params.stderr,
+            unapplied: params.unapplied,
+            exits: params.exits,
+            started: params.started
+          })
+        );
+        if (result.handback) {
+          const message = core.delivered(spawner, result.handback);
+          wake(spawner);
+          notifyFleet({
+            type: "message",
+            id: message.id,
+            thread: message.thread,
+            kind: message.kind,
+            from: message.from.address,
+            to: [message.to],
+            hop: message.hop
+          });
+        }
+        if (result.endpoint) {
+          notifyFleet({ type: "status", endpoint: result.endpoint.address, status: result.endpoint.status });
+          if ((known.get(result.endpoint.id) ?? "offline") !== result.endpoint.presence) presenceChanged(result.endpoint);
+          else bridge?.changed(result.endpoint.id);
+        }
+        return result;
+      }
+    }
+    throw new RelayError4("method_not_found", `no method ${method}`);
+  }
+  function realOrSelf(path) {
+    try {
+      return realpathSync(path);
+    } catch {
+      return path;
+    }
+  }
+  async function awaitReply(s, me, request, ms, sent) {
+    const deadline = Date.now() + ms;
+    const present = sent?.deliveries.filter((d) => !d.offline).map((d) => d.endpoint);
+    for (; ; ) {
+      if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+      const reply = core.replyTo(me, request);
+      if (reply) {
+        core.ack(me, [reply.seq]);
+        return { ...sent, id: request, reply };
+      }
+      if (core.requestExpired(request)) return { ...sent, id: request, expired: true };
+      const ended = core.requestEnded(me, request, present);
+      if (ended) return { ...sent, id: request, pending: true, ended };
+      if (s.data.closed || Date.now() >= deadline) return { ...sent, id: request, pending: true };
+      await waitFor(me, Math.min(ASK_RECHECK_MS, deadline - Date.now()), s);
+    }
+  }
+  async function stop() {
+    if (stopping) return stopping;
+    stopping = (async () => {
+      closing = true;
+      clearInterval(sweeper);
+      clearInterval(presenceTimer);
+      await bridge?.stop();
+      if (idleTimer) clearTimeout(idleTimer);
+      for (const set of [...waiters.values()]) for (const fn of [...set]) fn();
+      const deadline = Date.now() + 2e3;
+      while (pending > 0 && Date.now() < deadline) await sleep2(5);
+      await Promise.race([judge.settled(), sleep2(Math.max(0, deadline - Date.now()))]);
+      for (const s of connections) s.end();
+      listener.close();
+      try {
+        unlinkSync2(socket);
+      } catch {
+      }
+      if (socket !== join3(dir, "relay.sock")) {
+        try {
+          rmdirSync(dirname2(socket));
+        } catch {
+        }
+      }
+      db.close();
+      releaseBrokerLock(lock);
+      resolveStopped();
+    })();
+    return stopping;
+  }
+  activity();
+  return { socket, core, bridge, judge, policyFile, stopped, stop };
+}
+function compact(fields) {
+  return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== void 0));
+}
+function optional(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new RelayError4("invalid_params", `${key} must be a string`);
+  return value;
+}
+function required(params, key) {
+  const value = optional(params, key);
+  if (!value) throw new RelayError4("invalid_params", `${key} is required`);
+  return value;
+}
+function selectors(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) return void 0;
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) throw new RelayError4("invalid_params", `${key} must be a list of selectors`);
+  return value;
+}
+export {
+  BrokerRunning,
+  BrokerUnavailable,
+  MAX_LINE,
+  RelayClient,
+  accountHome,
+  connectBroker,
+  localHostName,
+  policyPath,
+  privateDir,
+  relayDir,
+  relaySocketUrl,
+  shortHostname,
+  socketPath,
+  startBroker,
+  systemHostname,
+  thisHostname
+};