@web_of_trust/adapter-automerge 0.1.2

package/dist/index.js

@@ -0,0 +1,1621 @@
+var re = Object.defineProperty;
+var ae = (c, e, t) => e in c ? re(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var d = (c, e, t) => ae(c, typeof e != "symbol" ? e + "" : e, t);
+import { NetworkAdapter as W, Repo as L, parseAutomergeUrl as Y, stringifyAutomergeUrl as ie } from "@automerge/automerge-repo";
+import * as D from "@automerge/automerge";
+import { verifyEnvelope as X, EncryptedSyncService as P, signEnvelope as Q, VaultClient as Z, base64ToUint8 as E, VaultPushScheduler as N, CompactStorageManager as ce, getMetrics as x, registerDebugApi as de } from "@web_of_trust/core";
+class le extends W {
+  // spaceId -> Set<DID>
+  constructor(t, n, s) {
+    super();
+    d(this, "messaging");
+    d(this, "identity");
+    d(this, "groupKeyService");
+    d(this, "ready", !1);
+    d(this, "readyResolve");
+    d(this, "readyPromise");
+    d(this, "unsubMessage");
+    /** Track message IDs we sent, so we can ignore our own echoes from the relay */
+    d(this, "sentMessageIds", /* @__PURE__ */ new Set());
+    /** Phantom peerId used for multi-device self-sync */
+    d(this, "selfPeerId", null);
+    // Document -> Space mapping (needed to find the right group key)
+    d(this, "docToSpace", /* @__PURE__ */ new Map());
+    // Known peers per space
+    d(this, "spacePeers", /* @__PURE__ */ new Map());
+    this.messaging = t, this.identity = n, this.groupKeyService = s, this.readyPromise = new Promise((o) => {
+      this.readyResolve = o;
+    });
+  }
+  // --- NetworkAdapter interface ---
+  isReady() {
+    return this.ready;
+  }
+  whenReady() {
+    return this.readyPromise;
+  }
+  connect(t, n) {
+    var s;
+    this.peerId = t, this.peerMetadata = n, this.unsubMessage = this.messaging.onMessage(async (o) => {
+      if (o.type === "content") {
+        if (this.sentMessageIds.has(o.id)) {
+          this.sentMessageIds.delete(o.id);
+          return;
+        }
+        if (o.signature && !await X(o)) {
+          console.warn("[EncryptedSync] Rejected message with invalid signature from", o.fromDid);
+          return;
+        }
+        try {
+          const i = JSON.parse(o.payload);
+          if (!i.syncData) return;
+          const r = i.spaceId, a = i.generation, l = this.groupKeyService.getKeyByGeneration(r, a);
+          if (!l) {
+            console.debug(`[EncryptedSync] No group key yet for space ${r} gen ${a} — will sync after metadata arrives`);
+            return;
+          }
+          const h = {
+            ciphertext: new Uint8Array(i.ciphertext),
+            nonce: new Uint8Array(i.nonce),
+            spaceId: r,
+            generation: a,
+            fromDid: o.fromDid
+          }, p = await P.decryptChange(h, l), m = i.documentId;
+          if (!m) return;
+          const y = o.fromDid === this.identity.getDid() && this.selfPeerId ? this.selfPeerId : o.fromDid, u = {
+            type: i.messageType || "sync",
+            senderId: y,
+            targetId: this.peerId,
+            documentId: m,
+            data: p
+          };
+          this.emit("message", u);
+        } catch (i) {
+          console.debug("EncryptedMessagingNetworkAdapter: failed to process message", i);
+        }
+      }
+    }), this.ready = !0, (s = this.readyResolve) == null || s.call(this), this.emit("ready", void 0);
+  }
+  send(t) {
+    if (!this.ready || !t.data || !t.documentId) return;
+    const n = this.docToSpace.get(t.documentId);
+    if (!n) return;
+    const s = this.groupKeyService.getCurrentKey(n);
+    if (!s) return;
+    const o = this.groupKeyService.getCurrentGeneration(n), i = t.targetId, r = i === this.selfPeerId ? this.identity.getDid() : i;
+    (async () => {
+      try {
+        const a = await P.encryptChange(
+          t.data,
+          s,
+          n,
+          o,
+          this.identity.getDid()
+        ), l = {
+          syncData: !0,
+          spaceId: n,
+          documentId: t.documentId,
+          messageType: t.type,
+          generation: o,
+          ciphertext: Array.from(a.ciphertext),
+          nonce: Array.from(a.nonce)
+        }, h = crypto.randomUUID();
+        this.sentMessageIds.add(h), setTimeout(() => this.sentMessageIds.delete(h), 3e4);
+        const p = {
+          v: 1,
+          id: h,
+          type: "content",
+          fromDid: this.identity.getDid(),
+          toDid: r,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          encoding: "json",
+          payload: JSON.stringify(l),
+          signature: ""
+        };
+        await Q(p, (m) => this.identity.sign(m)), await this.messaging.send(p);
+      } catch (a) {
+        console.debug("[EncryptedSync] Failed to send sync message:", a);
+      }
+    })();
+  }
+  disconnect() {
+    var t;
+    (t = this.unsubMessage) == null || t.call(this), this.unsubMessage = void 0, this.sentMessageIds.clear(), this.ready = !1;
+  }
+  // --- Space/Document registration ---
+  /**
+   * Register a document -> space mapping.
+   * Needed so we can look up the right group key when sending/receiving.
+   */
+  registerDocument(t, n) {
+    this.docToSpace.set(t, n);
+  }
+  /**
+   * Unregister a document mapping.
+   */
+  unregisterDocument(t) {
+    this.docToSpace.delete(t);
+  }
+  /**
+   * Register a peer (DID) as a member of a space.
+   * Emits peer-candidate so automerge-repo starts syncing with this peer.
+   */
+  registerSpacePeer(t, n) {
+    let s = this.spacePeers.get(t);
+    s || (s = /* @__PURE__ */ new Set(), this.spacePeers.set(t, s)), !s.has(n) && (s.add(n), this.emit("peer-candidate", {
+      peerId: n,
+      peerMetadata: { isEphemeral: !0 }
+    }));
+  }
+  /**
+   * Register a phantom peer representing "self on another device".
+   * Uses a different peerId so automerge-repo doesn't skip it as self,
+   * but send() routes messages to our own DID (relay delivers to other devices).
+   */
+  registerSelfPeer(t) {
+    this.selfPeerId || (this.selfPeerId = `${this.identity.getDid()}#other-device`), this.registerSpacePeer(t, this.selfPeerId);
+  }
+  /**
+   * Unregister a peer from a space.
+   */
+  unregisterSpacePeer(t, n) {
+    const s = this.spacePeers.get(t);
+    if (s) {
+      s.delete(n);
+      for (const [, o] of this.spacePeers)
+        if (o.has(n)) return;
+      this.emit("peer-disconnected", { peerId: n });
+    }
+  }
+}
+const M = class M {
+  constructor() {
+  }
+  static getInstance() {
+    return M.instance || (M.instance = new M()), M.instance;
+  }
+  /**
+   * Compact an Automerge document binary (strip change history).
+   * Yields to the browser between steps to keep the UI responsive.
+   *
+   * @param binary - Automerge.save() output (includes history)
+   * @returns Compacted binary (history-free)
+   */
+  async compact(e) {
+    const t = D.load(e);
+    await J();
+    const n = JSON.parse(JSON.stringify(t));
+    return await J(), D.save(D.from(n));
+  }
+  /**
+   * Whether the service is using a Web Worker (true) or main-thread with yielding (false).
+   */
+  get isUsingWorker() {
+    return !1;
+  }
+  destroy() {
+    M.instance = null;
+  }
+};
+d(M, "instance", null);
+let T = M;
+function J() {
+  var c;
+  return typeof globalThis < "u" && "scheduler" in globalThis && typeof ((c = globalThis.scheduler) == null ? void 0 : c.yield) == "function" ? globalThis.scheduler.yield() : new Promise((e) => setTimeout(e, 0));
+}
+class he {
+  constructor(e, t, n, s) {
+    d(this, "id");
+    d(this, "spaceState");
+    d(this, "docHandle");
+    d(this, "vaultScheduler");
+    d(this, "compactScheduler");
+    d(this, "remoteUpdateCallbacks", /* @__PURE__ */ new Set());
+    d(this, "closed", !1);
+    d(this, "localChanging", !1);
+    d(this, "unsubChange");
+    this.id = e.info.id, this.spaceState = e, this.docHandle = t, this.vaultScheduler = n, this.compactScheduler = s;
+    const o = () => {
+      this.localChanging || this._notifyRemoteUpdate();
+    };
+    this.docHandle.on("change", o), this.unsubChange = () => this.docHandle.off("change", o);
+  }
+  info() {
+    return { ...this.spaceState.info };
+  }
+  getDoc() {
+    return this.docHandle.doc();
+  }
+  getMeta() {
+    return {};
+  }
+  transact(e, t) {
+    if (this.closed) throw new Error("Handle is closed");
+    this.localChanging = !0;
+    try {
+      this.docHandle.change(e);
+    } finally {
+      this.localChanging = !1;
+    }
+    this.vaultScheduler && (t != null && t.stream ? this.vaultScheduler.pushDebounced() : this.vaultScheduler.pushImmediate()), this.compactScheduler && (t != null && t.stream ? this.compactScheduler.pushDebounced() : this.compactScheduler.pushImmediate());
+  }
+  onRemoteUpdate(e) {
+    return this.remoteUpdateCallbacks.add(e), () => {
+      this.remoteUpdateCallbacks.delete(e);
+    };
+  }
+  _notifyRemoteUpdate() {
+    this.compactScheduler && this.compactScheduler.pushDebounced();
+    for (const e of this.remoteUpdateCallbacks)
+      e();
+  }
+  close() {
+    var e;
+    this.closed = !0, (e = this.unsubChange) == null || e.call(this), this.remoteUpdateCallbacks.clear(), this.spaceState.handles.delete(this);
+  }
+}
+class xe {
+  constructor(e) {
+    d(this, "identity");
+    d(this, "messaging");
+    d(this, "groupKeyService");
+    d(this, "metadataStorage");
+    d(this, "repoStorage");
+    d(this, "compactStore", null);
+    d(this, "vault", null);
+    d(this, "spaces", /* @__PURE__ */ new Map());
+    d(this, "state", "idle");
+    d(this, "memberChangeCallbacks", /* @__PURE__ */ new Set());
+    d(this, "spacesSubscribers", /* @__PURE__ */ new Set());
+    d(this, "unsubscribeMessaging", null);
+    /** Local seq counter per doc — avoids a getDocInfo HTTP call (and its 404) on first push */
+    d(this, "vaultSeqs", /* @__PURE__ */ new Map());
+    /** VaultPushScheduler per space — handles immediate/debounced vault pushes */
+    d(this, "vaultSchedulers", /* @__PURE__ */ new Map());
+    /** VaultPushScheduler per space for CompactStore (2s debounce) */
+    d(this, "compactSchedulers", /* @__PURE__ */ new Map());
+    /** Optional filter to restrict which spaces are restored (e.g. by appTag) */
+    d(this, "spaceFilter");
+    d(this, "repo");
+    d(this, "networkAdapter");
+    this.identity = e.identity, this.messaging = e.messaging, this.groupKeyService = e.groupKeyService, this.metadataStorage = e.metadataStorage ?? null, this.repoStorage = e.repoStorage, this.compactStore = e.compactStore ?? null, this.spaceFilter = e.spaceFilter ?? null, e.vaultUrl && (this.vault = new Z(e.vaultUrl, e.identity));
+  }
+  /** Sign an envelope with our identity and send it */
+  async _signAndSend(e) {
+    await Q(e, (t) => this.identity.sign(t)), await this.messaging.send(e);
+  }
+  async start() {
+    this.networkAdapter = new le(
+      this.messaging,
+      this.identity,
+      this.groupKeyService
+    ), this.repo = new L({
+      peerId: this.identity.getDid(),
+      network: [this.networkAdapter],
+      storage: this.repoStorage,
+      // Share all documents with all peers (our NetworkAdapter handles routing)
+      sharePolicy: async () => !0
+    }), await this.restoreSpacesFromMetadata(), this.state = "idle", this._notifySpacesSubscribers(), this.unsubscribeMessaging = this.messaging.onMessage(
+      (e) => this.handleMessage(e)
+    );
+  }
+  /**
+   * Restore spaces from metadata storage.
+   * Called on start() and can be called again after remote sync
+   * delivers new space metadata (e.g. multi-device sync).
+   * Only loads spaces that aren't already known.
+   */
+  async restoreSpacesFromMetadata() {
+    if (!this.metadataStorage || !this.repo) return;
+    const e = await this.metadataStorage.loadAllSpaceMetadata();
+    let t = !1;
+    for (const n of e) {
+      if (this.spaces.has(n.info.id) || this.spaceFilter && !this.spaceFilter(n.info)) continue;
+      const s = /* @__PURE__ */ new Map();
+      for (const [a, l] of Object.entries(n.memberEncryptionKeys))
+        s.set(a, l);
+      const o = {
+        info: n.info,
+        documentId: n.documentId,
+        documentUrl: n.documentUrl,
+        handles: /* @__PURE__ */ new Set(),
+        memberEncryptionKeys: s
+      };
+      this.spaces.set(n.info.id, o), this.networkAdapter.registerDocument(o.documentId, n.info.id);
+      for (const a of n.info.members)
+        a !== this.identity.getDid() && this.networkAdapter.registerSpacePeer(n.info.id, a);
+      this.networkAdapter.registerSelfPeer(n.info.id);
+      const i = await this.metadataStorage.loadGroupKeys(n.info.id);
+      for (const a of i)
+        this.groupKeyService.importKey(a.spaceId, a.key, a.generation);
+      if (this.compactStore && await this._restoreFromCompactStore(o)) {
+        t = !0, console.log("[ReplicationAdapter] Restored space from CompactStore:", n.info.name || n.info.id);
+        continue;
+      }
+      if (this.vault && await this._restoreFromVault(o)) {
+        t = !0, console.log("[ReplicationAdapter] Restored space from vault:", n.info.name || n.info.id);
+        continue;
+      }
+      let r = !1;
+      try {
+        r = (await this.repo.find(o.documentUrl, {
+          allowableStates: ["ready", "unavailable"],
+          signal: AbortSignal.timeout(2e3)
+        })).isReady();
+      } catch {
+      }
+      r ? (t = !0, console.log("[ReplicationAdapter] Restored space from metadata:", n.info.name || n.info.id)) : (console.log("[ReplicationAdapter] Space registered, waiting for doc sync:", n.info.name || n.info.id), t = !0, this._waitForDoc(o));
+    }
+    t && this._notifySpacesSubscribers();
+  }
+  /**
+   * Try to restore a space doc from the vault.
+   * Returns true if doc was successfully imported from vault.
+   */
+  async _restoreFromVault(e) {
+    var n, s;
+    if (!this.vault) return !1;
+    const t = this.groupKeyService.getCurrentKey(e.info.id);
+    if (!t)
+      return console.warn("[ReplicationAdapter] No group key for vault restore:", e.info.name || e.info.id), !1;
+    try {
+      const o = await this.vault.getChanges(e.info.id);
+      if ((n = o.snapshot) != null && n.data) {
+        const i = E(o.snapshot.data), r = i[0], a = i.slice(1, 1 + r), l = i.slice(1 + r), h = this.groupKeyService.getCurrentGeneration(e.info.id), p = await P.decryptChange(
+          { ciphertext: l, nonce: a, spaceId: e.info.id, generation: h, fromDid: "" },
+          t
+        ), m = this.repo.import(p, {
+          docId: e.documentId
+        });
+        m.isReady() || m.doneLoading();
+        for (const u of o.changes) {
+          const g = E(u.data), w = g[0], f = g.slice(1, 1 + w), R = g.slice(1 + w), _ = await P.decryptChange(
+            { ciphertext: R, nonce: f, spaceId: e.info.id, generation: h, fromDid: u.authorDid },
+            t
+          );
+          m.merge(this.repo.import(_, void 0));
+        }
+        await this.repo.flush([e.documentId]);
+        const y = Math.max(
+          ((s = o.snapshot) == null ? void 0 : s.upToSeq) ?? 0,
+          ...o.changes.map((u) => u.seq ?? 0)
+        );
+        return y > 0 && this.vaultSeqs.set(e.info.id, y), !0;
+      }
+      if (o.changes.length > 0) {
+        const i = this.groupKeyService.getCurrentGeneration(e.info.id), r = E(o.changes[0].data), a = r[0], l = r.slice(1, 1 + a), h = r.slice(1 + a), p = await P.decryptChange(
+          { ciphertext: h, nonce: l, spaceId: e.info.id, generation: i, fromDid: o.changes[0].authorDid },
+          t
+        ), m = this.repo.import(p, {
+          docId: e.documentId
+        });
+        m.isReady() || m.doneLoading();
+        for (let u = 1; u < o.changes.length; u++) {
+          const g = E(o.changes[u].data), w = g[0], f = g.slice(1, 1 + w), R = g.slice(1 + w), _ = await P.decryptChange(
+            { ciphertext: R, nonce: f, spaceId: e.info.id, generation: i, fromDid: o.changes[u].authorDid },
+            t
+          );
+          m.merge(this.repo.import(_, void 0));
+        }
+        await this.repo.flush([e.documentId]);
+        const y = Math.max(...o.changes.map((u) => u.seq ?? 0));
+        return y > 0 && this.vaultSeqs.set(e.info.id, y), !0;
+      }
+    } catch (o) {
+      const i = e.info.name || e.info.id;
+      o instanceof DOMException && o.name === "OperationError" ? console.warn(`[ReplicationAdapter] Vault decryption failed for "${i}" — likely removed from space or key rotated`) : console.warn("[ReplicationAdapter] Vault restore failed for", i, ":", o);
+    }
+    return !1;
+  }
+  /**
+   * Try to restore a space doc from the CompactStore.
+   * Returns true if doc was successfully imported.
+   */
+  async _restoreFromCompactStore(e) {
+    if (!this.compactStore) return !1;
+    try {
+      const t = await this.compactStore.load(e.info.id);
+      if (!t) return !1;
+      const n = this.repo.import(t, {
+        docId: e.documentId
+      });
+      return n.isReady() || n.doneLoading(), await this.repo.flush([e.documentId]), !0;
+    } catch (t) {
+      return console.warn("[ReplicationAdapter] CompactStore restore failed for", e.info.name || e.info.id, ":", t), !1;
+    }
+  }
+  /**
+   * Save a snapshot to the CompactStore.
+   * Two-phase: save with history immediately (fast), then compact in Worker.
+   */
+  async _saveToCompactStore(e) {
+    if (!this.compactStore) return;
+    const t = this.repo.handles[e.documentId], n = t == null ? void 0 : t.doc();
+    if (!n) return;
+    const s = D.save(n);
+    await this.compactStore.save(e.info.id, s);
+    const i = await T.getInstance().compact(s);
+    i && i.length > 0 && await this.compactStore.save(e.info.id, i);
+  }
+  async _pushSnapshotToVault(e) {
+    if (!this.vault) return;
+    const t = this.groupKeyService.getCurrentKey(e.info.id);
+    if (!t) return;
+    const n = this.repo.handles[e.documentId], s = n == null ? void 0 : n.doc();
+    if (!s) return;
+    const o = D.save(s), r = await T.getInstance().compact(o), a = this.groupKeyService.getCurrentGeneration(e.info.id), l = await P.encryptChange(
+      r,
+      t,
+      e.info.id,
+      a,
+      this.identity.getDid()
+    ), p = (this.vaultSeqs.get(e.info.id) ?? 0) + 1;
+    await this.vault.putSnapshot(
+      e.info.id,
+      l.ciphertext,
+      l.nonce,
+      p
+    ), this.vaultSeqs.set(e.info.id, p);
+  }
+  /**
+   * Background wait for a space doc that isn't locally available yet.
+   * The doc may arrive via sync from another device.
+   */
+  _waitForDoc(e) {
+    (async () => {
+      try {
+        (await this.repo.find(e.documentUrl, {
+          allowableStates: ["ready"],
+          signal: AbortSignal.timeout(3e4)
+        })).isReady() && this.spaces.has(e.info.id) && (console.log("[ReplicationAdapter] Doc arrived via sync for space:", e.info.name || e.info.id), this._notifySpacesSubscribers());
+      } catch {
+        console.log("[ReplicationAdapter] Doc did not arrive within timeout for space:", e.info.name || e.info.id);
+      }
+    })();
+  }
+  async stop() {
+    this.unsubscribeMessaging && (this.unsubscribeMessaging(), this.unsubscribeMessaging = null);
+    for (const e of this.vaultSchedulers.values()) e.destroy();
+    this.vaultSchedulers.clear();
+    for (const e of this.compactSchedulers.values()) e.destroy();
+    this.compactSchedulers.clear(), this.vaultSeqs.clear();
+    for (const e of this.spaces.values())
+      for (const t of e.handles)
+        t.close();
+    this.repo && (this.networkAdapter.disconnect(), await this.repo.shutdown()), this.state = "idle";
+  }
+  getState() {
+    return this.state;
+  }
+  async createSpace(e, t, n) {
+    const s = crypto.randomUUID(), o = this.repo.create(t);
+    await o.whenReady(), await this.groupKeyService.createKey(s), this.networkAdapter.registerDocument(o.documentId, s), this.networkAdapter.registerSelfPeer(s);
+    const i = {
+      id: s,
+      type: e,
+      name: n == null ? void 0 : n.name,
+      description: n == null ? void 0 : n.description,
+      appTag: n == null ? void 0 : n.appTag,
+      members: [this.identity.getDid()],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, r = {
+      info: i,
+      documentId: o.documentId,
+      documentUrl: o.url,
+      handles: /* @__PURE__ */ new Set(),
+      memberEncryptionKeys: /* @__PURE__ */ new Map()
+    };
+    return this.spaces.set(s, r), this._notifySpacesSubscribers(), await this._persistSpaceMetadata(r), await this.repo.flush([o.documentId]), this._saveToCompactStore(r).catch(() => {
+    }), this._pushSnapshotToVault(r).catch(() => {
+    }), { ...i };
+  }
+  async getSpaces() {
+    return this._getSpacesSnapshot();
+  }
+  watchSpaces() {
+    return {
+      subscribe: (e) => (this.spacesSubscribers.add(e), () => {
+        this.spacesSubscribers.delete(e);
+      }),
+      getValue: () => this._getSpacesSnapshot()
+    };
+  }
+  _getSpacesSnapshot() {
+    return Array.from(this.spaces.values()).map((e) => ({ ...e.info }));
+  }
+  _notifySpacesSubscribers() {
+    const e = this._getSpacesSnapshot();
+    for (const t of this.spacesSubscribers)
+      t(e);
+  }
+  async getSpace(e) {
+    const t = this.spaces.get(e);
+    return t ? { ...t.info } : null;
+  }
+  async openSpace(e) {
+    const t = this.spaces.get(e);
+    if (!t)
+      throw new Error(`Unknown space: ${e}`);
+    const n = await Promise.race([
+      this.repo.find(t.documentUrl, {
+        allowableStates: ["ready", "unavailable"]
+      }),
+      new Promise(
+        (r, a) => setTimeout(() => a(new Error(`Space document timeout: ${e}`)), 1e4)
+      )
+    ]);
+    if (!n.isReady())
+      throw new Error(`Space document not ready: ${e}`);
+    let s = this.vaultSchedulers.get(e) ?? null;
+    !s && this.vault && (s = new N({
+      pushFn: () => this._pushSnapshotToVault(t),
+      getHeadsFn: () => {
+        const r = n.doc();
+        return r ? D.getHeads(r).join(",") : null;
+      },
+      debounceMs: 5e3
+    }), this.vaultSchedulers.set(e, s));
+    let o = this.compactSchedulers.get(e) ?? null;
+    !o && this.compactStore && (o = new N({
+      pushFn: () => this._saveToCompactStore(t),
+      getHeadsFn: () => {
+        const r = n.doc();
+        return r ? D.getHeads(r).join(",") : null;
+      },
+      debounceMs: 2e3
+    }), this.compactSchedulers.set(e, o));
+    const i = new he(t, n, s, o);
+    return t.handles.add(i), i;
+  }
+  async addMember(e, t, n) {
+    const s = this.spaces.get(e);
+    if (!s) throw new Error(`Unknown space: ${e}`);
+    s.info.members.includes(t) || (s.info.members.push(t), this._notifySpacesSubscribers()), s.memberEncryptionKeys.set(t, n), this.networkAdapter.registerSpacePeer(e, t);
+    const o = this.groupKeyService.getCurrentKey(e);
+    if (!o) throw new Error(`No group key for space: ${e}`);
+    const i = this.groupKeyService.getCurrentGeneration(e), r = await this.identity.encryptForRecipient(
+      o,
+      n
+    ), a = this.repo.handles[s.documentId], l = a == null ? void 0 : a.doc();
+    if (!l) throw new Error(`Cannot access doc for space: ${e}`);
+    const h = D.save(l), p = await P.encryptChange(
+      h,
+      o,
+      e,
+      i,
+      this.identity.getDid()
+    ), m = {
+      spaceId: e,
+      spaceType: s.info.type,
+      spaceName: s.info.name,
+      appTag: s.info.appTag,
+      members: s.info.members,
+      createdAt: s.info.createdAt,
+      generation: i,
+      documentUrl: s.documentUrl,
+      encryptedGroupKey: {
+        ciphertext: Array.from(r.ciphertext),
+        nonce: Array.from(r.nonce),
+        ephemeralPublicKey: Array.from(r.ephemeralPublicKey)
+      },
+      encryptedDoc: {
+        ciphertext: Array.from(p.ciphertext),
+        nonce: Array.from(p.nonce)
+      }
+    }, y = {
+      v: 1,
+      id: crypto.randomUUID(),
+      type: "space-invite",
+      fromDid: this.identity.getDid(),
+      toDid: t,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      encoding: "json",
+      payload: JSON.stringify(m),
+      signature: ""
+    };
+    await this._signAndSend(y);
+    for (const u of s.info.members) {
+      if (u === this.identity.getDid() || u === t) continue;
+      const g = {
+        spaceId: e,
+        action: "added",
+        memberDid: t,
+        members: s.info.members
+      }, w = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "member-update",
+        fromDid: this.identity.getDid(),
+        toDid: u,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: JSON.stringify(g),
+        signature: ""
+      };
+      await this._signAndSend(w);
+    }
+    await this._persistSpaceMetadata(s), this._pushSnapshotToVault(s).catch(() => {
+    });
+    for (const u of this.memberChangeCallbacks)
+      u({ spaceId: e, did: t, action: "added" });
+  }
+  async removeMember(e, t) {
+    const n = this.spaces.get(e);
+    if (!n) throw new Error(`Unknown space: ${e}`);
+    n.info.members = n.info.members.filter((r) => r !== t), n.memberEncryptionKeys.delete(t), this._notifySpacesSubscribers(), this.networkAdapter.unregisterSpacePeer(e, t);
+    const s = await this.groupKeyService.rotateKey(e), o = this.groupKeyService.getCurrentGeneration(e);
+    for (const [r, a] of n.memberEncryptionKeys.entries()) {
+      if (r === this.identity.getDid()) continue;
+      const l = await this.identity.encryptForRecipient(s, a), h = {
+        spaceId: e,
+        generation: o,
+        encryptedGroupKey: {
+          ciphertext: Array.from(l.ciphertext),
+          nonce: Array.from(l.nonce),
+          ephemeralPublicKey: Array.from(l.ephemeralPublicKey)
+        }
+      }, p = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "group-key-rotation",
+        fromDid: this.identity.getDid(),
+        toDid: r,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: JSON.stringify(h),
+        signature: ""
+      };
+      await this._signAndSend(p);
+    }
+    const i = [...n.info.members, t];
+    for (const r of i) {
+      if (r === this.identity.getDid()) continue;
+      const a = {
+        spaceId: e,
+        action: "removed",
+        memberDid: t,
+        members: n.info.members
+      }, l = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "member-update",
+        fromDid: this.identity.getDid(),
+        toDid: r,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: JSON.stringify(a),
+        signature: ""
+      };
+      await this._signAndSend(l);
+    }
+    await this._persistSpaceMetadata(n);
+    for (const r of this.memberChangeCallbacks)
+      r({ spaceId: e, did: t, action: "removed" });
+  }
+  onMemberChange(e) {
+    return this.memberChangeCallbacks.add(e), () => {
+      this.memberChangeCallbacks.delete(e);
+    };
+  }
+  async leaveSpace(e) {
+    throw new Error("leaveSpace not implemented for Automerge adapter");
+  }
+  async updateSpace(e, t) {
+    throw new Error("updateSpace not implemented for Automerge adapter");
+  }
+  getKeyGeneration(e) {
+    return this.groupKeyService.getCurrentGeneration(e);
+  }
+  async requestSync(e) {
+  }
+  async _persistSpaceMetadata(e) {
+    if (!this.metadataStorage) return;
+    const t = {};
+    for (const [s, o] of e.memberEncryptionKeys.entries())
+      t[s] = o;
+    await this.metadataStorage.saveSpaceMetadata({
+      info: e.info,
+      documentId: e.documentId,
+      documentUrl: e.documentUrl,
+      memberEncryptionKeys: t
+    });
+    const n = this.groupKeyService.getCurrentGeneration(e.info.id);
+    for (let s = 0; s <= n; s++) {
+      const o = this.groupKeyService.getKeyByGeneration(e.info.id, s);
+      o && o.length > 0 && await this.metadataStorage.saveGroupKey({ spaceId: e.info.id, generation: s, key: o });
+    }
+  }
+  async handleMessage(e) {
+    if (e.signature && !await X(e)) {
+      console.warn("[ReplicationAdapter] Rejected message with invalid signature from", e.fromDid);
+      return;
+    }
+    switch (e.type) {
+      case "space-invite":
+        await this.handleSpaceInvite(e);
+        break;
+      case "group-key-rotation":
+        await this.handleKeyRotation(e);
+        break;
+      case "member-update":
+        await this.handleMemberUpdate(e);
+        break;
+    }
+  }
+  async handleSpaceInvite(e) {
+    const t = JSON.parse(e.payload), n = {
+      ciphertext: new Uint8Array(t.encryptedGroupKey.ciphertext),
+      nonce: new Uint8Array(t.encryptedGroupKey.nonce),
+      ephemeralPublicKey: new Uint8Array(t.encryptedGroupKey.ephemeralPublicKey)
+    }, s = await this.identity.decryptForMe(n);
+    this.groupKeyService.importKey(t.spaceId, s, t.generation);
+    const o = {
+      ciphertext: new Uint8Array(t.encryptedDoc.ciphertext),
+      nonce: new Uint8Array(t.encryptedDoc.nonce),
+      spaceId: t.spaceId,
+      generation: t.generation,
+      fromDid: e.fromDid
+    }, i = await P.decryptChange(o, s), { documentId: r } = Y(t.documentUrl), a = this.repo.import(i, { docId: r });
+    a.isReady() || a.doneLoading(), this.networkAdapter.registerDocument(a.documentId, t.spaceId);
+    const l = t.members || [];
+    for (const m of l)
+      m !== this.identity.getDid() && this.networkAdapter.registerSpacePeer(t.spaceId, m);
+    this.networkAdapter.registerSelfPeer(t.spaceId);
+    const p = {
+      info: {
+        id: t.spaceId,
+        type: t.spaceType,
+        name: t.spaceName,
+        appTag: t.appTag,
+        members: l,
+        createdAt: t.createdAt
+      },
+      documentId: a.documentId,
+      documentUrl: a.url,
+      handles: /* @__PURE__ */ new Set(),
+      memberEncryptionKeys: /* @__PURE__ */ new Map()
+    };
+    this.spaces.set(t.spaceId, p), this._notifySpacesSubscribers(), await this._persistSpaceMetadata(p), await this.repo.flush([a.documentId]), this._saveToCompactStore(p).catch(() => {
+    }), this._pushSnapshotToVault(p).catch(() => {
+    });
+    for (const m of this.memberChangeCallbacks)
+      m({ spaceId: t.spaceId, did: this.identity.getDid(), action: "added" });
+  }
+  async handleKeyRotation(e) {
+    const t = JSON.parse(e.payload), n = this.spaces.get(t.spaceId);
+    if (n && !n.info.members.includes(e.fromDid)) {
+      console.warn("[ReplicationAdapter] Rejected key-rotation from non-member:", e.fromDid);
+      return;
+    }
+    const s = {
+      ciphertext: new Uint8Array(t.encryptedGroupKey.ciphertext),
+      nonce: new Uint8Array(t.encryptedGroupKey.nonce),
+      ephemeralPublicKey: new Uint8Array(t.encryptedGroupKey.ephemeralPublicKey)
+    }, o = await this.identity.decryptForMe(s);
+    this.groupKeyService.importKey(t.spaceId, o, t.generation), n && await this._persistSpaceMetadata(n);
+  }
+  async handleMemberUpdate(e) {
+    const t = JSON.parse(e.payload), n = this.spaces.get(t.spaceId);
+    if (!n) return;
+    if (t.action === "removed") {
+      if (e.fromDid !== n.info.members[0]) {
+        console.warn("[ReplicationAdapter] Rejected member removal from non-creator:", e.fromDid);
+        return;
+      }
+    } else if (!n.info.members.includes(e.fromDid)) {
+      console.warn("[ReplicationAdapter] Rejected member-update from non-member:", e.fromDid);
+      return;
+    }
+    const s = this.identity.getDid();
+    if (t.action === "removed" && t.memberDid === s && !t.members.includes(s)) {
+      console.log("[ReplicationAdapter] Removed from space:", n.info.name || n.info.id);
+      for (const l of n.handles)
+        l.close();
+      for (const l of n.info.members)
+        l !== s && this.networkAdapter.unregisterSpacePeer(t.spaceId, l);
+      this.networkAdapter.unregisterDocument(n.documentId), this.spaces.delete(t.spaceId), this.metadataStorage && (await this.metadataStorage.deleteSpaceMetadata(t.spaceId), await this.metadataStorage.deleteGroupKeys(t.spaceId));
+      const r = this.vaultSchedulers.get(t.spaceId);
+      r && (r.destroy(), this.vaultSchedulers.delete(t.spaceId));
+      const a = this.compactSchedulers.get(t.spaceId);
+      a && (a.destroy(), this.compactSchedulers.delete(t.spaceId)), this.compactStore && this.compactStore.delete(t.spaceId).catch(() => {
+      }), this.vaultSeqs.delete(t.spaceId), this._notifySpacesSubscribers();
+      for (const l of this.memberChangeCallbacks)
+        l({ spaceId: t.spaceId, did: s, action: "removed" });
+      return;
+    }
+    const i = new Set(n.info.members);
+    n.info.members = t.members, this._notifySpacesSubscribers();
+    for (const r of t.members)
+      r !== s && !i.has(r) && this.networkAdapter.registerSpacePeer(t.spaceId, r);
+    for (const r of i)
+      t.members.includes(r) || this.networkAdapter.unregisterSpacePeer(t.spaceId, r);
+    await this._persistSpaceMetadata(n);
+    for (const r of t.members)
+      if (!i.has(r))
+        for (const a of this.memberChangeCallbacks)
+          a({ spaceId: t.spaceId, did: r, action: "added" });
+    for (const r of i)
+      if (!t.members.includes(r))
+        for (const a of this.memberChangeCallbacks)
+          a({ spaceId: t.spaceId, did: r, action: "removed" });
+  }
+}
+class ue extends W {
+  constructor(t, n, s) {
+    super();
+    d(this, "messaging");
+    d(this, "personalKey");
+    d(this, "myDid");
+    d(this, "documentId", null);
+    d(this, "ready", !1);
+    d(this, "readyResolve");
+    d(this, "readyPromise");
+    d(this, "unsubMessage", null);
+    /** Track message IDs we sent, so we can ignore our own echoes from the relay */
+    d(this, "sentMessageIds", /* @__PURE__ */ new Set());
+    /** Gate incoming messages until the doc handle is confirmed ready (avoids automerge-repo 60s timeout) */
+    d(this, "docReady", !1);
+    this.messaging = t, this.personalKey = n, this.myDid = s, this.readyPromise = new Promise((o) => {
+      this.readyResolve = o;
+    });
+  }
+  /** Register the personal document ID for routing */
+  setDocumentId(t) {
+    this.documentId = t;
+  }
+  /** Signal that the doc handle is ready — incoming messages will be emitted to the repo */
+  setDocReady() {
+    this.docReady = !0;
+  }
+  // --- NetworkAdapter interface ---
+  isReady() {
+    return this.ready;
+  }
+  whenReady() {
+    return this.readyPromise;
+  }
+  connect(t) {
+    var n;
+    this.peerId = t, this.unsubMessage = this.messaging.onMessage(async (s) => {
+      if (s.type === "personal-sync" && !(!this.documentId || !this.docReady)) {
+        if (this.sentMessageIds.has(s.id)) {
+          this.sentMessageIds.delete(s.id);
+          return;
+        }
+        try {
+          const o = JSON.parse(s.payload), i = {
+            ciphertext: new Uint8Array(o.ciphertext),
+            nonce: new Uint8Array(o.nonce),
+            spaceId: "__personal__",
+            generation: 0,
+            fromDid: s.fromDid
+          }, r = await P.decryptChange(i, this.personalKey), a = {
+            type: o.messageType || "sync",
+            senderId: s.fromDid,
+            targetId: this.peerId,
+            documentId: this.documentId,
+            data: r
+          };
+          this.emit("message", a);
+        } catch (o) {
+          console.debug("[PersonalNetworkAdapter] Failed to process message:", o);
+        }
+      }
+    }), this.ready = !0, (n = this.readyResolve) == null || n.call(this), this.emit("ready", void 0);
+  }
+  send(t) {
+    this.ready && (!t.data || !this.documentId || t.documentId === this.documentId && (async () => {
+      try {
+        const n = await P.encryptChange(
+          t.data,
+          this.personalKey,
+          "__personal__",
+          0,
+          this.myDid
+        ), s = {
+          messageType: t.type,
+          ciphertext: Array.from(n.ciphertext),
+          nonce: Array.from(n.nonce)
+        }, o = crypto.randomUUID();
+        this.sentMessageIds.add(o), setTimeout(() => this.sentMessageIds.delete(o), 3e4);
+        const i = {
+          v: 1,
+          id: o,
+          type: "personal-sync",
+          fromDid: this.myDid,
+          toDid: this.myDid,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          encoding: "json",
+          payload: JSON.stringify(s),
+          signature: ""
+        };
+        await this.messaging.send(i);
+      } catch {
+      }
+    })());
+  }
+  disconnect() {
+    this.unsubMessage && (this.unsubMessage(), this.unsubMessage = null), this.sentMessageIds.clear(), this.docReady = !1, this.ready = !1;
+  }
+}
+class pe {
+  constructor(e = "wot-sync-states") {
+    d(this, "dbName");
+    d(this, "db", null);
+    d(this, "readyPromise");
+    this.dbName = e, this.readyPromise = this.open();
+  }
+  /** Wait until the IDB is open. */
+  async ready() {
+    return this.readyPromise;
+  }
+  async open() {
+    return new Promise((e, t) => {
+      const n = indexedDB.open(this.dbName, 1);
+      n.onupgradeneeded = () => {
+        const s = n.result;
+        s.objectStoreNames.contains("sync-states") || s.createObjectStore("sync-states");
+      }, n.onsuccess = () => {
+        this.db = n.result, e();
+      }, n.onerror = () => t(n.error);
+    });
+  }
+  isSyncState(e) {
+    return e.some((t) => t === "sync-state");
+  }
+  keyToString(e) {
+    return JSON.stringify(e);
+  }
+  stringToKey(e) {
+    return JSON.parse(e);
+  }
+  keyMatchesPrefix(e, t) {
+    if (e.length < t.length) return !1;
+    for (let n = 0; n < t.length; n++)
+      if (e[n] !== t[n]) return !1;
+    return !0;
+  }
+  async load(e) {
+    if (!this.isSyncState(e)) return;
+    await this.readyPromise;
+    const t = this.db;
+    return new Promise((n, s) => {
+      const r = t.transaction("sync-states", "readonly").objectStore("sync-states").get(this.keyToString(e));
+      r.onsuccess = () => n(r.result ?? void 0), r.onerror = () => s(r.error);
+    });
+  }
+  async save(e, t) {
+    if (!this.isSyncState(e)) return;
+    await this.readyPromise;
+    const n = this.db;
+    return new Promise((s, o) => {
+      const a = n.transaction("sync-states", "readwrite").objectStore("sync-states").put(t, this.keyToString(e));
+      a.onsuccess = () => s(), a.onerror = () => o(a.error);
+    });
+  }
+  async remove(e) {
+    if (!this.isSyncState(e)) return;
+    await this.readyPromise;
+    const t = this.db;
+    return new Promise((n, s) => {
+      const r = t.transaction("sync-states", "readwrite").objectStore("sync-states").delete(this.keyToString(e));
+      r.onsuccess = () => n(), r.onerror = () => s(r.error);
+    });
+  }
+  async loadRange(e) {
+    await this.readyPromise;
+    const t = this.db;
+    return new Promise((n, s) => {
+      const i = t.transaction("sync-states", "readonly").objectStore("sync-states"), r = [], a = i.openCursor();
+      a.onsuccess = () => {
+        const l = a.result;
+        if (l) {
+          const h = this.stringToKey(l.key);
+          this.keyMatchesPrefix(h, e) && r.push({ key: h, data: l.value }), l.continue();
+        } else
+          n(r);
+      }, a.onerror = () => s(a.error);
+    });
+  }
+  async removeRange(e) {
+    await this.readyPromise;
+    const t = this.db;
+    return new Promise((n, s) => {
+      const r = t.transaction("sync-states", "readwrite").objectStore("sync-states").openCursor();
+      r.onsuccess = () => {
+        const a = r.result;
+        if (a) {
+          const l = this.stringToKey(a.key);
+          this.keyMatchesPrefix(l, e) && a.delete(), a.continue();
+        } else
+          n();
+      }, r.onerror = () => s(r.error);
+    });
+  }
+  close() {
+    this.db && (this.db.close(), this.db = null);
+  }
+}
+const ye = 20;
+async function ge(c, e) {
+  try {
+    const t = await new Promise((o) => {
+      const i = indexedDB.open(c, 1);
+      i.onerror = () => o(0), i.onupgradeneeded = (r) => {
+        const a = r.target.result;
+        a.objectStoreNames.contains(e) || a.createObjectStore(e);
+      }, i.onsuccess = () => {
+        const r = i.result;
+        try {
+          const h = r.transaction(e, "readonly").objectStore(e).count();
+          h.onsuccess = () => {
+            r.close(), o(h.result);
+          }, h.onerror = () => {
+            r.close(), o(0);
+          };
+        } catch {
+          r.close(), o(0);
+        }
+      };
+    }), n = x();
+    n.setIdbChunkCount(t), console.log(`[personal-doc] IndexedDB chunk count: ${t}`);
+    const s = t <= ye;
+    return n.setHealthCheckResult(s), s;
+  } catch {
+    return !0;
+  }
+}
+async function me(c, e) {
+  return new Promise((t) => {
+    const n = indexedDB.open(c, 1);
+    let s = !1;
+    n.onupgradeneeded = () => {
+      s = !0;
+      const o = n.result;
+      o.objectStoreNames.contains(e) || o.createObjectStore(e);
+    }, n.onsuccess = () => {
+      const o = n.result;
+      if (s) {
+        o.close(), indexedDB.deleteDatabase(c), t(!1);
+        return;
+      }
+      try {
+        const a = o.transaction(e, "readonly").objectStore(e).count();
+        a.onsuccess = () => {
+          o.close(), t(a.result > 0);
+        }, a.onerror = () => {
+          o.close(), t(!1);
+        };
+      } catch {
+        o.close(), t(!1);
+      }
+    }, n.onerror = () => t(!1);
+  });
+}
+const G = "wot-personal-doc", q = "doc", fe = "personal";
+async function we() {
+  return new Promise((c) => {
+    const e = indexedDB.open(G, 1);
+    e.onupgradeneeded = () => {
+      e.result.close(), c(null);
+    }, e.onsuccess = () => {
+      const t = e.result;
+      if (!t.objectStoreNames.contains(q)) {
+        t.close(), c(null);
+        return;
+      }
+      const o = t.transaction(q, "readonly").objectStore(q).get(fe);
+      o.onsuccess = () => {
+        t.close(), c(o.result ?? null);
+      }, o.onerror = () => {
+        t.close(), c(null);
+      };
+    }, e.onerror = () => c(null);
+  });
+}
+async function be() {
+  return new Promise((c) => {
+    const e = indexedDB.deleteDatabase(G);
+    e.onsuccess = () => c(), e.onerror = () => c();
+  });
+}
+let I = null, v = null, C = null, B = /* @__PURE__ */ new Set(), $ = !1, O = null, U = null, F = 0, S = null, k = null, b = null;
+const A = "__personal__", ee = "wot-compact-store", te = "wot-personal-sync-states";
+function z() {
+  return {
+    profile: null,
+    contacts: {},
+    verifications: {},
+    attestations: {},
+    attestationMetadata: {},
+    outbox: {},
+    spaces: {},
+    groupKeys: {}
+  };
+}
+function ne() {
+  for (const c of B)
+    try {
+      c();
+    } catch {
+    }
+}
+async function Se(c) {
+  const e = await c.deriveFrameworkKey("personal-doc-v1"), t = e.slice(0, 16), n = ie(t), { documentId: s } = Y(n);
+  return { documentId: s, documentUrl: n, personalKey: e };
+}
+async function De(c, e) {
+  var t, n;
+  try {
+    const s = await c.getChanges(A);
+    if ((t = s.snapshot) != null && t.data) {
+      const o = E(s.snapshot.data), i = o[0], r = o.slice(1, 1 + i), a = o.slice(1 + i), l = await P.decryptChange(
+        { ciphertext: a, nonce: r, spaceId: A, generation: 0, fromDid: "" },
+        e
+      );
+      return F = ((n = s.snapshot) == null ? void 0 : n.upToSeq) ?? 0, l;
+    }
+  } catch (s) {
+    console.warn("[personal-doc] Vault snapshot decrypt failed — deleting and falling back to wot-profiles restore"), x().logError("load:vault:decrypt-failed", s);
+    try {
+      await c.deleteDoc(A), console.debug("[personal-doc] Deleted undecryptable vault snapshot — fresh snapshot will be pushed after restore");
+    } catch (o) {
+      x().logError("delete:vault:cleanup", o);
+    }
+  }
+  return null;
+}
+async function Ie() {
+  if (!(!k || !I))
+    try {
+      const c = I.doc();
+      if (!c) return;
+      const e = Date.now(), t = D.save(c), n = Date.now() - e;
+      if (!t || t.length === 0) return;
+      const s = Date.now();
+      await k.save(A, t), x().logSave("compact-store", Date.now() - s, t.length, n);
+      const o = T.getInstance(), i = await o.compact(t);
+      i && i.length > 0 && (await k.save(A, i), console.debug(`[personal-doc] Compacted: ${t.length}B → ${i.length}B (worker=${o.isUsingWorker})`));
+    } catch (c) {
+      x().logError("save:compact-store", c);
+    }
+}
+async function Pe() {
+  if (!(!O || !U || !v || !I))
+    try {
+      const c = I.doc();
+      if (!c) return;
+      if (!(c.profile || Object.keys(c.contacts).length > 0 || Object.keys(c.spaces).length > 0)) {
+        console.debug("[personal-doc] Skip vault push — no meaningful data yet");
+        return;
+      }
+      const t = D.save(c);
+      if (!t || t.length === 0) return;
+      const s = await T.getInstance().compact(t);
+      if (!s || s.length === 0) return;
+      const o = await P.encryptChange(
+        s,
+        U,
+        A,
+        0,
+        ""
+      );
+      F++;
+      const i = Date.now();
+      await O.putSnapshot(A, o.ciphertext, o.nonce, F), x().logSave("vault", Date.now() - i, s.length);
+    } catch (c) {
+      x().logError("save:vault", c);
+    }
+}
+async function Re(c, e, t) {
+  if (I && v) {
+    const y = I.doc();
+    if (y) return y;
+  }
+  const n = Date.now(), { documentId: s, documentUrl: o, personalKey: i } = await Se(c), r = c.getDid();
+  t && (O = new Z(t, c), U = i), k = new ce(ee), await k.open();
+  const a = new pe(te);
+  v = new L({
+    peerId: `${r}-personal`,
+    network: [],
+    storage: a,
+    sharePolicy: async () => !0
+  });
+  const l = x();
+  l.setImpl("compact-store"), de(l);
+  let h, p = "";
+  try {
+    const y = Date.now(), u = await k.load(A), g = Date.now();
+    if (u && u.length > 0) {
+      h = v.import(u, { docId: s });
+      const w = Date.now();
+      h.isReady() || h.doneLoading();
+      const f = h.doc(), R = Date.now();
+      if (console.debug(`[personal-doc] CompactStore load breakdown: idb=${g - y}ms import=${w - g}ms doc=${R - w}ms size=${u.length}B`), f && typeof f == "object") {
+        p = "compact-store";
+        const _ = Date.now() - y;
+        l.logLoad("compact-store", _, u.length, {
+          contacts: Object.keys(f.contacts ?? {}).length,
+          attestations: Object.keys(f.attestations ?? {}).length,
+          spaces: Object.keys(f.spaces ?? {}).length
+        }), l.setDocStats(
+          u.length,
+          Object.keys(f.contacts ?? {}).length,
+          Object.keys(f.attestations ?? {}).length,
+          Object.keys(f.spaces ?? {}).length
+        );
+      }
+    }
+  } catch (y) {
+    l.logError("load:compact-store", y);
+  }
+  if (!p)
+    try {
+      const y = Date.now(), u = await me("automerge-personal", "documents");
+      if (console.debug(`[personal-doc] Migration check: exists=${u} took=${Date.now() - y}ms`), u) {
+        if (await ge("automerge-personal", "documents")) {
+          const { IndexedDBStorageAdapter: w } = await import("./index-Dz-MvOzM.js"), f = new L({
+            peerId: `${r}-migration`,
+            network: [],
+            storage: new w("automerge-personal"),
+            sharePolicy: async () => !0
+          });
+          try {
+            const R = Date.now(), K = (await Promise.race([
+              f.find(o),
+              new Promise((j, H) => setTimeout(() => H(new Error("migration find timeout")), 8e3))
+            ])).doc();
+            if (K && typeof K == "object") {
+              const j = D.save(K);
+              await k.save(A, j), h = v.import(j, { docId: s }), h.isReady() || h.doneLoading(), p = "migration";
+              const H = Date.now() - R, V = l._idbChunkCount ?? 0;
+              l.logMigration(typeof V == "number" ? V : 0, j.length), l.logLoad("migration", H, j.length, {
+                contacts: Object.keys(K.contacts ?? {}).length,
+                attestations: Object.keys(K.attestations ?? {}).length,
+                spaces: Object.keys(K.spaces ?? {}).length,
+                source: "automerge-personal"
+              }), l.setDocStats(
+                j.length,
+                Object.keys(K.contacts ?? {}).length,
+                Object.keys(K.attestations ?? {}).length,
+                Object.keys(K.spaces ?? {}).length
+              );
+            }
+          } finally {
+            try {
+              f.shutdown();
+            } catch {
+            }
+          }
+        }
+        await new Promise((w) => {
+          const f = indexedDB.deleteDatabase("automerge-personal");
+          f.onsuccess = () => w(), f.onerror = () => w(), f.onblocked = () => w();
+        }).catch(() => {
+        }), console.debug("[personal-doc] Cleaned up old automerge-personal IDB");
+      }
+    } catch (y) {
+      l.logError("load:migration", y);
+    }
+  if (!p && O && U) {
+    const y = Date.now(), u = await De(O, U);
+    if (u && u.length > 0) {
+      h = v.import(u, { docId: s }), h.isReady() || h.doneLoading();
+      const g = h.doc();
+      if (g && typeof g == "object") {
+        p = "vault";
+        const w = Date.now() - y;
+        l.logLoad("vault", w, u.length, {
+          contacts: Object.keys(g.contacts ?? {}).length,
+          attestations: Object.keys(g.attestations ?? {}).length,
+          spaces: Object.keys(g.spaces ?? {}).length
+        }), l.setDocStats(
+          u.length,
+          Object.keys(g.contacts ?? {}).length,
+          Object.keys(g.attestations ?? {}).length,
+          Object.keys(g.spaces ?? {}).length
+        ), await k.save(A, u);
+      }
+    } else
+      console.debug("[personal-doc] Vault has no data");
+  }
+  if (!p) {
+    const y = await we();
+    if (y) {
+      const u = { ...z(), ...y };
+      h = v.import(new Uint8Array(0), { docId: s }), h.isReady() || h.doneLoading(), h.change((g) => {
+        Object.assign(g, u);
+      }), p = "migration", l.logLoad("migration", 0, 0, { source: "old-idb" }), await be();
+    } else
+      h = v.import(new Uint8Array(0), { docId: s }), h.isReady() || h.doneLoading(), h.change((u) => {
+        Object.assign(u, z());
+      }), p = "new", l.logLoad("new", 0, 0);
+  }
+  if (b = new N({
+    pushFn: Ie,
+    getHeadsFn: () => {
+      const y = h.doc();
+      return y ? D.getHeads(y).join(",") : null;
+    },
+    debounceMs: 2e3
+  }), p === "compact-store") {
+    const y = h.doc();
+    y && b.setLastPushedHeads(D.getHeads(y).join(","));
+  }
+  if (O) {
+    S = new N({
+      pushFn: Pe,
+      getHeadsFn: () => {
+        const u = h.doc();
+        return u ? D.getHeads(u).join(",") : null;
+      },
+      debounceMs: 5e3
+    });
+    const y = h.doc();
+    y && p === "vault" && S.setLastPushedHeads(D.getHeads(y).join(",")), p !== "vault" && p !== "new" && S.pushDebounced();
+  }
+  I = h, e && (C = new ue(e, i, r), C.setDocumentId(s), v.networkSubsystem.addNetworkAdapter(C), C.setDocReady()), h.on("change", () => {
+    $ || (console.debug("[personal-doc] Remote change detected, notifying listeners"), ne(), b == null || b.pushDebounced());
+  }), C && C.emit("peer-candidate", {
+    peerId: r,
+    peerMetadata: { isEphemeral: !0 }
+  });
+  const m = h.doc();
+  if (!m) throw new Error("Failed to initialize personal doc");
+  return console.debug(`[personal-doc] initPersonalDoc total: ${Date.now() - n}ms (loaded from: ${p})`), m;
+}
+function se() {
+  if (!I)
+    throw new Error("Personal doc not initialized. Call initPersonalDoc() first.");
+  const c = I.doc();
+  if (!c)
+    throw new Error("Personal doc not ready.");
+  return c;
+}
+function Oe() {
+  return I !== null && I.doc() !== void 0;
+}
+function oe(c, e) {
+  if (!I)
+    throw new Error("Personal doc not initialized. Call initPersonalDoc() first.");
+  $ = !0;
+  try {
+    I.change(c);
+  } finally {
+    $ = !1;
+  }
+  ne(), e != null && e.background ? (b == null || b.pushDebounced(), S == null || S.pushDebounced()) : (b == null || b.pushImmediate(), S == null || S.pushImmediate());
+  const t = I.doc();
+  if (!t) throw new Error("Doc disappeared after change");
+  return t;
+}
+function ve(c) {
+  return B.add(c), () => {
+    B.delete(c);
+  };
+}
+async function _e() {
+  await (b == null ? void 0 : b.flush()), await (S == null ? void 0 : S.flush());
+}
+async function ke() {
+  const c = v, e = C;
+  I = null, v = null, C = null, O = null, U = null, F = 0, b && (b.destroy(), b = null), S && (S.destroy(), S = null), k && (k.close(), k = null), B.clear();
+  try {
+    e == null || e.disconnect(), c == null || c.shutdown();
+  } catch {
+  }
+}
+async function je() {
+  await ke();
+  for (const c of [G, "automerge-personal", ee, te])
+    await Promise.race([
+      new Promise((e) => {
+        const t = indexedDB.deleteDatabase(c);
+        t.onsuccess = () => e(), t.onblocked = () => {
+          console.warn(`[personal-doc] deleteDatabase(${c}) blocked`), e();
+        }, t.onerror = () => e();
+      }),
+      new Promise((e) => setTimeout(e, 2e3))
+      // timeout fallback
+    ]);
+}
+class Ue {
+  constructor() {
+    d(this, "data", /* @__PURE__ */ new Map());
+  }
+  keyToString(e) {
+    return e.join("/");
+  }
+  async load(e) {
+    return this.data.get(this.keyToString(e));
+  }
+  async save(e, t) {
+    this.data.set(this.keyToString(e), t);
+  }
+  async remove(e) {
+    this.data.delete(this.keyToString(e));
+  }
+  async loadRange(e) {
+    const t = this.keyToString(e), n = [];
+    for (const [s, o] of this.data.entries())
+      s.startsWith(t) && n.push({ key: s.split("/"), data: o });
+    return n;
+  }
+  async removeRange(e) {
+    const t = this.keyToString(e);
+    for (const n of this.data.keys())
+      n.startsWith(t) && this.data.delete(n);
+  }
+}
+function Ae(c, e) {
+  return `${c}:${e}`;
+}
+class Te {
+  constructor(e) {
+    d(this, "getPersonalDoc");
+    d(this, "changePersonalDoc");
+    this.getPersonalDoc = (e == null ? void 0 : e.getPersonalDoc) ?? se, this.changePersonalDoc = (e == null ? void 0 : e.changePersonalDoc) ?? oe;
+  }
+  async saveSpaceMetadata(e) {
+    this.changePersonalDoc((t) => {
+      const n = {
+        id: e.info.id,
+        type: e.info.type,
+        name: e.info.name ?? null,
+        description: e.info.description ?? null,
+        members: [...e.info.members],
+        createdAt: e.info.createdAt
+      };
+      e.info.appTag != null && (n.appTag = e.info.appTag), t.spaces[e.info.id] = {
+        info: n,
+        documentId: e.documentId,
+        documentUrl: e.documentUrl,
+        memberEncryptionKeys: Object.fromEntries(
+          Object.entries(e.memberEncryptionKeys).map(
+            ([s, o]) => [s, Array.from(o)]
+          )
+        )
+      };
+    });
+  }
+  async loadSpaceMetadata(e) {
+    const n = this.getPersonalDoc().spaces[e];
+    return n ? this.deserialize(n) : null;
+  }
+  async loadAllSpaceMetadata() {
+    const e = this.getPersonalDoc();
+    return Object.values(e.spaces).map((t) => this.deserialize(t));
+  }
+  async deleteSpaceMetadata(e) {
+    this.changePersonalDoc((t) => {
+      delete t.spaces[e];
+    });
+  }
+  async saveGroupKey(e) {
+    const t = Ae(e.spaceId, e.generation);
+    this.changePersonalDoc((n) => {
+      n.groupKeys[t] = {
+        spaceId: e.spaceId,
+        generation: e.generation,
+        key: Array.from(e.key)
+      };
+    });
+  }
+  async loadGroupKeys(e) {
+    const t = this.getPersonalDoc();
+    return Object.values(t.groupKeys).filter((n) => n.spaceId === e).map((n) => ({
+      spaceId: n.spaceId,
+      generation: n.generation,
+      key: new Uint8Array(n.key)
+    }));
+  }
+  async deleteGroupKeys(e) {
+    this.changePersonalDoc((t) => {
+      for (const [n, s] of Object.entries(t.groupKeys))
+        s.spaceId === e && delete t.groupKeys[n];
+    });
+  }
+  async clearAll() {
+    this.changePersonalDoc((e) => {
+      for (const t of Object.keys(e.spaces))
+        delete e.spaces[t];
+      for (const t of Object.keys(e.groupKeys))
+        delete e.groupKeys[t];
+    });
+  }
+  deserialize(e) {
+    return {
+      info: {
+        id: e.info.id,
+        type: e.info.type,
+        ...e.info.name != null ? { name: e.info.name } : {},
+        ...e.info.description != null ? { description: e.info.description } : {},
+        ...e.info.appTag != null ? { appTag: e.info.appTag } : {},
+        members: [...e.info.members],
+        createdAt: e.info.createdAt
+      },
+      documentId: e.documentId,
+      documentUrl: e.documentUrl,
+      memberEncryptionKeys: Object.fromEntries(
+        Object.entries(e.memberEncryptionKeys).map(
+          ([t, n]) => [t, new Uint8Array(n)]
+        )
+      )
+    };
+  }
+}
+class Ee {
+  constructor(e) {
+    d(this, "getPersonalDoc");
+    d(this, "changePersonalDoc");
+    d(this, "onPersonalDocChange");
+    this.getPersonalDoc = (e == null ? void 0 : e.getPersonalDoc) ?? se, this.changePersonalDoc = (e == null ? void 0 : e.changePersonalDoc) ?? oe, this.onPersonalDocChange = (e == null ? void 0 : e.onPersonalDocChange) ?? ve;
+  }
+  async enqueue(e) {
+    await this.has(e.id) || this.changePersonalDoc((n) => {
+      n.outbox[e.id] = {
+        envelopeJson: JSON.stringify(e),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        retryCount: 0
+      };
+    });
+  }
+  async dequeue(e) {
+    this.changePersonalDoc((t) => {
+      delete t.outbox[e];
+    });
+  }
+  async getPending() {
+    const e = this.getPersonalDoc();
+    return Object.entries(e.outbox).map(([t, n]) => ({
+      envelope: JSON.parse(n.envelopeJson),
+      createdAt: n.createdAt,
+      retryCount: n.retryCount
+    })).sort((t, n) => t.createdAt.localeCompare(n.createdAt));
+  }
+  async has(e) {
+    const t = this.getPersonalDoc();
+    return e in t.outbox;
+  }
+  async incrementRetry(e) {
+    this.changePersonalDoc((t) => {
+      t.outbox[e] && (t.outbox[e].retryCount += 1);
+    });
+  }
+  async count() {
+    const e = this.getPersonalDoc();
+    return Object.keys(e.outbox).length;
+  }
+  watchPendingCount() {
+    const e = this, t = () => {
+      const s = e.getPersonalDoc();
+      return Object.keys(s.outbox).length;
+    };
+    let n = t();
+    return {
+      subscribe: (s) => e.onPersonalDocChange(() => {
+        const o = t();
+        o !== n && (n = o, s(n));
+      }),
+      getValue: () => n
+    };
+  }
+}
+export {
+  Ee as AutomergeOutboxStore,
+  xe as AutomergeReplicationAdapter,
+  Te as AutomergeSpaceMetadataStorage,
+  T as CompactionService,
+  le as EncryptedMessagingNetworkAdapter,
+  Ue as InMemoryRepoStorageAdapter,
+  ue as PersonalNetworkAdapter,
+  pe as SyncOnlyStorageAdapter,
+  oe as changePersonalDoc,
+  je as deletePersonalDocDB,
+  _e as flushPersonalDoc,
+  se as getPersonalDoc,
+  Re as initPersonalDoc,
+  Oe as isPersonalDocInitialized,
+  ve as onPersonalDocChange,
+  ke as resetPersonalDoc
+};