create-evda 0.1.7 → 0.1.8

package/dist/pairing.mjs

@@ -0,0 +1,4246 @@
+// Generated by create-evda's scripts/build-pairing.mjs from atlas-local's pairing code. Do not edit.
+
+// ../atlas-local/src/node/pair-owner.ts
+import { execFileSync } from "node:child_process";
+import { hostname } from "node:os";
+
+// ../atlas-local/src/node/pairing.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// ../changes/src/changes.ts
+function hashableFields(c) {
+  return {
+    changesetId: c.changesetId,
+    originAtlas: c.originAtlas,
+    originUser: c.originUser,
+    lamport: c.lamport,
+    ts: c.ts,
+    kind: c.kind,
+    target: c.target,
+    payload: c.payload,
+    prevHash: c.prevHash
+  };
+}
+function canonicalize(value) {
+  if (value === null || value === void 0) return JSON.stringify(value ?? null);
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map(canonicalize).join(",") + "]";
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const parts = keys.map(
+    (k) => JSON.stringify(k) + ":" + canonicalize(obj[k])
+  );
+  return "{" + parts.join(",") + "}";
+}
+function utf8Encode(str) {
+  const out = [];
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c < 128) {
+      out.push(c);
+      continue;
+    }
+    if (c < 2048) {
+      out.push(192 | c >> 6, 128 | c & 63);
+      continue;
+    }
+    if (c >= 55296 && c <= 56319) {
+      const lo = i + 1 < str.length ? str.charCodeAt(i + 1) : 0;
+      if (lo >= 56320 && lo <= 57343) {
+        const cp = 65536 + (c - 55296 << 10) + (lo - 56320);
+        out.push(
+          240 | cp >> 18,
+          128 | cp >> 12 & 63,
+          128 | cp >> 6 & 63,
+          128 | cp & 63
+        );
+        i++;
+        continue;
+      }
+      out.push(239, 191, 189);
+      continue;
+    }
+    if (c >= 56320 && c <= 57343) {
+      out.push(239, 191, 189);
+      continue;
+    }
+    out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+  }
+  return new Uint8Array(out);
+}
+async function sha256Canonical(value, sha256) {
+  const digest = await sha256(utf8Encode(canonicalize(value)));
+  return Array.from(digest).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function hashChange(h, sha256) {
+  return sha256Canonical(h, sha256);
+}
+async function hashPayload(payload, sha256) {
+  return sha256Canonical(payload, sha256);
+}
+async function hashSkeleton(s, sha256) {
+  return sha256Canonical(s, sha256);
+}
+function changeSkeleton(c) {
+  if (c.payloadHash === void 0) {
+    throw new Error(
+      `changeSkeleton: Change ${c.id} has no payloadHash (v1 envelope). Verify it with hashChange(hashableFields(c)) instead.`
+    );
+  }
+  return {
+    changesetId: c.changesetId,
+    originAtlas: c.originAtlas,
+    originUser: c.originUser,
+    lamport: c.lamport,
+    ts: c.ts,
+    kind: c.kind,
+    target: c.target,
+    prevHash: c.prevHash,
+    payloadHash: c.payloadHash
+  };
+}
+async function buildChange(input, sha256) {
+  const payloadHash = await hashPayload(input.payload, sha256);
+  const skeleton = {
+    changesetId: input.changesetId,
+    originAtlas: input.originAtlas,
+    originUser: input.originUser,
+    lamport: input.lamport,
+    ts: input.ts,
+    kind: input.kind,
+    target: input.target,
+    prevHash: input.prevHash,
+    payloadHash
+  };
+  return {
+    id: await hashSkeleton(skeleton, sha256),
+    changesetId: input.changesetId,
+    originAtlas: input.originAtlas,
+    originUser: input.originUser,
+    lamport: input.lamport,
+    ts: input.ts,
+    kind: input.kind,
+    target: input.target,
+    payload: input.payload,
+    prevHash: input.prevHash,
+    payloadHash,
+    state: input.state ?? "local",
+    originSignature: input.originSignature ?? null
+  };
+}
+async function deterministicGenesisHash(originAtlas, sha256) {
+  return sha256Canonical({ kind: "__genesis__", originAtlas }, sha256);
+}
+async function verifyChangeContent(c, sha256) {
+  if (c.payloadHash === void 0) {
+    return await hashChange(hashableFields(c), sha256) === c.id;
+  }
+  return await hashSkeleton(changeSkeleton(c), sha256) === c.id;
+}
+async function verifyChain(batch, sha256, known = /* @__PURE__ */ new Set(), verifySignature) {
+  const issues = [];
+  const sorted = [...batch].sort((a, b) => a.lamport - b.lamport);
+  const seen = new Set(known);
+  const genesisSeeded = /* @__PURE__ */ new Set();
+  for (const c of sorted) {
+    if (!genesisSeeded.has(c.originAtlas)) {
+      seen.add(await deterministicGenesisHash(c.originAtlas, sha256));
+      genesisSeeded.add(c.originAtlas);
+    }
+    if (!await verifyChangeContent(c, sha256)) {
+      issues.push({ change: c, issue: "hash-mismatch" });
+      continue;
+    }
+    if (c.prevHash !== null && !seen.has(c.prevHash)) {
+      issues.push({ change: c, issue: "broken-prev" });
+    }
+    if (verifySignature && c.originSignature !== null) {
+      const ok = await verifySignature(c.originAtlas, c.id, c.originSignature);
+      if (ok === false) {
+        issues.push({ change: c, issue: "bad-signature" });
+        continue;
+      }
+    }
+    seen.add(c.id);
+  }
+  return issues;
+}
+function lwwResolve(extract) {
+  return (changes) => {
+    if (changes.length === 0) return { kind: "merge-needed", candidates: [] };
+    const sorted = [...changes].sort((a, b) => {
+      if (a.lamport !== b.lamport) return b.lamport - a.lamport;
+      if (a.originAtlas !== b.originAtlas) {
+        return a.originAtlas.localeCompare(b.originAtlas);
+      }
+      return a.id.localeCompare(b.id);
+    });
+    return { kind: "resolved", value: extract(sorted[0]) };
+  };
+}
+var DECISION_NOTE_RULE = {
+  subKey: (c) => {
+    const p = c.payload;
+    return p && typeof p.decisionId === "string" ? p.decisionId : null;
+  },
+  resolve: lwwResolve((c) => {
+    const p = c.payload;
+    return {
+      actionId: p && typeof p.actionId === "string" ? p.actionId : "",
+      actionLabel: p && typeof p.actionLabel === "string" ? p.actionLabel : "",
+      note: p && typeof p.note === "string" ? p.note : ""
+    };
+  })
+};
+
+// ../atlas-local/src/bytes.ts
+var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function utf8Decode(bytes) {
+  let out = "";
+  let index = 0;
+  while (index < bytes.length) {
+    const lead = bytes[index];
+    if (lead <= 127) {
+      out += String.fromCharCode(lead);
+      index += 1;
+      continue;
+    }
+    let needed;
+    let code;
+    let lower = 128;
+    let upper = 191;
+    if (lead >= 194 && lead <= 223) {
+      needed = 1;
+      code = lead & 31;
+    } else if (lead >= 224 && lead <= 239) {
+      needed = 2;
+      code = lead & 15;
+      if (lead === 224) lower = 160;
+      if (lead === 237) upper = 159;
+    } else if (lead >= 240 && lead <= 244) {
+      needed = 3;
+      code = lead & 7;
+      if (lead === 240) lower = 144;
+      if (lead === 244) upper = 143;
+    } else {
+      out += "\uFFFD";
+      index += 1;
+      continue;
+    }
+    let consumed = 1;
+    let ok = true;
+    for (let offset = 0; offset < needed; offset += 1) {
+      const next = bytes[index + 1 + offset];
+      if (next === void 0) {
+        ok = false;
+        break;
+      }
+      const min = offset === 0 ? lower : 128;
+      const max = offset === 0 ? upper : 191;
+      if (next < min || next > max) {
+        ok = false;
+        break;
+      }
+      code = code << 6 | next & 63;
+      consumed += 1;
+    }
+    if (!ok) {
+      out += "\uFFFD";
+      index += consumed;
+      continue;
+    }
+    if (code > 65535) {
+      const adjusted = code - 65536;
+      out += String.fromCharCode(55296 + (adjusted >> 10), 56320 + (adjusted & 1023));
+    } else {
+      out += String.fromCharCode(code);
+    }
+    index += 1 + needed;
+  }
+  return out;
+}
+function base64(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i] ?? 0;
+    const b1 = bytes[i + 1];
+    const b2 = bytes[i + 2];
+    out += B64_ALPHABET[b0 >> 2];
+    out += B64_ALPHABET[(b0 & 3) << 4 | (b1 ?? 0) >> 4];
+    out += b1 === void 0 ? "=" : B64_ALPHABET[(b1 & 15) << 2 | (b2 ?? 0) >> 6];
+    out += b2 === void 0 ? "=" : B64_ALPHABET[b2 & 63];
+  }
+  return out;
+}
+function base64url(bytes) {
+  let out = "";
+  for (const char of base64(bytes)) {
+    if (char === "=") break;
+    out += char === "+" ? "-" : char === "/" ? "_" : char;
+  }
+  return out;
+}
+function fromBase64(value) {
+  const bytes = [];
+  let buffer = 0;
+  let bits = 0;
+  for (const char of value.trim()) {
+    if (char === "=") break;
+    const index = B64_ALPHABET.indexOf(char);
+    if (index < 0) throw new Error(`not base64: ${JSON.stringify(char)}`);
+    buffer = buffer << 6 | index;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      bytes.push(buffer >> bits & 255);
+    }
+  }
+  return Uint8Array.from(bytes);
+}
+function concatBytes(parts) {
+  let length = 0;
+  for (const part of parts) length += part.length;
+  const out = new Uint8Array(length);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function toHex(bytes) {
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// ../atlas-local/src/blobs.ts
+async function sealBlob(host, plaintext) {
+  if (plaintext.length === 0) throw new Error("blob: refusing to seal empty bytes");
+  const { publicKey, privateKey } = await host.crypto.newLinkKeypair();
+  const ciphertext = await host.crypto.seal(publicKey, plaintext);
+  return {
+    ciphertext,
+    contentKey: privateKey,
+    hash: base64url(await host.crypto.sha256(ciphertext))
+  };
+}
+async function openBlob(host, ciphertext, contentKey) {
+  return await host.crypto.openWith(contentKey, ciphertext);
+}
+
+// ../atlas-local/src/blob-store.ts
+var BlobStore = class {
+  constructor(host) {
+    this.host = host;
+  }
+  /** Seal bytes under a fresh content key and keep the ciphertext. */
+  async seal(plaintext) {
+    const sealed = await sealBlob(this.host, plaintext);
+    await this.host.sql.execute(
+      "INSERT OR IGNORE INTO blob_store (hash, ciphertext, created_at) VALUES (?, ?, ?)",
+      [sealed.hash, sealed.ciphertext, this.host.clock.now()]
+    );
+    return sealed;
+  }
+  /** Record that a Change references a blob, so a send of it re-uploads the blob. */
+  async link(changeId, hash) {
+    await this.host.sql.execute("INSERT OR IGNORE INTO change_blob (change_id, hash) VALUES (?, ?)", [
+      changeId,
+      hash
+    ]);
+  }
+  /** The ciphertext of every blob the given Changes reference. */
+  async forChanges(changeIds) {
+    if (changeIds.length === 0) return [];
+    const marks = changeIds.map(() => "?").join(", ");
+    const rows = await this.host.sql.query(
+      `SELECT DISTINCT b.hash AS hash, b.ciphertext AS ciphertext
+         FROM change_blob c JOIN blob_store b ON b.hash = c.hash
+        WHERE c.change_id IN (${marks})`,
+      changeIds
+    );
+    return rows.map((r) => ({ hash: r.hash, ciphertext: new Uint8Array(r.ciphertext) }));
+  }
+};
+
+// ../atlas-local/src/storage.ts
+function normalise(relPath) {
+  if (relPath.startsWith("/")) throw new Error(`path must be relative: ${relPath}`);
+  if (relPath.split("/").some((part) => part === "..")) {
+    throw new Error(`path may not traverse: ${relPath}`);
+  }
+  return relPath;
+}
+function likePrefix(prefix) {
+  return `${prefix.replace(/[\\%_]/g, "\\$&")}%`;
+}
+var SqlStorage = class {
+  constructor(host) {
+    this.host = host;
+  }
+  get sql() {
+    return this.host.sql;
+  }
+  async readText(relPath) {
+    const path = normalise(relPath);
+    const rows = await this.sql.query(
+      "SELECT text FROM vault_object WHERE path = ?",
+      [path]
+    );
+    const stored = rows[0]?.text;
+    if (stored != null) return stored;
+    const lines = await this.sql.query(
+      "SELECT line FROM vault_append WHERE path = ? ORDER BY seq",
+      [path]
+    );
+    if (lines.length === 0) return null;
+    return lines.map((row) => row.line).join("");
+  }
+  async readBytes(relPath) {
+    const rows = await this.sql.query(
+      "SELECT bytes FROM vault_object WHERE path = ?",
+      [normalise(relPath)]
+    );
+    const stored = rows[0]?.bytes;
+    if (stored == null) return null;
+    return stored instanceof Uint8Array ? stored : Uint8Array.from(stored);
+  }
+  async writeText(relPath, content) {
+    await this.put(normalise(relPath), { text: content });
+  }
+  async writeBytes(relPath, content) {
+    await this.put(normalise(relPath), { bytes: content });
+  }
+  async writeObject(relPath, value) {
+    await this.put(normalise(relPath), { body: JSON.stringify(value) });
+  }
+  async readObject(relPath) {
+    const rows = await this.sql.query(
+      "SELECT body FROM vault_object WHERE path = ?",
+      [normalise(relPath)]
+    );
+    const body = rows[0]?.body;
+    return body == null ? null : JSON.parse(body);
+  }
+  /**
+   * Append a line to a ledger.
+   *
+   * A row per append, never read-modify-write — the interface says why:
+   * ledger-style logs would race. It also makes `appendVersion` and
+   * `readTextTail` index reads instead of full-file parses.
+   */
+  async appendText(relPath, content) {
+    await this.sql.execute(
+      "INSERT INTO vault_append (path, line, created_at) VALUES (?, ?, ?)",
+      [normalise(relPath), content, this.host.clock.now()]
+    );
+  }
+  /** Idempotent — deleting what is absent is the outcome the caller wanted. */
+  async delete(relPath) {
+    const path = normalise(relPath);
+    await this.sql.batch([
+      { sql: "DELETE FROM vault_object WHERE path = ?", params: [path] },
+      { sql: "DELETE FROM vault_append WHERE path = ?", params: [path] }
+    ]);
+  }
+  async exists(relPath) {
+    const path = normalise(relPath);
+    const rows = await this.sql.query(
+      `SELECT (
+         EXISTS (SELECT 1 FROM vault_object WHERE path = ?) OR
+         EXISTS (SELECT 1 FROM vault_append WHERE path = ?)
+       ) AS n`,
+      [path, path]
+    );
+    return (rows[0]?.n ?? 0) === 1;
+  }
+  /**
+   * Recursive path listing under a prefix.
+   *
+   * LEAKY by the interface's own admission, and kept for the same narrow
+   * reasons — migration, admin, index building. Callers asking "which" or
+   * "how many" should use `findEntities` / `count`, which push down.
+   */
+  async listFiles(prefix) {
+    const rows = await this.sql.query(
+      `SELECT path FROM vault_object WHERE path LIKE ? ESCAPE '\\'
+       UNION
+       SELECT DISTINCT path FROM vault_append WHERE path LIKE ? ESCAPE '\\'`,
+      [likePrefix(prefix), likePrefix(prefix)]
+    );
+    return rows.map((row) => row.path);
+  }
+  /**
+   * Pushed-down entity query — kind and tags resolved inside SQLite.
+   *
+   * This is the local counterpart of the pg backend's JSONB containment. The
+   * fallback it replaces reads every candidate row and filters in JS, which
+   * on a real mailbox is the difference between a desk that opens and one
+   * that stalls.
+   */
+  async findEntities(query) {
+    const { sql, params } = this.entityWhere(query);
+    const rows = await this.sql.query(
+      `SELECT path, body FROM vault_object ${sql} ORDER BY path${query.limit ? " LIMIT ?" : ""}`,
+      query.limit ? [...params, query.limit] : params
+    );
+    return rows.map((row) => ({ path: row.path, body: JSON.parse(row.body) }));
+  }
+  /** The same filter, counted rather than fetched. `limit` is ignored. */
+  async count(query) {
+    const { sql, params } = this.entityWhere(query);
+    const rows = await this.sql.query(
+      `SELECT count(*) AS n FROM vault_object ${sql}`,
+      params
+    );
+    return rows[0]?.n ?? 0;
+  }
+  /** Last `maxLines` of a ledger, newest last. An index read, not a parse. */
+  async readTextTail(relPath, opts) {
+    const rows = await this.sql.query(
+      `SELECT line FROM (
+         SELECT line, seq FROM vault_append WHERE path = ? ORDER BY seq DESC LIMIT ?
+       ) ORDER BY seq`,
+      [normalise(relPath), opts.maxLines]
+    );
+    if (rows.length > 0) return rows.map((row) => row.line).join("");
+    return this.readText(relPath);
+  }
+  /**
+   * "Has anything been appended?" without reading it.
+   *
+   * `MAX(seq)` over an AUTOINCREMENT primary key: monotonic, and an
+   * index-only read. Returns null when the path has no append rows, which
+   * callers MUST read as "unknown → read it properly" and never as
+   * "unchanged" — the interface is emphatic, because a stale change feed is
+   * a wrong answer rather than a slow one.
+   */
+  async appendVersion(relPath) {
+    const rows = await this.sql.query(
+      "SELECT MAX(seq) AS seq FROM vault_append WHERE path = ?",
+      [normalise(relPath)]
+    );
+    return rows[0]?.seq ?? null;
+  }
+  entityWhere(query) {
+    const clauses = ["body IS NOT NULL"];
+    const params = [];
+    if (query.prefix) {
+      clauses.push("path LIKE ? ESCAPE '\\'");
+      params.push(likePrefix(query.prefix));
+    }
+    if (query.kind) {
+      clauses.push("json_extract(body, '$.kind') = ?");
+      params.push(query.kind);
+    }
+    for (const tag of query.tags ?? []) {
+      clauses.push(
+        `EXISTS (SELECT 1 FROM json_each(body, '$.metadata.tags') WHERE json_each.value = ?)`
+      );
+      params.push(tag);
+    }
+    return { sql: `WHERE ${clauses.join(" AND ")}`, params };
+  }
+  async put(path, content) {
+    await this.sql.execute(...unwrap(putStatement(path, content, this.host.clock.now())));
+  }
+};
+function putStatement(path, content, now) {
+  return {
+    sql: `INSERT INTO vault_object (path, body, text, bytes, updated_at)
+          VALUES (?, ?, ?, ?, ?)
+          ON CONFLICT (path) DO UPDATE SET
+            body = excluded.body,
+            text = excluded.text,
+            bytes = excluded.bytes,
+            updated_at = excluded.updated_at`,
+    params: [path, content.body ?? null, content.text ?? null, content.bytes ?? null, now]
+  };
+}
+function unwrap(statement) {
+  return [statement.sql, statement.params];
+}
+
+// ../atlas-local/src/change-log.ts
+var ChangeLog = class {
+  constructor(host, originAtlas, signingKeyId) {
+    this.host = host;
+    this.originAtlas = originAtlas;
+    this.signingKeyId = signingKeyId;
+  }
+  /**
+   * Head of this origin's chain, or null before it has authored anything.
+   *
+   * Ordered by lamport, not by insertion: lamport is authoritative and the
+   * wallclock `ts` is metadata, which `atlas-changes` is explicit about.
+   */
+  async head(originAtlas = this.originAtlas) {
+    const rows = await this.host.sql.query(
+      "SELECT lamport, id FROM change_log WHERE origin_atlas = ? ORDER BY lamport DESC LIMIT 1",
+      [originAtlas]
+    );
+    const row = rows[0];
+    return row ? { lamport: row.lamport, hash: row.id } : null;
+  }
+  /**
+   * The Lamport clock: the highest lamport this atlas has seen, from ANY origin.
+   *
+   * It was this origin's head alone, which made last-write-wins across devices
+   * compare two unrelated counters: the device that had authored more Changes
+   * won, not the later edit (Spec 08 §3, gap 2). Taking the maximum of
+   * everything received restores the clock. `verifyChain` checks hashes and
+   * links, not gaps, so a chain that jumps from 3 to 9 stays valid.
+   */
+  async clock() {
+    const rows = await this.host.sql.query(
+      "SELECT MAX(lamport) AS m FROM change_log"
+    );
+    return rows[0]?.m ?? 0;
+  }
+  /**
+   * Author a Change: log it, project it, queue it — atomically.
+   *
+   * The first Change of an origin chains to `deterministicGenesisHash` rather
+   * than to null. `atlas-changes` explains why and it is worth restating: with
+   * no fixed anchor, anyone with append access can insert a forged "first"
+   * Change claiming no predecessor, and `verifyChain` cannot tell it from the
+   * real one. Anchoring closes that.
+   */
+  async append(input) {
+    const head = await this.head();
+    const sha256 = (bytes) => this.host.crypto.sha256(bytes);
+    const prevHash = head ? head.hash : await deterministicGenesisHash(this.originAtlas, sha256);
+    const unsigned = await buildChange({
+      changesetId: input.changesetId,
+      originAtlas: this.originAtlas,
+      originUser: input.originUser,
+      lamport: await this.clock() + 1,
+      // ISO from the injected clock, never `new Date()` — the host owns time
+      // so tests and replay can control it.
+      ts: new Date(this.host.clock.now()).toISOString(),
+      kind: input.kind,
+      target: input.target,
+      payload: input.payload,
+      prevHash
+    }, sha256);
+    const change = this.signingKeyId ? {
+      ...unsigned,
+      originSignature: base64(
+        await this.host.crypto.sign(this.signingKeyId, utf8Encode(unsigned.id))
+      )
+    } : unsigned;
+    const now = this.host.clock.now();
+    const statements = [insertStatement(change, input.eco, now)];
+    for (const projection of input.projects ?? []) {
+      statements.push(putStatement(projection.path, { body: JSON.stringify(projection.value) }, now));
+    }
+    for (const peer of input.notify ?? []) {
+      statements.push({
+        sql: `INSERT INTO outbox (
+                push_batch_id, target_atlas, eco, origin_atlas, from_lamport,
+                payload, state, attempts, next_attempt_at, last_error,
+                created_at, updated_at
+              ) VALUES (?, ?, ?, ?, ?, ?, 'pending', 0, ?, NULL, ?, ?)
+              ON CONFLICT (push_batch_id) DO NOTHING`,
+        params: [
+          peer.pushBatchId,
+          peer.targetAtlas,
+          input.eco,
+          this.originAtlas,
+          head?.lamport ?? 0,
+          JSON.stringify([change]),
+          now,
+          now,
+          now
+        ]
+      });
+    }
+    await this.host.sql.batch(statements);
+    return change;
+  }
+  /**
+   * Record a Change authored elsewhere — the inbound half of sync.
+   *
+   * Separate from `append` because the two differ in the ways that matter:
+   * this one does not mint a lamport (the origin already did), does not touch
+   * the outbox (we do not re-broadcast a peer's history), and is idempotent
+   * on `id`, because at-least-once delivery through a mailbox means the same
+   * Change WILL arrive twice.
+   */
+  async receive(change, eco, projects = []) {
+    const now = this.host.clock.now();
+    await this.host.sql.batch([
+      insertStatement(change, eco, now),
+      ...projects.map((p) => putStatement(p.path, { body: JSON.stringify(p.value) }, now))
+    ]);
+  }
+  /** Everything an origin authored after `lamport`, oldest first. */
+  async since(lamport, originAtlas = this.originAtlas) {
+    const rows = await this.host.sql.query(
+      `SELECT body FROM change_log
+        WHERE origin_atlas = ? AND lamport > ?
+        ORDER BY lamport`,
+      [originAtlas, lamport]
+    );
+    return rows.map((row) => JSON.parse(row.body));
+  }
+  /** What happened to one entity, oldest first — the canvas history view. */
+  async forTarget(target) {
+    const rows = await this.host.sql.query(
+      "SELECT body FROM change_log WHERE target = ? ORDER BY lamport",
+      [target]
+    );
+    return rows.map((row) => JSON.parse(row.body));
+  }
+  /**
+   * What happened to one entity, oldest first, with the circle each Change was
+   * logged in: which circles a file has reached, and what a removal owes them.
+   */
+  async forTargetIn(target) {
+    const rows = await this.host.sql.query(
+      "SELECT eco, body FROM change_log WHERE target = ? ORDER BY lamport",
+      [target]
+    );
+    return rows.map((row) => ({ eco: row.eco, change: JSON.parse(row.body) }));
+  }
+  /** Every Change logged in one circle, oldest first: what a catch-up walks for files it once held. */
+  async forEco(eco) {
+    const rows = await this.host.sql.query(
+      "SELECT body FROM change_log WHERE eco = ? ORDER BY lamport",
+      [eco]
+    );
+    return rows.map((row) => JSON.parse(row.body));
+  }
+  /** Whether this log already holds Change `id` as received in circle `eco`. */
+  async holds(id, eco) {
+    const rows = await this.host.sql.query(
+      "SELECT count(*) AS n FROM change_log WHERE id = ? AND eco = ?",
+      [id, eco]
+    );
+    return (rows[0]?.n ?? 0) > 0;
+  }
+  async get(id) {
+    const rows = await this.host.sql.query(
+      "SELECT body FROM change_log WHERE id = ?",
+      [id]
+    );
+    const row = rows[0];
+    return row ? JSON.parse(row.body) : null;
+  }
+  /** How many Changes this atlas holds, by origin. */
+  async countByOrigin() {
+    const rows = await this.host.sql.query(
+      "SELECT origin_atlas, count(*) AS n FROM change_log GROUP BY origin_atlas"
+    );
+    return Object.fromEntries(rows.map((row) => [row.origin_atlas, row.n]));
+  }
+  /**
+   * Move a Change's lifecycle state — `local` → `propagating` → `confirmed`.
+   *
+   * State is per-peer metadata about how THIS atlas views the Change, not a
+   * property of the Change itself, which is why it is deliberately outside
+   * the hashed content and why changing it does not disturb the chain.
+   */
+  async setState(id, state) {
+    await this.host.sql.execute(
+      `UPDATE change_log
+          SET state = ?,
+              body = json_set(body, '$.state', ?)
+        WHERE id = ?`,
+      [state, state, id]
+    );
+  }
+};
+function insertStatement(change, eco, now) {
+  const params = [
+    change.id,
+    change.changesetId,
+    change.originAtlas,
+    change.lamport,
+    change.ts,
+    change.kind,
+    change.target,
+    eco,
+    change.state,
+    JSON.stringify(change),
+    now
+  ];
+  return {
+    // `DO NOTHING` on the content-hash primary key: appending the same Change
+    // twice is a no-op, not an error. Through an at-least-once mailbox that
+    // is the ordinary case, not an edge one.
+    sql: `INSERT INTO change_log (
+            id, changeset_id, origin_atlas, lamport, ts, kind, target,
+            eco, state, body, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT (id) DO NOTHING`,
+    params
+  };
+}
+
+// ../atlas-local/src/reconcile.ts
+function planReconcile(observed, indexed) {
+  const byPath = new Map(indexed.map((row) => [row.path, row]));
+  const plan = { mint: [], remove: [], ignored: [] };
+  for (const file of observed) {
+    const known = byPath.get(file.path);
+    byPath.delete(file.path);
+    if (!known) {
+      plan.mint.push({ path: file.path, reason: "new", sha256: file.sha256 });
+      continue;
+    }
+    if (known.sha256 !== file.sha256) {
+      plan.mint.push({ path: file.path, reason: "edited", sha256: file.sha256 });
+      continue;
+    }
+    plan.ignored.push({
+      path: file.path,
+      reason: known.origin === "applied" ? "echo" : "unchanged",
+      sha256: file.sha256
+    });
+  }
+  for (const orphan of byPath.values()) {
+    plan.remove.push({ path: orphan.path, reason: "removed", sha256: null });
+  }
+  return plan;
+}
+var FileIndex = class {
+  constructor(sql) {
+    this.sql = sql;
+  }
+  /** Everything we hold under a path prefix. */
+  async under(prefix) {
+    const rows = await this.sql.query("SELECT path, sha256, origin, stamp FROM file_index WHERE path LIKE ? ESCAPE '\\'", [
+      `${prefix.replace(/[\\%_]/g, "\\$&")}%`
+    ]);
+    return rows;
+  }
+  async get(path) {
+    const rows = await this.sql.query("SELECT path, sha256, origin, stamp FROM file_index WHERE path = ?", [path]);
+    return rows[0] ?? null;
+  }
+  /** Record that we have taken account of these bytes. `origin` is the
+   *  load-bearing argument — see the v4 migration. */
+  async record(path, sha256, origin, now, stamp = null) {
+    await this.sql.execute(
+      `INSERT INTO file_index (path, sha256, origin, updated_at, stamp) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT (path) DO UPDATE SET sha256 = excluded.sha256,
+                                        origin = excluded.origin,
+                                        updated_at = excluded.updated_at,
+                                        stamp = excluded.stamp`,
+      [path, sha256, origin, now, stamp]
+    );
+  }
+  /**
+   * Note that a file whose bytes were just hashed and found identical to the
+   * stored hash now looks like `stamp` on disk. Only the stamp moves: the hash
+   * and the origin are what they were, so an echo stays an echo.
+   */
+  async restamp(path, sha256, stamp) {
+    await this.sql.execute("UPDATE file_index SET stamp = ? WHERE path = ? AND sha256 = ?", [stamp, path, sha256]);
+  }
+  async forget(path) {
+    await this.sql.execute("DELETE FROM file_index WHERE path = ?", [path]);
+  }
+};
+
+// ../atlas-local/src/vault-scan.ts
+async function hashOf(host, bytes) {
+  return toHex(await host.crypto.sha256(bytes));
+}
+function stampOf(stat) {
+  return stat.modifiedAtNs === void 0 ? null : `${stat.size}:${stat.modifiedAtNs}`;
+}
+async function scanAndApply(deps, options) {
+  const { host, index } = deps;
+  const own = options.match ?? (() => true);
+  const trust = options.falsify === "stamp-ignored" ? false : options.falsify === "full-trusts-stamp" ? true : options.trustStamp ?? true;
+  const files = (await host.files.list(options.prefix, { recursive: true })).filter((f) => own(f.path));
+  const rows = (await index.under(options.prefix)).filter((row) => own(row.path));
+  const known = new Map(rows.map((row) => [row.path, row]));
+  const observed = [];
+  const bytesByPath = /* @__PURE__ */ new Map();
+  const stampByPath = /* @__PURE__ */ new Map();
+  const failed = [];
+  let read = 0;
+  for (const stat of files) {
+    const stamp = stampOf(stat);
+    const row = known.get(stat.path);
+    if (trust && stamp !== null && row?.stamp === stamp) {
+      observed.push({ path: stat.path, sha256: row.sha256 });
+      continue;
+    }
+    try {
+      const bytes = await host.files.read(stat.path);
+      read += 1;
+      const sha256 = await hashOf(host, bytes);
+      observed.push({ path: stat.path, sha256 });
+      stampByPath.set(stat.path, stamp);
+      if (row?.sha256 === sha256) {
+        if (row.stamp !== stamp && options.falsify !== "stamp-not-kept") await index.restamp(stat.path, sha256, stamp);
+      } else {
+        bytesByPath.set(stat.path, bytes);
+      }
+    } catch (error) {
+      failed.push({ path: stat.path, reason: message(error) });
+    }
+  }
+  const indexed = rows.filter((row) => !failed.some((f) => f.path === row.path));
+  const plan = planReconcile(observed, indexed);
+  let minted = 0;
+  for (const item of plan.mint) {
+    const bytes = bytesByPath.get(item.path);
+    if (!bytes || item.sha256 === null) continue;
+    try {
+      await options.mint(item, bytes);
+      const stamp = options.falsify === "stamp-not-kept" ? null : stampByPath.get(item.path) ?? null;
+      await index.record(item.path, item.sha256, "observed", host.clock.now(), stamp);
+      minted += 1;
+    } catch (error) {
+      failed.push({ path: item.path, reason: message(error) });
+    }
+  }
+  let removed = 0;
+  for (const item of plan.remove) {
+    try {
+      await options.mintRemoval(item);
+      await index.forget(item.path);
+      removed += 1;
+    } catch (error) {
+      failed.push({ path: item.path, reason: message(error) });
+    }
+  }
+  return {
+    scanned: files.length,
+    minted,
+    removed,
+    ignored: plan.ignored.length,
+    read,
+    echoes: plan.ignored.filter((item) => item.reason === "echo").length,
+    failed
+  };
+}
+async function applyInbound(deps, path, bytes) {
+  const { host, index } = deps;
+  await host.files.write(path, bytes);
+  await index.record(path, await hashOf(host, bytes), "applied", host.clock.now());
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../atlas-local/src/fold.ts
+var FILE_SET = "file.set";
+var FILE_REMOVE = "file.remove";
+function conflictPath(path, device, ts) {
+  const slash = path.lastIndexOf("/");
+  const dir = slash < 0 ? "" : path.slice(0, slash + 1);
+  const file = slash < 0 ? path : path.slice(slash + 1);
+  const dot = file.lastIndexOf(".");
+  const [name, ext] = dot > 0 ? [file.slice(0, dot), file.slice(dot)] : [file, ""];
+  return `${dir}${name} (conflict, ${device}, ${ts.slice(0, 10)})${ext}`;
+}
+function before(a, b) {
+  return a.lamport !== b.lamport ? a.lamport < b.lamport : a.origin < b.origin;
+}
+function supersedes(payload, localSha) {
+  return localSha === payload.baseSha256 || Array.isArray(payload.ancestors) && payload.ancestors.includes(localSha);
+}
+function conflictOriginal(path) {
+  const m = /^(.*) \(conflict, [^,/()]+, \d{4}-\d{2}-\d{2}\)(\.[^/.]*)?$/.exec(path);
+  if (!m) return null;
+  return `${m[1]}${m[2] ?? ""}`;
+}
+var mergeMarkdown = (input) => {
+  const { local, incoming, base, union } = input;
+  const { payload } = incoming;
+  if (local === null || local.sha256 === payload.baseSha256) {
+    return { action: "write", how: "fast-forward", text: payload.text };
+  }
+  if (local.sha256 === payload.sha256) return { action: "none", why: "already there" };
+  if (supersedes(payload, local.sha256)) return { action: "write", how: "fast-forward", text: payload.text };
+  if (union && base !== null && local.lamport !== null && local.origin !== null && local.text.startsWith(base) && payload.text.startsWith(base)) {
+    const mine = { lamport: local.lamport, origin: local.origin, added: local.text.slice(base.length) };
+    const theirs = { lamport: incoming.lamport, origin: incoming.origin, added: payload.text.slice(base.length) };
+    const [first, second] = before(mine, theirs) ? [mine, theirs] : [theirs, mine];
+    const joint = first.added === "" || second.added === "" || first.added.endsWith("\n") ? "" : "\n";
+    return { action: "write", how: "union", text: `${base}${first.added}${joint}${second.added}` };
+  }
+  return {
+    action: "conflict",
+    conflictPath: conflictPath(input.path, incoming.origin, incoming.ts),
+    text: payload.text
+  };
+};
+var InboundFold = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.merge = opts.merge ?? mergeMarkdown;
+  }
+  merge;
+  /**
+   * Apply one received Change and, only if it was accepted, log it.
+   *
+   * Applying before logging: a crash between the two redelivers the Change,
+   * whose sha then matches what is on disk, and the second pass is a no-op.
+   *
+   * A Change this log already holds, in this circle, is a no-op before
+   * anything is read (HQ-1219). Delivery is at least once: a sender re-sends
+   * every unacknowledged batch on its next tick, so an older version can arrive
+   * again after a newer one has been applied. Folded a second time it no longer
+   * matches the local base, and it became a conflict file beside a file that
+   * was already correct: seven of them in Hestia's shadow on 2026-09-22, each
+   * an earlier version of a file edited several times between two drains.
+   */
+  async apply(change, eco) {
+    const { host, log } = this.opts;
+    if (this.opts.falsify !== "redelivery-refolded" && await log.holds(change.id, eco)) {
+      return { status: "applied", changeId: change.id, path: change.target, action: "already there" };
+    }
+    if (change.kind !== FILE_SET && change.kind !== FILE_REMOVE) {
+      await log.receive(change, eco);
+      return { status: "applied", changeId: change.id, path: change.target, action: "logged" };
+    }
+    let payload;
+    try {
+      payload = await this.opts.open(change, eco);
+    } catch (error) {
+      return {
+        status: "refused",
+        changeId: change.id,
+        reason: `cannot open the payload for circle ${eco}: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    if (payload.path !== change.target) {
+      return { status: "refused", changeId: change.id, reason: `payload path ${payload.path} is not the Change's target ${change.target}` };
+    }
+    if (payload.path.startsWith("/") || payload.path.split("/").includes("..")) {
+      return { status: "refused", changeId: change.id, reason: `payload path ${payload.path} is not relative to the record root` };
+    }
+    const at = this.opts.localPath?.(eco, payload.path) ?? payload.path;
+    const local = await this.readLocal(at);
+    let result;
+    if (change.kind === FILE_REMOVE) {
+      if (local === null) {
+        result = { status: "applied", changeId: change.id, path: payload.path, action: "absent" };
+      } else if (supersedes(payload, local.sha256)) {
+        const reissue = this.reissues(at, eco, change);
+        await host.files.remove(at);
+        if (!reissue) await this.opts.index.forget(at);
+        await this.opts.onRemove?.(at);
+        result = { status: "applied", changeId: change.id, path: payload.path, action: "removed", ...reissue ? { reissued: true } : {} };
+      } else {
+        result = { status: "applied", changeId: change.id, path: payload.path, action: "kept" };
+      }
+    } else if (payload.blob) {
+      const outcome = await this.applyBlob(change, { ...payload, blob: payload.blob }, local, at, eco);
+      if (outcome.status !== "applied") return outcome;
+      result = outcome;
+    } else {
+      if (typeof payload.text !== "string" || typeof payload.sha256 !== "string") {
+        return { status: "refused", changeId: change.id, reason: `file.set for ${payload.path} carries no text` };
+      }
+      if (await hashOf(host, utf8Encode(payload.text)) !== payload.sha256) {
+        return { status: "refused", changeId: change.id, reason: `file.set for ${payload.path} does not hash to its sha256` };
+      }
+      const history = await this.history(payload.path, eco);
+      const localSide = local && {
+        ...local,
+        ...history.bySha.get(local.sha256) ?? { lamport: null, origin: null }
+      };
+      const decision = this.merge({
+        path: payload.path,
+        local: localSide,
+        incoming: {
+          payload: { ...payload, text: payload.text, sha256: payload.sha256 },
+          lamport: change.lamport,
+          origin: change.originAtlas,
+          ts: change.ts
+        },
+        base: await this.baseText(payload.baseSha256, local?.text ?? null, history.textBySha),
+        union: (this.opts.unionPath?.(at) ?? false) || payload.union === true
+      });
+      const twin = decision.action === "write" && local === null ? await this.ownTextUnder(at, eco, payload.sha256) : false;
+      if (twin) {
+        result = { status: "applied", changeId: change.id, path: payload.path, action: "already there" };
+      } else if (decision.action === "write") {
+        const reissue = this.reissues(at, eco, change);
+        await this.write(at, decision.text, eco, reissue);
+        result = { status: "applied", changeId: change.id, path: payload.path, action: decision.how, ...reissue ? { reissued: true } : {} };
+      } else if (decision.action === "none") {
+        result = { status: "applied", changeId: change.id, path: payload.path, action: "already there" };
+      } else {
+        const beside = this.opts.localPath?.(eco, decision.conflictPath) ?? decision.conflictPath;
+        await this.write(beside, decision.text, eco, this.reissues(at, eco, change));
+        result = {
+          status: "applied",
+          changeId: change.id,
+          path: payload.path,
+          action: "conflict",
+          conflictPath: decision.conflictPath
+        };
+      }
+    }
+    await log.receive(change, eco);
+    return result;
+  }
+  /**
+   * A file.set whose bytes ride the blob lane. Fetched, opened with the key in
+   * the payload, checked against the payload's sha, and only then merged:
+   * fast-forward when the local file is absent or is the base, nothing when it
+   * is already there, and otherwise a conflict file beside the local one. Bytes
+   * that are not text do not union.
+   */
+  async applyBlob(change, payload, local, at, eco) {
+    const { host } = this.opts;
+    if (typeof payload.sha256 !== "string") {
+      return { status: "refused", changeId: change.id, reason: `file.set for ${payload.path} carries no sha256` };
+    }
+    if (local !== null && local.sha256 === payload.sha256) {
+      return { status: "applied", changeId: change.id, path: payload.path, action: "already there" };
+    }
+    if (!this.opts.fetchBlob) {
+      return { status: "refused", changeId: change.id, reason: `file.set for ${payload.path} rides the blob lane and this device fetches no blobs` };
+    }
+    const ciphertext = await this.opts.fetchBlob(payload.blob.hash);
+    if (ciphertext === null) {
+      return { status: "deferred", changeId: change.id, path: payload.path, reason: `blob ${payload.blob.hash} is not on the relay` };
+    }
+    if (await hashOfBase64url(host, ciphertext) !== payload.blob.hash) {
+      return { status: "refused", changeId: change.id, reason: `blob for ${payload.path} does not hash to its name` };
+    }
+    let bytes;
+    try {
+      bytes = await openBlob(host, ciphertext, fromBase64(payload.blob.contentKey));
+    } catch (error) {
+      return { status: "refused", changeId: change.id, reason: `blob for ${payload.path} does not open: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (await hashOf(host, bytes) !== payload.sha256) {
+      return { status: "refused", changeId: change.id, reason: `blob for ${payload.path} does not hash to its sha256` };
+    }
+    if (local === null || supersedes(payload, local.sha256)) {
+      const reissue = this.reissues(at, eco, change);
+      if (reissue) await host.files.write(at, bytes);
+      else await applyInbound({ host, index: this.opts.index }, at, bytes);
+      return { status: "applied", changeId: change.id, path: payload.path, action: "fast-forward", ...reissue ? { reissued: true } : {} };
+    }
+    const beside = conflictPath(payload.path, change.originAtlas, change.ts);
+    const besideAt = this.opts.localPath?.(eco, beside) ?? beside;
+    if (this.reissues(at, eco, change)) await host.files.write(besideAt, bytes);
+    else await applyInbound({ host, index: this.opts.index }, besideAt, bytes);
+    return { status: "applied", changeId: change.id, path: payload.path, action: "conflict", conflictPath: beside };
+  }
+  /**
+   * Whether a write into `at` from circle `eco` is the home device folding
+   * another circle's copy of its own file: true when this device knows the
+   * path's home and it is not `eco`, or the Change comes from another holder
+   * (`foreign`). Such a write is left unrecorded, so the next scan mints it
+   * again into the home and every release (HQ-835).
+   */
+  reissues(at, eco, change) {
+    if (!this.opts.homeOf) return false;
+    const home = this.opts.homeOf(at);
+    if (home === null) return false;
+    return home !== eco || (this.opts.foreign?.(change.originAtlas) ?? false);
+  }
+  /** Whether `at` is a conflict file's name and its original already holds `sha` here. */
+  async ownTextUnder(at, eco, sha) {
+    void eco;
+    const original = conflictOriginal(at);
+    if (original === null) return false;
+    const held = await this.readLocal(original);
+    return held !== null && held.sha256 === sha;
+  }
+  /**
+   * The text an edit was based on. First from `change_log`, where every version
+   * this device minted or accepted is held; then, for a version that never
+   * passed through a Change (a file both devices already held when they were
+   * paired), from the local file itself: the prefix of it, ending at a line
+   * boundary, whose sha is the base. A sha match is the proof, so a prefix is
+   * never guessed.
+   */
+  async baseText(baseSha256, localText, known) {
+    if (baseSha256 === null) return null;
+    const held = known.get(baseSha256);
+    if (held !== void 0) return held;
+    if (localText === null) return null;
+    for (let end = localText.length; end >= 0; end -= 1) {
+      if (end !== 0 && end !== localText.length && localText[end - 1] !== "\n") continue;
+      const prefix = localText.slice(0, end);
+      if (await hashOf(this.opts.host, utf8Encode(prefix)) === baseSha256) return prefix;
+    }
+    return null;
+  }
+  /**
+   * Write through `applyInbound`, recorded as applied, so the scanner sees an
+   * echo; or, for a write the scanner must mint again, through the host alone,
+   * leaving the index at the previous sha so the scan reports it edited.
+   */
+  async write(path, text, eco, reissue) {
+    if (reissue) await this.opts.host.files.write(path, utf8Encode(text));
+    else await applyInbound({ host: this.opts.host, index: this.opts.index }, path, utf8Encode(text));
+    await this.opts.onWrite?.(path, text, eco);
+  }
+  async readLocal(path) {
+    const { host } = this.opts;
+    if (await host.files.stat(path) === null) return null;
+    const bytes = await host.files.read(path);
+    return { sha256: await hashOf(host, bytes), text: utf8Decode(bytes) };
+  }
+  /**
+   * Every version of a path this device can open, by sha: its text, and the
+   * newest Change that produced it. The union needs both — the base text, and
+   * the local side's lamport — and both come from `change_log`, which already
+   * holds every Change this device authored or accepted.
+   */
+  async history(path, eco) {
+    const textBySha = /* @__PURE__ */ new Map();
+    const bySha = /* @__PURE__ */ new Map();
+    for (const past of await this.opts.log.forTarget(path)) {
+      if (past.kind !== FILE_SET) continue;
+      try {
+        const opened = await this.opts.open(past, eco);
+        if (typeof opened.sha256 !== "string" || typeof opened.text !== "string") continue;
+        textBySha.set(opened.sha256, opened.text);
+        const seen = bySha.get(opened.sha256);
+        if (!seen || before(seen, { lamport: past.lamport, origin: past.originAtlas })) {
+          bySha.set(opened.sha256, { lamport: past.lamport, origin: past.originAtlas });
+        }
+      } catch {
+      }
+    }
+    return { textBySha, bySha };
+  }
+};
+async function hashOfBase64url(host, bytes) {
+  return base64url(await host.crypto.sha256(bytes));
+}
+
+// ../atlas-local/src/invites.ts
+var PENDING_INVITES_PREFIX = "atlas.eco/entities/pending-invites/";
+var PendingInvites = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  path(inviteId) {
+    return `${PENDING_INVITES_PREFIX}${inviteId}.json`;
+  }
+  async put(invite) {
+    await this.storage.writeObject(this.path(invite.inviteId), invite);
+  }
+  async get(inviteId) {
+    return await this.storage.readObject(this.path(inviteId));
+  }
+  async list() {
+    const paths = await this.storage.listFiles(PENDING_INVITES_PREFIX);
+    const invites = [];
+    for (const path of paths) {
+      const invite = await this.storage.readObject(path);
+      if (invite) invites.push(invite);
+    }
+    return invites.sort((a, b) => a.mintedAt - b.mintedAt);
+  }
+  /**
+   * Stop waiting on one — redeemed, expired, or withdrawn.
+   *
+   * Deliberately one verb for all three. A caller that had to say *why* would
+   * be asserting something it may not know: "expired" is a guess about a clock
+   * we do not own, and the relay is the authority on whether it was redeemed.
+   */
+  async forget(inviteId) {
+    await this.storage.delete(this.path(inviteId));
+  }
+};
+
+// ../atlas-local/src/relay-client.ts
+var RelayError = class extends Error {
+  constructor(status, reason, message2) {
+    super(message2);
+    this.status = status;
+    this.reason = reason;
+    this.name = "RelayError";
+  }
+  /**
+   * Retrying will not help.
+   *
+   * 4xx only — a 5xx or a dropped connection is a relay having a bad day, which
+   * is what the outbox's backoff exists for; treating that as permanent would
+   * discard mail because a machine rebooted.
+   *
+   * **429 is the exception, and it is a 4xx.** A rate limit says "not now",
+   * not "not ever", and marking it permanent would have the outbox abandon a
+   * batch the moment a relay got busy — exactly when giving up is worst. The
+   * storage ceiling (507) is temporary for the same reason and already falls
+   * on the retry side of the line, because envelopes expire.
+   */
+  get permanent() {
+    if (this.status === 429) return false;
+    return this.status >= 400 && this.status < 500;
+  }
+};
+var RelayClient = class {
+  constructor(host, relayUrl) {
+    this.host = host;
+    this.relayUrl = relayUrl;
+  }
+  info() {
+    return this.json("GET", "/relay/info");
+  }
+  mint(request) {
+    return this.json("POST", "/invite/mint", request);
+  }
+  redeem(request) {
+    return this.json("POST", "/invite/redeem", request);
+  }
+  confirm(request) {
+    return this.json("POST", "/invite/confirm", request);
+  }
+  /**
+   * Put a blob on the relay's second lane. Idempotent — the name is the hash,
+   * so a re-upload is free and extends its life rather than duplicating it.
+   */
+  async putBlob(ciphertext) {
+    const response = await this.send("POST", "/blob", { bytes: ciphertext });
+    return this.decode(response);
+  }
+  /** Fetch a blob's ciphertext. Opening it needs the content key, which never
+   *  travels this way. */
+  async getBlob(hash) {
+    const response = await this.send("GET", `/blob/${encodeURIComponent(hash)}`, {});
+    if (response.status !== 200) {
+      throw new Error(`relay GET /blob \u2192 ${response.status}`);
+    }
+    return response.body ?? new Uint8Array();
+  }
+  /**
+   * A blob's ciphertext, or null when the relay has none by that name: expired,
+   * or not uploaded yet. That is a state the fold waits on, not an error;
+   * anything other than 200 or 404 still throws.
+   */
+  async findBlob(hash) {
+    try {
+      return await this.getBlob(hash);
+    } catch (error) {
+      if (error instanceof RelayError && error.status === 404) return null;
+      throw error;
+    }
+  }
+  inviteState(inviteId, request) {
+    return this.json("POST", `/invite/${encodeURIComponent(inviteId)}/state`, request);
+  }
+  // ── the drop lane ──
+  //
+  // Claiming is two calls because the address derives from PUBLIC material.
+  // A signature alone would let anyone holding the contact card take the box
+  // and drain it — and draining deletes. So the first call proves the identity
+  // key vouches for the sealing key, and the second proves possession of that
+  // sealing key by opening what was sealed to it.
+  dropClaim(request) {
+    return this.json("POST", "/drop/claim", request);
+  }
+  dropClaimConfirm(claimId, nonce) {
+    return this.json("POST", `/drop/claim/${encodeURIComponent(claimId)}/confirm`, { nonce });
+  }
+  /** Collect and DELETE. The relay is a spool; the atlas that drains holds the
+   *  record from then on. */
+  dropDrain(address, request) {
+    return this.json("POST", `/drop/${address}/drain`, request);
+  }
+  async register(request) {
+    await this.send("POST", "/mailbox/register", { json: request });
+  }
+  /**
+   * Leave a sealed envelope.
+   *
+   * `ttlMs` is an intent the relay clamps to a ceiling it publishes, and asking
+   * for more than the ceiling is an error rather than a silent trim — so a
+   * sender never discovers the limit by losing mail to it.
+   */
+  async post(address, envelope, ttlMs) {
+    const query = ttlMs === void 0 ? "" : `?ttlMs=${ttlMs}`;
+    const response = await this.send("POST", `/mailbox/${address}${query}`, {
+      bytes: envelope
+    });
+    return this.decode(response);
+  }
+  async poll(address, pollCredential, limit) {
+    const query = limit === void 0 ? "" : `?limit=${limit}`;
+    const response = await this.send("GET", `/mailbox/${address}${query}`, {
+      bearer: pollCredential
+    });
+    const raw = this.decode(response);
+    const envelopes = (raw.envelopes ?? []).map((e) => ({
+      ...e,
+      id: e.id ?? String(e.seq),
+      envelope: e.envelope ?? e.body ?? ""
+    }));
+    const more = raw.more ?? (typeof raw.depth === "number" && raw.depth > envelopes.length);
+    return { envelopes, more };
+  }
+  /** Acknowledge — the relay may forget this envelope. */
+  async ack(address, id, pollCredential) {
+    await this.send("DELETE", `/mailbox/${address}/${encodeURIComponent(id)}`, {
+      bearer: pollCredential
+    });
+  }
+  async json(method, path, body) {
+    const response = await this.send(method, path, body === void 0 ? {} : { json: body });
+    return this.decode(response);
+  }
+  async send(method, path, init) {
+    const headers = {};
+    let body;
+    if (init.json !== void 0) {
+      headers["content-type"] = "application/json";
+      body = utf8Encode(JSON.stringify(init.json));
+    } else if (init.bytes !== void 0) {
+      headers["content-type"] = "application/octet-stream";
+      body = init.bytes;
+    }
+    if (init.bearer !== void 0) headers.authorization = `Bearer ${init.bearer}`;
+    const response = await this.host.http.request({
+      method,
+      url: `${this.relayUrl}${path}`,
+      headers,
+      body
+    });
+    if (response.status >= 400) {
+      const parsed = safeJson(response.body);
+      throw new RelayError(
+        response.status,
+        parsed?.error ?? null,
+        `relay ${method} ${path} \u2192 ${response.status}${parsed?.error ? ` (${parsed.error})` : ""}`
+      );
+    }
+    return response;
+  }
+  decode(response) {
+    const value = safeJson(response.body);
+    if (value === null) throw new RelayError(response.status, null, "relay answered unparseable JSON");
+    return value;
+  }
+};
+function safeJson(body) {
+  try {
+    return JSON.parse(utf8Decode(body));
+  } catch {
+    return null;
+  }
+}
+
+// ../atlas-local/src/mailbox.ts
+var MAILBOX_ADDRESS_DOMAIN = "xania/mailbox/v1";
+var MAILBOX_POLL_DOMAIN = "xania/mailbox-poll/v1";
+var FIELD_SEP = "|";
+var NUL = Uint8Array.of(0);
+function mailboxInfo(domain, inviteId, recipientAtlasId) {
+  return concatBytes([
+    utf8Encode(domain),
+    NUL,
+    utf8Encode(inviteId),
+    NUL,
+    utf8Encode(`to:${recipientAtlasId}`)
+  ]);
+}
+async function deriveMailboxes(host, input) {
+  const handle = async (recipientAtlasId) => {
+    const [address, pollCredential] = await Promise.all([
+      host.crypto.deriveShared(
+        input.keyId,
+        input.peerSealingPublicKey,
+        mailboxInfo(MAILBOX_ADDRESS_DOMAIN, input.inviteId, recipientAtlasId)
+      ),
+      host.crypto.deriveShared(
+        input.keyId,
+        input.peerSealingPublicKey,
+        mailboxInfo(MAILBOX_POLL_DOMAIN, input.inviteId, recipientAtlasId)
+      )
+    ]);
+    return { address: base64url(address), pollCredential: base64url(pollCredential) };
+  };
+  const [inbound, outbound] = await Promise.all([
+    handle(input.ourAtlasId),
+    handle(input.peerAtlasId)
+  ]);
+  return { inbound, outbound };
+}
+function canonicalInviteString(p) {
+  return join([p.inviteId, p.atlasId, p.identityPublicKey, p.sealingPublicKey]);
+}
+function canonicalMintString(p) {
+  return join(["xania/invite-mint/v1", p.nonce, p.atlasId, p.identityPublicKey, p.sealingPublicKey]);
+}
+function canonicalInviteStateString(p) {
+  return join(["xania/invite-state/v1", p.inviteId, p.atlasId, String(p.issuedAt)]);
+}
+function canonicalSealRotationString(p) {
+  return join([
+    "xania/seal-rotate/v1",
+    p.atlasId,
+    String(p.version),
+    p.sealingPublicKey
+  ]);
+}
+function canonicalCircleKeyString(p) {
+  return join(["evda/circle-key/v1", p.from, p.to, p.circleId, String(p.epoch), p.sealedKeyHash]);
+}
+function canonicalCircleDeclarationString(p) {
+  return join(["evda/circle-declaration/v1", p.from, p.to, p.circleId, p.declarationHash]);
+}
+function canonicalCircleRevocationString(p) {
+  return join(["evda/circle-revoked/v1", p.from, p.to, p.circleId, p.at]);
+}
+function canonicalHolderDeviceString(p) {
+  return join(["evda/holder-device/v1", p.from, p.to, p.noticeHash]);
+}
+function canonicalJson(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+  const record = value;
+  const keys = Object.keys(record).filter((key) => record[key] !== void 0).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+function join(fields) {
+  for (const field of fields) {
+    if (typeof field !== "string" || field.length === 0) {
+      throw new Error("canonical: every field must be a non-empty string");
+    }
+    if (field.includes(FIELD_SEP)) {
+      throw new Error('canonical fields must not contain "|"');
+    }
+  }
+  return fields.join(FIELD_SEP);
+}
+
+// ../atlas-local/src/outbox.ts
+function backoffMs(attempts) {
+  const HOUR = 36e5;
+  return Math.min(3e4 * 2 ** Math.max(0, attempts - 1), HOUR);
+}
+var Outbox = class {
+  constructor(host) {
+    this.host = host;
+  }
+  /**
+   * Record a batch as owed. Idempotent on `pushBatchId`.
+   *
+   * The caller supplies the id rather than receiving one, because the id has
+   * to be stable across every retry and across restarts — it is the
+   * receiver's idempotency key, and minting a fresh one per attempt is the
+   * exact bug this class exists to not have.
+   */
+  async enqueue(input) {
+    const now = this.host.clock.now();
+    await this.host.sql.execute(
+      `INSERT INTO outbox (
+         push_batch_id, target_atlas, eco, origin_atlas, from_lamport,
+         payload, state, attempts, next_attempt_at, last_error,
+         created_at, updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, 'pending', 0, ?, NULL, ?, ?)
+       ON CONFLICT (push_batch_id) DO NOTHING`,
+      [
+        input.pushBatchId,
+        input.targetAtlas,
+        input.eco,
+        input.originAtlas,
+        input.fromLamport,
+        JSON.stringify(input.events),
+        now,
+        now,
+        now
+      ]
+    );
+  }
+  /**
+   * Batches that should be attempted now, oldest first.
+   *
+   * `relayed` rows are included: the mailbox took the envelope but the peer
+   * has not acknowledged, and after the backoff elapses we ask again. Only
+   * `acknowledged` and `failed` are terminal.
+   */
+  async due(limit = 20) {
+    const rows = await this.host.sql.query(
+      `SELECT * FROM outbox
+        WHERE state IN ('pending','relayed') AND next_attempt_at <= ?
+        ORDER BY created_at, push_batch_id
+        LIMIT ?`,
+      [this.host.clock.now(), limit]
+    );
+    return rows.map(hydrate);
+  }
+  /** The mailbox accepted the envelope. Not delivery — see `OutboxState`. */
+  async onRelayed(pushBatchId) {
+    const now = this.host.clock.now();
+    const attempts = await this.attemptsOf(pushBatchId);
+    await this.host.sql.execute(
+      `UPDATE outbox
+          SET state = 'relayed', attempts = ?, next_attempt_at = ?,
+              last_error = NULL, updated_at = ?
+        WHERE push_batch_id = ? AND state IN ('pending','relayed')`,
+      [attempts + 1, now + backoffMs(attempts + 1), now, pushBatchId]
+    );
+  }
+  /**
+   * The peer applied the batch. The only success, and terminal.
+   *
+   * `newServerCursor` is the peer's head lamport after applying; the caller
+   * advances its push cursor with it. Kept in the signature to match
+   * `OutboundQueue.onAcknowledged` so the server can adopt this class.
+   */
+  async onAcknowledged(pushBatchId, _newServerCursor, targetAtlas) {
+    const now = this.host.clock.now();
+    const scoped = targetAtlas === void 0 ? "" : " AND target_atlas = ?";
+    await this.host.sql.execute(
+      `UPDATE outbox
+          SET state = 'acknowledged', last_error = NULL, updated_at = ?
+        WHERE push_batch_id = ?${scoped}`,
+      targetAtlas === void 0 ? [now, pushBatchId] : [now, pushBatchId, targetAtlas]
+    );
+  }
+  /**
+   * Delivery failed.
+   *
+   * `permanent` is honoured, which is the whole point — `chain-violation` and
+   * `origin-mismatch` mean the batch is malformed and will fail identically
+   * forever, so retrying is just noise that hides the real problem.
+   */
+  async onFailed(pushBatchId, error, permanent) {
+    const now = this.host.clock.now();
+    const attempts = await this.attemptsOf(pushBatchId) + 1;
+    if (permanent) {
+      await this.host.sql.execute(
+        `UPDATE outbox
+            SET state = 'failed', attempts = ?, last_error = ?, updated_at = ?
+          WHERE push_batch_id = ?`,
+        [attempts, error, now, pushBatchId]
+      );
+      return;
+    }
+    await this.host.sql.execute(
+      `UPDATE outbox
+          SET attempts = ?, next_attempt_at = ?, last_error = ?, updated_at = ?
+        WHERE push_batch_id = ? AND state IN ('pending','relayed')`,
+      [attempts, now + backoffMs(attempts), error, now, pushBatchId]
+    );
+  }
+  async get(pushBatchId) {
+    const rows = await this.host.sql.query(
+      "SELECT * FROM outbox WHERE push_batch_id = ?",
+      [pushBatchId]
+    );
+    const row = rows[0];
+    return row ? hydrate(row) : null;
+  }
+  /**
+   * How much this atlas still owes, by state — the number the control panel
+   * shows and the one a person asks about when they have been on a plane.
+   */
+  async counts() {
+    const rows = await this.host.sql.query(
+      "SELECT state, count(*) AS n FROM outbox GROUP BY state"
+    );
+    const out = {
+      pending: 0,
+      relayed: 0,
+      acknowledged: 0,
+      failed: 0
+    };
+    for (const row of rows) out[row.state] = row.n;
+    return out;
+  }
+  /**
+   * Drop acknowledged batches older than `olderThanMs`.
+   *
+   * Not automatic. An acknowledged batch is the local proof that a peer has
+   * something, and deleting it on a timer the caller did not choose is how an
+   * audit trail quietly disappears.
+   */
+  async prune(olderThanMs) {
+    const cutoff = this.host.clock.now() - olderThanMs;
+    const result = await this.host.sql.execute(
+      "DELETE FROM outbox WHERE state = 'acknowledged' AND updated_at < ?",
+      [cutoff]
+    );
+    return result.rowsAffected;
+  }
+  async attemptsOf(pushBatchId) {
+    const rows = await this.host.sql.query(
+      "SELECT attempts FROM outbox WHERE push_batch_id = ?",
+      [pushBatchId]
+    );
+    return rows[0]?.attempts ?? 0;
+  }
+};
+function hydrate(row) {
+  return {
+    pushBatchId: row.push_batch_id,
+    targetAtlas: row.target_atlas,
+    eco: row.eco,
+    originAtlas: row.origin_atlas,
+    fromLamport: row.from_lamport,
+    events: JSON.parse(row.payload),
+    state: row.state,
+    attempts: row.attempts,
+    nextAttemptAt: row.next_attempt_at,
+    lastError: row.last_error,
+    createdAt: row.created_at
+  };
+}
+
+// ../atlas-local/src/peers.ts
+var PEERS_PREFIX = "atlas.eco/entities/peers/";
+var Peers = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  path(atlasId) {
+    return `${PEERS_PREFIX}${atlasId}.json`;
+  }
+  async put(peer) {
+    await this.storage.writeObject(this.path(peer.atlasId), peer);
+  }
+  async get(atlasId) {
+    return await this.storage.readObject(this.path(atlasId));
+  }
+  async list() {
+    const paths = await this.storage.listFiles(PEERS_PREFIX);
+    const peers = [];
+    for (const path of paths) {
+      const peer = await this.storage.readObject(path);
+      if (peer) peers.push(peer);
+    }
+    return peers.sort((a, b) => a.atlasId.localeCompare(b.atlasId));
+  }
+  /**
+   * Forget a peer.
+   *
+   * Local only, and say so rather than implying more: it stops this atlas
+   * sending to them and stops it accepting what they send, because an unpinned
+   * origin fails strict verification. It does not reach their copy of anything
+   * they already hold, and it cannot — that is what "your record is yours" means
+   * when it is someone else's record.
+   */
+  async forget(atlasId) {
+    await this.storage.delete(this.path(atlasId));
+  }
+};
+
+// ../atlas-local/src/rendezvous.ts
+var PENDING_REDEMPTIONS_PREFIX = "atlas.eco/entities/pending-redemptions/";
+var MAX_DRAIN_PAGES = 50;
+async function addressingKey(host, keyId) {
+  await host.crypto.ensureSealKey(keyId);
+  const addressing = await host.crypto.sealAddressingPublicKey(keyId);
+  if (!addressing) throw new Error(`no addressing key for ${keyId}`);
+  return addressing;
+}
+async function mintInvite(deps, relayUrl, opts = {}) {
+  const { host, keyId, atlasId } = deps;
+  const identityPublicKey = base64(await host.crypto.ensureKey(keyId));
+  const sealingPublicKey = base64(await addressingKey(host, keyId));
+  const nonce = `mn_${toHex(await host.crypto.randomBytes(12))}`;
+  const relay = new RelayClient(host, relayUrl);
+  const minted = await relay.mint({
+    atlasId,
+    identityPublicKey,
+    sealingPublicKey,
+    nonce,
+    proof: base64(
+      await host.crypto.sign(
+        keyId,
+        utf8Encode(
+          canonicalMintString({ nonce, atlasId, identityPublicKey, sealingPublicKey })
+        )
+      )
+    ),
+    // The relay reads `expiresAt`; `ttlMs` alone was ignored and every invite lived 24 hours (HQ-1217).
+    ...opts.ttlMs === void 0 ? {} : { ttlMs: opts.ttlMs, expiresAt: host.clock.now() + opts.ttlMs }
+  });
+  const link = {
+    inviteId: minted.inviteId,
+    secret: minted.secret,
+    // The relay's own answer, not the URL we dialled: behind a proxy the public
+    // name is not ours to know, and an invite carrying an address the recipient
+    // cannot reach is well-formed and useless.
+    relayUrl: minted.relayUrl,
+    expiresAt: minted.expiresAt
+  };
+  await new PendingInvites(deps.storage).put({
+    ...link,
+    mintedAt: host.clock.now(),
+    ...opts.label === void 0 ? {} : { label: opts.label }
+  });
+  return link;
+}
+async function redeemInvite(deps, invite) {
+  const { host, keyId, atlasId } = deps;
+  const relay = new RelayClient(host, invite.relayUrl);
+  const identityPublicKey = base64(await host.crypto.ensureKey(keyId));
+  const sealingPublicKey = base64(await addressingKey(host, keyId));
+  const proof = base64(
+    await host.crypto.sign(
+      keyId,
+      utf8Encode(
+        canonicalInviteString({
+          inviteId: invite.inviteId,
+          atlasId,
+          identityPublicKey,
+          sealingPublicKey
+        })
+      )
+    )
+  );
+  const challenge = await relay.redeem({
+    inviteId: invite.inviteId,
+    secret: invite.secret,
+    atlasId,
+    identityPublicKey,
+    sealingPublicKey,
+    proof
+  });
+  const nonce = await host.crypto.unseal(keyId, fromBase64(challenge.sealedNonce));
+  const result = await relay.confirm({
+    challengeId: challenge.challengeId,
+    nonce: base64(nonce)
+  });
+  return await pinAndRegister(deps, result, "inviter");
+}
+async function collectInvite(deps, invite) {
+  const { host, keyId, atlasId } = deps;
+  const relay = new RelayClient(host, invite.relayUrl);
+  const issuedAt = host.clock.now();
+  const proof = base64(
+    await host.crypto.sign(
+      keyId,
+      utf8Encode(
+        canonicalInviteStateString({ inviteId: invite.inviteId, atlasId, issuedAt })
+      )
+    )
+  );
+  const state = await relay.inviteState(invite.inviteId, { atlasId, issuedAt, proof });
+  if (state.status !== "redeemed") return null;
+  return await pinAndRegister(deps, state, "redeemer");
+}
+async function pinAndRegister(deps, result, peerRole) {
+  const { host, keyId, atlasId, storage } = deps;
+  assertPinnable(result.peer);
+  const parked = `${PENDING_REDEMPTIONS_PREFIX}${result.inviteId}.json`;
+  await storage.writeObject(parked, result);
+  const refusal = await verifyPeerProof(deps, result.peer, peerRole);
+  if (refusal !== null) {
+    throw new Error(
+      `refusing to pin ${result.peer.atlasId}: ${refusal}. The response is kept at ${parked}; nothing was registered.`
+    );
+  }
+  const { inbound, outbound } = await deriveMailboxes(host, {
+    keyId,
+    peerSealingPublicKey: fromBase64(result.peer.sealingPublicKey),
+    inviteId: result.inviteId,
+    ourAtlasId: atlasId,
+    peerAtlasId: result.peer.atlasId
+  });
+  const relay = new RelayClient(host, result.relayUrl);
+  await relay.register({
+    grant: result.registrationGrant,
+    address: inbound.address,
+    // The HASH, never the credential. The relay needs to recognise a caller,
+    // not to be able to become one.
+    pollCredentialHash: base64(await host.crypto.sha256(utf8Encode(inbound.pollCredential)))
+  });
+  const peer = {
+    atlasId: result.peer.atlasId,
+    identityPublicKey: result.peer.identityPublicKey,
+    sealingPublicKey: result.peer.sealingPublicKey,
+    // Content starts as addressing and diverges at the peer's first rotation.
+    contentPublicKey: result.peer.sealingPublicKey,
+    contentKeyVersion: 0,
+    relayUrl: result.relayUrl,
+    inviteId: result.inviteId,
+    inboundAddress: inbound.address,
+    outboundAddress: outbound.address,
+    pinnedAt: host.clock.now(),
+    keyVersion: 1
+  };
+  await new Peers(storage).put(peer);
+  await storage.delete(parked);
+  const version = await host.crypto.sealKeyVersion(keyId);
+  if (version > 0) {
+    try {
+      await announceRotation(deps, peer, version);
+    } catch {
+    }
+  }
+  return peer;
+}
+async function announceRotation(deps, peer, version) {
+  const { host, keyId, atlasId } = deps;
+  const current = await host.crypto.sealPublicKey(keyId);
+  if (!current) throw new Error(`no sealing key for ${keyId}`);
+  const sealingPublicKey = base64(current);
+  await postSealed(deps, peer, {
+    v: 1,
+    type: "rotate",
+    atlasId,
+    version,
+    sealingPublicKey,
+    signature: base64(
+      await host.crypto.sign(
+        keyId,
+        utf8Encode(canonicalSealRotationString({ atlasId, version, sealingPublicKey }))
+      )
+    )
+  });
+}
+async function verifyPeerProof(deps, peer, peerRole) {
+  if (!peer.proof || !peer.proofContext) {
+    return "the relay returned no proof of possession";
+  }
+  let canonical;
+  try {
+    canonical = peerRole === "inviter" ? canonicalMintString({
+      nonce: peer.proofContext,
+      atlasId: peer.atlasId,
+      identityPublicKey: peer.identityPublicKey,
+      sealingPublicKey: peer.sealingPublicKey
+    }) : canonicalInviteString({
+      inviteId: peer.proofContext,
+      atlasId: peer.atlasId,
+      identityPublicKey: peer.identityPublicKey,
+      sealingPublicKey: peer.sealingPublicKey
+    });
+  } catch (error) {
+    return `proof material is malformed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  const ok = await deps.host.crypto.verify(
+    fromBase64(peer.identityPublicKey),
+    utf8Encode(canonical),
+    fromBase64(peer.proof)
+  );
+  return ok ? null : "the proof does not verify against the identity key presented";
+}
+function assertPinnable(peer) {
+  if (!peer.atlasId) throw new Error("relay returned a peer with no atlasId");
+  for (const [name, value] of [
+    ["identity", peer.identityPublicKey],
+    ["sealing", peer.sealingPublicKey]
+  ]) {
+    if (fromBase64(value).length !== 32) {
+      throw new Error(`relay returned a ${name} key that is not 32 bytes`);
+    }
+  }
+}
+async function notifyFor(deps, eco, changesetId) {
+  const peers = await new Peers(deps.storage).list();
+  const readers = deps.grants ? await deps.grants.readers(eco) : "all";
+  return peers.filter((peer) => readers === "all" || readers.includes(peer.atlasId)).map((peer) => ({ targetAtlas: peer.atlasId, pushBatchId: `${changesetId}>${peer.atlasId}` }));
+}
+async function sendDue(deps, limit = 20) {
+  const { host, storage } = deps;
+  const outbox = new Outbox(host);
+  const peers = new Peers(storage);
+  const blobs = new BlobStore(host);
+  const report = { relayed: 0, failed: 0, unknownPeers: 0 };
+  for (const row of await outbox.due(limit)) {
+    const peer = await peers.get(row.targetAtlas);
+    if (!peer) {
+      report.unknownPeers += 1;
+      continue;
+    }
+    const payload = {
+      v: 1,
+      type: "push",
+      pushBatchId: row.pushBatchId,
+      eco: row.eco,
+      originAtlas: row.originAtlas,
+      fromLamport: row.fromLamport,
+      events: row.events
+    };
+    try {
+      const relay = new RelayClient(host, peer.relayUrl);
+      for (const blob of await blobs.forChanges(row.events.map((e) => e.id))) {
+        const put = await relay.putBlob(blob.ciphertext);
+        if (put.hash !== blob.hash) {
+          throw new Error(`relay named blob ${blob.hash} as ${put.hash}; refusing to send a Change whose blob it altered`);
+        }
+      }
+      await postSealed(deps, peer, payload);
+      await outbox.onRelayed(row.pushBatchId);
+      report.relayed += 1;
+    } catch (error) {
+      const permanent = error instanceof RelayError && error.permanent;
+      await outbox.onFailed(row.pushBatchId, String(error), permanent);
+      report.failed += 1;
+    }
+  }
+  return report;
+}
+async function postSealed(deps, peer, payload) {
+  const { host } = deps;
+  const sealed = await host.crypto.seal(
+    fromBase64(peer.contentPublicKey),
+    utf8Encode(JSON.stringify(payload))
+  );
+  await new RelayClient(host, peer.relayUrl).post(peer.outboundAddress, sealed);
+}
+var CIRCLE_KEYS_SENT_PREFIX = "atlas.eco/entities/circle-keys-sent/";
+var sentKeyPath = (peer, circleId) => `${CIRCLE_KEYS_SENT_PREFIX}${peer}--${circleId}.json`;
+async function deliverCircleKeys(deps) {
+  const report = { delivered: 0, failed: 0, reasons: [] };
+  const { grants, host, storage, atlasId, keyId } = deps;
+  if (!grants?.circles || !grants.mayShareKey) return report;
+  const peers = await new Peers(storage).list();
+  for (const circleId of await grants.circles()) {
+    const key = await host.crypto.circleKey(circleId);
+    if (!key) continue;
+    if (!await grants.mayShareKey(atlasId, circleId)) continue;
+    const readers = await grants.readers(circleId);
+    for (const peer of peers) {
+      if (readers !== "all" && !readers.includes(peer.atlasId)) continue;
+      const sent = await storage.readObject(sentKeyPath(peer.atlasId, circleId));
+      if ((sent?.epoch ?? 0) >= key.epoch) continue;
+      try {
+        const sealed = await host.crypto.sealCircleKeyTo(circleId, key.epoch, fromBase64(peer.contentPublicKey));
+        const sealedKeyHash = base64(await host.crypto.sha256(sealed));
+        const signature = await host.crypto.sign(
+          keyId,
+          utf8Encode(
+            canonicalCircleKeyString({ from: atlasId, to: peer.atlasId, circleId, epoch: key.epoch, sealedKeyHash })
+          )
+        );
+        await postSealed(deps, peer, {
+          v: 1,
+          type: "circle-key",
+          from: atlasId,
+          to: peer.atlasId,
+          circleId,
+          epoch: key.epoch,
+          sealedKey: base64(sealed),
+          signature: base64(signature)
+        });
+        await storage.writeObject(sentKeyPath(peer.atlasId, circleId), { epoch: key.epoch, at: host.clock.now() });
+        if (sent === null) await oweCatchUp(deps, peer.atlasId, circleId, "join");
+        report.delivered += 1;
+      } catch (error) {
+        report.failed += 1;
+        report.reasons.push(`${peer.atlasId}/${circleId}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  return report;
+}
+async function rekeyCircle(deps, circleId) {
+  if (deps.grants?.mayShareKey && !await deps.grants.mayShareKey(deps.atlasId, circleId)) {
+    throw new Error(`${deps.atlasId} holds no owner grant on circle ${circleId}, so it cannot re-key it`);
+  }
+  const { epoch } = await deps.host.crypto.newCircleKey(circleId);
+  return { epoch, delivery: await deliverCircleKeys(deps) };
+}
+async function applyCircleKey(deps, peer, payload) {
+  if (payload.from !== peer.atlasId) return `circle key names ${payload.from}, not peer ${peer.atlasId}`;
+  if (payload.to !== deps.atlasId) return `circle key is for ${payload.to}, not ${deps.atlasId}`;
+  if (!Number.isInteger(payload.epoch) || payload.epoch < 1) return `circle key epoch ${String(payload.epoch)} is not >= 1`;
+  const sealed = fromBase64(payload.sealedKey);
+  let canonical;
+  try {
+    canonical = canonicalCircleKeyString({
+      from: payload.from,
+      to: payload.to,
+      circleId: payload.circleId,
+      epoch: payload.epoch,
+      sealedKeyHash: base64(await deps.host.crypto.sha256(sealed))
+    });
+  } catch (error) {
+    return `circle key is malformed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  const ok = await deps.host.crypto.verify(
+    fromBase64(peer.identityPublicKey),
+    utf8Encode(canonical),
+    fromBase64(payload.signature)
+  );
+  if (!ok) return "circle key does not verify against the pinned identity key";
+  const { grants } = deps;
+  if (!grants?.mayShareKey) return "this device reads no grants, so it accepts no circle key";
+  if (!await grants.mayShareKey(peer.atlasId, payload.circleId)) {
+    return `${peer.atlasId} holds no owner grant on circle ${payload.circleId}`;
+  }
+  const readers = await grants.readers(payload.circleId);
+  if (readers !== "all" && !readers.includes(deps.atlasId)) {
+    return `this device holds no grant on circle ${payload.circleId}`;
+  }
+  try {
+    await deps.host.crypto.importCircleKey(deps.keyId, payload.circleId, payload.epoch, sealed);
+  } catch (error) {
+    return `circle key does not open: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  return null;
+}
+var CATCH_UP_OWED_PREFIX = "atlas.eco/entities/catch-up-owed/";
+var CATCH_UP_BATCH = 25;
+var owedPath = (peer, circleId) => `${CATCH_UP_OWED_PREFIX}${peer}--${circleId}.json`;
+async function oweCatchUp(deps, peer, circleId, why) {
+  await deps.storage.writeObject(owedPath(peer, circleId), { peer, circleId, why, at: deps.host.clock.now() });
+}
+async function deliverCatchUp(deps) {
+  const report = { delivered: 0, changes: 0, failed: 0, reasons: [] };
+  const { catchUp, grants, host, storage } = deps;
+  if (!catchUp) return report;
+  const peers = new Peers(storage);
+  const blobs = new BlobStore(host);
+  const snapshots = /* @__PURE__ */ new Map();
+  for (const file of (await storage.listFiles(CATCH_UP_OWED_PREFIX)).sort()) {
+    const owed = await storage.readObject(file);
+    if (!owed) continue;
+    const peer = await peers.get(owed.peer);
+    try {
+      const readers = grants ? await grants.readers(owed.circleId) : "all";
+      if (!peer || readers !== "all" && !readers.includes(owed.peer)) {
+        await storage.delete(file);
+        continue;
+      }
+      let events = snapshots.get(owed.circleId);
+      if (!events) {
+        events = await catchUp.snapshot(owed.circleId);
+        snapshots.set(owed.circleId, events);
+      }
+      const relay = new RelayClient(host, peer.relayUrl);
+      for (let i = 0; i < events.length; i += CATCH_UP_BATCH) {
+        const batch = events.slice(i, i + CATCH_UP_BATCH);
+        for (const blob of await blobs.forChanges(batch.map((e) => e.id))) {
+          const put = await relay.putBlob(blob.ciphertext);
+          if (put.hash !== blob.hash) throw new Error(`relay named blob ${blob.hash} as ${put.hash}`);
+        }
+        await postSealed(deps, peer, {
+          v: 1,
+          type: "push",
+          pushBatchId: `catch-up:${owed.circleId}:${batch[0].id}>${peer.atlasId}`,
+          eco: owed.circleId,
+          originAtlas: deps.atlasId,
+          fromLamport: batch[0].lamport - 1,
+          events: batch
+        });
+      }
+      await storage.delete(file);
+      report.delivered += 1;
+      report.changes += events.length;
+    } catch (error) {
+      report.failed += 1;
+      report.reasons.push(`${owed.peer}/${owed.circleId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return report;
+}
+var CIRCLE_DECLARATIONS_SENT_PREFIX = "atlas.eco/entities/circle-declarations-sent/";
+var sentDeclarationPath = (peer, circleId) => `${CIRCLE_DECLARATIONS_SENT_PREFIX}${peer}--${circleId}.json`;
+async function declarationHash(host, declaration) {
+  return base64(await host.crypto.sha256(utf8Encode(canonicalJson(declaration))));
+}
+async function deliverCircleDeclarations(deps) {
+  const report = { delivered: 0, revoked: 0, failed: 0, reasons: [] };
+  const { grants, host, storage, atlasId, keyId } = deps;
+  if (!grants?.circles || !grants.mayShareKey || !grants.declaration) return report;
+  const own = grants.ownRecord ? await grants.ownRecord() : null;
+  const siblings = /* @__PURE__ */ new Set();
+  const peers = [];
+  for (const peer of await new Peers(storage).list()) {
+    if (own !== null && grants.recordOf && await grants.recordOf(peer.atlasId) === own) siblings.add(peer.atlasId);
+    else peers.push(peer);
+  }
+  for (const circleId of await grants.circles()) {
+    if (!await grants.mayShareKey(atlasId, circleId)) continue;
+    const declaration = await grants.declaration(circleId);
+    if (!declaration) continue;
+    const hash = await declarationHash(host, declaration);
+    const readers = await grants.readers(circleId);
+    for (const peer of peers) {
+      const path = sentDeclarationPath(peer.atlasId, circleId);
+      const sent = await storage.readObject(path);
+      const holds = readers === "all" || readers.includes(peer.atlasId);
+      try {
+        if (holds) {
+          if (sent?.hash === hash && sent.revokedAt === void 0) continue;
+          const signature = await host.crypto.sign(
+            keyId,
+            utf8Encode(canonicalCircleDeclarationString({ from: atlasId, to: peer.atlasId, circleId, declarationHash: hash }))
+          );
+          await postSealed(deps, peer, {
+            v: 1,
+            type: "circle-declaration",
+            from: atlasId,
+            to: peer.atlasId,
+            circleId,
+            declaration,
+            signature: base64(signature)
+          });
+          await storage.writeObject(path, { hash, at: host.clock.now() });
+          if (sent?.revokedAt !== void 0) await oweCatchUp(deps, peer.atlasId, circleId, "thaw");
+          report.delivered += 1;
+        } else if (sent && sent.revokedAt === void 0) {
+          const at = new Date(host.clock.now()).toISOString();
+          const signature = await host.crypto.sign(
+            keyId,
+            utf8Encode(canonicalCircleRevocationString({ from: atlasId, to: peer.atlasId, circleId, at }))
+          );
+          await postSealed(deps, peer, { v: 1, type: "circle-revoked", from: atlasId, to: peer.atlasId, circleId, at, signature: base64(signature) });
+          await storage.writeObject(path, { ...sent, revokedAt: host.clock.now() });
+          report.revoked += 1;
+        }
+      } catch (error) {
+        report.failed += 1;
+        report.reasons.push(`${peer.atlasId}/${circleId}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+  return report;
+}
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var nonEmptyString = (value) => typeof value === "string" && value.length > 0;
+function malformedDeclaration(d) {
+  if (!isRecord(d)) return "declaration is not an object";
+  if (!nonEmptyString(d.id) || d.id.includes("/") || d.id.includes("|")) return "declaration has no usable id";
+  if (d.namespace !== `${d.id}.eco`) return `declaration namespace ${String(d.namespace)} does not name circle ${d.id}`;
+  if (!nonEmptyString(d.title)) return "declaration has no title";
+  if (d.public !== false) return "a public circle travels as its export, not as a declaration";
+  if (d.release !== "never" && !(Array.isArray(d.release) && d.release.length > 0 && d.release.every(nonEmptyString))) return "declaration release is neither never nor a list of circle names";
+  if (!Array.isArray(d.grants) || d.grants.length === 0) return "declaration carries no grants";
+  for (const g of d.grants) {
+    if (!isRecord(g)) return "a grant in the declaration is not an object";
+    if (!nonEmptyString(g.principalId)) return "a grant in the declaration names no principal";
+    if (g.role !== "owner" && g.role !== "editor" && g.role !== "viewer") return `a grant in the declaration has role ${String(g.role)}`;
+    if (!isRecord(g.holder) || !nonEmptyString(g.holder.kind)) return `the grant to ${g.principalId} names no holder kind`;
+    if (!nonEmptyString(g.grantedAt) || !nonEmptyString(g.grantedBy)) return `the grant to ${g.principalId} says not when or by whom`;
+  }
+  return null;
+}
+async function applyCircleDeclaration(deps, peer, payload) {
+  if (payload.from !== peer.atlasId) return `circle declaration names ${payload.from}, not peer ${peer.atlasId}`;
+  if (payload.to !== deps.atlasId) return `circle declaration is for ${payload.to}, not ${deps.atlasId}`;
+  const malformed = malformedDeclaration(payload.declaration);
+  if (malformed !== null) return `circle declaration is malformed: ${malformed}`;
+  if (payload.declaration.id !== payload.circleId) return `circle declaration declares ${payload.declaration.id} inside an envelope for ${payload.circleId}`;
+  let canonical;
+  try {
+    canonical = canonicalCircleDeclarationString({
+      from: payload.from,
+      to: payload.to,
+      circleId: payload.circleId,
+      declarationHash: await declarationHash(deps.host, payload.declaration)
+    });
+  } catch (error) {
+    return `circle declaration is malformed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  let ok = false;
+  try {
+    ok = await deps.host.crypto.verify(fromBase64(peer.identityPublicKey), utf8Encode(canonical), fromBase64(payload.signature));
+  } catch {
+    ok = false;
+  }
+  if (!ok) return "circle declaration does not verify against the pinned identity key";
+  if (!deps.grants?.adoptDeclaration) return "this device reads no grants, so it holds no declared circle";
+  return await deps.grants.adoptDeclaration(payload.from, payload.declaration);
+}
+async function applyCircleRevocation(deps, peer, payload) {
+  if (payload.from !== peer.atlasId) return `circle revocation names ${payload.from}, not peer ${peer.atlasId}`;
+  if (payload.to !== deps.atlasId) return `circle revocation is for ${payload.to}, not ${deps.atlasId}`;
+  if (!nonEmptyString(payload.at) || Number.isNaN(Date.parse(payload.at))) return `circle revocation carries no instant`;
+  let canonical;
+  try {
+    canonical = canonicalCircleRevocationString({ from: payload.from, to: payload.to, circleId: payload.circleId, at: payload.at });
+  } catch (error) {
+    return `circle revocation is malformed: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  let ok = false;
+  try {
+    ok = await deps.host.crypto.verify(fromBase64(peer.identityPublicKey), utf8Encode(canonical), fromBase64(payload.signature));
+  } catch {
+    ok = false;
+  }
+  if (!ok) return "circle revocation does not verify against the pinned identity key";
+  if (!deps.grants?.freezeCircle) return "this device reads no grants, so it freezes no circle";
+  return await deps.grants.freezeCircle(payload.from, payload.circleId, payload.at);
+}
+async function noticeHash(host, notice) {
+  return base64(await host.crypto.sha256(utf8Encode(canonicalJson(notice))));
+}
+function malformedNotice(n) {
+  if (!isRecord(n)) return "notice is not an object";
+  if (!nonEmptyString(n.record)) return "notice names no record";
+  if (n.op !== "add" && n.op !== "retire") return `notice op ${String(n.op)} is neither add nor retire`;
+  if (!isRecord(n.device) || !nonEmptyString(n.device.atlasId) || !nonEmptyString(n.device.identityPublicKey)) return "notice names no device and key";
+  if (!nonEmptyString(n.at) || Number.isNaN(Date.parse(n.at))) return "notice carries no instant";
+  if (n.op === "add" && n.invite !== void 0) {
+    if (!isRecord(n.invite) || !nonEmptyString(n.invite.inviteId) || !nonEmptyString(n.invite.secret) || !nonEmptyString(n.invite.relayUrl)) return "the invite for an added device is malformed";
+  }
+  return null;
+}
+async function applyHolderDevice(deps, peer, payload, report) {
+  if (payload.from !== peer.atlasId) return `holder-device notice names ${payload.from}, not peer ${peer.atlasId}`;
+  if (payload.to !== deps.atlasId) return `holder-device notice is for ${payload.to}, not ${deps.atlasId}`;
+  const malformed = malformedNotice(payload.notice);
+  if (malformed !== null) return `holder-device notice is malformed: ${malformed}`;
+  const notice = payload.notice;
+  let ok = false;
+  try {
+    const canonical = canonicalHolderDeviceString({ from: payload.from, to: payload.to, noticeHash: await noticeHash(deps.host, notice) });
+    ok = await deps.host.crypto.verify(fromBase64(peer.identityPublicKey), utf8Encode(canonical), fromBase64(payload.signature));
+  } catch {
+    ok = false;
+  }
+  if (!ok) return "holder-device notice does not verify against the pinned identity key";
+  const { grants } = deps;
+  if (!grants?.admitDevice || !grants.retireDevice) return "this device reads no grants, so it keeps no device lists";
+  const introducer = { atlasId: peer.atlasId, identityPublicKey: peer.identityPublicKey };
+  const peers = new Peers(deps.storage);
+  const sibling = grants.ownRecord ? notice.record === await grants.ownRecord() : false;
+  if (notice.op === "add") {
+    const self = notice.device.atlasId === deps.atlasId;
+    if (self && !sibling) return `${peer.atlasId} lists this device as a device of ${notice.record}; only a device of this record's own holder lists it`;
+    const known = self ? null : await peers.get(notice.device.atlasId);
+    if (self && notice.device.identityPublicKey !== base64(await deps.host.crypto.ensureKey(deps.keyId))) {
+      return `the notice lists this device under an identity key that is not its own`;
+    }
+    if (known && known.identityPublicKey !== notice.device.identityPublicKey) {
+      return `${notice.device.atlasId} is already pinned here under a different identity key`;
+    }
+    if (!notice.invite && !sibling && !known) {
+      return `an added device of another holder comes with an invite, so this device can pin it`;
+    }
+    if (!known && !self && notice.invite) {
+      let pinned;
+      try {
+        pinned = await redeemInvite(deps, notice.invite);
+      } catch (error) {
+        return `the invite for ${notice.device.atlasId} does not redeem: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      if (pinned.atlasId !== notice.device.atlasId || pinned.identityPublicKey !== notice.device.identityPublicKey) {
+        await peers.forget(pinned.atlasId);
+        return `the invite pinned ${pinned.atlasId} with a key that is not the one ${peer.atlasId} introduced for ${notice.device.atlasId}; forgotten`;
+      }
+    }
+    const refusal2 = await grants.admitDevice(notice.record, notice.device, introducer, notice.at);
+    if (refusal2 !== null && !known && !self && notice.invite) await peers.forget(notice.device.atlasId);
+    return refusal2;
+  }
+  if (sibling) {
+    return await grants.retireDevice(notice.record, notice.device.atlasId, peer.atlasId, notice.at);
+  }
+  const affected = [];
+  for (const circleId of grants.circles ? await grants.circles() : []) {
+    const readers = await grants.readers(circleId);
+    if (readers === "all" || !readers.includes(notice.device.atlasId)) continue;
+    if (grants.mayShareKey && await grants.mayShareKey(deps.atlasId, circleId)) affected.push(circleId);
+  }
+  const refusal = await grants.retireDevice(notice.record, notice.device.atlasId, peer.atlasId, notice.at);
+  if (refusal !== null) return refusal;
+  for (const circleId of affected) {
+    const { epoch } = await rekeyCircle(deps, circleId);
+    (report.rekeyed ??= []).push(`${circleId}@${epoch}`);
+  }
+  return null;
+}
+async function rotateSealingKey(deps, opts = {}) {
+  const { host, keyId, atlasId, storage } = deps;
+  const keepVersions = opts.keepVersions ?? 2;
+  const { version } = await host.crypto.rotateSealKey(keyId);
+  const report = { version, announced: 0, failed: 0, dropped: 0 };
+  for (const peer of await new Peers(storage).list()) {
+    try {
+      await announceRotation(deps, peer, version);
+      report.announced += 1;
+    } catch {
+      report.failed += 1;
+    }
+  }
+  report.dropped = await host.crypto.dropRetiredSealKeys(keyId, keepVersions);
+  return report;
+}
+async function applyRotation(deps, peer, payload) {
+  if (payload.atlasId !== peer.atlasId) {
+    return `rotation names ${payload.atlasId}, not peer ${peer.atlasId}`;
+  }
+  if (!Number.isInteger(payload.version) || payload.version <= peer.contentKeyVersion) {
+    return `rotation to version ${String(payload.version)} does not move forwards`;
+  }
+  if (fromBase64(payload.sealingPublicKey).length !== 32) {
+    return "rotation carries a key that is not 32 bytes";
+  }
+  const canonical = canonicalSealRotationString({
+    atlasId: payload.atlasId,
+    version: payload.version,
+    sealingPublicKey: payload.sealingPublicKey
+  });
+  const ok = await deps.host.crypto.verify(
+    fromBase64(peer.identityPublicKey),
+    utf8Encode(canonical),
+    fromBase64(payload.signature)
+  );
+  if (!ok) return "rotation does not verify against the pinned identity key";
+  await new Peers(deps.storage).put({
+    ...peer,
+    contentPublicKey: payload.sealingPublicKey,
+    contentKeyVersion: payload.version
+  });
+  return null;
+}
+function causeChain(error) {
+  const parts = [];
+  let cur = error;
+  for (let i = 0; cur !== void 0 && cur !== null && i < 5; i += 1) {
+    if (cur instanceof Error) {
+      const code = cur.code;
+      parts.push(typeof code === "string" && !cur.message.includes(code) ? `${code} ${cur.message}` : cur.message);
+      cur = cur.cause;
+    } else {
+      parts.push(String(cur));
+      cur = void 0;
+    }
+  }
+  return parts.join(" <- ");
+}
+async function pollPeers(deps, limit = 50) {
+  const report = {
+    applied: 0,
+    unreachable: 0,
+    rotations: 0,
+    rejected: 0,
+    acknowledged: 0,
+    reasons: []
+  };
+  const peers = await new Peers(deps.storage).list();
+  for (const peer of peers) {
+    try {
+      await pollPeer(deps, peer, limit, report);
+    } catch (error) {
+      report.unreachable += 1;
+      report.reasons.push(`${peer.atlasId}: ${causeChain(error)}`);
+    }
+  }
+  if (peers.length > 0 && report.unreachable === peers.length) {
+    throw new Error(`no peer could be reached: ${report.reasons.join("; ")}`);
+  }
+  return report;
+}
+async function pollPeer(deps, peer, limit, report, pagesLeft = MAX_DRAIN_PAGES) {
+  const { host, keyId, storage } = deps;
+  const relay = new RelayClient(host, peer.relayUrl);
+  const { inbound } = await deriveMailboxes(host, {
+    keyId,
+    peerSealingPublicKey: fromBase64(peer.sealingPublicKey),
+    inviteId: peer.inviteId,
+    ourAtlasId: deps.atlasId,
+    peerAtlasId: peer.atlasId
+  });
+  const delivery = await relay.poll(inbound.address, inbound.pollCredential, limit);
+  const log = new ChangeLog(host, deps.atlasId, keyId);
+  const outbox = new Outbox(host);
+  for (const item of delivery.envelopes) {
+    let payload;
+    try {
+      const opened = await host.crypto.unseal(keyId, fromBase64(item.envelope));
+      payload = JSON.parse(utf8Decode(opened));
+    } catch {
+      report.rejected += 1;
+      report.reasons.push(`unopenable envelope ${item.id}`);
+      await relay.ack(inbound.address, item.id, inbound.pollCredential);
+      continue;
+    }
+    if (payload.type === "rotate") {
+      const refusal = await applyRotation(deps, peer, payload);
+      if (refusal === null) {
+        report.rotations += 1;
+      } else {
+        report.rejected += 1;
+        report.reasons.push(`${item.id}: ${refusal}`);
+      }
+      await relay.ack(inbound.address, item.id, inbound.pollCredential);
+      continue;
+    }
+    if (payload.type === "circle-declaration") {
+      const refusal = await applyCircleDeclaration(deps, peer, payload);
+      if (refusal === null) {
+        report.declarations = (report.declarations ?? 0) + 1;
+      } else {
+        report.rejected += 1;
+        report.reasons.push(`${item.id}: ${refusal}`);
+      }
+      await relay.ack(inbound.address, item.id, inbound.pollCredential);
+      continue;
+    }
+    if (payload.type === "circle-revoked") {
+      const refusal = await applyCircleRevocation(deps, peer, payload);
+      if (refusal === null) {
+        report.revocations = (report.revocations ?? 0) + 1;
+      } else {
+        report.rejected += 1;
+        report.reasons.push(`${item.id}: ${refusal}`);
+      }
+      await relay.ack(inbound.address, item.id, inbound.pollCredential);
+      continue;
+    }
+    if (payload.type === "holder-device") {
+      const refusal = await applyHolderDevice(deps, peer, payload, report);
+      if (refusal === null) {
+        report.devices = (report.devices ?? 0) + 1;
+      } else {
+        report.rejected += 1;
+        report.reasons.push(`${item.id}: ${refusal}`);
+      }
+      await relay.ack(inbound.address, item.id, inbound.pollCredential);
+      continue;
+    }
+    if (payload.type === "circle-key") {
+      const refusal = await applyCircleKey(deps, peer, payload);
+      if (refusal === null) {
+        report.circleKeys = (report.circleKeys ?? 0) + 1;
+      } else {
+        report.rejected += 1;
+        report.reasons.push(`${item.id}: ${refusal}`);
+      }
+      await relay.ack(inbound.address, item.id, inbound.pollCredential);
+      continue;
+    }
+    if (payload.type === "ack") {
+      await outbox.onAcknowledged(payload.pushBatchId, payload.newCursor, peer.atlasId);
+      report.acknowledged += 1;
+      await relay.ack(inbound.address, item.id, inbound.pollCredential);
+      continue;
+    }
+    const verdict = await verifyInbound(deps, peer, payload);
+    if (verdict !== null) {
+      report.rejected += 1;
+      report.reasons.push(`${item.id}: ${verdict}`);
+      await relay.ack(inbound.address, item.id, inbound.pollCredential);
+      continue;
+    }
+    if (deps.fold) {
+      let accepted = 0;
+      let deferred = 0;
+      for (const change of payload.events) {
+        const result = await deps.fold.apply(change, payload.eco);
+        (report.folds ??= []).push(result);
+        if (result.status === "refused") {
+          report.rejected += 1;
+          report.reasons.push(`${item.id}: ${result.changeId}: ${result.reason}`);
+        } else if (result.status === "deferred") {
+          deferred += 1;
+        } else {
+          accepted += 1;
+        }
+      }
+      report.applied += accepted;
+      if (deferred > 0) {
+        report.deferred = (report.deferred ?? 0) + 1;
+        report.reasons.push(`${item.id}: ${deferred} Change(s) wait on a blob`);
+        continue;
+      }
+      if (accepted === 0) {
+        await relay.ack(inbound.address, item.id, inbound.pollCredential);
+        continue;
+      }
+    } else {
+      for (const change of payload.events) {
+        await log.receive(change, payload.eco);
+      }
+      report.applied += payload.events.length;
+    }
+    await postSealed(deps, peer, {
+      v: 1,
+      type: "ack",
+      pushBatchId: payload.pushBatchId,
+      newCursor: payload.events.at(-1)?.lamport ?? payload.fromLamport
+    });
+    await relay.ack(inbound.address, item.id, inbound.pollCredential);
+  }
+  if (delivery.more && delivery.envelopes.length > 0 && pagesLeft > 1) {
+    await pollPeer(deps, peer, limit, report, pagesLeft - 1);
+  } else if (delivery.more && pagesLeft <= 1) {
+    report.reasons.push(`${peer.atlasId}: stopped after ${MAX_DRAIN_PAGES} pages, more waiting`);
+  }
+  void storage;
+}
+async function verifyInbound(deps, peer, payload) {
+  if (payload.v !== 1) return `unsupported envelope version ${String(payload.v)}`;
+  if (payload.originAtlas !== peer.atlasId) {
+    return `origin ${payload.originAtlas} is not peer ${peer.atlasId}`;
+  }
+  if (!Array.isArray(payload.events) || payload.events.length === 0) return "empty batch";
+  if (deps.grants && !await deps.grants.mayAuthor(payload.originAtlas, payload.eco)) {
+    return `origin ${payload.originAtlas} holds no owner or editor grant on circle ${payload.eco}`;
+  }
+  const pinned = fromBase64(peer.identityPublicKey);
+  for (const change of payload.events) {
+    if (change.originAtlas !== payload.originAtlas) {
+      return `change ${change.id} claims origin ${change.originAtlas}`;
+    }
+    if (!change.originSignature) return `change ${change.id} is unsigned`;
+    const ok = await deps.host.crypto.verify(
+      pinned,
+      utf8Encode(change.id),
+      fromBase64(change.originSignature)
+    );
+    if (!ok) return `change ${change.id} does not verify against the pinned key`;
+  }
+  const issues = await verifyChain(payload.events, (bytes) => deps.host.crypto.sha256(bytes));
+  const blocking = issues.filter((issue) => issue.issue !== "broken-prev");
+  if (blocking.length > 0) {
+    return `chain: ${blocking.map((issue) => `${issue.issue}@${issue.change.lamport}`).join(", ")}`;
+  }
+  return null;
+}
+
+// ../atlas-local/src/schema.ts
+var MIGRATIONS = [
+  [
+    `CREATE TABLE IF NOT EXISTS outbox (
+       push_batch_id   TEXT PRIMARY KEY,
+       target_atlas    TEXT NOT NULL,
+       eco             TEXT NOT NULL,
+       origin_atlas    TEXT NOT NULL,
+       from_lamport    INTEGER NOT NULL,
+       payload         TEXT NOT NULL,
+       state           TEXT NOT NULL CHECK (
+                         state IN ('pending','relayed','acknowledged','failed')
+                       ),
+       attempts        INTEGER NOT NULL DEFAULT 0,
+       next_attempt_at INTEGER NOT NULL,
+       last_error      TEXT,
+       created_at      INTEGER NOT NULL,
+       updated_at      INTEGER NOT NULL
+     )`,
+    // The only hot query: "what is due to send now". Ordering by
+    // created_at keeps a peer's batches in the order they were authored,
+    // which the receiver's lamport check requires.
+    `CREATE INDEX IF NOT EXISTS outbox_due
+       ON outbox (state, next_attempt_at, created_at)`
+  ],
+  // Migration 2 — the vault.
+  //
+  // `path` is the LOGICAL vault address and is suffix-free. The fs backend
+  // appends `.yaml` because there the bytes really are YAML in a file; here
+  // the row is JSON in SQLite, so a suffix would be a lie — the same
+  // conclusion the Postgres backend reached. Anything that filters this
+  // column on `.yaml` is a bug that returns empty, which reads as "there is
+  // nothing here". See docs/canon/architecture/vault/entity-keys.md.
+  //
+  // Three content columns and exactly one is ever set, enforced by CHECK
+  // rather than convention: a path is text, or an object, or bytes. Storing
+  // objects as TEXT rather than BLOB is what lets `json_extract` push kind
+  // and tag filters down into SQLite instead of reading every row and
+  // filtering in JS — the local equivalent of the pg backend's GIN
+  // containment, and the difference between a desk that opens and one that
+  // stalls on a real mailbox.
+  [
+    `CREATE TABLE IF NOT EXISTS vault_object (
+       path       TEXT PRIMARY KEY,
+       body       TEXT,
+       text       TEXT,
+       bytes      BLOB,
+       updated_at INTEGER NOT NULL,
+       CHECK ((body IS NOT NULL) + (text IS NOT NULL) + (bytes IS NOT NULL) = 1)
+     )`,
+    // Kind is the only folder axis, so it is the only generated column worth
+    // indexing. Tags are matched through json_each, which needs no index at
+    // this corpus size and would need a shadow table to have one.
+    `CREATE INDEX IF NOT EXISTS vault_by_kind
+       ON vault_object (json_extract(body, '$.kind'))
+       WHERE body IS NOT NULL`,
+    // Prefix scans (`listFiles`, and every query bounded by an eco dir) are
+    // range scans on the primary key, so no extra index is needed — but the
+    // append log is queried by path too and benefits from recency ordering.
+    `CREATE TABLE IF NOT EXISTS vault_append (
+       seq        INTEGER PRIMARY KEY AUTOINCREMENT,
+       path       TEXT NOT NULL,
+       line       TEXT NOT NULL,
+       created_at INTEGER NOT NULL
+     )`,
+    `CREATE INDEX IF NOT EXISTS vault_append_by_path
+       ON vault_append (path, seq)`
+  ],
+  // Migration 3 — the Change log.
+  //
+  // The full Change rides in `body` as JSON; the columns beside it are the
+  // ones queried. `id` is the content hash, so the primary key is doing
+  // integrity work as well as identity — appending the same Change twice is
+  // a no-op rather than a fork.
+  //
+  // UNIQUE (origin_atlas, lamport) is the load-bearing constraint. Two
+  // Changes at the same lamport from one origin IS a forked chain, and the
+  // database refusing it is better than `verifyChain` discovering it later
+  // on a peer's machine.
+  [
+    `CREATE TABLE IF NOT EXISTS change_log (
+       id           TEXT PRIMARY KEY,
+       changeset_id TEXT NOT NULL,
+       origin_atlas TEXT NOT NULL,
+       lamport      INTEGER NOT NULL,
+       ts           TEXT NOT NULL,
+       kind         TEXT NOT NULL,
+       target       TEXT NOT NULL,
+       eco          TEXT NOT NULL,
+       state        TEXT NOT NULL,
+       body         TEXT NOT NULL,
+       created_at   INTEGER NOT NULL,
+       UNIQUE (origin_atlas, lamport)
+     )`,
+    // Reading a chain, and finding the head to extend it.
+    `CREATE INDEX IF NOT EXISTS change_by_origin
+       ON change_log (origin_atlas, lamport)`,
+    // "What happened to this entity" — the audit view, and how a canvas
+    // shows its own history.
+    `CREATE INDEX IF NOT EXISTS change_by_target
+       ON change_log (target, lamport)`
+  ],
+  // Migration 4 — lexical search.
+  //
+  // FTS5 with porter stemming, so 'discharge' finds 'discharging'. This is
+  // the whole search story locally and that is not a compromise:
+  // SEARCH_EMBEDDINGS_DISABLED=1 is the default on every box shipped today,
+  // so lexical-only is the shipped reality rather than a downgrade.
+  //
+  // An external-content table was considered and rejected. It would avoid
+  // storing the text twice, but it requires triggers kept in lockstep with
+  // vault_object and silently returns wrong rows when they drift — and what
+  // gets indexed is rarely the raw body anyway (an email's text is its
+  // subject plus its parsed plain-text part, not its JSON).
+  [
+    `CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5 (
+       path UNINDEXED,
+       title,
+       text,
+       tokenize = 'porter unicode61'
+     )`
+  ],
+  // v4 — the reconcile ledger for files WE DO NOT OWN.
+  //
+  // When a person's own folder is the record and we are the index beside it,
+  // "has this file changed" cannot be answered from the file: markdown carries
+  // no version and no Lamport clock. So it is answered by content hash against
+  // what we last saw.
+  //
+  // `origin` is the whole reason this is a table rather than a hash cache.
+  // `observed` means the person wrote it; `applied` means WE wrote it while
+  // projecting an inbound Change. Without that distinction our own write fires
+  // the watcher, looks like a local edit, mints a second Change, and two
+  // devices ping-pong a file between them forever.
+  [
+    `CREATE TABLE IF NOT EXISTS file_index (
+       path       TEXT PRIMARY KEY,
+       sha256     TEXT NOT NULL,
+       origin     TEXT NOT NULL CHECK (origin IN ('observed', 'applied')),
+       updated_at INTEGER NOT NULL
+     )`,
+    `CREATE INDEX IF NOT EXISTS file_index_sha ON file_index (sha256)`
+  ],
+  // v6 — which circle each search row belongs to (Spec 08 §5).
+  //
+  // A side table rather than a column on `search_index`: an FTS5 table cannot
+  // gain a column without being rebuilt, and a query that filters by circle is
+  // a join on `path` either way. The filter is applied in the query, never
+  // left to a caller to remember.
+  [
+    `CREATE TABLE IF NOT EXISTS search_circle (
+       path TEXT PRIMARY KEY,
+       eco  TEXT NOT NULL
+     )`,
+    `CREATE INDEX IF NOT EXISTS search_circle_eco ON search_circle (eco)`
+  ],
+  // v7 — sealed blobs this device minted, and which Change references each
+  // (Spec 08 §3, "Offline"; HQ-1219).
+  //
+  // The relay forgets a blob after 3 days while the Change that names it is
+  // re-sent for as long as the peer takes to acknowledge. The sender cannot
+  // re-seal the file (a new seal is a new hash, and the Change already names
+  // the old one), so it keeps the CIPHERTEXT it uploaded and puts it back on
+  // every send. Ciphertext only: the content key travels inside the sealed
+  // Change payload and is not stored here.
+  [
+    `CREATE TABLE IF NOT EXISTS blob_store (
+       hash       TEXT PRIMARY KEY,
+       ciphertext BLOB NOT NULL,
+       created_at INTEGER NOT NULL
+     )`,
+    `CREATE TABLE IF NOT EXISTS change_blob (
+       change_id TEXT NOT NULL,
+       hash      TEXT NOT NULL,
+       PRIMARY KEY (change_id, hash)
+     )`
+  ],
+  // v8 — what a file looked like on disk when its hash was taken (HQ-1219).
+  //
+  // `<size>:<mtime in ns>`, from the listing that preceded the read. A scan
+  // that finds the same stamp reuses the stored hash instead of reading the
+  // file again, which is what turns a tick on a 3,300 file record from reading
+  // every byte into reading only what changed. Null until a scan that could
+  // stat the file has hashed it, and null always means "read it".
+  [`ALTER TABLE file_index ADD COLUMN stamp TEXT`]
+];
+var MIGRATION_TABLE = `CREATE TABLE IF NOT EXISTS atlas_local_migration (
+   version    INTEGER PRIMARY KEY,
+   applied_at INTEGER NOT NULL
+ )`;
+async function migrate(sql, now) {
+  await sql.execute(MIGRATION_TABLE);
+  const applied = await sql.query(
+    "SELECT version FROM atlas_local_migration ORDER BY version"
+  );
+  const current = applied.length;
+  if (current > MIGRATIONS.length) {
+    throw new Error(
+      `store is at schema v${current} but this build knows v${MIGRATIONS.length} \u2014 it was written by a newer Xania. Refusing to downgrade.`
+    );
+  }
+  for (let index = current; index < MIGRATIONS.length; index++) {
+    const version = index + 1;
+    const statements = (MIGRATIONS[index] ?? []).map((s) => ({ sql: s }));
+    await sql.batch([
+      ...statements,
+      {
+        sql: "INSERT INTO atlas_local_migration (version, applied_at) VALUES (?, ?)",
+        params: [version, now]
+      }
+    ]);
+  }
+  return MIGRATIONS.length;
+}
+
+// ../atlas-local/src/search.ts
+function indexLocation(home, recordId) {
+  if (!recordId || /[/\\]/.test(recordId) || recordId === "." || recordId === "..") {
+    throw new Error(`not a record id: ${recordId}`);
+  }
+  return `${home.replace(/\/+$/, "")}/.evda/${recordId}`;
+}
+function assertIndexOutsideRecord(location, recordRoot) {
+  const root = recordRoot.replace(/\/+$/, "");
+  if (location === root || location.startsWith(`${root}/`)) {
+    throw new Error(`refusing an index inside the record (${location} is under ${root})`);
+  }
+}
+
+// ../atlas-local/src/drops.ts
+var DROP_DOMAIN = "xania/drop/v1";
+var DROP_POLL_DOMAIN = "xania/drop-poll/v1";
+var EMPTY_SALT = new Uint8Array(0);
+function dropInfo(domain, atlasId) {
+  const d = utf8Encode(domain);
+  const to = utf8Encode(`to:${atlasId}`);
+  const out = new Uint8Array(d.length + 1 + to.length);
+  out.set(d, 0);
+  out[d.length] = 0;
+  out.set(to, d.length + 1);
+  return out;
+}
+function base64url2(bytes) {
+  return base64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function dropAddressFor(host, sealingPublicKey, atlasId) {
+  if (sealingPublicKey.length !== 32) {
+    throw new Error("dropAddress: sealing public key must be 32 raw bytes");
+  }
+  if (!atlasId || atlasId.includes("|")) {
+    throw new Error("dropAddress: atlasId must be non-empty and contain no '|'");
+  }
+  return base64url2(
+    await host.crypto.hkdf(sealingPublicKey, EMPTY_SALT, dropInfo(DROP_DOMAIN, atlasId), 32)
+  );
+}
+async function ownDropAddress(deps) {
+  const sealing = await deps.host.crypto.sealPublicKey(deps.keyId);
+  if (!sealing) throw new Error("no sealing key: cannot derive a drop address");
+  return dropAddressFor(deps.host, sealing, deps.atlasId);
+}
+function canonicalDropPollString(p) {
+  const issuedAt = String(p.issuedAt);
+  for (const [name, f] of [["atlasId", p.atlasId], ["issuedAt", issuedAt]]) {
+    if (!f || f.includes("|")) {
+      throw new Error(`dropPoll: ${name} must be non-empty and contain no '|'`);
+    }
+  }
+  return [DROP_POLL_DOMAIN, p.atlasId, issuedAt].join("|");
+}
+function canonicalClaimString(p) {
+  return ["xania/invite-mint/v1", p.nonce, p.atlasId, p.identityPublicKey, p.sealingPublicKey].join("|");
+}
+async function claimDropBox(deps, relayUrl) {
+  const { host, keyId, atlasId } = deps;
+  const identityRaw = await host.crypto.publicKey(keyId);
+  const sealingRaw = await host.crypto.sealPublicKey(keyId);
+  if (!identityRaw || !sealingRaw) throw new Error("claimDropBox: identity or sealing key missing");
+  const identityPublicKey = base64(identityRaw);
+  const sealingPublicKey = base64(sealingRaw);
+  const nonce = `dcn_${base64url2(await host.crypto.randomBytes(12))}`;
+  const proof = base64(
+    await host.crypto.sign(
+      keyId,
+      utf8Encode(canonicalClaimString({ nonce, atlasId, identityPublicKey, sealingPublicKey }))
+    )
+  );
+  const relay = new RelayClient(host, relayUrl);
+  const claimed = await relay.dropClaim({
+    atlasId,
+    sealingPublicKey,
+    identityPublicKey,
+    nonce,
+    proof
+  });
+  if (claimed.alreadyClaimed) return { address: claimed.address, alreadyClaimed: true };
+  if (!claimed.claimId || !claimed.envelope) {
+    throw new Error("claimDropBox: relay issued no possession challenge");
+  }
+  const nonceBack = utf8Decode(
+    await host.crypto.unseal(keyId, fromBase64(claimed.envelope))
+  );
+  await relay.dropClaimConfirm(claimed.claimId, nonceBack);
+  return { address: claimed.address, alreadyClaimed: false };
+}
+async function drainDrops(deps, relayUrl) {
+  const { host, keyId, atlasId } = deps;
+  const address = await ownDropAddress(deps);
+  const issuedAt = host.clock.now();
+  const proof = base64(
+    await host.crypto.sign(keyId, utf8Encode(canonicalDropPollString({ atlasId, issuedAt })))
+  );
+  const relay = new RelayClient(host, relayUrl);
+  const drained = await relay.dropDrain(address, { atlasId, issuedAt, proof });
+  const collected = [];
+  let unopenable = 0;
+  for (const item of drained.items) {
+    try {
+      collected.push({
+        id: item.id,
+        receivedAt: item.receivedAt,
+        bytes: await host.crypto.unseal(keyId, fromBase64(item.body))
+      });
+    } catch {
+      unopenable += 1;
+    }
+  }
+  return { collected, unopenable };
+}
+
+// ../atlas-local/src/sync.ts
+var SyncEngine = class {
+  constructor(deps, options = {}) {
+    this.deps = deps;
+    this.intervalMs = options.intervalMs ?? 3e4;
+    this.rotateAfterPairing = options.rotateAfterPairing ?? true;
+    this.dropRelayUrl = options.dropRelayUrl ?? null;
+  }
+  status = "idle";
+  lastAttemptAt = null;
+  lastSuccessAt = null;
+  consecutiveFailures = 0;
+  lastError = null;
+  nextDueAt = 0;
+  running = false;
+  intervalMs;
+  rotateAfterPairing;
+  dropRelayUrl;
+  /** Claiming is idempotent, so this is an optimisation rather than
+   *  correctness — it keeps a round trip out of every cycle, not a second box
+   *  out of existence. */
+  dropBoxClaimed = false;
+  get host() {
+    return this.deps.host;
+  }
+  async state() {
+    const counts = await new Outbox(this.host).counts();
+    return {
+      status: this.status,
+      lastAttemptAt: this.lastAttemptAt,
+      lastSuccessAt: this.lastSuccessAt,
+      consecutiveFailures: this.consecutiveFailures,
+      lastError: this.lastError,
+      nextDueAt: this.nextDueAt,
+      // `relayed` counts too: the relay took it, the peer has not acknowledged,
+      // and a person asking "has it gone?" is owed the honest answer.
+      owed: counts.pending + counts.relayed,
+      peers: (await new Peers(this.deps.storage).list()).length,
+      pendingInvites: (await new PendingInvites(this.deps.storage).list()).length
+    };
+  }
+  /**
+   * Run a cycle if one is due. Safe to call as often as a shell likes.
+   *
+   * The re-entrancy guard is load-bearing rather than tidy: a tick that spans
+   * several round trips can easily outlive its own interval, and two concurrent
+   * cycles would double-post from the outbox and race each other's
+   * acknowledgements.
+   */
+  async tick() {
+    if (this.running) return { ran: false, skipped: "already running" };
+    const now = this.host.clock.now();
+    if (now < this.nextDueAt) return { ran: false, skipped: "not due" };
+    return this.run();
+  }
+  /** Run now, whatever the schedule says — a person pressing sync. */
+  async syncNow() {
+    if (this.running) return { ran: false, skipped: "already running" };
+    return this.run();
+  }
+  async run() {
+    this.running = true;
+    this.status = "syncing";
+    const startedAt = this.host.clock.now();
+    this.lastAttemptAt = startedAt;
+    const report = { ran: true };
+    try {
+      report.pinned = await this.collectPending();
+      const declarations = await deliverCircleDeclarations(this.deps);
+      if (declarations.delivered + declarations.revoked + declarations.failed > 0) report.declarations = declarations;
+      const keys = await deliverCircleKeys(this.deps);
+      if (keys.delivered + keys.failed > 0) report.keys = keys;
+      const catchUp = await deliverCatchUp(this.deps);
+      if (catchUp.delivered + catchUp.failed > 0) report.catchUp = catchUp;
+      report.sent = await sendDue(this.deps);
+      report.received = await pollPeers(this.deps);
+      const drops = await this.collectDrops();
+      if (drops) report.drops = drops;
+      const rotated = await this.rotateIfFirstPairing();
+      if (rotated !== null) report.rotatedTo = rotated;
+      this.consecutiveFailures = 0;
+      this.lastError = null;
+      this.lastSuccessAt = this.host.clock.now();
+      this.status = "idle";
+      this.nextDueAt = this.lastSuccessAt + this.intervalMs;
+    } catch (error) {
+      this.consecutiveFailures += 1;
+      this.lastError = error instanceof Error ? error.message : String(error);
+      this.status = "offline";
+      this.nextDueAt = this.host.clock.now() + backoffMs(this.consecutiveFailures);
+      report.error = this.lastError;
+    } finally {
+      this.running = false;
+    }
+    return report;
+  }
+  /**
+   * Claim the drop box if it is not claimed yet, then drain it.
+   *
+   * Inside the try, so a drop relay that is down fails the cycle and takes the
+   * same backoff as everything else — a lane that failed quietly would look
+   * like an atlas nobody is sending to, which is indistinguishable from working.
+   *
+   * Returns null when no drop relay is configured, which is the default.
+   */
+  async collectDrops() {
+    if (!this.dropRelayUrl) return null;
+    if (!this.dropBoxClaimed) {
+      await claimDropBox(this.deps, this.dropRelayUrl);
+      this.dropBoxClaimed = true;
+    }
+    const { collected, unopenable } = await drainDrops(this.deps, this.dropRelayUrl);
+    return { collected: collected.length, unopenable };
+  }
+  /**
+   * Ask the relay about every invite still outstanding.
+   *
+   * One failure does not abandon the rest — invites may sit on different
+   * relays, and one being unreachable says nothing about another.
+   */
+  async collectPending() {
+    const invites = new PendingInvites(this.deps.storage);
+    const pinned = [];
+    const now = this.host.clock.now();
+    for (const invite of await invites.list()) {
+      if (invite.expiresAt <= now) {
+        await invites.forget(invite.inviteId);
+        continue;
+      }
+      try {
+        const peer = await collectInvite(this.deps, {
+          inviteId: invite.inviteId,
+          relayUrl: invite.relayUrl
+        });
+        if (peer) {
+          await invites.forget(invite.inviteId);
+          pinned.push(peer.atlasId);
+        }
+      } catch {
+      }
+    }
+    return pinned;
+  }
+  /**
+   * Rotate once, at the first pairing.
+   *
+   * Version 0 seals the rotation notice and nothing else afterwards, which is
+   * the pattern the rotation design argues for and which nothing previously
+   * scheduled. Later rotations are a policy this does not yet have.
+   */
+  async rotateIfFirstPairing() {
+    if (!this.rotateAfterPairing) return null;
+    const version = await this.host.crypto.sealKeyVersion(this.deps.keyId);
+    if (version !== 0) return null;
+    const peers = await new Peers(this.deps.storage).list();
+    if (peers.length === 0) return null;
+    const rotation = await rotateSealingKey(this.deps);
+    return rotation.version;
+  }
+};
+
+// ../atlas-local/src/node/host.ts
+import { DatabaseSync } from "node:sqlite";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  lstatSync,
+  writeFileSync
+} from "node:fs";
+import {
+  dirname as dirnamePath,
+  join as joinPath,
+  relative as relativePath,
+  resolve as resolvePath,
+  sep as pathSep
+} from "node:path";
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  createPrivateKey,
+  createPublicKey,
+  diffieHellman,
+  generateKeyPairSync,
+  hkdfSync,
+  randomBytes,
+  sign,
+  verify
+} from "node:crypto";
+var TestClock = class {
+  constructor(current = 17e11) {
+    this.current = current;
+  }
+  now() {
+    return this.current;
+  }
+  advance(ms) {
+    this.current += ms;
+  }
+};
+var SEAL_VERSION = 1;
+var SEAL_KDF_DOMAIN = Buffer.from("xania/seal/v1");
+function rawPublicKey(key) {
+  const { x } = key.export({ format: "jwk" });
+  return Buffer.from(x, "base64url");
+}
+function importX25519Public(raw) {
+  return createPublicKey({
+    key: { kty: "OKP", crv: "X25519", x: Buffer.from(raw).toString("base64url") },
+    format: "jwk"
+  });
+}
+function rawPrivateKey(key) {
+  const { d } = key.export({ format: "jwk" });
+  return Buffer.from(d, "base64url");
+}
+var X25519_PKCS8 = "302e020100300506032b656e04220420";
+var ED25519_PKCS8 = "302e020100300506032b657004220420";
+function importPrivateFromRaw(raw, prefixHex) {
+  return createPrivateKey({
+    key: Buffer.concat([Buffer.from(prefixHex, "hex"), Buffer.from(raw)]),
+    format: "der",
+    type: "pkcs8"
+  });
+}
+function importX25519Private(raw) {
+  return importPrivateFromRaw(raw, X25519_PKCS8);
+}
+function importEd25519Private(seed) {
+  return importPrivateFromRaw(seed, ED25519_PKCS8);
+}
+function importEd25519Public(raw) {
+  return createPublicKey({
+    key: { kty: "OKP", crv: "Ed25519", x: Buffer.from(raw).toString("base64url") },
+    format: "jwk"
+  });
+}
+function openSealed(privateKey, envelope) {
+  if (envelope.length < 1 + 32 + 16) {
+    throw new Error(`envelope is ${envelope.length} bytes, too short to be one`);
+  }
+  if (envelope[0] !== SEAL_VERSION) {
+    throw new Error(`envelope version ${envelope[0]} is not ${SEAL_VERSION}`);
+  }
+  const bytes = Buffer.from(envelope);
+  const header = bytes.subarray(0, 1 + 32);
+  const ephemeralPublic = bytes.subarray(1, 1 + 32);
+  const body = bytes.subarray(1 + 32, bytes.length - 16);
+  const tag = bytes.subarray(bytes.length - 16);
+  const agreed = diffieHellman({
+    privateKey,
+    publicKey: importX25519Public(new Uint8Array(ephemeralPublic))
+  });
+  const { key, nonce } = sealDerive(
+    agreed,
+    new Uint8Array(ephemeralPublic),
+    rawPublicKey(createPublicKey(privateKey))
+  );
+  const decipher = createDecipheriv("chacha20-poly1305", key, nonce, { authTagLength: 16 });
+  decipher.setAAD(header, { plaintextLength: body.length });
+  decipher.setAuthTag(tag);
+  try {
+    return new Uint8Array(Buffer.concat([decipher.update(body), decipher.final()]));
+  } catch {
+    throw new Error("unseal failed: not sealed to this key, or altered in transit");
+  }
+}
+function sealDerive(shared, ephemeralPublic, recipientPublic) {
+  const info = Buffer.concat([
+    SEAL_KDF_DOMAIN,
+    Buffer.from(ephemeralPublic),
+    Buffer.from(recipientPublic)
+  ]);
+  const okm = Buffer.from(hkdfSync("sha256", shared, Buffer.alloc(0), info, 44));
+  return { key: okm.subarray(0, 32), nonce: okm.subarray(32, 44) };
+}
+async function sealTo(recipientPublicKey, plaintext) {
+  const ephemeral = generateKeyPairSync("x25519");
+  const ephemeralPublic = rawPublicKey(ephemeral.publicKey);
+  const shared = diffieHellman({
+    privateKey: ephemeral.privateKey,
+    publicKey: importX25519Public(recipientPublicKey)
+  });
+  const header = Buffer.concat([Buffer.from([SEAL_VERSION]), ephemeralPublic]);
+  const { key, nonce } = sealDerive(shared, ephemeralPublic, recipientPublicKey);
+  const cipher = createCipheriv("chacha20-poly1305", key, nonce, { authTagLength: 16 });
+  cipher.setAAD(header, { plaintextLength: plaintext.length });
+  const body = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  return new Uint8Array(Buffer.concat([header, body, cipher.getAuthTag()]));
+}
+function bind(value) {
+  if (typeof value === "boolean") return value ? 1 : 0;
+  return value;
+}
+function diskFiles(root, clock2, options = {}) {
+  const abs = (path) => {
+    const full = resolvePath(root, path);
+    if (full !== root && !full.startsWith(root + pathSep)) {
+      throw new Error(`path escapes the files root: ${path}`);
+    }
+    return full;
+  };
+  const toRel = (full) => relativePath(root, full).split(pathSep).join("/");
+  const statOf = (full) => {
+    const st = statSync(full, { bigint: true });
+    return {
+      path: toRel(full),
+      size: Number(st.size),
+      modifiedAt: Number(st.mtimeMs) || clock2.now(),
+      modifiedAtNs: st.mtimeNs.toString()
+    };
+  };
+  return {
+    read: async (path) => new Uint8Array(readFileSync(abs(path))),
+    write: async (path, bytes) => {
+      const full = abs(path);
+      mkdirSync(dirnamePath(full), { recursive: true });
+      writeFileSync(full, bytes);
+    },
+    remove: async (path) => {
+      rmSync(abs(path), { force: true });
+    },
+    list: async (prefix, opts) => {
+      const out = [];
+      const walk = (dir) => {
+        if (!existsSync(dir)) return;
+        for (const name of readdirSync(dir).sort()) {
+          const full = joinPath(dir, name);
+          const st = lstatSync(full);
+          if (st.isSymbolicLink()) continue;
+          const rel = toRel(full);
+          if (options.skip?.(rel, st)) continue;
+          if (st.isDirectory()) {
+            walk(full);
+            continue;
+          }
+          if (!rel.startsWith(prefix)) continue;
+          if (opts?.recursive !== true && rel.slice(prefix.length).includes("/")) continue;
+          out.push(statOf(full));
+        }
+      };
+      const slash = prefix.lastIndexOf("/");
+      walk(slash < 0 ? root : abs(prefix.slice(0, slash)));
+      return out;
+    },
+    stat: async (path) => {
+      const full = abs(path);
+      return existsSync(full) && statSync(full).isFile() ? statOf(full) : null;
+    }
+  };
+}
+function hkdfSha256(ikm, salt, info, length) {
+  return new Uint8Array(
+    hkdfSync("sha256", ikm, Buffer.from(salt), Buffer.from(info), length)
+  );
+}
+var EMPTY_SALT2 = new Uint8Array(0);
+function sqliteVault(db) {
+  db.exec(`CREATE TABLE IF NOT EXISTS host_key (
+    slot  TEXT PRIMARY KEY,   -- 'id:<keyId>' or 'seal:<keyId>#<version>'
+    pkcs8 BLOB NOT NULL       -- the private half; the public is derived
+  )`);
+  const qGet = db.prepare("SELECT pkcs8 FROM host_key WHERE slot = ?");
+  const qPut = db.prepare("INSERT OR REPLACE INTO host_key (slot, pkcs8) VALUES (?, ?)");
+  const qDel = db.prepare("DELETE FROM host_key WHERE slot = ?");
+  const qList = db.prepare("SELECT slot FROM host_key WHERE slot LIKE ?");
+  return {
+    kind: "sqlite",
+    get: (slot) => {
+      const row = qGet.get(slot);
+      return row?.pkcs8 ? new Uint8Array(row.pkcs8) : null;
+    },
+    put: (slot, pkcs8) => {
+      qPut.run(slot, pkcs8);
+    },
+    delete: (slot) => {
+      qDel.run(slot);
+    },
+    slots: (prefix) => qList.all(`${prefix}%`).map((r) => r.slot)
+  };
+}
+var deviceKeyFile = (stateDir) => joinPath(stateDir, "keys.json");
+var KEY_FILE_MODE = 384;
+function fileVault(db, options) {
+  const path = resolvePath(options.path);
+  const dir = dirnamePath(path);
+  mkdirSync(dir, { recursive: true });
+  const load = () => {
+    if (!existsSync(path)) return {};
+    const mode = statSync(path).mode & 511;
+    if (mode !== KEY_FILE_MODE) {
+      throw new Error(`key file ${path} is mode ${mode.toString(8)}; it must be ${KEY_FILE_MODE.toString(8)} and nothing else`);
+    }
+    const text = readFileSync(path, "utf8");
+    return text.trim() === "" ? {} : JSON.parse(text);
+  };
+  const save = (all) => {
+    const tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync(tmp, `${JSON.stringify(all, null, 2)}
+`, { mode: KEY_FILE_MODE });
+    chmodSync(tmp, KEY_FILE_MODE);
+    renameSync(tmp, path);
+    chmodSync(path, KEY_FILE_MODE);
+  };
+  db.exec("CREATE TABLE IF NOT EXISTS host_key_slot (slot TEXT PRIMARY KEY)");
+  const qAdd = db.prepare("INSERT OR IGNORE INTO host_key_slot (slot) VALUES (?)");
+  const qDel = db.prepare("DELETE FROM host_key_slot WHERE slot = ?");
+  const qList = db.prepare("SELECT slot FROM host_key_slot WHERE slot LIKE ?");
+  return {
+    kind: "file",
+    get: (slot) => {
+      const hex = load()[slot];
+      return hex ? new Uint8Array(Buffer.from(hex, "hex")) : null;
+    },
+    put: (slot, pkcs8) => {
+      const hex = Buffer.from(pkcs8).toString("hex");
+      const all = load();
+      all[slot] = hex;
+      save(all);
+      if (load()[slot] !== hex) throw new Error(`key file write of ${slot} did not read back`);
+      qAdd.run(slot);
+    },
+    delete: (slot) => {
+      const all = load();
+      if (slot in all) {
+        delete all[slot];
+        save(all);
+      }
+      qDel.run(slot);
+    },
+    slots: (prefix) => qList.all(`${prefix}%`).map((r) => r.slot)
+  };
+}
+function createNodeHost(options = {}) {
+  const dbPath = options.dbPath ?? ":memory:";
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA busy_timeout = 30000");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS host_seal_version (
+      key_id  TEXT PRIMARY KEY,
+      version INTEGER NOT NULL
+    );
+  `);
+  const vault = typeof options.keyVault === "function" ? options.keyVault(db) : options.keyVault ?? sqliteVault(db);
+  const qVerGet = db.prepare("SELECT version FROM host_seal_version WHERE key_id = ?");
+  const qVerPut = db.prepare(
+    "INSERT OR REPLACE INTO host_seal_version (key_id, version) VALUES (?, ?)"
+  );
+  class KeyStore {
+    constructor(prefix) {
+      this.prefix = prefix;
+    }
+    #cache = /* @__PURE__ */ new Map();
+    get(slot) {
+      const hit = this.#cache.get(slot);
+      if (hit) return hit;
+      const pkcs8 = vault.get(`${this.prefix}:${slot}`);
+      if (!pkcs8) return void 0;
+      const privateKey = createPrivateKey({
+        key: Buffer.from(pkcs8),
+        format: "der",
+        type: "pkcs8"
+      });
+      const pair = { privateKey, publicKey: createPublicKey(privateKey) };
+      this.#cache.set(slot, pair);
+      return pair;
+    }
+    set(slot, pair) {
+      this.#cache.set(slot, pair);
+      vault.put(
+        `${this.prefix}:${slot}`,
+        new Uint8Array(pair.privateKey.export({ format: "der", type: "pkcs8" }))
+      );
+    }
+    has(slot) {
+      return this.get(slot) !== void 0;
+    }
+    /** Returns whether anything was there — `dropRetiredSealKeys` counts on it.
+     *  Deletes from BOTH halves: a retired key that survives in the cache is a
+     *  key that is still readable, which is the whole thing rotation destroys. */
+    delete(slot) {
+      const existed = this.has(slot);
+      this.#cache.delete(slot);
+      vault.delete(`${this.prefix}:${slot}`);
+      return existed;
+    }
+    /** Every slot this store holds. Reads the table rather than the cache, so a
+     *  fresh process sees the keys it persisted last time. */
+    entries() {
+      const out = [];
+      for (const slot of vault.slots(`${this.prefix}:`)) {
+        const bare = slot.slice(this.prefix.length + 1);
+        const pair = this.get(bare);
+        if (pair) out.push([bare, pair]);
+      }
+      return out;
+    }
+  }
+  class VersionStore {
+    get(keyId) {
+      const row = qVerGet.get(keyId);
+      return row?.version;
+    }
+    set(keyId, version) {
+      qVerPut.run(keyId, version);
+    }
+  }
+  const clock2 = options.clock ?? new TestClock();
+  const files = /* @__PURE__ */ new Map();
+  const secrets = new Map(Object.entries(options.secrets ?? {}));
+  const keys = new KeyStore("id");
+  const sealKeys = new KeyStore("seal");
+  const sealVersions = new VersionStore();
+  const sealSlot = (keyId, version) => `${keyId}#${version}`;
+  const circleKeys = new KeyStore("circle");
+  const circleVersionKey = (circleId) => `circle:${circleId}`;
+  const heldEpochs = (circleId) => circleKeys.entries().map(([slot]) => slot.split("#")).filter(([id]) => id === circleId).map(([, epoch]) => Number(epoch)).sort((a, b) => b - a);
+  const unsealWithDevice = (keyId, envelope) => {
+    const current = sealVersions.get(keyId) ?? 0;
+    for (let version = current; version >= 0; version -= 1) {
+      const pair = sealKeys.get(sealSlot(keyId, version));
+      if (!pair) continue;
+      try {
+        return openSealed(pair.privateKey, envelope);
+      } catch {
+      }
+    }
+    throw new Error("unseal failed: not sealed to this key, or altered in transit");
+  };
+  let httpHandler = null;
+  const exec = (sql, params = []) => {
+    const result = db.prepare(sql).run(...params.map(bind));
+    return {
+      rowsAffected: Number(result.changes),
+      lastInsertId: result.lastInsertRowid === void 0 || Number(result.lastInsertRowid) === 0 ? null : Number(result.lastInsertRowid)
+    };
+  };
+  return {
+    info: { platform: "web", appVersion: "0.0.0-test", dataDir: "/tmp/atlas-local-test" },
+    sql: {
+      query: async (sql, params = []) => db.prepare(sql).all(...params.map(bind)),
+      execute: async (sql, params = []) => exec(sql, params),
+      batch: async (statements) => {
+        db.exec("BEGIN");
+        try {
+          const results = statements.map((s) => exec(s.sql, s.params ?? []));
+          db.exec("COMMIT");
+          return results;
+        } catch (error) {
+          db.exec("ROLLBACK");
+          throw error;
+        }
+      }
+    },
+    files: options.filesRoot ? diskFiles(resolvePath(options.filesRoot), clock2) : {
+      read: async (path) => {
+        const bytes = files.get(path);
+        if (!bytes) throw new Error(`no such file: ${path}`);
+        return bytes;
+      },
+      write: async (path, bytes) => {
+        files.set(path, bytes);
+      },
+      remove: async (path) => {
+        files.delete(path);
+      },
+      list: async (prefix, opts) => [...files.entries()].filter(([path]) => path.startsWith(prefix)).filter(([path]) => opts?.recursive === true || !path.slice(prefix.length).includes("/")).map(([path, bytes]) => ({ path, size: bytes.length, modifiedAt: clock2.now() })),
+      stat: async (path) => {
+        const bytes = files.get(path);
+        return bytes ? { path, size: bytes.length, modifiedAt: clock2.now() } : null;
+      }
+    },
+    http: {
+      request: async (req) => {
+        if (httpHandler) return httpHandler(req);
+        if (options.network) {
+          const res = await fetch(req.url, {
+            method: req.method,
+            ...req.headers ? { headers: { ...req.headers } } : {},
+            ...req.body ? { body: Buffer.from(req.body) } : {}
+          });
+          return {
+            status: res.status,
+            headers: Object.fromEntries(res.headers.entries()),
+            body: new Uint8Array(await res.arrayBuffer())
+          };
+        }
+        throw new Error(`node-host makes no network calls (attempted ${req.method} ${req.url})`);
+      }
+    },
+    crypto: {
+      // Ed25519 is REAL here, and was not always: it began as a stable hash
+      // per key id, on the reasoning that the genuine signing path lives in
+      // the Rust host. That reasoning held exactly until core code had to
+      // REJECT a signature. A stub whose `verify` answers "true for anything
+      // 64 bytes long" admits a forgery, and the test that should have caught
+      // it passes — the same shape of hole the relay design keeps naming.
+      // Core code that decides whether to trust a Change needs a host that
+      // genuinely refuses.
+      ensureKey: async (keyId) => {
+        let pair = keys.get(keyId);
+        if (!pair) {
+          pair = generateKeyPairSync("ed25519");
+          keys.set(keyId, pair);
+        }
+        return new Uint8Array(rawPublicKey(pair.publicKey));
+      },
+      publicKey: async (keyId) => {
+        const pair = keys.get(keyId);
+        return pair ? new Uint8Array(rawPublicKey(pair.publicKey)) : null;
+      },
+      sign: async (keyId, message2) => {
+        const pair = keys.get(keyId);
+        if (!pair) throw new Error(`no such key: ${keyId}`);
+        return new Uint8Array(sign(null, Buffer.from(message2), pair.privateKey));
+      },
+      verify: async (publicKey, message2, signature) => {
+        try {
+          return verify(
+            null,
+            Buffer.from(message2),
+            importEd25519Public(publicKey),
+            Buffer.from(signature)
+          );
+        } catch {
+          return false;
+        }
+      },
+      sha256: async (bytes) => new Uint8Array(createHash("sha256").update(Buffer.from(bytes)).digest()),
+      randomBytes: async (count) => new Uint8Array(randomBytes(count)),
+      // Sealing IS real here, unlike the signing above, and for a reason: core
+      // code that handles envelopes needs a host whose `unseal` genuinely
+      // FAILS for the wrong recipient and for altered bytes. A stub that
+      // round-trips would let a mailbox that mixes up recipients pass its own
+      // tests. Node has X25519 and ChaCha20-Poly1305, so honesty is ~15 lines.
+      //
+      // Interop with the Rust host is NOT claimed and is not needed — both
+      // ends of a real envelope are the same implementation. The layout is
+      // kept identical only so the two read the same way.
+      ensureSealKey: async (keyId) => {
+        const version = sealVersions.get(keyId) ?? 0;
+        let pair = sealKeys.get(sealSlot(keyId, version));
+        if (!pair) {
+          pair = generateKeyPairSync("x25519");
+          sealKeys.set(sealSlot(keyId, version), pair);
+        }
+        return rawPublicKey(pair.publicKey);
+      },
+      sealPublicKey: async (keyId) => {
+        const pair = sealKeys.get(sealSlot(keyId, sealVersions.get(keyId) ?? 0));
+        return pair ? rawPublicKey(pair.publicKey) : null;
+      },
+      sealKeyVersion: async (keyId) => sealVersions.get(keyId) ?? 0,
+      // Version 0 always — see the contract for why an invite must not carry
+      // the rotating key.
+      sealAddressingPublicKey: async (keyId) => {
+        const pair = sealKeys.get(sealSlot(keyId, 0));
+        return pair ? new Uint8Array(rawPublicKey(pair.publicKey)) : null;
+      },
+      // Retire, never replace: a peer who has been offline is still sealing to
+      // the version it last heard about. `dropRetiredSealKeys` is what actually
+      // makes an epoch unreadable.
+      rotateSealKey: async (keyId) => {
+        const current = sealVersions.get(keyId) ?? 0;
+        if (!sealKeys.has(sealSlot(keyId, current))) {
+          sealKeys.set(sealSlot(keyId, current), generateKeyPairSync("x25519"));
+        }
+        const next = current + 1;
+        const pair = generateKeyPairSync("x25519");
+        sealKeys.set(sealSlot(keyId, next), pair);
+        sealVersions.set(keyId, next);
+        return { publicKey: new Uint8Array(rawPublicKey(pair.publicKey)), version: next };
+      },
+      // The forward-secrecy step, and the only irreversible one here. Version 0
+      // survives regardless — addressing depends on it.
+      dropRetiredSealKeys: async (keyId, keep) => {
+        const current = sealVersions.get(keyId) ?? 0;
+        if (current === 0) return 0;
+        const floor = Math.max(0, current - keep);
+        let dropped = 0;
+        for (let version = 1; version < floor; version += 1) {
+          if (sealKeys.delete(sealSlot(keyId, version))) dropped += 1;
+        }
+        return dropped;
+      },
+      seal: async (recipientPublicKey, plaintext) => sealTo(recipientPublicKey, plaintext),
+      // Same envelope, a caller-supplied key. Shares `openSealed` with unseal so
+      // the two cannot drift into disagreeing about the layout.
+      newLinkKeypair: async () => {
+        const pair = generateKeyPairSync("x25519");
+        return {
+          publicKey: new Uint8Array(rawPublicKey(pair.publicKey)),
+          privateKey: new Uint8Array(rawPrivateKey(pair.privateKey))
+        };
+      },
+      openWith: async (privateKey, envelope) => {
+        if (privateKey.length !== 32) {
+          throw new Error("x25519 private key must be 32 bytes");
+        }
+        return openSealed(importX25519Private(privateKey), envelope);
+      },
+      // Walk backwards from the current version to the addressing key. Mail on
+      // a relay was sealed before this device rotated, and a peer that has been
+      // offline is still using an older version.
+      unseal: async (keyId, envelope) => {
+        const current = sealVersions.get(keyId) ?? 0;
+        let found = false;
+        for (let version = current; version >= 0; version -= 1) {
+          const pair = sealKeys.get(sealSlot(keyId, version));
+          if (!pair) continue;
+          found = true;
+          try {
+            return openSealed(pair.privateKey, envelope);
+          } catch {
+          }
+        }
+        if (!found) throw new Error(`no such seal key: ${keyId}`);
+        throw new Error("unseal failed: not sealed to this key, or altered in transit");
+      },
+      // The shared secret never leaves this function — only a key derived for
+      // the purpose `info` names. See the contract's doc comment for why that
+      // is not fussiness.
+      // Version 0 always. Deriving from the rotating key would move every
+      // mailbox address on every rotation — see the contract.
+      deriveShared: async (keyId, peerPublicKey, info) => {
+        const pair = sealKeys.get(sealSlot(keyId, 0));
+        if (!pair) throw new Error(`no such seal key: ${keyId}`);
+        const shared = diffieHellman({
+          privateKey: pair.privateKey,
+          publicKey: importX25519Public(peerPublicKey)
+        });
+        return hkdfSha256(shared, EMPTY_SALT2, info, 32);
+      },
+      // HKDF-SHA256 alone, for key material the caller already holds — the
+      // drop-lane address derives from a raw public key, so there is no ECDH to
+      // do. Fixed to SHA-256 with no algorithm parameter, on purpose: a member
+      // that took one would be a generic crypto escape hatch, and every future
+      // host would implement a switch instead of a call.
+      hkdf: async (ikm, salt, info, length) => {
+        if (!Number.isInteger(length) || length <= 0) {
+          throw new Error("hkdf: length must be a positive integer");
+        }
+        if (length > 255 * 32) throw new Error("hkdf: length exceeds 255 * 32 bytes");
+        if (ikm.length === 0) throw new Error("hkdf: refusing to derive from empty key material");
+        return hkdfSha256(ikm, salt, info, length);
+      },
+      // ── Circle keys ────────────────────────────────────────────────────
+      // Stored in the host's key vault beside the device keys: SQLite rows by
+      // default, which is the exposure Spec 08 §2 names, and the macOS Keychain
+      // under `createDeviceHost` (ruling 5, HQ-1219).
+      newCircleKey: async (circleId) => {
+        const epoch = (sealVersions.get(circleVersionKey(circleId)) ?? 0) + 1;
+        const pair = generateKeyPairSync("x25519");
+        circleKeys.set(sealSlot(circleId, epoch), pair);
+        sealVersions.set(circleVersionKey(circleId), epoch);
+        return { publicKey: new Uint8Array(rawPublicKey(pair.publicKey)), epoch };
+      },
+      circleKey: async (circleId) => {
+        const epoch = sealVersions.get(circleVersionKey(circleId));
+        if (epoch === void 0) return null;
+        const pair = circleKeys.get(sealSlot(circleId, epoch));
+        return pair ? { publicKey: new Uint8Array(rawPublicKey(pair.publicKey)), epoch } : null;
+      },
+      sealCircleKeyTo: async (circleId, epoch, devicePublicKey) => {
+        const pair = circleKeys.get(sealSlot(circleId, epoch));
+        if (!pair) throw new Error(`no key for circle ${circleId} at epoch ${epoch}`);
+        const sealed = await sealTo(devicePublicKey, rawPrivateKey(pair.privateKey));
+        return sealed;
+      },
+      importCircleKey: async (keyId, circleId, epoch, sealedKey) => {
+        if (!Number.isInteger(epoch) || epoch < 1) throw new Error(`circle epoch must be >= 1, got ${epoch}`);
+        const scalar = unsealWithDevice(keyId, sealedKey);
+        if (scalar.length !== 32) throw new Error("a circle key is 32 bytes");
+        const privateKey = importX25519Private(scalar);
+        const pair = { privateKey, publicKey: createPublicKey(privateKey) };
+        circleKeys.set(sealSlot(circleId, epoch), pair);
+        sealVersions.set(
+          circleVersionKey(circleId),
+          Math.max(sealVersions.get(circleVersionKey(circleId)) ?? 0, epoch)
+        );
+        return new Uint8Array(rawPublicKey(pair.publicKey));
+      },
+      openCircle: async (circleId, envelope) => {
+        const epochs = heldEpochs(circleId);
+        if (epochs.length === 0) throw new Error(`no key held for circle ${circleId}`);
+        for (const epoch of epochs) {
+          const pair = circleKeys.get(sealSlot(circleId, epoch));
+          if (!pair) continue;
+          try {
+            return openSealed(pair.privateKey, envelope);
+          } catch {
+          }
+        }
+        throw new Error(`no held epoch of circle ${circleId} opens this envelope`);
+      }
+    },
+    secrets: {
+      get: async (key) => secrets.get(key) ?? null,
+      set: async (key, value) => {
+        secrets.set(key, value);
+      },
+      delete: async (key) => {
+        secrets.delete(key);
+      }
+    },
+    clock: clock2,
+    installKey: (keyId, material) => {
+      if (material.identity) {
+        const privateKey = importEd25519Private(material.identity);
+        keys.set(keyId, { privateKey, publicKey: createPublicKey(privateKey) });
+      }
+      if (material.sealing) {
+        const privateKey = importX25519Private(material.sealing);
+        sealKeys.set(sealSlot(keyId, 0), { privateKey, publicKey: createPublicKey(privateKey) });
+      }
+      for (const [version, scalar] of Object.entries(material.content ?? {})) {
+        const privateKey = importX25519Private(scalar);
+        sealKeys.set(sealSlot(keyId, Number(version)), {
+          privateKey,
+          publicKey: createPublicKey(privateKey)
+        });
+        sealVersions.set(keyId, Math.max(sealVersions.get(keyId) ?? 0, Number(version)));
+      }
+    },
+    exportKey: (keyId) => {
+      const identityPair = keys.get(keyId);
+      const content = {};
+      for (const [slot, pair] of sealKeys.entries()) {
+        const [id, rawVersion] = slot.split("#");
+        if (id !== keyId) continue;
+        const version = Number(rawVersion);
+        if (version > 0) content[version] = new Uint8Array(rawPrivateKey(pair.privateKey));
+      }
+      return {
+        identity: identityPair ? new Uint8Array(rawPrivateKey(identityPair.privateKey)) : null,
+        content,
+        version: sealVersions.get(keyId) ?? 0
+      };
+    },
+    serveHttp: (handler) => {
+      httpHandler = handler;
+    },
+    keyVaultKind: vault.kind,
+    close: () => db.close()
+  };
+}
+
+// ../atlas-local/src/node/person-record-dir.ts
+import { resolve } from "node:path";
+var PERSON_RECORD = resolve(import.meta.dirname, "../../../person-record");
+
+// ../atlas-local/src/node/pairing.ts
+var PAIR_FALSIFY_MODES = ["no-expiry", "grant-all", "keep-grant", "no-rekey", "reuse-pairing"];
+var FALSIFY = process.env.EVDA_PAIR_FALSIFY ?? "";
+if (FALSIFY && !PAIR_FALSIFY_MODES.includes(FALSIFY)) throw new Error(`unknown EVDA_PAIR_FALSIFY=${FALSIFY}`);
+var layer = null;
+var personRecordRoot = PERSON_RECORD;
+function usePersonRecord(dir) {
+  personRecordRoot = resolve2(dir);
+  layer = null;
+}
+async function personLayer() {
+  if (layer) return layer;
+  const lib = (name) => import(pathToFileURL(join2(personRecordRoot, "lib", name)).href);
+  const [fc, mf, gr, ci] = await Promise.all([lib("filechanges.mjs"), lib("manifest.mjs"), lib("grants.mjs"), lib("circles.mjs")]);
+  layer = { ...fc, openEvda: mf.openEvda, grant: gr.grant, revoke: gr.revoke, readCircles: ci.readCircles };
+  return layer;
+}
+var DEFAULT_RELAY = "https://evda-relay.fly.dev";
+var PAIR_CODE_TTL_MS = 10 * 60 * 1e3;
+var DEFAULT_DAY_DIR = "record/daily";
+var NO_PRIVATE_PARTS = "Your EV\xD0A has no private parts yet, so there is nothing to give a device. Split it into parts first with `evda circles declare --plan <file>`, then pair again.";
+var b64url = (s) => base64(utf8Encode(s)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var unb64url = (s) => utf8Decode(fromBase64(s.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - s.length % 4) % 4)));
+function encodePairCode(c) {
+  const fields = [c.inviteId, c.secret];
+  if (c.relayUrl !== DEFAULT_RELAY || c.dayDir !== DEFAULT_DAY_DIR) fields.push(c.relayUrl);
+  if (c.dayDir !== DEFAULT_DAY_DIR) fields.push(c.dayDir);
+  return `evda1.${b64url(fields.join("\n"))}`;
+}
+function decodePairCode(code) {
+  const bad = new Error("That is not a pairing code. Copy it again from the computer your EV\xD0A is on.");
+  const trimmed = code.trim();
+  const link = /^evda:\/\/pair\?c=([^&]*)(&.*)?$/s.exec(trimmed);
+  const text = link ? link[1] : trimmed;
+  if (!text.startsWith("evda1.")) throw bad;
+  let fields;
+  try {
+    fields = unb64url(text.slice("evda1.".length)).split("\n");
+  } catch {
+    throw bad;
+  }
+  const [inviteId, secret, relayUrl, dayDir] = fields;
+  if (!inviteId || !secret || fields.length > 4) throw bad;
+  return { inviteId, secret, relayUrl: relayUrl || DEFAULT_RELAY, dayDir: dayDir || DEFAULT_DAY_DIR };
+}
+var pairQrPayload = (code) => `evda://pair?c=${code}`;
+async function openRecordDevice(o) {
+  const pr = await personLayer();
+  const recordDir = resolve2(o.recordDir);
+  const evda = pr.openEvda(recordDir);
+  const atlasId = evda.manifest.id;
+  if (typeof atlasId !== "string" || atlasId === "") throw new Error(NO_PRIVATE_PARTS);
+  const stateDir = indexLocation(resolve2(o.home), atlasId);
+  assertIndexOutsideRecord(stateDir, recordDir);
+  mkdirSync2(stateDir, { recursive: true });
+  const host = createNodeHost({
+    dbPath: join2(stateDir, "atlas.db"),
+    clock: { now: () => Date.now() },
+    network: true,
+    filesRoot: recordDir,
+    keyVault: (o.keys ?? "file") === "file" ? (db) => fileVault(db, { path: deviceKeyFile(stateDir) }) : sqliteVault
+  });
+  await migrate(host.sql, host.clock.now());
+  await host.crypto.ensureKey("identity");
+  const index = new FileIndex(host.sql);
+  const log = new ChangeLog(host, atlasId, "identity");
+  const sealer = pr.circleCrypto(host.crypto);
+  const blobs = new BlobStore(host);
+  const grants = pr.grantView(evda);
+  const deps = { host, storage: new SqlStorage(host), atlasId, keyId: "identity", grants };
+  const open = async (change, eco) => {
+    const circle = pr.circleById(grants.index, eco);
+    if (!circle) throw new Error(`no circle ${eco} in this record`);
+    return sealer.open(circle, change.payload);
+  };
+  const relayUrl = o.relayUrl ?? DEFAULT_RELAY;
+  deps.fold = new InboundFold({
+    host,
+    index,
+    log,
+    open,
+    unionPath: pr.unionPaths(evda),
+    merge: mergeMarkdown,
+    localPath: (eco, address) => pr.addressing(grants.index).local(eco, address),
+    homeOf: (rel) => pr.addressing(grants.index).homeOf(rel),
+    foreign: (origin) => grants.isForeign(origin),
+    fetchBlob: async (hash) => new RelayClient(host, relayUrl).findBlob(hash)
+  });
+  deps.catchUp = pr.catchUp({
+    evda,
+    view: () => grants,
+    log,
+    seal: (c, p) => sealer.seal(c, p),
+    open,
+    changesetId: async () => `cs_${toHex(await host.crypto.randomBytes(8))}`,
+    unionPath: pr.unionPaths(evda),
+    blobs: { seal: (b) => blobs.seal(b), link: (id, h) => blobs.link(id, h) }
+  });
+  return {
+    atlasId,
+    recordDir,
+    stateDir,
+    host,
+    evda,
+    deps,
+    engine: new SyncEngine(deps, { intervalMs: 1 }),
+    index,
+    log,
+    folds: [],
+    refusals: [],
+    close: () => host.close()
+  };
+}
+async function scanRecord(d) {
+  const pr = await personLayer();
+  const view = d.deps.grants;
+  const sealer = pr.circleCrypto(d.host.crypto);
+  const blobs = new BlobStore(d.host);
+  const minter = pr.fileMinter({
+    log: d.log,
+    index: view.index,
+    seal: (c, p) => sealer.seal(c, p),
+    notifyFor: (eco, id) => notifyFor(d.deps, eco, id),
+    previousSha: async (path) => (await d.index.get(path))?.sha256 ?? null,
+    changesetId: async () => `cs_${toHex(await d.host.crypto.randomBytes(8))}`,
+    unionPath: pr.unionPaths(d.evda),
+    readText: (rel) => existsSync2(join2(d.recordDir, rel)) ? readFileSync2(join2(d.recordDir, rel), "utf8") : null,
+    blobs: { seal: (b) => blobs.seal(b), link: (id, h) => blobs.link(id, h) }
+  });
+  const total = { scanned: 0, minted: 0, removed: 0, ignored: 0, read: 0, echoes: 0, failed: [] };
+  for (const { prefix, match } of pr.scanPrefixes(view.index, view.holds(d.atlasId))) {
+    const r = await scanAndApply({ host: d.host, index: d.index }, { prefix, match, mint: minter.mint, mintRemoval: minter.mintRemoval });
+    total.scanned += r.scanned;
+    total.minted += r.minted;
+    total.removed += r.removed;
+    total.ignored += r.ignored;
+    total.echoes += r.echoes;
+    total.read += r.read;
+    total.failed.push(...r.failed);
+  }
+  return total;
+}
+async function exchange(d) {
+  const report = await d.engine.syncNow();
+  d.deps.grants.reload();
+  d.folds.push(...report.received?.folds ?? []);
+  d.refusals.push(...report.received?.reasons ?? []);
+  if (report.error) throw new Error(`sync failed: ${report.error}`);
+  return report;
+}
+async function settle(d, rounds = 50) {
+  for (let i = 0, calm = 0; i < rounds && calm < 2; i += 1) {
+    const r = await exchange(d);
+    const moved = (r.sent?.relayed ?? 0) + (r.received?.applied ?? 0) + (r.keys?.delivered ?? 0) + (r.received?.circleKeys ?? 0) + (r.declarations?.delivered ?? 0) + (r.catchUp?.delivered ?? 0) + (r.received?.acknowledged ?? 0) + (r.pinned?.length ?? 0);
+    calm = moved === 0 ? calm + 1 : 0;
+  }
+}
+var pairedFile = (d) => join2(d.stateDir, "paired-devices.json");
+function readPaired(d) {
+  try {
+    return JSON.parse(readFileSync2(pairedFile(d), "utf8"));
+  } catch {
+    return [];
+  }
+}
+var writePaired = (d, list) => writeFileSync2(pairedFile(d), `${JSON.stringify(list, null, 2)}
+`, { mode: 384 });
+async function ownedCircles(d) {
+  const out = [];
+  for (const c of d.deps.grants.index) {
+    if (c.public || c.mount) continue;
+    if (await d.deps.grants.mayShareKey(d.atlasId, c.id)) out.push(c);
+  }
+  return out;
+}
+async function ensureCircleKeys(d) {
+  for (const c of await ownedCircles(d)) if (!await d.host.crypto.circleKey(c.id)) await d.host.crypto.newCircleKey(c.id);
+}
+async function startPairing(d, opts) {
+  const name = opts.name.trim();
+  if (!name) throw new Error("Give the device a name, such as phone.");
+  const list = readPaired(d);
+  if (list.some((p) => p.name === name && !p.removedAt)) throw new Error(`There is already a device called ${name}. Remove it first, or pick another name.`);
+  const owned = await ownedCircles(d);
+  if (owned.length === 0) throw new Error(NO_PRIVATE_PARTS);
+  const unknown = opts.circles.filter((c) => !owned.some((o) => o.name === c));
+  if (unknown.length) throw new Error(`This record has no private part called ${unknown.join(", ")}. It has: ${owned.map((o) => o.name).join(", ")}.`);
+  if (opts.circles.length === 0) throw new Error("Name at least one part of the record the device may read and add to.");
+  await ensureCircleKeys(d);
+  const ttlMs = opts.ttlMs ?? PAIR_CODE_TTL_MS;
+  const link = await mintInvite(d.deps, opts.relayUrl ?? DEFAULT_RELAY, FALSIFY === "no-expiry" ? { label: name } : { label: name, ttlMs });
+  await new PendingInvites(d.deps.storage).forget(link.inviteId);
+  list.push({
+    name,
+    atlasId: null,
+    circles: [...opts.circles],
+    inviteId: link.inviteId,
+    relayUrl: link.relayUrl,
+    expiresAt: link.expiresAt,
+    createdAt: new Date(d.host.clock.now()).toISOString()
+  });
+  writePaired(d, list);
+  const code = encodePairCode({ relayUrl: link.relayUrl, inviteId: link.inviteId, secret: link.secret, dayDir: opts.dayDir ?? DEFAULT_DAY_DIR });
+  return { name, code, qr: pairQrPayload(code), expiresAt: link.expiresAt, circles: [...opts.circles] };
+}
+async function collectPairings(d) {
+  const pr = await personLayer();
+  const list = readPaired(d);
+  const paired = [];
+  for (const p of list) {
+    if (p.removedAt || p.atlasId && FALSIFY !== "reuse-pairing") continue;
+    const peer = await collectInvite(d.deps, { inviteId: p.inviteId, relayUrl: p.relayUrl }).catch(() => null);
+    if (!peer) continue;
+    if (peer.atlasId === d.atlasId || d.deps.grants.index.some((c) => c.mount?.holder === peer.atlasId)) continue;
+    const circles = FALSIFY === "grant-all" ? (await ownedCircles(d)).map((c) => c.name) : p.circles;
+    const at = new Date(d.host.clock.now()).toISOString();
+    for (const circle of circles) {
+      pr.grant(d.evda, { circle, to: { id: peer.atlasId, kind: "person", name: p.name }, role: "editor", by: d.atlasId, at }, { overwrite: true });
+    }
+    p.atlasId = peer.atlasId;
+    p.pairedAt = at;
+    paired.push(p.name);
+  }
+  if (paired.length) {
+    writePaired(d, list);
+    d.deps.grants.reload();
+  }
+  return paired;
+}
+async function syncRecord(d) {
+  const folds = d.folds.length;
+  const refusals = d.refusals.length;
+  await settle(d);
+  const paired = await collectPairings(d);
+  if (paired.length || (await ownedCircles(d)).length) await ensureCircleKeys(d).catch(() => void 0);
+  const scan = await scanRecord(d);
+  if (scan.failed.length) throw new Error(`could not read ${scan.failed.length} file(s): ${JSON.stringify(scan.failed[0])}`);
+  await settle(d);
+  return {
+    paired,
+    // What changed a file here. A Change for bytes already present ("already there", "logged") is
+    // the other side's echo of what this device sent, and is not news to the person.
+    received: d.folds.slice(folds).filter((f) => f.status === "applied" && !["already there", "logged", "kept", "absent"].includes(f.action)).length,
+    sent: scan.minted + scan.removed,
+    refused: d.refusals.slice(refusals)
+  };
+}
+function listDevices(d, now = Date.now()) {
+  return readPaired(d).map((p) => ({
+    name: p.name,
+    state: p.removedAt ? "removed" : p.atlasId ? "paired" : p.expiresAt <= now ? "code expired" : "waiting for the device to use its code",
+    circles: p.circles,
+    since: p.removedAt ?? p.pairedAt ?? p.createdAt
+  }));
+}
+async function removeDevice(d, name) {
+  const pr = await personLayer();
+  const list = readPaired(d);
+  const p = list.find((x) => x.name === name && !x.removedAt);
+  if (!p) throw new Error(`There is no paired device called ${name}.`);
+  const rekeyed = [];
+  if (p.atlasId) {
+    const granted = d.deps.grants.index.filter((c) => !c.public && !c.mount);
+    for (const c of granted) {
+      if (FALSIFY === "keep-grant") break;
+      if (pr.revoke(d.evda, { circle: c.name, id: p.atlasId })) rekeyed.push(c.name);
+    }
+    d.deps.grants.reload();
+    if (FALSIFY !== "no-rekey") for (const c of granted.filter((x) => rekeyed.includes(x.name))) await d.host.crypto.newCircleKey(c.id);
+  }
+  p.removedAt = new Date(d.host.clock.now()).toISOString();
+  writePaired(d, list);
+  return { name, rekeyed };
+}
+var JOINED_FILE = "joined.json";
+async function joinWithCode(code, o) {
+  const c = decodePairCode(code);
+  const dir = resolve2(o.dir);
+  if (existsSync2(join2(dir, "evda.json"))) throw new Error(`${dir} already holds a record. Join into an empty folder.`);
+  const atlasId = `device-${toHex(crypto.getRandomValues(new Uint8Array(8)))}.atlas`;
+  mkdirSync2(join2(dir, "Mounts"), { recursive: true });
+  mkdirSync2(join2(dir, "Circles"), { recursive: true });
+  mkdirSync2(join2(dir, "Grants"), { recursive: true });
+  mkdirSync2(join2(dir, ".evda"), { recursive: true });
+  writeFileSync2(join2(dir, ".evda/version"), "1\n");
+  writeFileSync2(join2(dir, "evda.json"), `${JSON.stringify({
+    evda: 1,
+    id: atlasId,
+    name: "A paired device",
+    owner: { name: "this device", kind: "person" },
+    created: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    layers: ["record", "circles"],
+    mapping: { circles: "Circles", grants: "Grants", mounts: "Mounts" }
+  }, null, 2)}
+`);
+  const d = await openRecordDevice({ recordDir: dir, home: o.home, relayUrl: c.relayUrl, ...o.keys ? { keys: o.keys } : {} });
+  try {
+    await redeemInvite(d.deps, { inviteId: c.inviteId, secret: c.secret, relayUrl: c.relayUrl });
+  } catch (error) {
+    d.close();
+    const status = error.status;
+    if (status === 403 || status === 409 || /40[39]/.test(String(error))) {
+      throw new Error("That code has expired or was already used. Make a new one on the computer your EV\xD0A is on.");
+    }
+    throw new Error(`Could not reach your EV\xD0A through the relay: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  writeFileSync2(join2(d.stateDir, JOINED_FILE), `${JSON.stringify({ relayUrl: c.relayUrl, dayDir: c.dayDir }, null, 2)}
+`);
+  return d;
+}
+async function openJoinedDevice(o) {
+  const pr = await personLayer();
+  const id = pr.openEvda(resolve2(o.dir)).manifest.id;
+  const joined = JSON.parse(readFileSync2(join2(indexLocation(resolve2(o.home), id), JOINED_FILE), "utf8"));
+  const d = await openRecordDevice({ recordDir: o.dir, home: o.home, relayUrl: joined.relayUrl, ...o.keys ? { keys: o.keys } : {} });
+  return Object.assign(d, { dayDir: joined.dayDir });
+}
+var two = (n) => String(n).padStart(2, "0");
+var dayOf = (t) => `${t.getFullYear()}-${two(t.getMonth() + 1)}-${two(t.getDate())}`;
+function writeNote(d, text, o) {
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  const held = d.deps.grants.index.filter((c) => c.mount && !c.frozen);
+  if (held.length === 0) {
+    throw new Error(d.deps.grants.index.some((c) => c.mount) ? "This device was removed from your EV\xD0A, so it cannot add to it anymore." : "This device has not received anything from your EV\xD0A yet. Sync once your computer has.");
+  }
+  const withDays = held.filter((c) => existsSync2(join2(d.recordDir, c.mount.rel, o.dayDir)));
+  const target = withDays[0] ?? (held.length === 1 ? held[0] : void 0);
+  if (!target) throw new Error("This device cannot tell which part of your EV\xD0A holds the journal. Pair it again with the journal included.");
+  const rel = `${target.mount.rel}/${o.dayDir}/${dayOf(now)}.md`;
+  const abs = join2(d.recordDir, rel);
+  mkdirSync2(join2(abs, ".."), { recursive: true });
+  const before2 = existsSync2(abs) ? readFileSync2(abs, "utf8") : `# ${dayOf(now)}
+`;
+  writeFileSync2(abs, `${before2.replace(/\n*$/, "\n")}
+## ${two(now.getHours())}:${two(now.getMinutes())}
+
+${text.replace(/\n*$/, "")}
+`);
+  return rel;
+}
+async function heldParts(d) {
+  const pr = await personLayer();
+  const titles = new Map((pr.readCircles(d.evda) ?? []).map((c) => [c.name, c.manifest?.title ?? c.name]));
+  const count = (abs) => {
+    if (!existsSync2(abs)) return 0;
+    let n = 0;
+    for (const name of readdirSync2(abs)) {
+      const p = join2(abs, name);
+      n += statSync2(p).isDirectory() ? count(p) : 1;
+    }
+    return n;
+  };
+  return d.deps.grants.index.filter((c) => c.mount).map((c) => ({ name: titles.get(c.name) ?? c.name, files: count(join2(d.recordDir, c.mount.rel)), removed: c.frozen !== null }));
+}
+
+// ../atlas-local/src/node/pair-owner.ts
+function computerName(env = process.env) {
+  const pick = (s) => (s ?? "").replace(/\s+/g, " ").trim().slice(0, 64);
+  if (pick(env.EVDA_COMPUTER_NAME)) return pick(env.EVDA_COMPUTER_NAME);
+  if (process.platform === "darwin") {
+    try {
+      const n = pick(execFileSync("/usr/sbin/scutil", ["--get", "ComputerName"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2e3 }));
+      if (n) return n;
+    } catch {
+    }
+  }
+  return pick(hostname().replace(/\.local$/, "")) || "your computer";
+}
+var namedQr = (qr, computer) => `${qr}&n=${encodeURIComponent(computer)}`;
+var clock = (ms) => new Date(ms).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+var when = (iso) => new Date(iso).toLocaleString([], { dateStyle: "medium", timeStyle: "short" });
+var PLAIN = /^(Your EVÐA|This record|There is|Give the device|Name at least|That code|This device|Could not reach)/;
+function plain(error) {
+  const message2 = error instanceof Error ? error.message : String(error);
+  if (PLAIN.test(message2)) return new Error(message2);
+  if (/^sync failed|fetch failed|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|network|relay/i.test(message2)) {
+    return new Error("Could not reach the relay that carries your EV\xD0A between devices. Check the connection and try again.");
+  }
+  return new Error(`Pairing stopped: ${message2.replace(/[0-9a-f]{16,}|[A-Za-z0-9_-]{32,}|\S+\.atlas\b|inv_\S+/g, "(hidden)")}`);
+}
+async function withOwner(o, fn) {
+  let d = null;
+  try {
+    d = await openRecordDevice({ recordDir: o.record, home: o.home, relayUrl: o.relayUrl ?? DEFAULT_RELAY });
+    return await fn(d);
+  } catch (error) {
+    throw plain(error);
+  } finally {
+    d?.close();
+  }
+}
+function pairDevice(o, opts = {}) {
+  return withOwner(o, async (d) => {
+    const name = (opts.name ?? "phone").trim();
+    const parts = opts.parts?.length ? opts.parts : ["journal"];
+    const p = await startPairing(d, { name, circles: parts, relayUrl: o.relayUrl ?? DEFAULT_RELAY, ...opts.ttlMs ? { ttlMs: opts.ttlMs } : {} });
+    const computer = computerName();
+    return {
+      name: p.name,
+      code: p.code,
+      qr: namedQr(p.qr, computer),
+      computer,
+      expiresAt: p.expiresAt,
+      parts: p.circles,
+      lines: [
+        `Code for ${p.name}: ${p.code}`,
+        `It works once, until ${clock(p.expiresAt)}. Type it on the device, or scan: ${p.qr}`,
+        `${p.name} will be able to read and add to: ${p.circles.join(", ")}. Nothing else in your EV\xD0A reaches it.`,
+        "It is added the next time this computer syncs after the device uses the code (evda sync)."
+      ],
+      phoneSteps: [
+        "Open the EV\xD0A app on the phone and choose to join an EV\xD0A.",
+        `Scan the QR link or paste the code. It works once, until ${clock(p.expiresAt)}.`,
+        "Once the phone says it joined, sync on this computer (evda sync, or ask me to), then sync on the phone.",
+        `The phone then holds ${p.circles.join(", ")}, and what you write there lands in today's page here on the next sync.`
+      ]
+    };
+  });
+}
+function deviceList(o) {
+  return withOwner(o, async (d) => listDevices(d).map((l) => ({ name: l.name, state: l.state, parts: [...l.circles], since: l.since })));
+}
+async function deviceLines(o) {
+  const list = await deviceList(o);
+  if (list.length === 0) return ["No devices are paired with this EV\xD0A."];
+  return list.map((l) => `${l.name}: ${l.state}, reads and adds to ${l.parts.join(", ")} (since ${when(l.since)})`);
+}
+function removeDeviceWords(o, name) {
+  return withOwner(o, async (d) => {
+    await removeDevice(d, name);
+    const s = await syncRecord(d);
+    return [
+      `Removed ${name}. It can no longer add to your EV\xD0A, and nothing new reaches it. What it already had stays on it.`,
+      ...s.refused.length ? [`Turned away ${s.refused.length} change(s) from a device that is no longer allowed.`] : []
+    ];
+  });
+}
+function syncOnce(o) {
+  return withOwner(o, async (d) => {
+    const s = await syncRecord(d);
+    return { paired: [...s.paired], received: s.received, sent: s.sent, refused: s.refused.length };
+  });
+}
+async function syncWords(o) {
+  const s = await syncOnce(o);
+  return [
+    ...s.paired.map((n) => `${n} is now paired.`),
+    `Synced: ${s.received} change(s) in, ${s.sent} out.${s.refused ? ` Turned away ${s.refused} from a device that is no longer allowed.` : ""}`
+  ];
+}
+export {
+  DEFAULT_RELAY,
+  decodePairCode,
+  deviceLines,
+  deviceList,
+  heldParts,
+  joinWithCode,
+  openJoinedDevice,
+  pairDevice,
+  removeDeviceWords,
+  syncOnce,
+  syncRecord,
+  syncWords,
+  usePersonRecord,
+  writeNote
+};