@scp-dev/hub 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,2878 @@
+// src/federation.ts
+import {
+  ACCOUNT_HANDLE,
+  admits,
+  cleanLabels,
+  cleanText,
+  effectiveSelector,
+  findSecret,
+  GONE_PREFIX,
+  groupCapKey,
+  HUMAN_HANDLE,
+  LIMITS,
+  MESSAGE_KINDS,
+  newId,
+  one,
+  randomHex,
+  RelayCore,
+  RelayError,
+  STATUS_STATES,
+  SYSTEM_HANDLE,
+  seqList,
+  unreachable,
+  validHandle,
+  validHarness,
+  validSelector
+} from "@scp-dev/core";
+var MACHINE_NAME = /^[a-z0-9][a-z0-9-]{0,31}$/;
+var REMOTE = /^[a-z0-9][a-z0-9._-]{0,63}\/([a-z0-9][a-z0-9._-]{0,62})?$/;
+var MESSAGE_ID = /^[a-z]{2,8}_[a-z0-9]{8,64}$/;
+var AUTHS = ["local-uid", "account", "account+bridge", "contact"];
+var PRESENCES = ["online", "idle", "offline"];
+var UNKNOWN = { tree: null, parent_ep: null, depth: null };
+var REFS = /* @__PURE__ */ new Set(["human", "policy", "inherited", "gone"]);
+var INCARNATION = /^[A-Za-z0-9._:-]{1,128}$/;
+var SCOPE_BYTES = 16 * 1024;
+var XACCT_MIGRATION = [
+  `CREATE TABLE IF NOT EXISTS xinbox (seq INTEGER PRIMARY KEY, id TEXT NOT NULL, from_account TEXT NOT NULL, client_id TEXT NOT NULL, endpoint TEXT NOT NULL, sender TEXT NOT NULL, message TEXT NOT NULL, thread TEXT NOT NULL, grant TEXT, expires_at INTEGER NOT NULL, at INTEGER NOT NULL, UNIQUE (from_account, client_id))`,
+  `CREATE TABLE IF NOT EXISTS xcursor (endpoint TEXT PRIMARY KEY, acked_seq INTEGER NOT NULL, at INTEGER, old_seq INTEGER, old_at INTEGER) WITHOUT ROWID`,
+  `CREATE TABLE IF NOT EXISTS xstate (key TEXT PRIMARY KEY, value TEXT) WITHOUT ROWID`,
+  `CREATE TABLE IF NOT EXISTS xcounters (contact TEXT PRIMARY KEY, day INTEGER, sent INTEGER, at INTEGER) WITHOUT ROWID`
+];
+var XINBOX_KEEP_MS = 864e5;
+var SEQ_TOP = `MAX(COALESCE((SELECT seq FROM sqlite_sequence WHERE name = 'deliveries'), 0), COALESCE((SELECT MAX(seq) FROM xinbox), 0),
+  COALESCE((SELECT MAX(acked_seq) FROM xcursor), 0), COALESCE((SELECT CAST(value AS INTEGER) FROM xstate WHERE key = 'seq_floor'), 0))`;
+var machinePart = (remote) => remote.slice(0, remote.indexOf("/"));
+var isForeign = (remote) => remote.startsWith("@");
+var foreignOf = (remote) => remote.slice(1, remote.indexOf("/"));
+function foreignNode(peer) {
+  const address = `${peer.account}/${peer.machine}/${peer.handle || "me"}`;
+  return {
+    id: `@${address}`,
+    address,
+    subject: { handle: peer.handle, harness: null, kind: peer.handle === "" ? "human" : "agent", labels: {}, account: peer.account },
+    rules: {},
+    caps: { caps: [], allow: {} },
+    groups: [],
+    policy: []
+  };
+}
+var handlePart = (remote) => remote.slice(remote.indexOf("/") + 1);
+var FederatedCore = class extends RelayCore {
+  machine;
+  aliases;
+  scope = null;
+  defaultAuth;
+  endpointCap;
+  refusalsPerMinute;
+  refusals = /* @__PURE__ */ new Map();
+  xinbox;
+  xfrom = null;
+  constructor(sql, options) {
+    super(sql, options);
+    this.machine = options.machine ?? null;
+    this.aliases = new Set(options.aliases ?? []);
+    this.defaultAuth = options.auth ?? "local-uid";
+    this.endpointCap = options.endpointCap ?? null;
+    this.refusalsPerMinute = options.refusalsPerMinute ?? null;
+    this.xinbox = options.xinbox === true;
+  }
+  migrate() {
+    super.migrate();
+    const columns = this.sql.all(`PRAGMA table_info(endpoints)`).map((c) => c.name);
+    if (!columns.includes("remote")) this.sql.all(`ALTER TABLE endpoints ADD COLUMN remote TEXT`);
+    if (!columns.includes("auth")) this.sql.all(`ALTER TABLE endpoints ADD COLUMN auth TEXT`);
+    if (!columns.includes("incarnation")) this.sql.all(`ALTER TABLE endpoints ADD COLUMN incarnation TEXT`);
+    if (!columns.includes("scope_epoch")) this.sql.all(`ALTER TABLE endpoints ADD COLUMN scope_epoch INTEGER`);
+    if (!columns.includes("mirrored_caps")) this.sql.all(`ALTER TABLE endpoints ADD COLUMN mirrored_caps TEXT`);
+    this.sql.all(`CREATE UNIQUE INDEX IF NOT EXISTS endpoints_remote ON endpoints (remote) WHERE remote IS NOT NULL`);
+    if (this.xinbox) for (const statement of XACCT_MIGRATION) this.sql.all(statement);
+  }
+  /** with xinbox, a delivery takes the next seq past xinbox's too, so a bridge's replay and ack cursor stay one space */
+  insertDelivery(messageId, endpoint, expiresAt) {
+    if (!this.xinbox) return super.insertDelivery(messageId, endpoint, expiresAt);
+    return one(
+      this.sql,
+      `INSERT INTO deliveries (seq, message_id, endpoint, expires_at) VALUES (1 + ${SEQ_TOP}, ?, ?, ?) RETURNING seq`,
+      messageId,
+      endpoint,
+      expiresAt
+    ).seq;
+  }
+  setAliases(aliases) {
+    this.aliases = new Set(aliases);
+  }
+  /** runs `fn` with unqualified handles resolving on `machine`: a direct client's own namespace on the hub */
+  within(machine, fn) {
+    const previous = this.scope;
+    this.scope = machine;
+    try {
+      return fn();
+    } finally {
+      this.scope = previous;
+    }
+  }
+  // addresses
+  /** the hub-side address (`<machine>/<handle>`) an address names, another account's as it is, or null when it is on this machine */
+  route(address) {
+    if (this.foreignAccount(address)) return String(address).trim();
+    const { machine, handle } = this.locate(address);
+    return machine === null ? null : `${machine}/${handle}`;
+  }
+  /** whether an address names an endpoint on another machine or of another account; malformed addresses are not remote */
+  isRemote(address) {
+    try {
+      return this.route(address) !== null;
+    } catch {
+      return false;
+    }
+  }
+  /** the local endpoint id a hub delivery for `<machine>/<handle>` is for */
+  localTarget(target) {
+    if (typeof target !== "string" || !REMOTE.test(target) || machinePart(target) !== this.machine)
+      throw new RelayError("not_found", `no endpoint ${String(target)} on this machine`);
+    const handle = handlePart(target);
+    const row = handle === "" ? this.byHandle(HUMAN_HANDLE) : validHandle(handle) ? this.byHandle(handle) : void 0;
+    if (!row) throw new RelayError("not_found", `no endpoint ${target} on this machine`);
+    return row.id;
+  }
+  /** the live row of `<machine>/<handle>`, for a bridge acting on its own machine's endpoints */
+  remoteEndpoint(machine, handle) {
+    if (typeof handle !== "string" || handle.includes("/")) throw new RelayError("invalid_params", "from is a handle on the bridge's own machine");
+    const row = this.byRemote(`${machine}/${handle}`);
+    if (!row) throw new RelayError("not_found", `no endpoint ${machine}/${handle}`);
+    return row.id;
+  }
+  /** the machine an endpoint row belongs to, or null for a row of this host */
+  machineOf(endpoint) {
+    const row = this.byId(endpoint);
+    return row?.remote ? machinePart(row.remote) : null;
+  }
+  /** `<account>/<machine>/<handle>` of another account (handle empty for its machine's human, `me`), or null for any other address */
+  foreignAccount(address) {
+    if (typeof address !== "string") return null;
+    const parts = address.trim().split("/");
+    if (parts.length !== 3) return null;
+    const [account, machine, handle] = parts;
+    if (this.isLocalUser(account) || !ACCOUNT_HANDLE.test(account) || !MACHINE_NAME.test(machine)) return null;
+    if (handle !== "me" && handle !== "" && !validHandle(handle)) return null;
+    return { account, machine, handle: handle === "me" ? "" : handle };
+  }
+  isLocalUser(part) {
+    return part === "me" || part === this.user || this.aliases.has(part);
+  }
+  /** whether an endpoint of another account `part` ever reached this relay, so `<part>/me` is that account's human */
+  knownAccount(part) {
+    return !this.isLocalUser(part) && ACCOUNT_HANDLE.test(part) && one(this.sql, `SELECT 1 FROM endpoints WHERE substr(remote, 1, ?) = ? LIMIT 1`, part.length + 2, `@${part}/`) !== void 0;
+  }
+  locate(address) {
+    if (typeof address !== "string" || !address.trim()) throw new RelayError("invalid_params", "an address is machine/handle, user/handle, or a handle");
+    const text = address.trim();
+    const parts = text.split("/");
+    let machine;
+    let handle;
+    if (parts.length === 1) [machine, handle] = [null, parts[0]];
+    else if (parts.length === 2 && parts[1] === "me" && this.knownAccount(parts[0]))
+      throw new RelayError(
+        "invalid_params",
+        `${text} is account ${parts[0]}'s human, which takes no messages yet; message one of its endpoints (${parts[0]}/<machine>/<handle>)`
+      );
+    else if (parts.length === 2) [machine, handle] = [this.isLocalUser(parts[0]) ? null : parts[0], parts[1]];
+    else if (parts.length === 3 && this.isLocalUser(parts[0])) [machine, handle] = [parts[1], parts[2]];
+    else throw unreachable(text);
+    if (machine !== null && handle === "me") handle = "";
+    if (machine === null && this.scope !== null && handle !== "") machine = this.scope;
+    if (machine !== null && machine === this.machine) machine = null;
+    return { machine, handle };
+  }
+  resolve(address) {
+    const { machine, handle } = this.locate(address);
+    const text = String(address).trim();
+    if (machine === null) {
+      const row2 = handle === "" ? this.byHandle(HUMAN_HANDLE) : validHandle(handle) ? this.byHandle(handle) : void 0;
+      if (!row2) throw unreachable(text);
+      return row2;
+    }
+    const row = this.byRemote(`${machine}/${handle}`);
+    if (!row) throw unreachable(text);
+    return row;
+  }
+  addressUsers() {
+    return [this.user, "me", ...this.aliases];
+  }
+  localRow(row) {
+    return !row.remote;
+  }
+  address(row) {
+    const remote = row.remote;
+    if (remote && isForeign(remote)) return remote.slice(1);
+    return remote ? `${this.user}/${remote}` : super.address(row);
+  }
+  subject(row) {
+    const remote = row.remote;
+    if (!remote) return super.subject(row);
+    return {
+      handle: "",
+      harness: row.harness,
+      kind: row.kind,
+      labels: JSON.parse(row.labels),
+      ...isForeign(remote) ? { account: foreignOf(remote) } : {}
+    };
+  }
+  /** a stand-in for another account's sender is no endpoint of this relay: list, peers and snapshots leave it out */
+  listable(row) {
+    const remote = row.remote;
+    return !remote || !isForeign(remote);
+  }
+  /** an address of another account (a sender's stand-in, or a target with none) is checked as that account's endpoint */
+  policySubject(address) {
+    const proxy = typeof address === "string" ? this.byRemote(`@${address.trim()}`) : void 0;
+    if (proxy) return this.subject(proxy);
+    const foreign = this.foreignAccount(address);
+    if (foreign) return foreignNode(foreign).subject;
+    return super.policySubject(address);
+  }
+  /**
+   * another machine's row sits in no local tree: a fleet of its own on its machine, so a scoped local endpoint reaches it only by a leaving
+   * selector; its mirrored ancestors are kept so a cap widened by one of them is clipped as on its machine
+   */
+  scopeSubject(row) {
+    const remote = row.remote;
+    if (!remote) return super.scopeSubject(row);
+    const ancestors = [];
+    for (let id = row.parent_ep; id && id !== row.id && !ancestors.includes(id) && ancestors.length <= LIMITS.depthMax; id = this.byId(id)?.parent_ep ?? null)
+      ancestors.push(id);
+    return { id: row.id, tree: row.tree ?? row.id, ancestors, groups: [], rootHandle: "", machine: machinePart(remote), local: false };
+  }
+  /** another machine's row has the rules and caps its machine mirrored; only the hub's own human (a full login on the hub) is the account's human */
+  scopeNode(row) {
+    const remote = row.remote;
+    if (!remote) return super.scopeNode(row);
+    if (isForeign(remote))
+      return { id: row.id, address: this.address(row), subject: this.subject(row), rules: {}, caps: { caps: [], allow: {} }, groups: [], policy: [] };
+    const subject = row.kind === "system" ? this.subject(row) : { ...this.subject(row), scope: this.scopeSubject(row) };
+    const human = row.kind === "human" && handlePart(remote) === "" && this.isLocalUser(machinePart(remote));
+    const caps = row.caps ? JSON.parse(row.caps) : { caps: [], allow: {} };
+    return {
+      id: row.id,
+      address: this.address(row),
+      subject,
+      human,
+      rules: row.rules ? JSON.parse(row.rules) : {},
+      caps: { caps: caps.caps, allow: caps.allow ?? {} },
+      groups: [],
+      policy: []
+    };
+  }
+  /**
+   * throws not_found, as send() does, when the scope refuses a local endpoint's message to an address on another machine, a reply
+   * (`replyTo`, its parent) to a message it got from that address passing as a solicited one; to another account, the cross-account rule on
+   * the sender's out lists, unless it replies to a message it got from exactly that address
+   */
+  scopeCheck(from, to, replyTo) {
+    const foreign = this.foreignAccount(to);
+    if (!foreign) {
+      const parent = replyTo === void 0 ? void 0 : one(this.sql, `SELECT * FROM messages WHERE id = ?`, String(replyTo));
+      this.checkScope(this.mustEndpoint(from), this.resolve(to), String(to).trim(), parent);
+      return;
+    }
+    const sender = this.mustEndpoint(from);
+    const text = String(to).trim();
+    if (replyTo !== void 0) {
+      const parent = one(
+        this.sql,
+        `SELECT m.from_ep AS from_ep FROM messages m JOIN deliveries d ON d.message_id = m.id WHERE m.id = ? AND d.endpoint = ?`,
+        replyTo,
+        from
+      );
+      const origin = parent ? this.byId(parent.from_ep) : void 0;
+      if (origin && this.address(origin) === text) return;
+    }
+    const admission = this.crossAdmission(from, "out", foreignNode(foreign));
+    if (admission.ok) return;
+    this.audit("scope_refused", from, null, { from: this.address(sender), to: text, dir: "out", reason: admission.why });
+    throw new RelayError("not_found", `no endpoint ${text}`);
+  }
+  /** whether direction `dir` of `endpoint` admits an endpoint of another account: only an `acct:` selector in each list, or no list at all */
+  crossAdmission(endpoint, dir, peer) {
+    const world = this.scopeWorld();
+    const node = world.node(endpoint);
+    if (!node) return { ok: false, why: "the endpoint is gone" };
+    return admits(world, node, dir, "id" in peer ? peer : foreignNode(peer));
+  }
+  envelope(row, seq, recipient) {
+    const envelope = super.envelope(row, seq, recipient);
+    const sender = this.byId(row.from_ep);
+    if (sender?.remote && isForeign(sender.remote)) {
+      const account = foreignOf(sender.remote);
+      const parts = sender.remote.slice(1).split("/");
+      const { rel: _, ...from } = envelope.from;
+      envelope.from = {
+        ...from,
+        user: account,
+        auth: "contact",
+        account,
+        rel: `contact:${account}`,
+        ...parts.length === 3 ? { machine: parts[1] } : {},
+        ...sender.kind === "human" ? { human: true } : {}
+      };
+      return envelope;
+    }
+    const machine = sender?.remote ? machinePart(sender.remote) : null;
+    const other = machine !== null && !this.isLocalUser(machine);
+    const human = other && sender?.kind === "human" && row.sender_tty === 1;
+    envelope.from = { ...envelope.from, auth: sender?.auth ?? this.defaultAuth, ...other ? { machine } : {}, ...human ? { human: true } : {} };
+    return envelope;
+  }
+  // mirrored and claimed rows
+  /**
+   * upserts a machine's endpoints from its views, never over a direct client's claimed row; `full` marks its mirrored rows missing from the
+   * list offline. An agent's place is worked out here from its mirrored parent, and a cap seen once stays until the endpoint is released
+   * (a new `incarnation`). A row is written only when something in it changed. `seen` gathers the remotes of a full mirror sent in several
+   * frames: each frame adds its own, and the closing `full` one counts every remote in it as listed.
+   */
+  mirror(machine, views, options = {}) {
+    this.checkMachine(machine);
+    if (!Array.isArray(views)) throw new RelayError("invalid_params", "endpoints must be a list");
+    if (views.length > (this.endpointCap ?? 4096)) throw new RelayError("too_large", `at most ${this.endpointCap ?? 4096} endpoints`);
+    const parsed = [...new Map(views.map((view) => this.parseView(view)).map((view) => [view.handle, view])).values()];
+    const auth = options.auth ?? null;
+    return this.tx(() => {
+      const now = this.now();
+      const changes = [];
+      const seen = options.seen ?? /* @__PURE__ */ new Set();
+      const batch = [];
+      for (const view of parsed) {
+        const remote = `${machine}/${view.handle}`;
+        seen.add(remote);
+        const before = this.byRemote(remote);
+        if (before && before.token_hash !== null) continue;
+        if (!before) this.checkCap();
+        batch.push({ view, id: before?.id ?? this.insertRemote(remote, view.kind, view.harness, auth, now), before });
+      }
+      const place = this.placer(machine, batch);
+      for (const { view, id, before } of batch) {
+        const row = before ?? this.byId(id);
+        if (before && view.kind === "agent") this.dropEarlierHolder(before, view.scope.incarnation);
+        const live = view.presence !== "offline";
+        const next = {
+          kind: view.kind,
+          harness: view.harness,
+          model: view.model,
+          cwd: view.cwd,
+          labels: view.labels,
+          status_state: view.status?.state ?? null,
+          status_note: view.status?.note ?? null,
+          token_hash: null,
+          connections: live ? 1 : 0,
+          last_seen: view.lastSeen ?? (live ? now : before?.last_seen ?? null),
+          auth: auth ?? row.auth,
+          ...view.kind === "agent" ? this.scopeColumns(machine, view.scope, row, place(view.handle)) : {}
+        };
+        const columns = Object.entries(next).filter(([column, value]) => row[column] !== value);
+        if (!columns.length) continue;
+        this.sql.all(
+          `UPDATE endpoints SET ${columns.map(([column]) => `${column} = ?`).join(", ")} WHERE id = ?`,
+          ...columns.map(([, value]) => value),
+          id
+        );
+        const change = this.diff(before, this.byId(id));
+        if (change) changes.push(change);
+      }
+      if (options.full) {
+        const missing = this.sql.all(
+          `SELECT * FROM endpoints WHERE substr(remote, 1, ?) = ? AND token_hash IS NULL AND connections > 0`,
+          machine.length + 1,
+          `${machine}/`
+        );
+        for (const row of missing.filter((r) => !seen.has(r.remote))) {
+          this.sql.all(`UPDATE endpoints SET connections = 0, last_seen = ? WHERE id = ?`, now, row.id);
+          changes.push({ view: this.remoteView(this.byId(row.id)), added: false, presence: true, status: false });
+        }
+      }
+      return changes;
+    });
+  }
+  /**
+   * a local agent's place, rules and caps as its machine's bridge mirrors them (MirrorScope), with its title; nothing for another row. Caps
+   * looser than the ones mirrored last move the endpoint's scope epoch and so its incarnation: a hub keeps the caps it has seen until that changes
+   */
+  mirrorScope(endpoint) {
+    const row = this.mustEndpoint(endpoint);
+    if (row.kind !== "agent" || !this.localRow(row)) return {};
+    const node = this.scopeNode(row);
+    const root = row.tree ? this.byId(row.tree) : row;
+    const parent = row.parent_ep ? this.byId(row.parent_ep) : void 0;
+    const caps = [...node.caps.caps];
+    for (const group of node.groups) {
+      for (const dir of ["in", "out"]) {
+        const rules2 = group[dir];
+        if (!rules2) continue;
+        const list = { source: "", by: group.owner, group: group.name, entries: [] };
+        const sels = [...rules2, ...node.caps.allow[groupCapKey(group.name, dir)] ?? []].map((entry) => ({ ...entry, sel: effectiveSelector(list, entry) }));
+        caps.push({ id: groupCapKey(group.name, dir), dir, by: group.owner, sels });
+      }
+    }
+    for (const cap of node.policy) caps.push({ id: `policy:${cap.match}:${cap.dir}`, dir: cap.dir, by: "policy", sels: cap.sels });
+    const allow = Object.fromEntries(Object.entries(node.caps.allow).filter(([key]) => key.startsWith("inherited:")));
+    const rules = { ...node.rules.in ? { in: node.rules.in } : {}, ...node.rules.out ? { out: node.rules.out } : {} };
+    const wire = caps.length || Object.keys(allow).length ? this.wireCaps({ caps, allow }) : null;
+    const epoch = this.scopeEpoch(row, wire);
+    return {
+      tree: root?.handle ?? null,
+      parent_ep: parent?.handle ?? null,
+      depth: row.depth ?? 0,
+      rules: Object.keys(rules).length ? rules : null,
+      caps: wire,
+      title: row.title ?? null,
+      incarnation: `${this.hash(row.spawned_at ? `${row.id}@${row.spawned_at}` : row.id).slice(0, 24)}.${epoch}`
+    };
+  }
+  scopeEpoch(row, caps) {
+    const epoch = row.scope_epoch ?? 0;
+    const text = caps ? JSON.stringify(caps) : null;
+    if (text === row.mirrored_caps) return epoch;
+    const seen = row.mirrored_caps ? JSON.parse(row.mirrored_caps) : null;
+    const next = seen && loosens(seen, caps ?? { caps: [] }) ? epoch + 1 : epoch;
+    this.sql.all(`UPDATE endpoints SET scope_epoch = ?, mirrored_caps = ? WHERE id = ?`, next || null, text, row.id);
+    return next;
+  }
+  /**
+   * a direct client's claim of `<machine>/<handle>`, with claim()'s takeover and suffix rules, and its `exact`, `scope`, `allow`, `in` and
+   * `out`: a new row takes the claim's own rules, a taken-over one keeps its own. An exact claim is never suffixed: it joins a live claimed
+   * row of the same harness no process or session holds, with no new token, and is refused as claim() refuses one otherwise
+   */
+  claimOn(machine, claim, auth = "account") {
+    this.checkMachine(machine);
+    const harness = cleanText(claim.harness, "harness", 32) ?? "cli";
+    if (!validHarness(harness)) throw new RelayError("invalid_params", `harness ${JSON.stringify(harness)} is not a valid name`);
+    const wanted = cleanText(claim.handle, "handle", 63) ?? harness;
+    if (!validHandle(wanted)) throw new RelayError("invalid_params", `handle ${JSON.stringify(wanted)} is not valid: lowercase letters, digits, . _ -`);
+    const fields = {
+      model: cleanText(claim.model, "model", 128),
+      cwd: cleanText(claim.cwd, "cwd", 1024),
+      parent: cleanText(claim.parent, "parent", 128),
+      labels: JSON.stringify(cleanLabels(claim.labels))
+    };
+    const leaked = [wanted, fields.model, fields.cwd, fields.parent, fields.labels].map((v) => v ? findSecret(v) : null).find(Boolean);
+    if (leaked) throw new RelayError("secret_refused", `the claim looks like it carries a credential (${leaked})`);
+    const rules = this.claimRules(claim);
+    const exact = claim.exact === true;
+    return this.tx(() => {
+      const now = this.now();
+      let row;
+      let created = false;
+      let joined = false;
+      for (let n = 1; n < (exact ? 2 : 1e3) && !row; n++) {
+        const handle = n === 1 ? wanted : `${wanted.slice(0, 58)}-${n}`;
+        const held = this.byRemote(`${machine}/${handle}`);
+        if (!held) {
+          this.checkCap();
+          row = this.byId(this.insertRemote(`${machine}/${handle}`, "agent", harness, auth, now));
+          created = true;
+        } else if (held.kind === "agent" && held.connections === 0 && held.harness === harness) {
+          row = held;
+        } else if (exact && held.kind === "agent" && held.token_hash !== null && held.process === null && held.session === null && held.parent_ep === null && held.harness === harness) {
+          row = held;
+          joined = true;
+        } else if (held.kind === "agent" && held.connections === 0 && (held.last_seen ?? held.created_at) < now - LIMITS.handleBoundS * 1e3) {
+          this.retire(held.id);
+          n--;
+        }
+      }
+      if (!row) {
+        if (exact) throw this.exactRefusal(this.byRemote(`${machine}/${wanted}`), wanted, harness, now);
+        throw new RelayError("invalid_params", `no free handle for ${wanted} on ${machine}`);
+      }
+      if (created) {
+        const own = this.boundRules(rules);
+        if (Object.keys(own).length) this.sql.all(`UPDATE endpoints SET rules = ? WHERE id = ?`, JSON.stringify(own), row.id);
+        for (const dir of ["in", "out"]) this.needGroups(this.byId(row.id), rules[dir]);
+      }
+      const token = joined ? void 0 : `kre_${randomHex(32)}`;
+      this.sql.all(
+        `UPDATE endpoints SET harness = ?, model = ?, cwd = ?, parent = ?, labels = ?, token_hash = ${token ? "?" : "token_hash"}, auth = ?, connections = connections + 1, last_seen = ? WHERE id = ?`,
+        harness,
+        fields.model,
+        fields.cwd,
+        fields.parent,
+        fields.labels,
+        ...token ? [this.hash(token)] : [],
+        auth,
+        now,
+        row.id
+      );
+      this.audit("claim", row.id, null, { handle: row.remote, harness, ...joined ? { joined: true } : {} });
+      return { endpoint: this.view(this.byId(row.id)), ...token ? { token } : {} };
+    });
+  }
+  /**
+   * resume() for a direct client of `machine`, its labels replaced by what `relabel` makes of them, held to the label limits: a token of
+   * another machine's endpoint is refused
+   */
+  resumeOn(machine, token, relabel) {
+    const row = typeof token === "string" ? one(this.sql, `SELECT * FROM endpoints WHERE token_hash = ?`, this.hash(token)) : void 0;
+    if (!row?.remote || machinePart(row.remote) !== machine) throw new RelayError("unauthorized", "unknown resume token");
+    if (!relabel) return this.resume(token);
+    const merged = JSON.stringify(cleanLabels(relabel(JSON.parse(row.labels))));
+    return this.tx(() => {
+      if (merged !== row.labels) this.sql.all(`UPDATE endpoints SET labels = ? WHERE id = ?`, merged, row.id);
+      return this.resume(token);
+    });
+  }
+  /** every live row of other machines (or of one machine), as views with their machine */
+  remoteViews(filter = {}) {
+    return this.sql.all(`SELECT * FROM endpoints WHERE remote IS NOT NULL ORDER BY remote`).filter((row) => (!filter.except || machinePart(row.remote) !== filter.except) && (!filter.machine || machinePart(row.remote) === filter.machine)).map((row) => this.remoteView(row));
+  }
+  remoteRowsOf(machine) {
+    return this.remoteViews({ machine });
+  }
+  /** a bridge went away: its mirrored rows show offline */
+  markOffline(machine) {
+    const rows = this.sql.all(
+      `UPDATE endpoints SET connections = 0, last_seen = ? WHERE substr(remote, 1, ?) = ? AND token_hash IS NULL AND connections > 0 RETURNING id`,
+      this.now(),
+      machine.length + 1,
+      `${machine}/`
+    );
+    return rows.map((row) => ({ view: this.remoteView(this.byId(row.id)), added: false, presence: true, status: false }));
+  }
+  /**
+   * a released machine: its rows are retired like a gone handle and can't be resolved or resumed again; with `queue`,
+   * their unread deliveries go too, and each message they leave delivered to no one, unless it is a request or has
+   * replies, which askers still look up
+   */
+  dropMachine(machine, options = {}) {
+    const rows = this.sql.all(
+      `UPDATE endpoints SET handle = ? || id, remote = NULL, token_hash = NULL, connections = 0 WHERE substr(remote, 1, ?) = ? RETURNING id`,
+      GONE_PREFIX,
+      machine.length + 1,
+      `${machine}/`
+    );
+    if (options.queue && this.xinbox) {
+      this.xfloor();
+      this.sql.all(`DELETE FROM xinbox WHERE substr(endpoint, 1, ?) = ?`, machine.length + 1, `${machine}/`);
+    }
+    if (options.queue) {
+      for (const { id } of rows) {
+        for (const { message_id } of this.sql.all(
+          `DELETE FROM deliveries WHERE endpoint = ? AND acked_at IS NULL RETURNING message_id`,
+          id
+        )) {
+          this.sql.all(
+            `DELETE FROM messages WHERE id = ? AND kind != 'request' AND NOT EXISTS (SELECT 1 FROM deliveries WHERE message_id = ?) AND NOT EXISTS (SELECT 1 FROM messages WHERE reply_to = ?)`,
+            message_id,
+            message_id,
+            message_id
+          );
+        }
+      }
+    }
+    return rows.length;
+  }
+  /**
+   * hands a machine's direct-client rows with no connection (or only `endpoint`) to its bridge: their resume tokens are
+   * dropped, so the bridge mirrors them, and their unread deliveries get fresh seqs past any bridge's replay cursor;
+   * returns those deliveries
+   */
+  adoptClaimed(machine, endpoint) {
+    return this.tx(() => {
+      const now = this.now();
+      const rows = this.sql.all(
+        `UPDATE endpoints SET token_hash = NULL WHERE substr(remote, 1, ?) = ? AND token_hash IS NOT NULL AND connections = 0 ${endpoint ? "AND id = ?" : ""} RETURNING id`,
+        ...[machine.length + 1, `${machine}/`, ...endpoint ? [endpoint] : []]
+      );
+      const adopted = [];
+      for (const { id } of rows) {
+        const unread = this.sql.all(
+          `DELETE FROM deliveries WHERE endpoint = ? AND acked_at IS NULL AND expires_at > ? RETURNING seq, message_id, expires_at`,
+          id,
+          now
+        );
+        for (const row of unread.sort((a, b) => a.seq - b.seq)) {
+          const seq = this.insertDelivery(row.message_id, id, row.expires_at);
+          adopted.push({ seq, endpoint: id });
+        }
+      }
+      return adopted;
+    });
+  }
+  // hops
+  /** the hop a message from this endpoint would get from what it received lately */
+  causalHop(endpoint) {
+    const row = this.mustEndpoint(endpoint);
+    return row.last_received_at !== null && row.last_received_at >= this.now() - LIMITS.causalWindowS * 1e3 ? (row.last_received_hop ?? 0) + 1 : 0;
+  }
+  /** records that an endpoint received a message of `hop`, as reading its inbox does */
+  markReceived(endpoint, hop) {
+    const now = this.now();
+    this.sql.all(
+      `UPDATE endpoints SET last_received_at = ?, last_received_hop = MAX(?, CASE WHEN last_received_at >= ? THEN COALESCE(last_received_hop, 0) ELSE 0 END) WHERE id = ?`,
+      now,
+      hop,
+      now - LIMITS.causalWindowS * 1e3,
+      endpoint
+    );
+  }
+  // messages across machines
+  /**
+   * why the local policy refuses a hub delivery to the local `endpoint`, or null; checks the message as admit() does and creates its sender's
+   * proxy row; relay notices always pass. A scope refusal throws not_found, as send() does; a redelivery of an admitted message skips it.
+   */
+  inboundRefusal(endpoint, message) {
+    const recipient = this.mustEndpoint(endpoint);
+    this.checkEnvelope(message);
+    const sender = this.byId(this.tx(() => this.proxyFor(message.from)));
+    if (sender.kind === "system") return null;
+    if (!one(this.sql, `SELECT 1 FROM deliveries WHERE message_id = ? AND endpoint = ?`, message.id, endpoint)) {
+      const parent = message.kind === "reply" && message.reply_to ? one(this.sql, `SELECT * FROM messages WHERE id = ?`, message.reply_to) : void 0;
+      const remote = sender.remote;
+      if (remote && isForeign(remote)) this.checkForeignIn(sender, recipient, parent);
+      else this.checkScope(sender, recipient, this.address(recipient), parent);
+    }
+    return this.checkPolicy(this.addressOf(sender.id), this.addressOf(endpoint));
+  }
+  /**
+   * a message the hub delivered to a local endpoint, stored under the hub's id from a proxy of its sender; idempotent.
+   * Throws inbox_full past the inbox cap, which a redelivery, the first reply to the endpoint's own message (as in
+   * send()) and relay notices skip.
+   */
+  admit(endpoint, message) {
+    this.mustEndpoint(endpoint);
+    const checked = this.checkEnvelope(message);
+    const stored2 = this.tx(() => {
+      const sender = this.proxyFor(message.from);
+      const had = one(this.sql, `SELECT seq FROM deliveries WHERE message_id = ? AND endpoint = ?`, message.id, endpoint);
+      if (had) return { seq: had.seq, duplicate: true };
+      const unacked = this.inboxFull(endpoint, sender, message);
+      if (unacked !== null) return { sender, unacked };
+      this.sql.all(
+        `INSERT OR IGNORE INTO messages (id, thread, reply_to, kind, from_ep, to_addr, body, mime, data_class, attachments, hop, created_at, expires_at, sender_tty, require_reply)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        message.id,
+        message.thread,
+        message.reply_to,
+        message.kind,
+        sender,
+        message.to,
+        message.body.text,
+        message.body.mime,
+        message.data_class,
+        JSON.stringify(message.attachments.map((a) => ({ kind: "path", path: a.path }))),
+        message.hop,
+        checked.createdAt,
+        checked.expiresAt,
+        message.from.claims.tty === void 0 ? null : message.from.claims.tty ? 1 : 0,
+        message.require_reply === true && message.kind === "request" ? 1 : null
+      );
+      const seq = this.insertDelivery(message.id, endpoint, checked.expiresAt);
+      this.audit("inject", endpoint, message.id, { from: message.from.address, hop: message.hop });
+      return { seq, duplicate: false };
+    });
+    if ("unacked" in stored2) throw this.refuse(stored2.sender, "inbox_full", `${this.addressOf(endpoint)} has ${stored2.unacked} unread messages`);
+    return stored2;
+  }
+  /** inject() for the hooks of a local endpoint; another machine's row (mirrored, claimed on the hub, or a sender's proxy) has none and gets nothing */
+  inject(endpoint, options = {}) {
+    if (this.machineOf(endpoint) !== null) return { messages: [], offered: [], hold: null, more: 0, unread: 0, block: false };
+    return super.inject(endpoint, options);
+  }
+  /** offer() for a local endpoint's channel; another machine's row is offered nothing */
+  offer(endpoint, options = {}) {
+    if (this.machineOf(endpoint) !== null) return { messages: [], hold: null };
+    return super.offer(endpoint, options);
+  }
+  /** stopHeld() for a local endpoint; another machine's row has no hooks */
+  stopHeld(endpoint, options = {}) {
+    return this.machineOf(endpoint) === null && super.stopHeld(endpoint, options);
+  }
+  /** the endpoint's unacked count when a new delivery from `sender` would pass the inbox cap, else null */
+  inboxFull(endpoint, sender, message) {
+    if (this.byId(sender).kind === "system") return null;
+    const parent = message.kind === "reply" && message.reply_to ? one(this.sql, `SELECT id, from_ep FROM messages WHERE id = ?`, message.reply_to) : void 0;
+    const firstReply = parent?.from_ep === endpoint && one(this.sql, `SELECT 1 FROM messages WHERE reply_to = ? AND from_ep = ? AND kind = 'reply' AND id != ?`, parent.id, sender, message.id) === void 0;
+    if (firstReply) return null;
+    const unacked = one(
+      this.sql,
+      `SELECT COUNT(*) AS n FROM deliveries WHERE endpoint = ? AND acked_at IS NULL AND expires_at > ?`,
+      endpoint,
+      this.now()
+    ).n;
+    return unacked >= LIMITS.inboxMax ? unacked : null;
+  }
+  /** a send the hub accepted for a local endpoint, stored under the hub's id with no deliveries, so replyTo() and a retried client_id work */
+  recordForward(from, params, result, origin = {}) {
+    const sender = this.mustEndpoint(from);
+    const now = this.now();
+    const ttl = Number.isInteger(params.ttl_s) ? params.ttl_s : LIMITS.ttlDefaultS;
+    const targets = Array.isArray(params.to) ? params.to : [params.to];
+    const clientId = cleanText(params.client_id, "client_id", 128);
+    const kind = params.kind ?? "message";
+    this.tx(() => {
+      this.sql.all(
+        `INSERT OR IGNORE INTO messages (id, thread, reply_to, kind, from_ep, to_addr, body, mime, data_class, attachments, hop, created_at, expires_at, sender_tty, require_reply)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        result.id,
+        result.thread,
+        params.reply_to ?? null,
+        kind,
+        from,
+        targets.map(String).join(","),
+        params.body,
+        params.mime ?? "text/markdown",
+        params.data_class ?? "public",
+        JSON.stringify((params.attachments ?? []).map((a) => ({ kind: "path", path: a.path }))),
+        result.hop,
+        now,
+        now + ttl * 1e3,
+        sender.kind === "human" ? origin.tty === true ? 1 : 0 : null,
+        params.require_reply === true && kind === "request" ? 1 : null
+      );
+      if (clientId) {
+        const { duplicate: _, ...stored2 } = result;
+        this.sql.all(
+          `INSERT OR REPLACE INTO idempotency (from_ep, client_id, payload_hash, result, created_at) VALUES (?, ?, ?, ?, ?)`,
+          from,
+          clientId,
+          this.forwardHash(params),
+          JSON.stringify(stored2),
+          now
+        );
+      }
+      if (params.reply_to)
+        this.sql.all(`UPDATE deliveries SET acked_at = ? WHERE message_id = ? AND endpoint = ? AND acked_at IS NULL`, now, params.reply_to, from);
+      this.audit("forward", from, result.id, { to: result.deliveries.map((d) => d.address), kind, hop: result.hop, thread: result.thread });
+    });
+  }
+  /** the earlier result of a forwarded send with this client_id, or null; a different message under the same client_id is refused */
+  forwarded(from, params) {
+    const clientId = cleanText(params.client_id, "client_id", 128);
+    if (!clientId) return null;
+    const seen = one(
+      this.sql,
+      `SELECT result, payload_hash, created_at FROM idempotency WHERE from_ep = ? AND client_id = ?`,
+      from,
+      clientId
+    );
+    if (!seen || seen.created_at < this.now() - LIMITS.idempotencyS * 1e3) return null;
+    if (seen.payload_hash !== this.forwardHash(params)) throw new RelayError("invalid_params", `client_id ${clientId} was already used for a different message`);
+    return { ...JSON.parse(seen.result), duplicate: true };
+  }
+  /** one delivery as the hub pushes it, or null when it is gone, acked or expired */
+  delivery(seq) {
+    const row = one(
+      this.sql,
+      `SELECT m.*, d.seq AS seq, d.endpoint AS recipient, e.remote AS remote, e.token_hash IS NOT NULL AS claimed FROM deliveries d JOIN messages m ON m.id = d.message_id JOIN endpoints e ON e.id = d.endpoint
+       WHERE d.seq = ? AND d.acked_at IS NULL AND d.expires_at > ?`,
+      seq,
+      this.now()
+    );
+    if (row)
+      return {
+        seq: row.seq,
+        endpoint: row.remote,
+        recipient: row.recipient,
+        mirrored: row.claimed === 0,
+        message: this.envelope(row, void 0, row.recipient)
+      };
+    return this.xinbox ? this.xinboxPage(`x.seq = ?`, [seq], 1)[0] ?? null : null;
+  }
+  /** the unacked deliveries to `machine`'s mirrored rows after `after` (xinbox rows after `xafter`), oldest first */
+  pending(machine, after, limit = 200, xafter = after) {
+    const deliveries = this.sql.all(
+      `SELECT m.*, d.seq AS seq, d.endpoint AS recipient, e.remote AS remote FROM deliveries d JOIN messages m ON m.id = d.message_id JOIN endpoints e ON e.id = d.endpoint
+         WHERE substr(e.remote, 1, ?) = ? AND e.token_hash IS NULL AND d.acked_at IS NULL AND d.expires_at > ? AND d.seq > ? ORDER BY d.seq LIMIT ?`,
+      machine.length + 1,
+      `${machine}/`,
+      this.now(),
+      after,
+      limit
+    ).map(
+      (row) => ({
+        seq: row.seq,
+        endpoint: row.remote,
+        recipient: row.recipient,
+        mirrored: true,
+        message: this.envelope(row, void 0, row.recipient)
+      })
+    );
+    if (!this.xinbox) return deliveries;
+    const others = this.xinboxPage(`substr(x.endpoint, 1, ?) = ? AND x.seq > ?`, [machine.length + 1, `${machine}/`, xafter], limit);
+    return others.length ? [...deliveries, ...others].sort((a, b) => a.seq - b.seq).slice(0, limit) : deliveries;
+  }
+  /**
+   * acks deliveries of `machine`'s mirrored rows only; each counts as received for the causal hop. A seq of xinbox moves its endpoint's
+   * cursor instead: one row per endpoint for the whole batch, no audit
+   */
+  ackOn(machine, seqs) {
+    let acked = 0;
+    const batches = /* @__PURE__ */ new Map();
+    for (const seq of seqList(seqs)) {
+      const row = this.ownDelivery(machine, seq);
+      if (!row) {
+        const endpoint = this.ownXinbox(machine, seq);
+        if (endpoint !== null) batches.set(endpoint, (batches.get(endpoint) ?? /* @__PURE__ */ new Set()).add(seq));
+        continue;
+      }
+      this.sql.all(`UPDATE deliveries SET acked_at = ? WHERE seq = ?`, this.now(), seq);
+      this.markReceived(row.endpoint, row.hop);
+      acked++;
+    }
+    if (acked) this.audit("ack", null, null, { machine, count: acked });
+    for (const [endpoint, batch] of batches) acked += this.advanceCursor(endpoint, batch);
+    return acked;
+  }
+  /** a delivery `machine`'s local policy refused: acked, and a status notice from the relay to the sender */
+  rejectOn(machine, seq, code) {
+    if (!Number.isInteger(seq)) throw new RelayError("invalid_params", "seq must be an integer");
+    if (typeof code !== "string" || !/^[a-z_]{1,32}$/.test(code)) throw new RelayError("invalid_params", "code is an error code");
+    const row = this.ownDelivery(machine, seq);
+    if (!row) {
+      const endpoint = this.ownXinbox(machine, seq);
+      if (endpoint === null) throw new RelayError("not_found", `no unacked delivery ${String(seq)} for ${machine}`);
+      this.advanceCursor(endpoint, /* @__PURE__ */ new Set([seq]));
+      return { notice: null };
+    }
+    return this.tx(() => {
+      this.sql.all(`UPDATE deliveries SET acked_at = ? WHERE seq = ?`, this.now(), seq);
+      this.audit("reject", row.endpoint, row.message_id, { code, machine });
+      const sender = this.byId(row.from_ep);
+      if (!sender || sender.kind === "system") return { notice: null };
+      const recipient = this.byId(row.endpoint);
+      const noticeSeq = this.noticeTo(sender.id, `${this.address(recipient)} refused message ${row.message_id} (${code}).`);
+      return { notice: { seq: noticeSeq, endpoint: sender.id } };
+    });
+  }
+  audit(event, endpoint, ref, detail) {
+    if (event === "refuse" && this.refusalsPerMinute !== null) {
+      const minute = Math.floor(this.now() / 6e4);
+      const code = String(detail.code);
+      let budget = this.refusals.get(code);
+      if (!budget) {
+        budget = { minute, written: 0, suppressed: 0 };
+        this.refusals.set(code, budget);
+      }
+      if (budget.minute !== minute) Object.assign(budget, { minute, written: 0 });
+      if (budget.written >= this.refusalsPerMinute) {
+        budget.suppressed++;
+        return;
+      }
+      budget.written++;
+      if (budget.suppressed) {
+        detail = { ...detail, suppressed: budget.suppressed };
+        budget.suppressed = 0;
+      }
+    }
+    super.audit(event, endpoint, ref, detail);
+  }
+  /** an audit row from outside the core (hub events: machine binds, releases, revocations) */
+  record(event, endpoint, ref, detail) {
+    this.audit(event, endpoint, ref, detail);
+  }
+  /**
+   * drops what expired, and with xinbox the rows received over XINBOX_KEEP_MS ago that expired or were acked that long ago, keeping
+   * the highest seq they held as the floor of the next one
+   */
+  sweep() {
+    super.sweep();
+    if (!this.xinbox) return;
+    this.xfloor();
+    const now = this.now();
+    const settled = now - XINBOX_KEEP_MS;
+    this.sql.all(
+      `DELETE FROM xinbox WHERE at <= ? AND (expires_at <= ? OR EXISTS (SELECT 1 FROM xcursor c WHERE c.endpoint = xinbox.endpoint
+         AND ((xinbox.seq <= c.acked_seq AND c.at <= ?) OR (xinbox.seq <= c.old_seq AND c.old_at <= ?))))`,
+      settled,
+      now,
+      settled,
+      settled
+    );
+    this.sql.all(`DELETE FROM xcursor WHERE endpoint NOT IN (SELECT endpoint FROM xinbox)`);
+  }
+  // other accounts (the hosted relay)
+  /** the mirrored row of `<machine>/<handle>` (a bridge's, never a direct client's), or null */
+  xendpoint(remote) {
+    const row = this.byRemote(remote);
+    return row && row.token_hash === null && row.kind !== "system" && !isForeign(remote) ? this.xview(row) : null;
+  }
+  /** the mirrored row an endpoint id is, or null for anything else */
+  xsender(endpoint) {
+    const row = this.byId(endpoint);
+    return row?.remote && row.token_hash === null && row.kind !== "system" && !isForeign(row.remote) ? this.xview(row) : null;
+  }
+  /** every mirrored row, for discovery */
+  xendpoints() {
+    return this.sql.all(`SELECT * FROM endpoints WHERE remote IS NOT NULL AND token_hash IS NULL AND kind != 'system' ORDER BY remote`).filter((row) => !isForeign(row.remote)).map((row) => this.xview(row));
+  }
+  /** the xinbox row `id` delivered to `<machine>/<handle>`, or null */
+  xreceived(endpoint, id) {
+    return this.xinbox ? one(this.sql, `SELECT * FROM xinbox WHERE endpoint = ? AND id = ?`, endpoint, id) ?? null : null;
+  }
+  /** the earlier row of a message from `fromAccount` under `clientId`, or null */
+  xduplicate(fromAccount, clientId) {
+    const row = one(
+      this.sql,
+      `SELECT id, seq, endpoint FROM xinbox WHERE from_account = ? AND client_id = ?`,
+      fromAccount,
+      clientId
+    );
+    if (!row) return null;
+    const cursor = one(this.sql, `SELECT acked_seq FROM xcursor WHERE endpoint = ?`, row.endpoint)?.acked_seq ?? 0;
+    return { id: row.id, acked: row.seq <= cursor };
+  }
+  /** what `fromAccount` sent here: from `sender` to `endpoint` in the last minute and hour (each with its oldest), and since `since` */
+  xcounts(fromAccount, sender, endpoint, since) {
+    const now = this.now();
+    const pair = one(
+      this.sql,
+      `SELECT COALESCE(SUM(at > ?), 0) AS minute, MIN(CASE WHEN at > ? THEN at END) AS minute_at, COUNT(*) AS hour, MIN(at) AS hour_at FROM xinbox
+       WHERE from_account = ? AND sender = ? AND endpoint = ? AND at > ?`,
+      now - 6e4,
+      now - 6e4,
+      fromAccount,
+      sender,
+      endpoint,
+      now - 36e5
+    );
+    const day = one(this.sql, `SELECT COUNT(*) AS n FROM xinbox WHERE from_account = ? AND at >= ?`, fromAccount, since).n;
+    return { minute: pair.minute, minuteAt: pair.minute_at, hour: pair.hour, hourAt: pair.hour_at, day };
+  }
+  /** an endpoint's unread messages: its unacked, unexpired xinbox rows and deliveries */
+  xunread(endpoint) {
+    const now = this.now();
+    return one(
+      this.sql,
+      `SELECT (SELECT COUNT(*) FROM xinbox x WHERE x.endpoint = ? AND x.expires_at > ? AND x.seq > COALESCE((SELECT acked_seq FROM xcursor WHERE endpoint = x.endpoint), 0))
+         + (SELECT COUNT(*) FROM deliveries WHERE endpoint = ? AND acked_at IS NULL AND expires_at > ?) AS n`,
+      endpoint.remote,
+      now,
+      endpoint.id,
+      now
+    ).n;
+  }
+  /** the accounts whose xinbox rows may be read out now; null (unknown) reads none */
+  xsenders(accounts) {
+    this.xfrom = accounts;
+  }
+  /** deletes the xinbox rows of every account but `keep`; how many it deleted */
+  xprune(keep) {
+    if (!this.xinbox) return 0;
+    const json = JSON.stringify([...keep]);
+    if (!one(this.sql, `SELECT 1 FROM xinbox WHERE from_account NOT IN (SELECT value FROM json_each(?)) LIMIT 1`, json)) return 0;
+    this.xfloor();
+    return this.sql.all(`DELETE FROM xinbox WHERE from_account NOT IN (SELECT value FROM json_each(?)) RETURNING seq`, json).length;
+  }
+  xthreadCount(endpoint, thread) {
+    return one(this.sql, `SELECT COUNT(*) AS n FROM xinbox WHERE endpoint = ? AND thread = ?`, endpoint, thread).n;
+  }
+  /** one xinbox row under the next seq; null when a row of the same sender and client_id is there already */
+  xinsert(row) {
+    return one(
+      this.sql,
+      `INSERT INTO xinbox (seq, id, from_account, client_id, endpoint, sender, message, thread, grant, expires_at, at) SELECT 1 + ${SEQ_TOP}, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? WHERE true
+         ON CONFLICT (from_account, client_id) DO NOTHING RETURNING seq`,
+      row.id,
+      row.from_account,
+      row.client_id,
+      row.endpoint,
+      row.sender,
+      row.message,
+      row.thread,
+      row.grant,
+      row.expires_at,
+      row.at
+    )?.seq ?? null;
+  }
+  /** a value of the cross-account state, written once */
+  xstate(key, init) {
+    const found = one(this.sql, `SELECT value FROM xstate WHERE key = ?`, key);
+    if (found) return found.value;
+    const value = init();
+    this.sql.all(`INSERT INTO xstate (key, value) VALUES (?, ?) ON CONFLICT (key) DO NOTHING`, key, value);
+    return one(this.sql, `SELECT value FROM xstate WHERE key = ?`, key).value;
+  }
+  xview(row) {
+    const remote = row.remote;
+    return {
+      id: row.id,
+      remote,
+      machine: machinePart(remote),
+      handle: handlePart(remote),
+      kind: row.kind,
+      depth: row.kind === "agent" ? row.depth : null,
+      harness: row.harness,
+      presence: this.view(row).presence
+    };
+  }
+  /** unacked, unexpired xinbox rows of mirrored endpoints from the accounts xsenders() named, as deliveries, by `where` over `x` */
+  xinboxPage(where, params, limit) {
+    if (!this.xfrom?.size) return [];
+    return this.sql.all(
+      `SELECT x.seq AS seq, x.endpoint AS endpoint, x.message AS message, e.id AS recipient FROM xinbox x JOIN endpoints e ON e.remote = x.endpoint AND e.token_hash IS NULL
+         WHERE ${where} AND x.expires_at > ? AND x.from_account IN (SELECT value FROM json_each(?))
+         AND x.seq > COALESCE((SELECT acked_seq FROM xcursor WHERE endpoint = x.endpoint), 0) ORDER BY x.seq LIMIT ?`,
+      ...params,
+      this.now(),
+      JSON.stringify([...this.xfrom]),
+      limit
+    ).map((row) => ({ seq: row.seq, endpoint: row.endpoint, recipient: row.recipient, mirrored: true, message: JSON.parse(row.message) }));
+  }
+  /** the endpoint of an unacked xinbox seq of `machine`, or null */
+  ownXinbox(machine, seq) {
+    if (!this.xinbox) return null;
+    return one(
+      this.sql,
+      `SELECT x.endpoint AS endpoint FROM xinbox x WHERE x.seq = ? AND substr(x.endpoint, 1, ?) = ? AND x.seq > COALESCE((SELECT acked_seq FROM xcursor WHERE endpoint = x.endpoint), 0)`,
+      seq,
+      machine.length + 1,
+      `${machine}/`
+    )?.endpoint ?? null;
+  }
+  /**
+   * moves an endpoint's cursor over the leading run of its unacked, unexpired rows that `batch` names, in one write or none; a seq past
+   * a row it does not name stays unacked and replays. How many rows it moved over
+   */
+  advanceCursor(endpoint, batch) {
+    const now = this.now();
+    const cursor = one(this.sql, `SELECT acked_seq FROM xcursor WHERE endpoint = ?`, endpoint)?.acked_seq ?? 0;
+    let to = cursor;
+    let moved = 0;
+    for (const { seq } of this.sql.all(
+      `SELECT seq FROM xinbox WHERE endpoint = ? AND seq > ? AND seq <= ? AND expires_at > ? ORDER BY seq`,
+      endpoint,
+      cursor,
+      Math.max(...batch),
+      now
+    )) {
+      if (!batch.has(seq)) break;
+      to = seq;
+      moved++;
+    }
+    if (to === cursor) return 0;
+    this.sql.all(
+      `INSERT INTO xcursor (endpoint, acked_seq, at) VALUES (?, ?, ?) ON CONFLICT (endpoint) DO UPDATE SET
+         old_seq = CASE WHEN old_at IS NULL OR excluded.at - old_at >= ? THEN acked_seq ELSE old_seq END,
+         old_at = CASE WHEN old_at IS NULL OR excluded.at - old_at >= ? THEN at ELSE old_at END,
+         acked_seq = excluded.acked_seq, at = excluded.at`,
+      endpoint,
+      to,
+      now,
+      XINBOX_KEEP_MS,
+      XINBOX_KEEP_MS
+    );
+    return moved;
+  }
+  /** when the holder part of a mirrored agent's incarnation moved, drops its xinbox rows and deliveries: they were the earlier holder's */
+  dropEarlierHolder(row, incarnation) {
+    const holder = (value) => value?.includes(".") ? value.slice(0, value.indexOf(".")) : null;
+    const was = holder(row.incarnation);
+    const next = holder(incarnation);
+    if (was === null || next === null || was === next) return;
+    let xinbox = 0;
+    if (this.xinbox) {
+      this.xfloor();
+      xinbox = this.sql.all(`DELETE FROM xinbox WHERE endpoint = ? RETURNING seq`, row.remote).length;
+    }
+    const deliveries = this.sql.all(`DELETE FROM deliveries WHERE endpoint = ? RETURNING seq`, row.id).length;
+    this.audit("mirror_reset", row.id, null, { target: row.remote, xinbox, deliveries });
+  }
+  /** keeps the highest xinbox seq as the floor of the next one, before rows are deleted */
+  xfloor() {
+    const top = one(this.sql, `SELECT MAX(seq) AS n FROM xinbox`).n;
+    const floor = Number(one(this.sql, `SELECT value FROM xstate WHERE key = 'seq_floor'`)?.value ?? 0);
+    if (top !== null && top > floor)
+      this.sql.all(`INSERT INTO xstate (key, value) VALUES ('seq_floor', ?) ON CONFLICT (key) DO UPDATE SET value = excluded.value`, String(top));
+  }
+  // internals
+  ownDelivery(machine, seq) {
+    return one(
+      this.sql,
+      `SELECT d.endpoint AS endpoint, d.message_id AS message_id, m.from_ep AS from_ep, m.hop AS hop FROM deliveries d JOIN messages m ON m.id = d.message_id JOIN endpoints e ON e.id = d.endpoint
+       WHERE d.seq = ? AND d.acked_at IS NULL AND substr(e.remote, 1, ?) = ? AND e.token_hash IS NULL`,
+      seq,
+      machine.length + 1,
+      `${machine}/`
+    );
+  }
+  noticeTo(endpoint, text) {
+    const system = this.byHandle(SYSTEM_HANDLE);
+    const now = this.now();
+    const id = newId("msg", now);
+    const expires = now + LIMITS.ttlDefaultS * 1e3;
+    this.sql.all(
+      `INSERT INTO messages (id, thread, reply_to, kind, from_ep, to_addr, body, mime, data_class, attachments, hop, created_at, expires_at)
+       VALUES (?, ?, NULL, 'status', ?, ?, ?, 'text/plain', 'public', '[]', 0, ?, ?)`,
+      id,
+      newId("thr", now),
+      system.id,
+      this.addressOf(endpoint),
+      text,
+      now,
+      expires
+    );
+    return this.insertDelivery(id, endpoint, expires);
+  }
+  forwardHash(params) {
+    const targets = (Array.isArray(params.to) ? params.to : [params.to]).map(String).sort();
+    return this.hash(
+      JSON.stringify([
+        "forward",
+        targets,
+        params.body,
+        params.kind ?? "message",
+        params.thread ?? null,
+        params.reply_to ?? null,
+        params.data_class ?? "public",
+        (params.attachments ?? []).map((a) => a.path).sort(),
+        params.mime ?? null,
+        params.ttl_s ?? null
+      ])
+    );
+  }
+  /** a message from another account passes the recipient's in lists by `acct:`, or as a reply to the recipient's own message to that sender */
+  checkForeignIn(sender, recipient, parent) {
+    if (parent && parent.from_ep === recipient.id && parent.to_addr.split(",").some((to) => to.trim() === this.address(sender))) return;
+    const admission = this.crossAdmission(recipient.id, "in", this.scopeNode(sender));
+    if (admission.ok) return;
+    this.audit("scope_refused", sender.id, null, { from: this.address(sender), to: this.address(recipient), dir: "in", reason: admission.why });
+    throw new RelayError("not_found", `no endpoint ${this.address(recipient)}`);
+  }
+  /** the stand-in row of another account's sender: `@<account>/<machine>/<handle>`, or `@<account>/me` for its human at a terminal */
+  foreignProxy(from) {
+    const bad2 = () => new RelayError("invalid_params", `the sender ${String(from.address)} is not an endpoint of a contact`);
+    const account = from.account;
+    if (typeof account !== "string" || !ACCOUNT_HANDLE.test(account) || this.isLocalUser(account) || from.user !== account) throw bad2();
+    let remote;
+    if (from.human === true) {
+      if (from.address !== `${account}/me`) throw bad2();
+      remote = `@${account}/me`;
+    } else {
+      const parsed = this.foreignAccount(from.address);
+      if (!parsed || parsed.account !== account) throw bad2();
+      remote = `@${account}/${parsed.machine}/${parsed.handle}`;
+    }
+    const harness = from.claims.harness && validHarness(from.claims.harness) ? from.claims.harness : null;
+    const existing = this.byRemote(remote);
+    const id = existing?.id ?? this.insertProxy(remote, from.human === true ? "human" : "agent", harness, from.auth);
+    if (existing && existing.harness !== harness) this.sql.all(`UPDATE endpoints SET harness = ? WHERE id = ?`, harness, id);
+    return id;
+  }
+  proxyFor(from) {
+    if (from.auth === "contact") return this.foreignProxy(from);
+    const prefix = `${from.user}/`;
+    if (!from.address.startsWith(prefix)) throw new RelayError("invalid_params", "the sender's address is not of its user");
+    const rest = from.address.slice(prefix.length);
+    const remote = rest.includes("/") ? rest : `${from.user}/${rest}`;
+    if (!REMOTE.test(remote)) throw new RelayError("invalid_params", `the sender's address ${from.address} is not valid`);
+    const handle = handlePart(remote);
+    const kind = handle === "" ? "human" : rest.includes("/") ? "agent" : "system";
+    const harness = from.claims.harness && validHarness(from.claims.harness) ? from.claims.harness : null;
+    const model = cleanText(from.claims.model, "model", 128);
+    const existing = this.byRemote(remote);
+    const id = existing?.id ?? this.insertProxy(remote, kind, harness, from.auth);
+    if (!existing || existing.harness !== harness || existing.model !== model || existing.auth !== from.auth) {
+      this.sql.all(`UPDATE endpoints SET harness = ?, model = ?, auth = ? WHERE id = ?`, harness, model, from.auth, id);
+    }
+    return id;
+  }
+  checkEnvelope(message) {
+    const bad2 = (what) => new RelayError("invalid_params", `the message's ${what} is not valid`);
+    if (!message || typeof message !== "object") throw bad2("shape");
+    if (typeof message.id !== "string" || !MESSAGE_ID.test(message.id)) throw bad2("id");
+    if (typeof message.thread !== "string" || !message.thread || message.thread.length > 128) throw bad2("thread");
+    if (message.reply_to !== null && (typeof message.reply_to !== "string" || message.reply_to.length > 128)) throw bad2("reply_to");
+    if (!MESSAGE_KINDS.includes(message.kind)) throw bad2("kind");
+    if (typeof message.to !== "string" || message.to.length > 4096) throw bad2("to");
+    if (!message.body || typeof message.body.text !== "string" || typeof message.body.mime !== "string" || message.body.mime.length > 64) throw bad2("body");
+    if (new TextEncoder().encode(message.body.text).length > LIMITS.bodyBytes)
+      throw new RelayError("too_large", `the body is more than ${LIMITS.bodyBytes} bytes`);
+    if (message.data_class !== "public" && message.data_class !== "private") throw bad2("data_class");
+    if (!Array.isArray(message.attachments) || message.attachments.length > LIMITS.attachments || message.attachments.some((a) => a?.kind !== "path" || typeof a.path !== "string" || !a.path.startsWith("/")))
+      throw bad2("attachments");
+    if (!Number.isInteger(message.hop) || message.hop < 0 || message.hop > LIMITS.hopMax) throw bad2("hop");
+    const from = message.from;
+    if (!from || typeof from.address !== "string" || typeof from.user !== "string" || !from.claims || !AUTHS.includes(from.auth)) throw bad2("sender");
+    if (from.claims.tty !== void 0 && typeof from.claims.tty !== "boolean") throw bad2("sender");
+    const createdAt = Date.parse(message.created_at);
+    const expiresAt = Date.parse(message.expires_at);
+    if (!Number.isFinite(createdAt) || !Number.isFinite(expiresAt)) throw bad2("timestamps");
+    const secret = findSecret(message.body.text);
+    if (secret) throw new RelayError("secret_refused", `the message looks like it carries a credential (${secret})`);
+    return { createdAt, expiresAt };
+  }
+  parseView(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) throw new RelayError("invalid_params", "an endpoint is an object");
+    const view = value;
+    if (typeof view.address !== "string") throw new RelayError("invalid_params", "an endpoint needs an address");
+    const handle = view.address.slice(view.address.lastIndexOf("/") + 1);
+    const kind = view.kind;
+    if (kind !== "agent" && kind !== "human") throw new RelayError("invalid_params", "an endpoint's kind is agent or human");
+    if (kind === "human" ? handle !== "" : !validHandle(handle))
+      throw new RelayError("invalid_params", `${JSON.stringify(view.address)} is not a valid endpoint address`);
+    const harness = cleanText(view.harness, "harness", 32);
+    if (harness !== null && !validHarness(harness)) throw new RelayError("invalid_params", `harness ${JSON.stringify(harness)} is not a valid name`);
+    let status = null;
+    if (view.status) {
+      if (!STATUS_STATES.includes(view.status.state)) throw new RelayError("invalid_params", `state must be one of ${STATUS_STATES.join(", ")}`);
+      status = { state: view.status.state, note: cleanText(view.status.note, "note", LIMITS.noteChars) ?? "" };
+    }
+    const presence = view.presence ?? "offline";
+    if (!PRESENCES.includes(presence)) throw new RelayError("invalid_params", "presence is online, idle or offline");
+    const parsedSeen = typeof view.last_seen === "string" ? Date.parse(view.last_seen) : Number.NaN;
+    const out = {
+      handle,
+      kind,
+      harness,
+      model: cleanText(view.model, "model", 128),
+      cwd: cleanText(view.cwd, "cwd", 1024),
+      labels: JSON.stringify(cleanLabels(view.labels)),
+      status,
+      presence,
+      lastSeen: Number.isFinite(parsedSeen) ? parsedSeen : null,
+      scope: kind === "agent" ? parseScope(view) : {}
+    };
+    const leaked = [handle, out.model, out.cwd, out.labels, status?.note, out.scope.title].map((v) => v ? findSecret(v) : null).find(Boolean);
+    if (leaked) throw new RelayError("secret_refused", `an endpoint looks like it carries a credential (${leaked})`);
+    return out;
+  }
+  diff(before, after) {
+    const view = this.remoteView(after);
+    if (!before) return { view, added: true, presence: true, status: true };
+    const was = this.view(before);
+    const presence = was.presence !== view.presence;
+    const status = before.status_state !== after.status_state || before.status_note !== after.status_note;
+    const other = ["kind", "harness", "model", "cwd", "labels", "title", "tree", "parent_ep", "depth", "rules", "caps", "incarnation"].some(
+      (field) => before[field] !== after[field]
+    );
+    return presence || status || other ? { view, added: false, presence, status } : null;
+  }
+  remoteView(row) {
+    const remote = row.remote;
+    const view = { ...this.view(row), machine: remote ? machinePart(remote) : this.machine ?? "" };
+    if (row.kind !== "agent") return view;
+    const handle = (id) => {
+      const other = id ? this.byId(id) : void 0;
+      return other?.remote ? handlePart(other.remote) : null;
+    };
+    return {
+      ...view,
+      tree: row.depth === null ? null : row.tree ? handle(row.tree) : remote ? handlePart(remote) : row.handle,
+      parent_ep: handle(row.parent_ep),
+      depth: row.depth,
+      rules: row.rules ? JSON.parse(row.rules) : null,
+      caps: row.caps ? this.wireCaps(JSON.parse(row.caps)) : null,
+      incarnation: row.incarnation ?? null
+    };
+  }
+  /**
+   * the place each agent of a mirror batch gets, worked out here: a root is a view with no parent and depth 0; a child sits one below its
+   * parent, which must be an agent this machine mirrors; anything else (a parent on another machine or not mirrored, a cycle, a root
+   * claiming depth) is unknown. Undefined when the view says nothing about its place.
+   */
+  placer(machine, batch) {
+    const agents = new Map(batch.filter((entry) => entry.view.kind === "agent").map((entry) => [entry.view.handle, entry]));
+    const memo = /* @__PURE__ */ new Map();
+    const place = (handle, trail) => {
+      if (trail.includes(handle)) return UNKNOWN;
+      if (memo.has(handle)) return memo.get(handle);
+      const { parent, depth } = agents.get(handle).view.scope;
+      let result;
+      if (parent === void 0 && depth === void 0) result = void 0;
+      else if (parent === void 0) result = UNKNOWN;
+      else if (parent === null) result = depth === 0 ? { tree: null, parent_ep: null, depth: 0 } : UNKNOWN;
+      else {
+        const row = validHandle(parent) ? this.byRemote(`${machine}/${parent}`) : void 0;
+        if (!row || row.token_hash !== null || row.kind !== "agent") result = UNKNOWN;
+        else {
+          const up = agents.has(parent) ? place(parent, [...trail, handle]) ?? (agents.get(parent).before ? stored(agents.get(parent).before) : UNKNOWN) : stored(row);
+          result = up.depth === null || up.depth + 1 > LIMITS.depthMax ? UNKNOWN : { tree: up.tree ?? row.id, parent_ep: row.id, depth: up.depth + 1 };
+        }
+      }
+      if (!trail.length) memo.set(handle, result);
+      return result;
+    };
+    return (handle) => place(handle, []);
+  }
+  /** an agent row's place, rules, caps, title and incarnation after a view: what it left out stays, unless the endpoint is a new incarnation */
+  scopeColumns(machine, scope, row, placement) {
+    const fresh = scope.incarnation !== void 0 && scope.incarnation !== null && row.incarnation !== null && scope.incarnation !== row.incarnation;
+    const place = placement ?? (fresh ? UNKNOWN : stored(row));
+    let caps = fresh ? null : row.caps;
+    if (scope.caps !== void 0) {
+      const next = this.localCaps(machine, scope.caps ?? { caps: [], allow: {} });
+      const merged = fresh || !row.caps ? next : stickyCaps(JSON.parse(row.caps), next);
+      caps = merged.caps.length || Object.keys(merged.allow).length ? JSON.stringify(merged) : null;
+    }
+    const rules = scope.rules !== void 0 ? scope.rules : fresh ? null : void 0;
+    return {
+      ...place,
+      rules: rules === void 0 ? row.rules : rules && (rules.in || rules.out) ? JSON.stringify(rules) : null,
+      caps,
+      title: scope.title !== void 0 ? scope.title : fresh ? null : row.title,
+      incarnation: scope.incarnation ?? row.incarnation
+    };
+  }
+  /** wire caps of `machine` with their `ep:<handle>` references as this core's row ids; an endpoint the machine does not mirror is `gone`, which admits nothing */
+  localCaps(machine, caps) {
+    const ref = (value) => {
+      if (REFS.has(value)) return value;
+      const handle = value.startsWith("ep:") ? value.slice(3) : "";
+      const row = validHandle(handle) ? this.byRemote(`${machine}/${handle}`) : void 0;
+      return row && row.token_hash === null && row.kind === "agent" ? row.id : "gone";
+    };
+    return mapRefs(caps, ref);
+  }
+  /** caps with this core's row ids named as `ep:<handle>`, as they cross machines */
+  wireCaps(caps) {
+    const ref = (value) => {
+      if (REFS.has(value)) return value;
+      const row = this.byId(value);
+      if (row?.kind !== "agent") return "gone";
+      return `ep:${row.remote ? handlePart(row.remote) : row.handle}`;
+    };
+    const mapped = mapRefs(caps, ref);
+    return { caps: mapped.caps, allow: mapped.allow };
+  }
+  insertRemote(remote, kind, harness, auth, now) {
+    const id = newId("ep", now);
+    this.sql.all(
+      `INSERT INTO endpoints (id, handle, kind, harness, labels, created_at, remote, auth) VALUES (?, ?, ?, ?, '{}', ?, ?, ?)`,
+      id,
+      `_r_${id}`,
+      kind,
+      harness,
+      now,
+      remote,
+      auth
+    );
+    return id;
+  }
+  retire(id) {
+    this.sql.all(`UPDATE endpoints SET handle = ? || id, remote = NULL, token_hash = NULL, connections = 0 WHERE id = ?`, GONE_PREFIX, id);
+    this.dropPeek(id);
+  }
+  /** a new proxy row, within the endpoint cap */
+  insertProxy(remote, kind, harness, auth) {
+    this.checkCap();
+    return this.insertRemote(remote, kind, harness, auth, this.now());
+  }
+  checkCap() {
+    if (this.endpointCap === null) return;
+    const live = one(
+      this.sql,
+      `SELECT COUNT(*) AS n FROM endpoints WHERE kind != 'system' AND substr(handle, 1, ?) != ?`,
+      GONE_PREFIX.length,
+      GONE_PREFIX
+    ).n;
+    if (live >= this.endpointCap) throw new RelayError("too_large", `at most ${this.endpointCap} endpoints on this relay`);
+  }
+  checkMachine(machine) {
+    if (typeof machine !== "string" || !MACHINE_NAME.test(machine))
+      throw new RelayError("invalid_params", `machine ${JSON.stringify(machine)} is not a valid name`);
+  }
+  byRemote(remote) {
+    return one(this.sql, `SELECT * FROM endpoints WHERE remote = ?`, remote);
+  }
+  /** a judge status notice to `endpoint` from the relay; its delivery seq */
+  judgeNoticeTo(endpoint, text) {
+    return this.noticeTo(endpoint, text);
+  }
+};
+var stored = (row) => ({ tree: row.tree, parent_ep: row.parent_ep, depth: row.depth });
+function mapRefs(caps, ref) {
+  const entries = (list) => list.map((entry) => entry.via === void 0 ? entry : { ...entry, via: ref(entry.via) });
+  return {
+    caps: caps.caps.map((cap) => ({ ...cap, by: ref(cap.by), sels: entries(cap.sels) })),
+    allow: Object.fromEntries(Object.entries(caps.allow ?? {}).map(([key, list]) => [key, entries(list)]))
+  };
+}
+function stickyCaps(seen, next) {
+  const plain = (entry) => entry.via === void 0;
+  const caps = next.caps.map((cap) => {
+    const old = seen.caps.find((had) => had.id === cap.id);
+    return old ? { ...cap, sels: cap.sels.filter((entry) => !plain(entry) || old.sels.some((had) => plain(had) && had.sel === entry.sel && had.group === entry.group)) } : cap;
+  });
+  for (const old of seen.caps) if (!next.caps.some((cap) => cap.id === old.id)) caps.push(old);
+  return { caps, allow: next.allow };
+}
+function loosens(seen, next) {
+  const plain = (entry) => entry.via === void 0;
+  return seen.caps.some((old) => {
+    const cap = next.caps.find((c) => c.id === old.id);
+    return !cap || cap.sels.some((entry) => plain(entry) && !old.sels.some((had) => plain(had) && had.sel === entry.sel && had.group === entry.group));
+  });
+}
+var bad = (what) => new RelayError("invalid_params", `an endpoint's ${what} is not valid`);
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function shortText(value, what, max = 128) {
+  if (typeof value !== "string" || !value || value.length > max) throw bad(what);
+  return value;
+}
+function parseSelectors(value, what) {
+  if (!Array.isArray(value) || value.length > 64 || value.some((sel) => !validSelector(sel))) throw bad(what);
+  return value;
+}
+function parseEntries(value) {
+  if (!Array.isArray(value) || value.length > 64) throw bad("caps");
+  return value.map((entry) => {
+    if (!isRecord(entry) || !validSelector(entry.sel)) throw bad("caps");
+    return {
+      sel: entry.sel,
+      ...entry.via === void 0 ? {} : { via: shortText(entry.via, "caps") },
+      ...entry.group === void 0 ? {} : { group: shortText(entry.group, "caps") },
+      ...entry.base === true ? { base: true } : {},
+      ...entry.member === true ? { member: true } : {}
+    };
+  });
+}
+function parseScope(view) {
+  const out = {};
+  const given = (key) => key in view && view[key] !== void 0;
+  if (given("tree")) out.tree = view.tree === null ? null : shortText(view.tree, "tree");
+  if (given("parent_ep")) out.parent = view.parent_ep === null ? null : shortText(view.parent_ep, "parent_ep");
+  if (given("depth")) {
+    if (view.depth !== null && (!Number.isInteger(view.depth) || view.depth < 0 || view.depth > 1e3)) throw bad("depth");
+    out.depth = view.depth ?? null;
+  }
+  if (given("rules")) {
+    if (view.rules !== null && !isRecord(view.rules)) throw bad("rules");
+    const rules = view.rules;
+    out.rules = rules ? {
+      ...rules.in === void 0 ? {} : { in: parseSelectors(rules.in, "rules") },
+      ...rules.out === void 0 ? {} : { out: parseSelectors(rules.out, "rules") }
+    } : null;
+  }
+  if (given("caps")) {
+    if (view.caps === null) out.caps = null;
+    else {
+      const caps = view.caps;
+      if (!isRecord(caps) || !Array.isArray(caps.caps) || caps.caps.length > 64 || caps.allow !== void 0 && !isRecord(caps.allow)) throw bad("caps");
+      const allow = Object.entries(caps.allow ?? {});
+      if (allow.length > 64) throw bad("caps");
+      out.caps = {
+        caps: caps.caps.map((cap) => {
+          if (!isRecord(cap) || cap.dir !== "in" && cap.dir !== "out") throw bad("caps");
+          return { id: shortText(cap.id, "caps"), dir: cap.dir, by: shortText(cap.by, "caps"), sels: parseEntries(cap.sels) };
+        }),
+        allow: Object.fromEntries(allow.map(([key, list]) => [shortText(key, "caps"), parseEntries(list)]))
+      };
+    }
+  }
+  if (new TextEncoder().encode(JSON.stringify([out.rules ?? null, out.caps ?? null])).length > SCOPE_BYTES)
+    throw new RelayError("too_large", `an endpoint's rules and caps are more than ${SCOPE_BYTES} bytes`);
+  if (given("title"))
+    out.title = view.title === null ? null : cleanText(typeof view.title === "string" ? view.title.replace(/\s+/g, " ") : view.title, "title", 64) || null;
+  if (given("incarnation")) {
+    if (view.incarnation !== null && (typeof view.incarnation !== "string" || !INCARNATION.test(view.incarnation))) throw bad("incarnation");
+    out.incarnation = view.incarnation ?? null;
+  }
+  return out;
+}
+
+// src/hub.ts
+import {
+  allowlisted,
+  CAPABILITIES,
+  CLI_NAME,
+  cleanText as cleanText2,
+  dayStart,
+  declaredLimits,
+  findSecret as findSecret2,
+  gateRefusal,
+  HUMAN_HANDLE as HUMAN_HANDLE2,
+  honestSender,
+  joinRedacted,
+  judgeDetailForAgents,
+  LIMITS as LIMITS2,
+  MESSAGE_KINDS as MESSAGE_KINDS2,
+  newId as newId2,
+  one as one2,
+  PREAMBLE,
+  PROTOCOL,
+  parseXMessage,
+  RelayError as RelayError2,
+  randomHex as randomHex2,
+  replyGrant,
+  SERVER_FIELDS,
+  SYSTEM_HANDLE as SYSTEM_HANDLE2,
+  sameSecret,
+  untilTomorrow,
+  XCounters,
+  XLIMITS,
+  xlimits
+} from "@scp-dev/core";
+var HUB_LIMITS = {
+  machines: 16,
+  endpoints: 512,
+  sockets: 64,
+  frameBytes: 262144,
+  callsPerMinute: 120,
+  bridgeCallsPerMinute: 600,
+  accountCallsPerMinute: 1200,
+  acksPerMinute: 1200,
+  accountAcksPerMinute: 4800,
+  storedBytes: 256 * 1024 * 1024,
+  clientMachineIdleS: 14 * 86400,
+  idlePurgeS: 30 * 86400,
+  httpWaitS: 25,
+  revalidateMs: 3e5,
+  deniedS: 3600,
+  refusalsPerMinute: 10
+};
+var DURATIONS = ["clientMachineIdleS", "idlePurgeS", "httpWaitS", "revalidateMs", "deniedS"];
+var SWEEP_MS = 10 * 6e4;
+var DAY_MS = 864e5;
+var MIN_ALARM_MS = 6e4;
+var REVALIDATE_RETRY_MS = 3e4;
+var REVALIDATE_ERROR = "revalidate_error:";
+var DENIED = "denied:";
+var TOUCH_MS = 1e4;
+var HUB_MIGRATION = [
+  `CREATE TABLE IF NOT EXISTS machines (name TEXT PRIMARY KEY, token_id TEXT NOT NULL, kind TEXT NOT NULL, created_at INTEGER NOT NULL, last_seen INTEGER)`,
+  `CREATE TABLE IF NOT EXISTS hub_state (key TEXT PRIMARY KEY, value INTEGER NOT NULL)`,
+  `CREATE TABLE IF NOT EXISTS machine_tombstones (name TEXT PRIMARY KEY, actor_id TEXT, user_id TEXT, at INTEGER NOT NULL)`
+];
+var OBSERVER_METHODS = /* @__PURE__ */ new Set(["list", "snapshot", "watch", "log", "machines", "machines_rm"]);
+var CLIENT_METHODS = /* @__PURE__ */ new Set(["whoami", "send", "ask", "ask_wait", "inbox", "ack", "status", "event", ...OBSERVER_METHODS]);
+var iso = (ms) => ms === null ? null : new Date(ms).toISOString();
+function rpcError(error) {
+  if (!(error instanceof RelayError2)) return { code: -32603, message: "internal error", data: { code: "unavailable" } };
+  const code = error.code === "method_not_found" ? -32601 : error.code === "invalid_params" ? -32602 : -32e3;
+  return { code, message: error.message, data: { code: error.code, ...error.retryAfterS ? { retry_after: error.retryAfterS } : {} } };
+}
+function mirrorSync(value) {
+  if (value === void 0 || value === null) return null;
+  const { id, part, parts } = value;
+  if (typeof id !== "string" || !id || id.length > 64 || !Number.isInteger(parts) || parts < 1 || parts > 4096 || !Number.isInteger(part) || part < 1 || part > parts) {
+    throw new RelayError2("invalid_params", "sync is { id, part, parts } of a full mirror in several frames");
+  }
+  return { id, part, parts };
+}
+function serverFields(params) {
+  for (const field of SERVER_FIELDS) if (field in params) throw new RelayError2("invalid_params", `${field} is set by the relay, not the sender`);
+}
+function object(value, what) {
+  if (value === void 0) return {};
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new RelayError2("invalid_params", `${what} must be an object`);
+  return value;
+}
+var fullLogin = (grant) => grant.scoped === false;
+var fullOf = (grant, actorId) => fullLogin(grant) && grant.actorId === actorId;
+var accountAdmin = (grant) => fullLogin(grant) && (grant.role === "owner" || grant.role === "admin" || (grant.role ?? null) === null && grant.actorId === null);
+function grantLabels(grant, labels) {
+  if (!grant.labels || !Object.keys(grant.labels).length) return labels;
+  if (labels !== void 0 && labels !== null && (typeof labels !== "object" || Array.isArray(labels))) return labels;
+  return { ...labels, ...grant.labels };
+}
+function grantViews(grant, views) {
+  if (!grant.labels || !Array.isArray(views)) return views;
+  return views.map(
+    (view) => view && typeof view === "object" && !Array.isArray(view) ? { ...view, labels: grantLabels(grant, view.labels) } : view
+  );
+}
+function listFilters(params) {
+  return {
+    all: params.all === true,
+    harness: typeof params.harness === "string" ? params.harness : void 0,
+    kind: params.kind === "agent" || params.kind === "human" ? params.kind : void 0,
+    presence: params.presence === "online" || params.presence === "idle" || params.presence === "offline" ? params.presence : void 0
+  };
+}
+var RelayHub = class _RelayHub {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? Date.now;
+    this.limits = { ...HUB_LIMITS, ...deps.limits };
+    for (const key of DURATIONS) if (!Number.isFinite(this.limits[key])) throw new RangeError(`hub limit ${key} must be finite`);
+  }
+  deps;
+  core = null;
+  account = "";
+  now;
+  waiters = /* @__PURE__ */ new Map();
+  buckets = /* @__PURE__ */ new Map();
+  transient = /* @__PURE__ */ new Set();
+  gone = /* @__PURE__ */ new Set();
+  /** per machine, the full mirror its bridge is sending in several frames; lost on eviction, which only skips that sync's offline sweep */
+  syncs = /* @__PURE__ */ new Map();
+  stored = null;
+  denied = null;
+  xcounters = null;
+  xkey = null;
+  limits;
+  /** idempotent: migrates and records the account handle (the address user part, e.g. "ada"); call before handling each request */
+  init(account) {
+    if (this.core && this.account === account.user) return;
+    for (const statement of HUB_MIGRATION) this.deps.sql.all(statement);
+    const columns = this.deps.sql.all(`PRAGMA table_info(machines)`).map((c) => c.name);
+    if (!columns.includes("user_id")) this.deps.sql.all(`ALTER TABLE machines ADD COLUMN user_id TEXT`);
+    if (!columns.includes("actor_id")) this.deps.sql.all(`ALTER TABLE machines ADD COLUMN actor_id TEXT`);
+    const core = new FederatedCore(this.deps.sql, {
+      user: account.user,
+      now: this.now,
+      hash: this.deps.hash,
+      ...this.deps.transaction ? { transaction: this.deps.transaction } : {},
+      auth: "account",
+      endpointCap: this.limits.endpoints,
+      refusalsPerMinute: this.limits.refusalsPerMinute,
+      capEverySender: true,
+      xinbox: this.deps.crossAccount !== void 0
+    });
+    core.migrate();
+    this.core = core;
+    this.account = account.user;
+    if (this.deps.crossAccount) {
+      this.xkey = core.xstate("key", () => randomHex2(32));
+      this.xcounters = new XCounters(this.deps.sql, this.now);
+    }
+  }
+  /** forgets the core and in-memory state after the object's storage was deleted; the next init migrates afresh */
+  reset() {
+    this.core = null;
+    this.account = "";
+    this.stored = null;
+    this.denied = null;
+    this.xcounters = null;
+    this.xkey = null;
+    this.buckets.clear();
+    this.gone.clear();
+  }
+  /** a fresh connection state for an accepted socket */
+  static connection(grant) {
+    return { id: newId2("conn"), grant, role: "new", machine: null, endpoint: null, watching: false, subscribed: false };
+  }
+  /** a socket would exceed the `sockets` limit: the host refuses it (429) instead of accepting */
+  full() {
+    return this.deps.sockets().length >= this.limits.sockets;
+  }
+  /** one JSON-RPC text frame from a socket; replies and pushes go out through socket.send */
+  async message(socket, text) {
+    if (new TextEncoder().encode(text).length > this.limits.frameBytes) {
+      this.write(socket, { jsonrpc: "2.0", id: null, error: rpcError(new RelayError2("too_large", `a frame is at most ${this.limits.frameBytes} bytes`)) });
+      socket.close(1009, "frame too large");
+      this.closed(socket);
+      return;
+    }
+    let request;
+    try {
+      request = JSON.parse(text);
+    } catch {
+      this.write(socket, { jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+      return;
+    }
+    if (!request || typeof request !== "object" || Array.isArray(request)) {
+      this.write(socket, { jsonrpc: "2.0", id: null, error: { code: -32600, message: "one JSON-RPC request per frame" } });
+      return;
+    }
+    const response = await this.handle(socket, request);
+    if (response) this.write(socket, response);
+  }
+  /** the socket closed (any reason) */
+  closed(socket) {
+    this.release(socket, false);
+  }
+  /** POST /v1/relay/rpc: a JSON-RPC request or batch run in order on a short-lived connection; returns the response(s) */
+  async batch(grant, body) {
+    if (JSON.stringify(body ?? null).length > this.limits.frameBytes) {
+      return { jsonrpc: "2.0", id: null, error: rpcError(new RelayError2("too_large", `a request is at most ${this.limits.frameBytes} bytes`)) };
+    }
+    const requests = Array.isArray(body) ? body : [body];
+    if (!requests.length) return { jsonrpc: "2.0", id: null, error: { code: -32600, message: "an empty batch" } };
+    const socket = { conn: _RelayHub.connection(grant), send: () => {
+    }, close: () => {
+    } };
+    this.transient.add(socket);
+    const responses = [];
+    try {
+      for (const request of requests) {
+        if (!request || typeof request !== "object" || Array.isArray(request)) {
+          responses.push({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "a request is an object" } });
+          continue;
+        }
+        const response = await this.handle(socket, request);
+        if (response) responses.push(response);
+      }
+    } finally {
+      this.closed(socket);
+      this.transient.delete(socket);
+    }
+    return Array.isArray(body) ? responses : responses[0] ?? null;
+  }
+  /**
+   * closes every socket (and in-flight /rpc call) whose grant matches with 1008, audits it, and unbinds the machines
+   * the matching grants bound behind a tombstone of their member, keeping their endpoint rows and queued messages;
+   * returns how many closed
+   */
+  revoke(match) {
+    const keys = Object.entries(match).filter(([, value]) => value !== void 0);
+    if (!keys.length) return 0;
+    let closed = 0;
+    const tokens = new Set(match.tokenId !== void 0 ? [match.tokenId] : []);
+    for (const socket of [...this.deps.sockets(), ...this.transient]) {
+      if (this.gone.has(socket.conn.id) || !keys.every(([key, value]) => socket.conn.grant[key] === value)) continue;
+      tokens.add(socket.conn.grant.tokenId);
+      this.kick(socket, "the token was revoked");
+      closed++;
+    }
+    if (closed) this.relay.record("revoke", null, null, { sockets: closed });
+    const columns = match.tokenId !== void 0 ? [["token_id", match.tokenId]] : keys.map(([key, value]) => [key === "userId" ? "user_id" : "actor_id", value]);
+    const where = columns.map(([column]) => `${column} = ?`).join(" AND ");
+    const now = this.now();
+    for (const row of this.deps.sql.all(
+      `DELETE FROM machines WHERE ${where} RETURNING name, token_id, actor_id, user_id`,
+      ...columns.map(([, value]) => value)
+    )) {
+      tokens.add(row.token_id);
+      this.deps.sql.all(`INSERT OR REPLACE INTO machine_tombstones (name, actor_id, user_id, at) VALUES (?, ?, ?, ?)`, row.name, row.actor_id, row.user_id, now);
+      this.relay.record("machine_unbind", null, row.name, { machine: row.name });
+    }
+    const denied = this.deniedGrants();
+    for (const token of tokens) {
+      denied.set(DENIED + token, now);
+      this.setState(DENIED + token, now);
+    }
+    this.deps.log?.("relay_action", { account: this.account, method: "revoke", sockets: closed });
+    return closed;
+  }
+  /**
+   * the host's alarm: revalidates each socket's grant and sweeps; returns the next alarm time in ms, or null. A failed
+   * check closes with 1008, an expired grant with 4001 (reconnect for a new one). A check that throws keeps the
+   * sockets and retries in 30 s; once a token's checks kept throwing for the `revalidateMs` limit its sockets close
+   * with the retryable 1013.
+   */
+  async alarm(validate) {
+    const now = this.now();
+    this.xcounters?.trueUp();
+    const checks = /* @__PURE__ */ new Map();
+    const erroring = /* @__PURE__ */ new Set();
+    for (const socket of [...this.deps.sockets()]) {
+      const grant = socket.conn.grant;
+      if (grant.expiresAt <= now) {
+        this.kick(socket, "the token grant expired, reconnect", 4001);
+        continue;
+      }
+      const key = JSON.stringify([grant.tokenId, grant.userId, grant.actorId, grant.expiresAt, grant.scoped, grant.role]);
+      let check = checks.get(key);
+      if (!check) {
+        check = validate(grant).catch((error) => {
+          this.deps.log?.("relay_revalidate_error", { account: this.account, error: error instanceof Error ? error.name : "error" });
+          return null;
+        });
+        checks.set(key, check);
+      }
+      const valid = await check;
+      if (valid === false) {
+        this.kick(socket, "the token is no longer valid");
+      } else if (valid === null) {
+        erroring.add(grant.tokenId);
+        const key2 = REVALIDATE_ERROR + grant.tokenId;
+        let since = this.state(key2);
+        if (since === null) {
+          since = now;
+          this.setState(key2, since);
+        }
+        if (now - since >= this.limits.revalidateMs) this.kick(socket, "the token could not be revalidated, try again", 1013);
+      }
+    }
+    for (const { key } of this.deps.sql.all(`SELECT key FROM hub_state WHERE key LIKE ?`, `${REVALIDATE_ERROR}%`)) {
+      const tokenId = key.slice(REVALIDATE_ERROR.length);
+      const lingering = this.deps.sockets().some((s) => s.conn.grant.tokenId === tokenId && !this.gone.has(s.conn.id));
+      if (!erroring.has(tokenId) || !lingering) this.deps.sql.all(`DELETE FROM hub_state WHERE key = ?`, key);
+    }
+    this.setState("last_validated", now);
+    if (now - (this.state("last_sweep") ?? 0) >= SWEEP_MS) {
+      this.relay.sweep();
+      this.expireMachines(now);
+      this.forgetTombstones(now);
+      const denied = this.deniedGrants();
+      for (const [key, at] of denied) {
+        if (at > now - this.limits.deniedS * 1e3) continue;
+        denied.delete(key);
+        this.deps.sql.all(`DELETE FROM hub_state WHERE key = ?`, key);
+      }
+      this.stored = null;
+      this.gone.clear();
+      for (const [key, bucket] of this.buckets) if (bucket.tokens + (now - bucket.at) * bucket.rate / 6e4 >= bucket.rate) this.buckets.delete(key);
+      this.xcounters?.prune();
+      this.setState("last_sweep", now);
+    }
+    if (this.idle(now)) {
+      if (this.state("idle_since") === null) this.setState("idle_since", now);
+    } else {
+      this.deps.sql.all(`DELETE FROM hub_state WHERE key = 'idle_since'`);
+    }
+    return this.nextAlarm();
+  }
+  /** when the next alarm should fire (earliest grant expiry, revalidation or its retry after an error, sweep, retention), or null when the hub holds nothing */
+  nextAlarm() {
+    const now = this.now();
+    const trueUp = this.xcounters?.dueAt() ?? null;
+    const held = this.retentionAlarm(now);
+    const retention = held === null || trueUp === null ? held ?? trueUp : Math.min(held, trueUp);
+    const sockets = this.deps.sockets();
+    if (!sockets.length) return retention;
+    let validated = this.state("last_validated");
+    if (validated === null) {
+      validated = now;
+      this.setState("last_validated", validated);
+    }
+    let swept = this.state("last_sweep");
+    if (swept === null) {
+      swept = now;
+      this.setState("last_sweep", swept);
+    }
+    const retrying = one2(this.deps.sql, `SELECT 1 FROM hub_state WHERE key LIKE ? LIMIT 1`, `${REVALIDATE_ERROR}%`) !== void 0;
+    return Math.min(
+      validated + (retrying ? REVALIDATE_RETRY_MS : this.limits.revalidateMs),
+      swept + SWEEP_MS,
+      retention ?? Number.POSITIVE_INFINITY,
+      ...sockets.map((s) => s.conn.grant.expiresAt)
+    );
+  }
+  /** the account held no machines, tombstones, sockets or queued messages for the `idlePurgeS` limit: the object may delete its storage */
+  purgeDue() {
+    const since = this.state("idle_since");
+    return since !== null && this.now() - since >= this.limits.idlePurgeS * 1e3 && this.idle(this.now());
+  }
+  /** while the hub holds rows: the earliest unacked delivery's expiry, at most a day and at least a minute away */
+  retentionAlarm(now) {
+    const sql = this.deps.sql;
+    const held = one2(
+      sql,
+      `SELECT EXISTS (SELECT 1 FROM machines) OR EXISTS (SELECT 1 FROM machine_tombstones) OR EXISTS (SELECT 1 FROM endpoints WHERE handle NOT IN (?, ?))
+       OR EXISTS (SELECT 1 FROM messages) OR EXISTS (SELECT 1 FROM deliveries) OR EXISTS (SELECT 1 FROM audit) AS held`,
+      HUMAN_HANDLE2,
+      SYSTEM_HANDLE2
+    ).held;
+    if (!held) return null;
+    const expiry = one2(sql, `SELECT MIN(expires_at) AS at FROM deliveries WHERE acked_at IS NULL`).at;
+    return Math.max(now + MIN_ALARM_MS, Math.min(expiry ?? Number.POSITIVE_INFINITY, now + DAY_MS));
+  }
+  /** no machine bound or tombstoned, no live socket and nothing queued */
+  idle(now) {
+    if (this.deps.sockets().some((s) => !this.gone.has(s.conn.id))) return false;
+    return !one2(
+      this.deps.sql,
+      `SELECT EXISTS (SELECT 1 FROM machines) OR EXISTS (SELECT 1 FROM machine_tombstones) OR EXISTS (SELECT 1 FROM deliveries WHERE acked_at IS NULL AND expires_at > ?) AS busy`,
+      now
+    ).busy;
+  }
+  // dispatch
+  get relay() {
+    if (!this.core) throw new Error("RelayHub.init was not called");
+    return this.core;
+  }
+  async handle(socket, request) {
+    const id = request.id ?? null;
+    const method = String(request.method);
+    let code = "ok";
+    try {
+      this.refuseDenied(socket);
+      this.spend(socket, method, request.params);
+      const result = await this.dispatch(socket, method, object(request.params, "params"));
+      return request.id === void 0 ? null : { jsonrpc: "2.0", id, result };
+    } catch (error) {
+      code = error instanceof RelayError2 ? error.code : "internal";
+      if (code === "internal") this.deps.log?.("relay_internal_error", { account: this.account, method, error: error instanceof Error ? error.name : "error" });
+      return request.id === void 0 ? null : { jsonrpc: "2.0", id, error: rpcError(error) };
+    } finally {
+      this.deps.log?.("relay_action", { account: this.account, machine: socket.conn.machine, method, code });
+    }
+  }
+  /**
+   * one call from the token's bucket for the connection's role (a bridge, or a bridge hello, has its own, larger one)
+   * and from the account's; acks (one token per seq) and rejects spend from separate ack buckets of the token and the
+   * account instead, so they never starve calls, and an activity event is refused once either call bucket is below a
+   * quarter, so sends keep the rest
+   */
+  spend(socket, method, params) {
+    const conn = socket.conn;
+    const now = this.now();
+    if (method === "ack" && (conn.role === "client" || conn.role === "bridge") || method === "reject" && conn.role === "bridge") {
+      const seqs = params?.seqs;
+      const cost = method === "ack" && Array.isArray(seqs) ? Math.min(Math.max(seqs.length, 1), LIMITS2.inboxPage) : 1;
+      const token = this.bucket(`${conn.grant.tokenId}:ack`, this.limits.acksPerMinute, now);
+      const account2 = this.bucket("account:ack", this.limits.accountAcksPerMinute, now);
+      for (const [b, scope] of [
+        [token, "a token"],
+        [account2, "an account"]
+      ]) {
+        if (b.tokens < cost)
+          throw new RelayError2("rate_limited", `at most ${b.rate} acked seqs per minute on ${scope}`, Math.max(1, Math.ceil((cost - b.tokens) * 60 / b.rate)));
+      }
+      token.tokens -= cost;
+      account2.tokens -= cost;
+      return;
+    }
+    const bridge = conn.role === "bridge" || conn.role === "new" && method === "hello" && params?.bridge === true;
+    const rate = bridge ? this.limits.bridgeCallsPerMinute : this.limits.callsPerMinute;
+    const bucket = this.bucket(`${conn.grant.tokenId}:${bridge ? "bridge" : "client"}`, rate, now);
+    const account = this.bucket("account", this.limits.accountCallsPerMinute, now);
+    if (method === "event") {
+      for (const b of [bucket, account]) {
+        if (b.tokens < b.rate / 4)
+          throw new RelayError2(
+            "rate_limited",
+            "activity events wait while the token or the account is near its call limit",
+            Math.max(1, Math.ceil((b.rate / 4 - b.tokens) * 60 / b.rate))
+          );
+      }
+    }
+    if (bucket.tokens < 1) {
+      if (++bucket.refused >= rate) {
+        socket.close(1013, "rate limited");
+        this.closed(socket);
+      }
+      throw new RelayError2(
+        "rate_limited",
+        `at most ${rate} ${bridge ? "bridge " : ""}calls per minute on a token`,
+        Math.max(1, Math.ceil((1 - bucket.tokens) * 60 / rate))
+      );
+    }
+    if (account.tokens < 1) {
+      throw new RelayError2(
+        "rate_limited",
+        `at most ${this.limits.accountCallsPerMinute} calls per minute on an account`,
+        Math.max(1, Math.ceil((1 - account.tokens) * 60 / account.rate))
+      );
+    }
+    bucket.tokens -= 1;
+    bucket.refused = 0;
+    account.tokens -= 1;
+  }
+  bucket(key, rate, now) {
+    if (rate === Number.POSITIVE_INFINITY) return { rate, tokens: rate, at: now, refused: 0 };
+    const bucket = this.buckets.get(key) ?? { rate, tokens: rate, at: now, refused: 0 };
+    bucket.tokens = Math.min(rate, bucket.tokens + (now - bucket.at) * rate / 6e4);
+    bucket.at = now;
+    this.buckets.set(key, bucket);
+    return bucket;
+  }
+  async dispatch(socket, method, params) {
+    if (this.gone.has(socket.conn.id)) throw new RelayError2("unauthorized", "this connection is closed");
+    if (method === "hello") return this.hello(socket, params);
+    if (socket.conn.role === "new") throw new RelayError2("unauthorized", "call hello first");
+    if (socket.conn.role === "bridge") return this.bridgeMethod(socket, method, params);
+    if (socket.conn.role === "observer" && !OBSERVER_METHODS.has(method)) {
+      if (CLIENT_METHODS.has(method)) throw new RelayError2("unauthorized", "this connection only observes: say hello as an agent or the human");
+      throw new RelayError2("method_not_found", `no method ${method}`);
+    }
+    return this.clientMethod(socket, method, params);
+  }
+  hello(socket, params) {
+    const core = this.relay;
+    const conn = socket.conn;
+    if (conn.role !== "new") throw new RelayError2("invalid_params", "hello was already called on this connection");
+    if (params.protocol !== PROTOCOL) throw new RelayError2("invalid_params", `this relay speaks ${PROTOCOL}`);
+    if (params.transient !== void 0)
+      throw new RelayError2("invalid_params", "the hub takes no hook connections: hooks report to the local broker, which bridges them");
+    serverFields(params);
+    const observe = params.observe === true;
+    const named = params.machine;
+    if ((!observe || named !== void 0) && (typeof named !== "string" || !MACHINE_NAME.test(named) || named === "me" || named === this.account)) {
+      throw new RelayError2("invalid_params", "machine is a name of lowercase letters, digits and -, other than me and the account handle");
+    }
+    const bridge = params.bridge === true;
+    const human = params.human === true;
+    this.deps.sql.all(`DELETE FROM hub_state WHERE key = 'idle_since'`);
+    const info = { account: this.account, capabilities: CAPABILITIES, server_time: new Date(this.now()).toISOString(), limits: { ...LIMITS2, ...this.limits } };
+    if (observe) {
+      if (bridge || human || params.claim !== void 0 || params.resume !== void 0)
+        throw new RelayError2("invalid_params", "an observer hello has no bridge, human, claim or resume");
+      conn.role = "observer";
+      conn.machine = typeof named === "string" ? named : null;
+      this.save(socket);
+      return { ...info, ...conn.machine ? { machine: conn.machine } : {} };
+    }
+    const machine = named;
+    const base = { ...info, machine };
+    if (bridge && this.transient.has(socket)) throw new RelayError2("invalid_params", "a bridge connects over the WebSocket");
+    if (human && typeof params.tty !== "boolean")
+      throw new RelayError2("invalid_params", "a human hello says whether a terminal is attached (tty: true or false)");
+    if (human) {
+      if (!fullLogin(conn.grant)) throw new RelayError2("unauthorized", "a scoped token acts as an agent: use --as");
+      const endpoint2 = core.claimHuman(params.tty);
+      conn.role = "client";
+      conn.machine = machine;
+      conn.endpoint = endpoint2.id;
+      conn.tty = params.tty;
+      this.save(socket);
+      this.fleet({ type: "presence", machine, endpoint: endpoint2.address, presence: endpoint2.presence, harness: endpoint2.harness, labels: endpoint2.labels });
+      return { ...base, endpoint: endpoint2, preamble: PREAMBLE };
+    }
+    const claimed = object(params.claim, "claim");
+    const claim = conn.grant.labels ? { ...claimed, labels: grantLabels(conn.grant, claimed.labels) } : claimed;
+    const held = this.bindable(machine, conn.grant);
+    if (bridge) {
+      this.bind(machine, conn.grant, "bridge", held);
+      core.adoptClaimed(machine);
+      conn.role = "bridge";
+      conn.machine = machine;
+      this.save(socket);
+      for (const other of [...this.deps.sockets()]) {
+        if (other.conn.id === conn.id || other.conn.role !== "bridge" || other.conn.machine !== machine) continue;
+        other.close(4e3, "replaced by a newer bridge for this machine");
+        this.release(other, true);
+      }
+      core.record("bridge", null, machine, { machine });
+      return { ...base, endpoints: core.remoteViews({ except: machine }) };
+    }
+    if (one2(this.deps.sql, `SELECT kind FROM machines WHERE name = ?`, machine)?.kind === "bridge") {
+      throw new RelayError2(
+        "invalid_params",
+        `machine ${machine} is linked through its broker's bridge; run the command there without --cloud, or pick another --machine`
+      );
+    }
+    let endpoint;
+    let token;
+    if (typeof params.resume === "string")
+      endpoint = core.resumeOn(machine, params.resume, conn.grant.labels ? (own) => grantLabels(conn.grant, own) : void 0);
+    else ({ endpoint, token } = core.claimOn(machine, claim, "account"));
+    this.bind(machine, conn.grant, "client", held);
+    conn.role = "client";
+    conn.machine = machine;
+    conn.endpoint = endpoint.id;
+    this.save(socket);
+    this.fleet({ type: "presence", machine, endpoint: endpoint.address, presence: endpoint.presence, harness: endpoint.harness, labels: endpoint.labels });
+    this.announceEndpoint(endpoint.id);
+    return { ...base, endpoint, ...token ? { token } : {}, preamble: PREAMBLE };
+  }
+  /** refuses a machine bound to another token, a revoked token's machine to anyone but its member or an admin, or one past the machine cap; returns whether this token already holds it */
+  bindable(machine, grant) {
+    const bound = one2(this.deps.sql, `SELECT token_id FROM machines WHERE name = ?`, machine);
+    if (bound && bound.token_id !== grant.tokenId) {
+      this.relay.record("refuse", null, machine, { code: "unauthorized", machine });
+      throw new RelayError2("unauthorized", `machine ${machine} is bound to another token; release it with ${CLI_NAME} machines rm ${machine}`);
+    }
+    if (bound) return true;
+    const tomb = one2(this.deps.sql, `SELECT actor_id FROM machine_tombstones WHERE name = ?`, machine);
+    if (tomb && !fullOf(grant, tomb.actor_id) && !accountAdmin(grant)) {
+      this.relay.record("refuse", null, machine, { code: "unauthorized", machine });
+      throw new RelayError2(
+        "unauthorized",
+        `machine ${machine} was unbound when its token was revoked; a full login of the same member (or an org owner or admin) can take it back, or ${CLI_NAME} machines rm ${machine} drops its queued messages`
+      );
+    }
+    const count = one2(this.deps.sql, `SELECT COUNT(*) AS n FROM machines`).n;
+    if (count >= this.limits.machines)
+      throw new RelayError2("too_large", `at most ${this.limits.machines} machines per account; release one with ${CLI_NAME} machines rm`);
+    return false;
+  }
+  /** binds the machine to the token once its hello succeeded; `held` is what bindable() returned */
+  bind(machine, grant, kind, held) {
+    const core = this.relay;
+    const now = this.now();
+    if (held) {
+      this.deps.sql.all(
+        `UPDATE machines SET last_seen = ?, user_id = ?, actor_id = ?, kind = CASE WHEN kind = 'bridge' THEN 'bridge' ELSE ? END WHERE name = ?`,
+        now,
+        grant.userId,
+        grant.actorId,
+        kind,
+        machine
+      );
+      return;
+    }
+    this.deps.sql.all(
+      `INSERT INTO machines (name, token_id, user_id, actor_id, kind, created_at, last_seen) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+      machine,
+      grant.tokenId,
+      grant.userId,
+      grant.actorId,
+      kind,
+      now,
+      now
+    );
+    this.deps.sql.all(`DELETE FROM machine_tombstones WHERE name = ?`, machine);
+    this.deps.sql.all(`DELETE FROM hub_state WHERE key = 'idle_since'`);
+    core.record("machine_bind", null, machine, { machine, kind });
+    this.deps.log?.("relay_action", { account: this.account, machine, method: "machine_bind", code: "ok" });
+  }
+  async clientMethod(socket, method, params) {
+    const core = this.relay;
+    const conn = socket.conn;
+    const me = conn.endpoint;
+    if (me) core.touch(me, TOUCH_MS);
+    switch (method) {
+      case "list":
+        if (params.contacts === true) return { contacts: await this.contactList() };
+        return { endpoints: core.list(listFilters(params)) };
+      case "snapshot":
+        return core.snapshot({ all: params.all === true, activity: typeof params.activity === "number" ? params.activity : void 0 });
+      case "watch":
+        conn.watching = true;
+        this.save(socket);
+        return core.snapshot({ activity: 20 });
+      case "log":
+        return {
+          rows: core.log({ since: params.since, limit: params.limit }).map((row) => row.event.startsWith("judge_") ? { ...row, detail: judgeDetailForAgents(row.detail) } : row)
+        };
+      case "machines":
+        return { machines: this.machineList() };
+      case "machines_rm":
+        return this.releaseMachine(socket, params.name);
+    }
+    if (!me) throw new RelayError2("unauthorized", "this connection has no endpoint");
+    switch (method) {
+      case "whoami":
+        return core.whoami(me);
+      case "send":
+      case "ask": {
+        serverFields(params);
+        const send = { ...params };
+        delete send.wait_s;
+        if (method === "ask") send.kind = "request";
+        const bytes = this.room(me, send.body);
+        const result = core.within(conn.machine, () => core.send(me, send, conn.tty === void 0 ? {} : { tty: conn.tty }));
+        if (!result.duplicate) this.stash(bytes);
+        if (!result.duplicate) this.delivered(me, result, send.kind ?? "message");
+        if (method === "send") return result;
+        return this.awaitReply(socket, me, result.id, this.waitMs(socket, params.wait_s), result);
+      }
+      case "ask_wait": {
+        if (typeof params.id !== "string") throw new RelayError2("invalid_params", "id is the request's message id");
+        return this.awaitReply(socket, me, params.id, this.waitMs(socket, params.wait_s));
+      }
+      case "inbox": {
+        const query = { after: params.after, limit: params.limit };
+        const deadline = Date.now() + this.waitMs(socket, params.wait_s);
+        let messages = core.inbox(me, query);
+        while (!messages.length && !this.gone.has(conn.id) && Date.now() < deadline) {
+          await this.waitFor(me, deadline - Date.now(), socket);
+          messages = core.inbox(me, query);
+        }
+        return { messages, next: messages.length ? messages[messages.length - 1].seq : query.after ?? 0 };
+      }
+      case "ack":
+        return { acked: core.ack(me, params.seqs) };
+      case "status": {
+        core.status(me, params.state, params.note);
+        const view = core.whoami(me);
+        this.fleet({ type: "status", machine: conn.machine, endpoint: view.address, status: view.status });
+        this.announceEndpoint(me);
+        return view;
+      }
+      case "event": {
+        const row = core.event(me, params);
+        this.fleet({ type: "activity", machine: conn.machine, ...row });
+        return row;
+      }
+    }
+    throw new RelayError2("method_not_found", `no method ${method}`);
+  }
+  async bridgeMethod(socket, method, params) {
+    const core = this.relay;
+    const conn = socket.conn;
+    const machine = conn.machine;
+    switch (method) {
+      case "mirror": {
+        const sync = mirrorSync(params.sync);
+        if (!sync) {
+          const full = params.full === true;
+          const changes2 = core.mirror(machine, grantViews(conn.grant, params.endpoints), { full, auth: "account+bridge" });
+          this.announce(machine, changes2, full);
+          return { changed: changes2.length };
+        }
+        let state = this.syncs.get(machine);
+        if (sync.part === 1) {
+          state = { id: sync.id, parts: sync.parts, next: 1, seen: /* @__PURE__ */ new Set() };
+          this.syncs.set(machine, state);
+        }
+        const intact = state !== void 0 && state.id === sync.id && state.parts === sync.parts && state.next === sync.part;
+        if (!intact) this.syncs.delete(machine);
+        const closing = intact && sync.part === sync.parts;
+        const changes = core.mirror(machine, grantViews(conn.grant, params.endpoints), {
+          full: closing,
+          auth: "account+bridge",
+          ...intact ? { seen: state.seen } : {}
+        });
+        if (intact) state.next++;
+        if (closing) this.syncs.delete(machine);
+        this.announce(machine, changes, closing);
+        return { changed: changes.length };
+      }
+      case "forward": {
+        const sender = core.remoteEndpoint(machine, params.from);
+        const send = { ...object(params.params, "params") };
+        serverFields(send);
+        const asked = params.hop_floor ?? 0;
+        if (!Number.isInteger(asked) || asked < 0 || asked > 1e3) throw new RelayError2("invalid_params", "hop_floor is a hop count");
+        if ([send.to].flat().some((to) => core.foreignAccount(to) !== null)) return this.xsend(sender, send, { tty: params.tty === true, hop: asked });
+        delete send.attachments;
+        const floor = Math.min(asked, LIMITS2.hopMax + 1);
+        if (floor > 0) core.markReceived(sender, floor - 1);
+        const bytes = this.room(sender, send.body);
+        const result = core.within(machine, () => core.send(sender, send, { tty: params.tty === true }));
+        if (!result.duplicate) this.stash(bytes);
+        if (!result.duplicate) this.delivered(sender, result, send.kind ?? "message");
+        return result;
+      }
+      case "subscribe": {
+        const after = params.after ?? 0;
+        if (!Number.isInteger(after) || after < 0) throw new RelayError2("invalid_params", "after is a seq");
+        if (this.deps.crossAccount) core.xsenders(await this.xinbound());
+        conn.subscribed = true;
+        this.save(socket);
+        let cursor = 0;
+        let replayed = 0;
+        for (; ; ) {
+          const page = core.pending(machine, Math.max(cursor, after), 200, cursor);
+          for (const delivery of page)
+            this.write(socket, { jsonrpc: "2.0", method: "deliver", params: { seq: delivery.seq, endpoint: delivery.endpoint, message: delivery.message } });
+          replayed += page.length;
+          if (page.length) cursor = page[page.length - 1].seq;
+          if (page.length < 200) break;
+        }
+        return { replayed, next: Math.max(cursor, after) };
+      }
+      case "ack":
+        return { acked: core.ackOn(machine, params.seqs) };
+      case "reject": {
+        const { notice } = core.rejectOn(machine, params.seq, params.code);
+        if (notice) this.route(notice.seq, notice.endpoint);
+        return { rejected: true };
+      }
+      case "event": {
+        const sender = core.remoteEndpoint(machine, params.from);
+        const row = core.event(sender, params);
+        this.fleet({ type: "activity", machine, ...row });
+        return row;
+      }
+      case "list":
+        if (params.contacts === true) return { contacts: await this.contactList() };
+        return { endpoints: core.list(listFilters(params)) };
+      case "watch":
+        conn.watching = true;
+        this.save(socket);
+        return core.snapshot({ activity: 20 });
+    }
+    throw new RelayError2("method_not_found", `no method ${method} on a bridge`);
+  }
+  // other accounts
+  /**
+   * A bridge's forward to another account's endpoint, writing no row here: shape, the contact, the sender on this account's allowlist,
+   * its scope (or the reply grant of the message it answers), the caps, the scrubber, the egress gate, then the peer relay. Anything
+   * unresolvable is not_found, as for a missing endpoint.
+   */
+  async xsend(sender, send, origin) {
+    const core = this.relay;
+    const link = this.deps.crossAccount;
+    const targets = [send.to].flat();
+    const missing = () => new RelayError2("not_found", `no endpoint ${targets.map(String).join(", ")}`);
+    if (targets.length !== 1) throw new RelayError2("invalid_params", "a message to another account goes to exactly one endpoint: no lists, groups or tree:");
+    const target = core.foreignAccount(targets[0]);
+    if (!target || !link || !this.xcounters || !this.xkey) throw missing();
+    if (typeof send.body !== "string") throw new RelayError2("invalid_params", "body must be a string");
+    const bytes = new TextEncoder().encode(send.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 (send.attachments !== void 0 && !(Array.isArray(send.attachments) && !send.attachments.length))
+      throw new RelayError2("data_class_refused", "attachments stay in this account");
+    if (send.data_class === "private") throw new RelayError2("data_class_refused", "a private message stays in this account");
+    if (send.data_class !== void 0 && send.data_class !== "public") throw new RelayError2("invalid_params", "data_class must be public or private");
+    const kind = send.kind ?? "message";
+    if (!MESSAGE_KINDS2.includes(kind)) throw new RelayError2("invalid_params", `kind must be one of ${MESSAGE_KINDS2.join(", ")}`);
+    if (send.reply_to !== void 0 && typeof send.reply_to !== "string") throw new RelayError2("invalid_params", "reply_to is a message id");
+    if (origin.hop > XLIMITS.hopMax)
+      throw new RelayError2(
+        "loop_guard",
+        `this message would be hop ${origin.hop} of a chain across accounts (limit ${XLIMITS.hopMax}); stop and report to your user`
+      );
+    const contact = await link.contactByHandle(target.account);
+    if (!contact || contact.dir === "in" || contact.peerHandle !== target.account) throw missing();
+    const me = core.xsender(sender);
+    if (!me || !allowlisted(contact.allow, me.machine, me.handle, me.depth)) throw missing();
+    const address = `${target.account}/${target.machine}/${target.handle || "me"}`;
+    const replyTo = send.reply_to ?? null;
+    const parent = replyTo ? core.xreceived(me.remote, replyTo) : null;
+    const answered = parent && parent.from_account === contact.peerId ? JSON.parse(parent.message) : null;
+    const granted = answered && answered.from.address === address ? parent : null;
+    if (!granted && !core.crossAdmission(sender, "out", target).ok) throw missing();
+    const now = this.now();
+    const thread = granted?.thread ?? cleanText2(send.thread, "thread", 64) ?? newId2("thr", now);
+    const hop = Math.max(origin.hop, granted ? answered.hop + 1 : 0);
+    if (hop > XLIMITS.hopMax)
+      throw new RelayError2("loop_guard", `this message would be hop ${hop} of a chain across accounts (limit ${XLIMITS.hopMax}); stop and report to your user`);
+    this.xcounters.check(contact, me.remote, address, thread);
+    const secret = findSecret2(send.body);
+    if (secret) throw new RelayError2("secret_refused", `the message looks like it carries a credential (${secret}); send a reference instead`);
+    const ttl = send.ttl_s ?? LIMITS2.ttlDefaultS;
+    if (!Number.isInteger(ttl) || ttl < 1 || ttl > LIMITS2.ttlMaxS)
+      throw new RelayError2("invalid_params", `ttl_s must be 1 to ${LIMITS2.ttlMaxS}`);
+    const self = link.self;
+    const own = `${self.handle}/${me.machine}/${me.handle || "me"}`;
+    const human = me.kind === "human" && me.handle === "" && origin.tty;
+    const from = {
+      account: self.handle,
+      address: human ? `${self.handle}/me` : own,
+      human,
+      auth: "contact",
+      rel: `contact:${self.handle}`,
+      machine: me.machine,
+      harness: me.harness
+    };
+    const id = origin.id ?? newId2("msg", now);
+    const expiresAt = now + ttl * 1e3;
+    const declared = declaredLimits(contact.limits);
+    const msg = {
+      id,
+      from,
+      to: `${target.machine}/${target.handle}`,
+      body: send.body,
+      kind,
+      thread,
+      reply_to: replyTo,
+      hop,
+      client_id: origin.clientId ?? this.deps.hash(`${own}|${address}|${cleanText2(send.client_id, "client_id", 128) ?? newId2("cid", now)}`),
+      created_at: now,
+      expires_at: expiresAt,
+      ...granted?.grant ? { reply_grant: granted.grant, reply_grant_expires_at: granted.expires_at } : {},
+      grant: replyGrant(this.deps.hash, this.xkey, id, own, contact.peerId, expiresAt),
+      ...declared ? { limits: declared } : {}
+    };
+    const verdict = origin.judged ? { verdict: "pass" } : await link.gate.egress(msg, { side: "egress", account: self.handle, peer: contact.peerHandle, peer_id: contact.peerId, sender });
+    if (verdict.verdict === "refuse") throw gateRefusal(verdict, "egress");
+    if (verdict.verdict === "hold") return { id: verdict.hold_id, thread, hop, deliveries: [], held: { hold_id: verdict.hold_id, side: "egress" } };
+    if (verdict.verdict === "duplicate") return { id: verdict.hold_id, thread, hop, deliveries: [], duplicate: true };
+    if (verdict.verdict === "redact") {
+      const result = await this.xsend(sender, { ...send, body: verdict.body }, { ...origin, judged: true });
+      const redacted = joinRedacted(verdict.redacted, result.redacted);
+      return { ...result, ...redacted ? { redacted } : {} };
+    }
+    this.xcounters.check(contact, me.remote, address, thread);
+    const refund = this.xcounters.sent(contact, me.remote, address, thread);
+    let delivered;
+    try {
+      delivered = await link.deliver(contact, msg);
+    } catch (error) {
+      if (!(error instanceof RelayError2) || error.code === "unavailable") refund();
+      throw error;
+    }
+    this.fleet({ type: "message", machine: me.machine, id: delivered.id, thread, kind, from: from.address, to: [address], hop });
+    return {
+      id: delivered.id,
+      thread,
+      hop,
+      deliveries: [{ endpoint: address, address, seq: 0, offline: delivered.state === "queued", last_seen: null }],
+      ...delivered.duplicate ? { duplicate: true } : {},
+      ...delivered.held ? { held: { hold_id: delivered.held.hold_id, side: "ingress" } } : {},
+      ...delivered.redacted ? { redacted: delivered.redacted } : {}
+    };
+  }
+  /**
+   * A message from the account `fromAccountId`'s relay (the host's internal route, never a client): the contact, the target on this
+   * account's allowlist, its scope (or the reply grant), shape, a retry's earlier answer, the scrubber, the ingress gate, then one xinbox
+   * row pushed to the target's bridge. Anything unresolvable is not_found, as for a missing endpoint.
+   */
+  async xreceive(fromAccountId, raw, judged = false) {
+    const core = this.relay;
+    const link = this.deps.crossAccount;
+    const msg = parseXMessage(raw);
+    const missing = () => new RelayError2("not_found", `no endpoint ${link?.self.handle ?? this.account}/${msg.to}`);
+    if (!link || !this.xcounters || !this.xkey) throw missing();
+    const contact = await link.contactById(fromAccountId);
+    if (!contact || contact.dir === "out" || contact.peerId !== fromAccountId || msg.from.account !== contact.peerHandle) throw missing();
+    const target = core.xendpoint(msg.to);
+    if (!target || !allowlisted(contact.allow, target.machine, target.handle, target.depth)) throw missing();
+    const address = `${link.self.handle}/${target.machine}/${target.handle || "me"}`;
+    const grantExpiry = msg.reply_grant_expires_at;
+    const granted = msg.reply_to !== null && msg.reply_grant !== void 0 && grantExpiry !== void 0 && grantExpiry > this.now() && sameSecret(msg.reply_grant, replyGrant(this.deps.hash, this.xkey, msg.reply_to, address, fromAccountId, grantExpiry));
+    const parts = msg.from.address.split("/");
+    const peer = {
+      account: contact.peerHandle,
+      machine: parts.length === 3 ? parts[1] : msg.from.machine ?? "me",
+      handle: parts.length === 3 && parts[2] !== "me" ? parts[2] : ""
+    };
+    if (!granted && !core.crossAdmission(target.id, "in", peer).ok) throw missing();
+    if (!honestSender(msg.from)) throw new RelayError2("invalid_params", "the sender is not one its relay may name");
+    const bytes = new TextEncoder().encode(msg.body).length;
+    if (bytes > XLIMITS.bodyBytes) throw new RelayError2("too_large", `a message from another account is at most ${XLIMITS.bodyBytes} bytes`);
+    if (msg.hop > XLIMITS.hopMax) throw new RelayError2("loop_guard", `hop ${msg.hop} is past the limit across accounts (${XLIMITS.hopMax})`);
+    if (msg.expires_at <= this.now()) throw new RelayError2("invalid_params", "the message expired");
+    const earlier = core.xduplicate(fromAccountId, msg.client_id);
+    if (earlier) return { id: earlier.id, state: earlier.acked ? "delivered" : "queued", duplicate: true };
+    const envelope = {
+      id: msg.id,
+      thread: msg.thread,
+      reply_to: msg.reply_to,
+      kind: msg.kind,
+      from: {
+        address: msg.from.address,
+        endpoint: msg.from.address,
+        user: contact.peerHandle,
+        auth: "contact",
+        ...msg.from.machine ? { machine: msg.from.machine } : {},
+        claims: { harness: msg.from.harness ?? null, model: null },
+        rel: `contact:${contact.peerHandle}`,
+        account: contact.peerHandle,
+        ...msg.from.human ? { human: true } : {}
+      },
+      to: address,
+      body: { text: msg.body, mime: "text/markdown" },
+      data_class: "public",
+      attachments: [],
+      hop: msg.hop,
+      created_at: new Date(msg.created_at).toISOString(),
+      expires_at: new Date(msg.expires_at).toISOString()
+    };
+    const message = JSON.stringify(envelope);
+    const stored2 = new TextEncoder().encode(message).length;
+    this.xadmit(fromAccountId, contact, msg, target, stored2);
+    const secret = findSecret2(msg.body);
+    if (secret) throw new RelayError2("secret_refused", `the message looks like it carries a credential (${secret})`);
+    const verdict = judged ? { verdict: "pass" } : await link.gate.ingress(msg, { side: "ingress", account: link.self.handle, peer: contact.peerHandle, peer_id: fromAccountId });
+    if (verdict.verdict === "refuse") throw gateRefusal(verdict, "ingress");
+    if (verdict.verdict === "hold") return { id: msg.id, state: "queued", held: { hold_id: verdict.hold_id } };
+    if (verdict.verdict === "duplicate") return { id: msg.id, state: "delivered", duplicate: true };
+    if (verdict.verdict === "redact") return { ...await this.xreceive(fromAccountId, { ...msg, body: verdict.body }, true), redacted: verdict.redacted };
+    const raced = () => {
+      const row = core.xduplicate(fromAccountId, msg.client_id);
+      return row ? { id: row.id, state: row.acked ? "delivered" : "queued", duplicate: true } : null;
+    };
+    const again = raced();
+    if (again) return again;
+    this.xadmit(fromAccountId, contact, msg, target, stored2);
+    const seq = core.xinsert({
+      id: msg.id,
+      from_account: fromAccountId,
+      client_id: msg.client_id,
+      endpoint: target.remote,
+      sender: msg.from.address,
+      message,
+      thread: msg.thread,
+      grant: msg.grant ?? null,
+      expires_at: msg.expires_at,
+      at: this.now()
+    });
+    if (seq === null) return raced();
+    this.stash(stored2);
+    let pushed = false;
+    for (const socket of this.deps.sockets()) {
+      if (socket.conn.role !== "bridge" || !socket.conn.subscribed || socket.conn.machine !== target.machine || this.gone.has(socket.conn.id)) continue;
+      this.write(socket, { jsonrpc: "2.0", method: "deliver", params: { seq, endpoint: target.remote, message: envelope } });
+      pushed = true;
+    }
+    this.wake(target.id);
+    this.fleet({
+      type: "message",
+      machine: msg.from.machine ?? null,
+      id: msg.id,
+      thread: msg.thread,
+      kind: msg.kind,
+      from: msg.from.address,
+      to: [address],
+      hop: msg.hop
+    });
+    return { id: msg.id, state: pushed ? "delivered" : "queued" };
+  }
+  /** this account's endpoints the account `fromAccountId` may reach under its contact's allowlist: address, harness and presence only */
+  async xlist(fromAccountId) {
+    const link = this.deps.crossAccount;
+    if (!link) return [];
+    const contact = await link.contactById(fromAccountId);
+    if (!contact || contact.dir === "out" || contact.peerId !== fromAccountId) return [];
+    return this.relay.xendpoints().filter((e) => allowlisted(contact.allow, e.machine, e.handle, e.depth)).map((e) => ({ address: `${link.self.handle}/${e.machine}/${e.handle || "me"}`, harness: e.harness, presence: e.presence }));
+  }
+  /**
+   * throws when one more message from `fromAccountId` would pass a cap of this side: the pair a minute and an hour and the contact a
+   * day (the lower of this account's limits for the contact and the sender's declared ones), the thread, the account's stored bytes or
+   * the target's unread messages; counted from xinbox itself, so a wake keeps them
+   */
+  xadmit(fromAccountId, contact, msg, target, bytes) {
+    const core = this.relay;
+    const now = this.now();
+    const { perMinute, perHour, perDay } = xlimits(contact.limits, msg.limits);
+    const counts = core.xcounts(fromAccountId, msg.from.address, target.remote, dayStart(now));
+    const retry = (since, ms) => Math.max(1, Math.ceil(((since ?? now) + ms - now) / 1e3));
+    if (counts.minute >= perMinute)
+      throw new RelayError2("rate_limited", `${perMinute} messages from ${msg.from.address} to ${msg.to} a minute`, retry(counts.minuteAt, 6e4));
+    if (counts.hour >= perHour)
+      throw new RelayError2("rate_limited", `${perHour} messages from ${msg.from.address} to ${msg.to} an hour`, retry(counts.hourAt, 36e5));
+    if (counts.day >= perDay) throw new RelayError2("rate_limited", `${perDay} messages from ${contact.peerHandle} today`, untilTomorrow(now));
+    if (core.xthreadCount(target.remote, msg.thread) >= XLIMITS.threadMax)
+      throw new RelayError2("loop_guard", `thread ${msg.thread} reached ${XLIMITS.threadMax} messages across accounts`);
+    const cap = this.limits.storedBytes;
+    if (this.storedNow() + bytes > cap) throw new RelayError2("inbox_full", `the receiving account's relay holds its cap of ${cap} bytes of messages`);
+    const unread = core.xunread(target);
+    if (unread >= LIMITS2.inboxMax) throw new RelayError2("inbox_full", `${msg.to} has ${unread} unread messages`);
+  }
+  /**
+   * deletes the queued messages of every account that is no longer an active contact allowed to message this one, after the
+   * contacts changed; nothing when the contacts cannot be loaded
+   */
+  async xprune() {
+    if (!this.deps.crossAccount || !this.core) return;
+    const senders = await this.xinbound();
+    if (!senders || !this.core) return;
+    this.relay.xsenders(senders);
+    if (this.relay.xprune(senders)) this.stored = null;
+  }
+  /** the accounts whose messages this account takes now: active contacts with dir in or both; null when they cannot be loaded */
+  async xinbound() {
+    const contacts = await this.deps.crossAccount?.contacts();
+    return contacts ? new Set(contacts.filter((contact) => contact.dir !== "out").map((contact) => contact.peerId)) : null;
+  }
+  /** what every contact this account may message lets it reach */
+  async contactList() {
+    const link = this.deps.crossAccount;
+    if (!link) return [];
+    const contacts = (await link.contacts() ?? []).filter((contact) => contact.dir !== "in");
+    const lists = await Promise.all(
+      contacts.map(
+        (contact) => link.list(contact).then(
+          (list) => ({ contact, list }),
+          () => ({ contact, list: [] })
+        )
+      )
+    );
+    return lists.flatMap(
+      ({ contact, list }) => list.filter((e) => typeof e?.address === "string" && e.address.startsWith(`${contact.peerHandle}/`)).map((e) => ({
+        address: e.address,
+        harness: typeof e.harness === "string" ? e.harness : null,
+        presence: typeof e.presence === "string" ? e.presence : "offline"
+      }))
+    );
+  }
+  // push and wait
+  delivered(from, result, kind) {
+    const core = this.relay;
+    for (const delivery of result.deliveries) this.route(delivery.seq, delivery.endpoint);
+    this.fleet({
+      type: "message",
+      machine: core.machineOf(from),
+      id: result.id,
+      thread: result.thread,
+      kind,
+      from: core.addressOf(from),
+      to: result.deliveries.map((d) => d.address),
+      hop: result.hop
+    });
+  }
+  /** the body's bytes when the account can hold them; refuses a send past the `storedBytes` limit */
+  room(sender, body) {
+    if (typeof body !== "string") return 0;
+    const bytes = new TextEncoder().encode(body).length;
+    const cap = this.limits.storedBytes;
+    if (this.storedNow() + bytes > cap) {
+      this.relay.record("refuse", sender, null, { code: "too_large" });
+      throw new RelayError2(
+        "too_large",
+        `the account relay holds its cap of ${cap} bytes of message bodies; ack or let messages expire, or release a machine with ${CLI_NAME} machines rm`
+      );
+    }
+    return bytes;
+  }
+  /** bytes of message bodies held, and of the messages from other accounts */
+  storedNow() {
+    const xinbox = this.deps.crossAccount ? ` + (SELECT COALESCE(SUM(LENGTH(CAST(message AS BLOB))), 0) FROM xinbox)` : "";
+    this.stored ??= one2(this.deps.sql, `SELECT (SELECT COALESCE(SUM(LENGTH(CAST(body AS BLOB))), 0) FROM messages)${xinbox} AS n`).n;
+    return this.stored;
+  }
+  stash(bytes) {
+    if (this.stored !== null) this.stored += bytes;
+  }
+  /** wakes direct waiters and pushes a delivery for a mirrored row to the subscribed bridge of its machine */
+  route(seq, endpoint) {
+    this.wake(endpoint);
+    const delivery = this.relay.delivery(seq);
+    if (!delivery?.endpoint || !delivery.mirrored) return;
+    const machine = delivery.endpoint.slice(0, delivery.endpoint.indexOf("/"));
+    for (const socket of this.deps.sockets()) {
+      if (socket.conn.role === "bridge" && socket.conn.subscribed && socket.conn.machine === machine) {
+        this.write(socket, { jsonrpc: "2.0", method: "deliver", params: { seq, endpoint: delivery.endpoint, message: delivery.message } });
+      }
+    }
+  }
+  /** a machine's endpoint changes: `endpoints` to the other bridges, presence and status to watchers */
+  announce(machine, changes, full) {
+    if (full || changes.length) {
+      const endpoints = full ? this.relay.remoteRowsOf(machine) : changes.map((c) => c.view);
+      this.toBridges(machine, { machine, endpoints, full });
+    }
+    for (const change of changes) {
+      const view = change.view;
+      if (change.added || change.presence)
+        this.fleet({ type: "presence", machine, endpoint: view.address, presence: view.presence, harness: view.harness, labels: view.labels });
+      if (change.status && !change.added) this.fleet({ type: "status", machine, endpoint: view.address, status: view.status });
+    }
+  }
+  /** a direct client's endpoint changed: the other bridges mirror it */
+  announceEndpoint(endpoint) {
+    const machine = this.relay.machineOf(endpoint);
+    if (!machine) return;
+    const view = this.relay.remoteRowsOf(machine).find((v) => v.id === endpoint);
+    if (view) this.toBridges(machine, { machine, endpoints: [view], full: false });
+  }
+  toBridges(machine, params) {
+    for (const socket of this.deps.sockets()) {
+      if (socket.conn.role === "bridge" && socket.conn.machine !== machine) this.write(socket, { jsonrpc: "2.0", method: "endpoints", params });
+    }
+  }
+  fleet(event) {
+    const at = new Date(this.now()).toISOString();
+    for (const socket of this.deps.sockets()) if (socket.conn.watching) this.write(socket, { jsonrpc: "2.0", method: "fleet", params: { at, ...event } });
+  }
+  write(socket, value) {
+    if (this.gone.has(socket.conn.id)) return;
+    try {
+      socket.send(JSON.stringify(value));
+    } catch {
+      this.deps.log?.("relay_send_failed", { account: this.account, machine: socket.conn.machine });
+    }
+  }
+  save(socket) {
+    if (this.transient.has(socket)) return;
+    this.deps.save(socket);
+  }
+  waitMs(socket, value) {
+    if (value === void 0) return 0;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new RelayError2("invalid_params", "wait_s must be a number of seconds");
+    return Math.min(value, this.transient.has(socket) ? this.limits.httpWaitS : LIMITS2.waitMaxS) * 1e3;
+  }
+  wake(endpoint) {
+    const set = this.waiters.get(endpoint);
+    if (!set) return;
+    this.waiters.delete(endpoint);
+    for (const fn of set) fn();
+  }
+  waitFor(endpoint, ms, socket) {
+    return new Promise((resolve) => {
+      const done = () => {
+        clearTimeout(timer);
+        this.waiters.get(endpoint)?.delete(done);
+        resolve();
+      };
+      const timer = setTimeout(done, ms);
+      let set = this.waiters.get(endpoint);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        this.waiters.set(endpoint, set);
+      }
+      set.add(done);
+      if (this.gone.has(socket.conn.id)) done();
+    });
+  }
+  async awaitReply(socket, me, request, ms, sent) {
+    const core = this.relay;
+    const deadline = Date.now() + ms;
+    for (; ; ) {
+      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 };
+      if (this.gone.has(socket.conn.id) || Date.now() >= deadline) return { ...sent, id: request, pending: true };
+      await this.waitFor(me, deadline - Date.now(), socket);
+    }
+  }
+  // connections and machines
+  kick(socket, reason, code = 1008) {
+    this.write(socket, { jsonrpc: "2.0", method: "revoked", params: { reason } });
+    socket.close(code, reason);
+    this.release(socket, false);
+  }
+  release(socket, replaced) {
+    const conn = socket.conn;
+    if (this.gone.has(conn.id)) return;
+    this.gone.add(conn.id);
+    if (conn.role === "new" || !this.core) return;
+    const core = this.core;
+    const bound = this.boundMachine(conn);
+    if (conn.role === "client" && conn.endpoint) {
+      const endpoint = conn.endpoint;
+      core.disconnect(endpoint);
+      const machine = core.machineOf(endpoint);
+      if (machine && one2(this.deps.sql, `SELECT kind FROM machines WHERE name = ?`, machine)?.kind === "bridge") {
+        for (const delivery of core.adoptClaimed(machine, endpoint)) this.route(delivery.seq, delivery.endpoint);
+      }
+      this.wake(endpoint);
+      const view = core.whoami(endpoint);
+      this.fleet({ type: "presence", machine: conn.machine, endpoint: view.address, presence: view.presence });
+      this.announceEndpoint(endpoint);
+    } else if (conn.role === "bridge" && conn.machine) {
+      const newer = this.deps.sockets().some((s) => s.conn.id !== conn.id && s.conn.role === "bridge" && s.conn.machine === conn.machine && !this.gone.has(s.conn.id));
+      if (!replaced && !newer) this.announce(conn.machine, core.markOffline(conn.machine), false);
+    }
+    if (bound) this.deps.sql.all(`UPDATE machines SET last_seen = ? WHERE name = ?`, this.now(), bound);
+    conn.role = "new";
+    conn.endpoint = null;
+    conn.subscribed = false;
+    conn.watching = false;
+    if (!this.transient.has(socket)) {
+      try {
+        this.deps.save(socket);
+      } catch {
+      }
+    }
+  }
+  /** the machine a bridge or agent client connection holds; a human's or observer's machine is only a namespace */
+  boundMachine(conn) {
+    if (!conn.machine || !this.core) return null;
+    if (conn.role === "bridge") return conn.machine;
+    return conn.role === "client" && conn.endpoint !== null && this.core.machineOf(conn.endpoint) === conn.machine ? conn.machine : null;
+  }
+  /** machines a live connection holds */
+  liveMachines() {
+    const live = /* @__PURE__ */ new Set();
+    for (const socket of [...this.deps.sockets(), ...this.transient]) {
+      const machine = this.gone.has(socket.conn.id) ? null : this.boundMachine(socket.conn);
+      if (machine) live.add(machine);
+    }
+    return live;
+  }
+  /** bindings, then names a revoke left behind (kind `revoked`) */
+  /** a read-only view of the account for a dashboard: its machines, listed endpoints and latest activity */
+  overview(activity = 20) {
+    const { endpoints, activity: rows } = this.relay.snapshot({ activity });
+    return { machines: this.machineList(), endpoints, activity: rows };
+  }
+  machineList() {
+    const sockets = this.deps.sockets().filter((s) => !this.gone.has(s.conn.id));
+    const bound = this.deps.sql.all(`SELECT name, kind, created_at, last_seen FROM machines ORDER BY name`).map((row) => ({
+      name: row.name,
+      kind: row.kind,
+      online: sockets.some((s) => this.boundMachine(s.conn) === row.name),
+      bridge: sockets.some((s) => s.conn.role === "bridge" && s.conn.machine === row.name),
+      created_at: iso(row.created_at),
+      last_seen: iso(row.last_seen)
+    }));
+    const revoked = this.deps.sql.all(`SELECT name, at FROM machine_tombstones WHERE name NOT IN (SELECT name FROM machines) ORDER BY name`).map((row) => ({ name: row.name, kind: "revoked", online: false, bridge: false, created_at: null, last_seen: iso(row.at) }));
+    return [...bound, ...revoked];
+  }
+  /** only the token the machine is bound to, a full login of the member who bound it, or an admin may release it (or a revoked token's name) */
+  releaseMachine(caller, name) {
+    const core = this.relay;
+    if (typeof name !== "string" || !MACHINE_NAME.test(name)) throw new RelayError2("invalid_params", "name is a machine name");
+    const bound = one2(this.deps.sql, `SELECT token_id, actor_id FROM machines WHERE name = ?`, name);
+    const tomb = bound ? void 0 : one2(this.deps.sql, `SELECT actor_id FROM machine_tombstones WHERE name = ?`, name);
+    if (!bound && !tomb) throw new RelayError2("not_found", `no machine ${name}`);
+    const grant = caller.conn.grant;
+    if (!(bound?.token_id === grant.tokenId || fullOf(grant, (bound ?? tomb).actor_id) || accountAdmin(grant))) {
+      core.record("refuse", null, name, { code: "unauthorized", machine: name });
+      throw new RelayError2(
+        "unauthorized",
+        `only the token machine ${name} is bound to, a full login of the member who bound it, or an org owner or admin can release it`
+      );
+    }
+    for (const socket of [...this.deps.sockets()]) {
+      if (socket.conn.id !== caller.conn.id && this.boundMachine(socket.conn) === name) this.kick(socket, `machine ${name} was released`);
+    }
+    const dropped = this.tx(() => {
+      const count = core.dropMachine(name, { queue: true });
+      this.deps.sql.all(`DELETE FROM machines WHERE name = ?`, name);
+      this.deps.sql.all(`DELETE FROM machine_tombstones WHERE name = ?`, name);
+      core.record("machine_release", null, name, { machine: name, endpoints: count });
+      return count;
+    });
+    this.stored = null;
+    this.toBridges(name, { machine: name, endpoints: [], full: true });
+    this.deps.log?.("relay_action", { account: this.account, machine: name, method: "machine_release", code: "ok" });
+    return { removed: name, endpoints: dropped };
+  }
+  /** releases client bindings with no live connection, idle for the `clientMachineIdleS` limit, with nothing queued and no unanswered ask open; bridge bindings never expire */
+  expireMachines(now) {
+    const core = this.relay;
+    const live = this.liveMachines();
+    const idle = this.deps.sql.all(
+      `SELECT name FROM machines WHERE kind = 'client' AND COALESCE(last_seen, created_at) <= ?`,
+      now - this.limits.clientMachineIdleS * 1e3
+    );
+    for (const { name } of idle) {
+      if (live.has(name)) continue;
+      const queued = one2(
+        this.deps.sql,
+        `SELECT 1 FROM deliveries d JOIN endpoints e ON e.id = d.endpoint WHERE substr(e.remote, 1, ?) = ? AND d.acked_at IS NULL AND d.expires_at > ? LIMIT 1`,
+        name.length + 1,
+        `${name}/`,
+        now
+      );
+      const asking = one2(
+        this.deps.sql,
+        `SELECT 1 FROM messages m JOIN endpoints e ON e.id = m.from_ep WHERE substr(e.remote, 1, ?) = ? AND m.kind = 'request' AND m.expires_at > ?
+         AND NOT EXISTS (SELECT 1 FROM messages r WHERE r.reply_to = m.id AND r.kind = 'reply') LIMIT 1`,
+        name.length + 1,
+        `${name}/`,
+        now
+      );
+      if (queued || asking) continue;
+      const dropped = this.tx(() => {
+        const count = core.dropMachine(name);
+        this.deps.sql.all(`DELETE FROM machines WHERE name = ?`, name);
+        core.record("machine_expire", null, name, { machine: name, endpoints: count });
+        return count;
+      });
+      this.toBridges(name, { machine: name, endpoints: [], full: true });
+      this.deps.log?.("relay_action", { account: this.account, machine: name, method: "machine_expire", code: "ok", endpoints: dropped });
+    }
+  }
+  /** drops the tombstones past their age with nothing queued for their machine, and retires the rows and xinbox of each name still unbound */
+  forgetTombstones(now) {
+    const forgotten = this.tx(() => {
+      const names = this.deps.sql.all(
+        `DELETE FROM machine_tombstones WHERE at <= ? AND NOT EXISTS (SELECT 1 FROM deliveries d JOIN endpoints e ON e.id = d.endpoint
+         WHERE substr(e.remote, 1, length(machine_tombstones.name) + 1) = machine_tombstones.name || '/' AND d.acked_at IS NULL AND d.expires_at > ?)
+         RETURNING name`,
+        now - (LIMITS2.ttlMaxS + LIMITS2.purgeAfterS) * 1e3,
+        now
+      );
+      const unbound = names.map((row) => row.name).filter((name) => !one2(this.deps.sql, `SELECT 1 FROM machines WHERE name = ?`, name));
+      for (const name of unbound) this.relay.record("machine_forget", null, name, { machine: name, endpoints: this.relay.dropMachine(name, { queue: true }) });
+      return unbound;
+    });
+    for (const name of forgotten) this.toBridges(name, { machine: name, endpoints: [], full: true });
+  }
+  /** the hub_state keys (`denied:<tokenId>`) of tokens revoked lately, to when; loaded once per object lifetime */
+  deniedGrants() {
+    this.denied ??= new Map(
+      this.deps.sql.all(`SELECT key, value FROM hub_state WHERE key LIKE ?`, `${DENIED}%`).map((row) => [row.key, row.value])
+    );
+    return this.denied;
+  }
+  /** a token revoked lately is refused even when the host accepted its grant before the revoke reached the object */
+  refuseDenied(socket) {
+    const at = this.deniedGrants().get(DENIED + socket.conn.grant.tokenId);
+    if (at === void 0 || at <= this.now() - this.limits.deniedS * 1e3) return;
+    this.kick(socket, "the token was revoked");
+    throw new RelayError2("unauthorized", "the token was revoked");
+  }
+  tx(fn) {
+    return this.deps.transaction ? this.deps.transaction(fn) : fn();
+  }
+  state(key) {
+    return one2(this.deps.sql, `SELECT value FROM hub_state WHERE key = ?`, key)?.value ?? null;
+  }
+  setState(key, value) {
+    this.deps.sql.all(`INSERT OR REPLACE INTO hub_state (key, value) VALUES (?, ?)`, key, value);
+  }
+  /**
+   * a held cross-account message its account's human released (the host claimed the hold first): the rest of that side's path, with
+   * every check run again and only the gate skipped. Egress sends as the stored sender with the time left, under the hold id its sender
+   * got, and with the message's own client id, so the peer answers both a retried release and the sender's retry of the original as the
+   * duplicate. Ingress runs xreceive again
+   */
+  async xrelease(hold) {
+    if (hold.side === "ingress") return this.xreceive(hold.from_account, hold.message, true);
+    const msg = hold.message;
+    const left = Math.ceil((msg.expires_at - this.now()) / 1e3);
+    if (left < 1) throw new RelayError2("invalid_params", "the held message expired");
+    const send = {
+      to: `${hold.peer}/${msg.to.endsWith("/") ? `${msg.to}me` : msg.to}`,
+      body: msg.body,
+      kind: msg.kind,
+      thread: msg.thread,
+      ...msg.reply_to ? { reply_to: msg.reply_to } : {},
+      ttl_s: Math.min(left, LIMITS2.ttlMaxS)
+    };
+    return this.xsend(hold.sender, send, { tty: msg.from.human, hop: msg.hop, judged: true, clientId: msg.client_id, id: hold.hold_id });
+  }
+  /** a status message from the relay to one of this account's endpoints (a held message's sender), pushed to its bridge */
+  xnotice(endpoint, text) {
+    this.route(this.relay.judgeNoticeTo(endpoint, text), endpoint);
+  }
+};
+export {
+  FederatedCore,
+  HUB_LIMITS,
+  MACHINE_NAME,
+  RelayHub
+};