@web_of_trust/adapter-yjs 0.1.2

package/dist/index.js

@@ -0,0 +1,1816 @@
+var Se = Object.defineProperty;
+var we = (a, e, t) => e in a ? Se(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
+var y = (a, e, t) => we(a, typeof e != "symbol" ? e + "" : e, t);
+import * as d from "yjs";
+import { EncryptedSyncService as D, signEnvelope as O, getMetrics as be, registerDebugApi as De, CompactStorageManager as ve, VaultClient as ae, VaultPushScheduler as q, base64ToUint8 as B, verifyEnvelope as Me } from "@web_of_trust/core";
+class Ae {
+  constructor(e, t, s, n, i) {
+    y(this, "doc");
+    y(this, "messaging");
+    y(this, "personalKey");
+    y(this, "myDid");
+    y(this, "unsubDocUpdate", null);
+    y(this, "unsubMessage", null);
+    y(this, "unsubStateChange", null);
+    y(this, "started", !1);
+    /** Track message IDs we sent, so we ignore our own echoes from the relay */
+    y(this, "sentMessageIds", /* @__PURE__ */ new Set());
+    y(this, "signFn");
+    this.doc = e, this.messaging = t, this.personalKey = s, this.myDid = n, this.signFn = i;
+  }
+  start() {
+    if (this.started) return;
+    this.started = !0, this.sendFullState(), this.unsubStateChange = this.messaging.onStateChange((t) => {
+      t === "connected" && this.started && (this.sendFullState(), this.sendSyncRequest());
+    });
+    const e = (t, s) => {
+      s !== "remote" && this.sendUpdate(t);
+    };
+    this.doc.on("update", e), this.unsubDocUpdate = () => this.doc.off("update", e), this.unsubMessage = this.messaging.onMessage(async (t) => {
+      if (t.type === "personal-sync") {
+        if (this.sentMessageIds.has(t.id)) {
+          this.sentMessageIds.delete(t.id);
+          return;
+        }
+        try {
+          const s = JSON.parse(t.payload);
+          if (s.syncRequest) {
+            this.sendFullState();
+            return;
+          }
+          const n = {
+            ciphertext: new Uint8Array(s.ciphertext),
+            nonce: new Uint8Array(s.nonce),
+            spaceId: "__personal__",
+            generation: 0,
+            fromDid: t.fromDid
+          }, i = await D.decryptChange(n, this.personalKey);
+          d.applyUpdate(this.doc, i, "remote");
+        } catch (s) {
+          console.debug("[YjsPersonalSync] Failed to process message:", s);
+        }
+      }
+    }), this.sendSyncRequest();
+  }
+  sendSyncRequest() {
+    const e = crypto.randomUUID();
+    this.sentMessageIds.add(e), setTimeout(() => this.sentMessageIds.delete(e), 3e4);
+    const t = {
+      v: 1,
+      id: e,
+      type: "personal-sync",
+      fromDid: this.myDid,
+      toDid: this.myDid,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      encoding: "json",
+      payload: JSON.stringify({ syncRequest: !0 }),
+      signature: ""
+    };
+    this.signFn ? O(t, this.signFn).then(
+      (s) => this.messaging.send(s)
+    ).catch(() => {
+    }) : this.messaging.send(t).catch(() => {
+    });
+  }
+  sendFullState() {
+    const e = d.encodeStateAsUpdate(this.doc);
+    e.length > 1 && this.sendUpdate(e);
+  }
+  async sendUpdate(e) {
+    try {
+      const t = await D.encryptChange(
+        e,
+        this.personalKey,
+        "__personal__",
+        0,
+        this.myDid
+      ), s = {
+        ciphertext: Array.from(t.ciphertext),
+        nonce: Array.from(t.nonce)
+      }, n = crypto.randomUUID();
+      this.sentMessageIds.add(n), setTimeout(() => this.sentMessageIds.delete(n), 3e4);
+      const i = {
+        v: 1,
+        id: n,
+        type: "personal-sync",
+        fromDid: this.myDid,
+        toDid: this.myDid,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: JSON.stringify(s),
+        signature: ""
+      };
+      if (this.signFn) {
+        const o = await O(i, this.signFn);
+        await this.messaging.send(o);
+      } else
+        await this.messaging.send(i);
+    } catch {
+    }
+  }
+  destroy() {
+    this.unsubDocUpdate && (this.unsubDocUpdate(), this.unsubDocUpdate = null), this.unsubMessage && (this.unsubMessage(), this.unsubMessage = null), this.unsubStateChange && (this.unsubStateChange(), this.unsubStateChange = null), this.sentMessageIds.clear(), this.started = !1;
+  }
+}
+const ie = "wot-yjs-compact-store", H = "personal-doc", V = "personal-doc";
+let h = null, U = null, A = null, C = null, _ = null, j = null, N = 0, k = null, $ = /* @__PURE__ */ new Set();
+function W() {
+  return h.getMap("profile");
+}
+function oe() {
+  return h.getMap("contacts");
+}
+function re() {
+  return h.getMap("verifications");
+}
+function ce() {
+  return h.getMap("attestations");
+}
+function de() {
+  return h.getMap("attestationMetadata");
+}
+function le() {
+  return h.getMap("outbox");
+}
+function ue() {
+  return h.getMap("spaces");
+}
+function pe() {
+  return h.getMap("groupKeys");
+}
+function G() {
+  if (!h) throw new Error("Yjs personal doc not initialized");
+  const a = W();
+  return {
+    profile: a.size > 0 ? Z(a) : null,
+    contacts: F(oe()),
+    verifications: F(re()),
+    attestations: F(ce()),
+    attestationMetadata: F(de()),
+    outbox: F(le()),
+    spaces: F(ue()),
+    groupKeys: F(pe())
+  };
+}
+function Z(a) {
+  const e = {};
+  return a.forEach((t, s) => {
+    t instanceof d.Map ? e[s] = Z(t) : t instanceof d.Array ? e[s] = t.toArray() : e[s] = t;
+  }), e;
+}
+function F(a) {
+  const e = {};
+  return a.forEach((t, s) => {
+    t instanceof d.Map && (e[s] = Z(t));
+  }), e;
+}
+function Ke() {
+  return {
+    get profile() {
+      const a = W();
+      return a.size === 0 ? null : ee(a);
+    },
+    set profile(a) {
+      const e = W();
+      if (a === null)
+        for (const t of Array.from(e.keys()))
+          e.delete(t);
+      else {
+        for (const t of Array.from(e.keys()))
+          t in a || e.delete(t);
+        L(e, a);
+      }
+    },
+    get contacts() {
+      return J(oe());
+    },
+    set contacts(a) {
+    },
+    get verifications() {
+      return J(re());
+    },
+    set verifications(a) {
+    },
+    get attestations() {
+      return J(ce());
+    },
+    set attestations(a) {
+    },
+    get attestationMetadata() {
+      return J(de());
+    },
+    set attestationMetadata(a) {
+    },
+    get outbox() {
+      return J(le());
+    },
+    set outbox(a) {
+    },
+    get spaces() {
+      return J(ue());
+    },
+    set spaces(a) {
+    },
+    get groupKeys() {
+      return J(pe());
+    },
+    set groupKeys(a) {
+    }
+  };
+}
+function J(a) {
+  return new Proxy({}, {
+    get(e, t) {
+      if (t === Symbol.iterator || t === "toJSON") return;
+      const s = a.get(t);
+      return s instanceof d.Map ? ee(s) : s;
+    },
+    set(e, t, s) {
+      if (s && typeof s == "object" && !(s instanceof d.Map)) {
+        let n = a.get(t);
+        n instanceof d.Map || (n = new d.Map(), a.set(t, n)), L(n, s);
+      } else
+        a.set(t, s);
+      return !0;
+    },
+    deleteProperty(e, t) {
+      return a.delete(t), !0;
+    },
+    has(e, t) {
+      return a.has(t);
+    },
+    ownKeys() {
+      return Array.from(a.keys());
+    },
+    getOwnPropertyDescriptor(e, t) {
+      if (a.has(t))
+        return { configurable: !0, enumerable: !0, writable: !0, value: a.get(t) };
+    }
+  });
+}
+function ee(a) {
+  return new Proxy({}, {
+    get(e, t) {
+      const s = a.get(t);
+      return s instanceof d.Map ? ee(s) : s instanceof d.Array ? s.toArray() : s;
+    },
+    set(e, t, s) {
+      if (Array.isArray(s)) {
+        const n = new d.Array();
+        n.push(s), a.set(t, n);
+      } else if (s && typeof s == "object") {
+        let n = a.get(t);
+        n instanceof d.Map || (n = new d.Map(), a.set(t, n)), L(n, s);
+      } else
+        a.set(t, s);
+      return !0;
+    },
+    deleteProperty(e, t) {
+      return a.delete(t), !0;
+    },
+    has(e, t) {
+      return a.has(t);
+    },
+    ownKeys() {
+      return Array.from(a.keys());
+    },
+    getOwnPropertyDescriptor(e, t) {
+      if (a.has(t))
+        return { configurable: !0, enumerable: !0, writable: !0, value: a.get(t) };
+    }
+  });
+}
+function L(a, e) {
+  for (const [t, s] of Object.entries(e))
+    if (Array.isArray(s)) {
+      const n = new d.Array();
+      n.push(s), a.set(t, n);
+    } else if (s && typeof s == "object") {
+      let n = a.get(t);
+      n instanceof d.Map || (n = new d.Map(), a.set(t, n)), L(n, s);
+    } else
+      a.set(t, s);
+}
+async function Q() {
+  if (!(!U || !h))
+    try {
+      const a = d.encodeStateAsUpdate(h);
+      await U.save(H, a);
+    } catch (a) {
+      console.error("[yjs-personal-doc] CompactStore save failed:", a);
+    }
+}
+async function X() {
+  if (!(!_ || !j || !h))
+    try {
+      const a = G();
+      if (!(a.profile || Object.keys(a.contacts).length > 0 || Object.keys(a.spaces).length > 0)) {
+        console.debug("[yjs-personal-doc] Skip vault push — no meaningful data yet");
+        return;
+      }
+      const t = d.encodeStateAsUpdate(h);
+      if (!t || t.length === 0) return;
+      const s = await D.encryptChange(
+        t,
+        j,
+        V,
+        0,
+        ""
+      );
+      N++, await _.putSnapshot(V, s.ciphertext, s.nonce, N), console.debug(`[yjs-personal-doc] Vault push: ${t.length}B`);
+    } catch (a) {
+      console.error("[yjs-personal-doc] Vault push failed:", a);
+    }
+}
+async function he() {
+  var a;
+  if (!_ || !j || !h) return !1;
+  try {
+    const e = await _.getChanges(V, 0);
+    if (!e) return !1;
+    if ((a = e.snapshot) != null && a.data) {
+      const t = B(e.snapshot.data), s = t[0], n = t.slice(1, 1 + s), i = t.slice(1 + s), o = await D.decryptChange(
+        { ciphertext: i, nonce: n, spaceId: V, generation: 0, fromDid: "" },
+        j
+      );
+      d.applyUpdate(h, o), N = e.snapshot.upToSeq, console.debug("[yjs-personal-doc] Restored from vault snapshot");
+    }
+    for (const t of e.changes) {
+      const s = B(t.data), n = s[0], i = s.slice(1, 1 + n), o = s.slice(1 + n), r = await D.decryptChange(
+        { ciphertext: o, nonce: i, spaceId: V, generation: 0, fromDid: "" },
+        j
+      );
+      d.applyUpdate(h, r), N = Math.max(N, t.seq);
+    }
+    return e.snapshot !== null || e.changes.length > 0;
+  } catch (e) {
+    return console.debug("[yjs-personal-doc] Vault restore failed:", e), !1;
+  }
+}
+function E() {
+  if (!h) return null;
+  const a = d.encodeStateVector(h);
+  return Array.from(a).join(",");
+}
+function fe() {
+  for (const a of $)
+    try {
+      a();
+    } catch (e) {
+      console.error("[yjs-personal-doc] Listener error:", e);
+    }
+}
+async function Ie(a, e, t, s) {
+  if (h) return G();
+  const n = Date.now(), i = be();
+  i.setImpl("yjs"), De(i), typeof window < "u" && (window.wotDeleteSpace = async (u) => {
+    if (!h) return console.warn("PersonalDoc not loaded");
+    const p = h.getMap("spaces"), l = h.getMap("groupKeys"), g = p.size;
+    h.transact(() => {
+      p.delete(u);
+      for (const w of Array.from(l.keys()))
+        w.startsWith(u + ":") && (l.delete(w), console.log(`Deleted group key ${w}`));
+    }, "local");
+    const m = p.size;
+    console.log(`Deleted space ${u} (spaces: ${g} → ${m})`), await Q(), await X(), console.log("Persisted to CompactStore + Vault");
+  }, window.wotDocSizes = () => {
+    var g;
+    if (!h) return console.warn("PersonalDoc not loaded");
+    const u = ["profile", "contacts", "verifications", "attestations", "attestationMetadata", "spaces", "groupKeys", "outbox"], p = [];
+    for (const m of u) {
+      const w = h.getMap(m);
+      let b = 0;
+      const S = [];
+      for (const [M, I] of w.entries()) {
+        let P = 0;
+        try {
+          P = ((g = JSON.stringify(I)) == null ? void 0 : g.length) ?? 0;
+        } catch {
+          P = 100;
+        }
+        b += P, P > 10240 && S.push({ key: M, sizeKB: (P / 1024).toFixed(1) });
+      }
+      p.push({ map: m, entries: w.size, jsonSizeKB: (b / 1024).toFixed(1) }), S.length > 0 && console.log(`  ${m} large entries:`, S);
+    }
+    const l = d.encodeStateAsUpdate(h).byteLength;
+    return p.push({ map: "TOTAL (binary)", entries: "-", jsonSizeKB: (l / 1024).toFixed(1) }), console.table(p), p;
+  }), h = new d.Doc();
+  let o = "new";
+  s ? (U = s, await U.open()) : (U = new ve(ie), await U.open());
+  const r = Date.now(), c = await U.load(H);
+  if (c && (d.applyUpdate(h, c), o = "compact-store", i.logLoad("compact-store", Date.now() - r, c.length), console.debug("[yjs-personal-doc] Restored from CompactStore")), t && (j = await a.deriveFrameworkKey("personal-doc-v1"), _ = new ae(t, a), o === "new")) {
+    const p = Date.now();
+    if (await he()) {
+      o = "vault";
+      const g = d.encodeStateAsUpdate(h).length;
+      i.logLoad("vault", Date.now() - p, g);
+    }
+  }
+  if (h.getMap("outbox").size > 0) {
+    const u = h, p = d.encodeStateAsUpdate(u).byteLength, l = ["profile", "contacts", "verifications", "attestations", "attestationMetadata", "spaces", "groupKeys"], g = /* @__PURE__ */ new Map();
+    for (const S of l) {
+      const M = u.getMap(S);
+      M.size > 0 && g.set(S, M.toJSON());
+    }
+    const m = new d.Doc();
+    m.transact(() => {
+      for (const [S, M] of g) {
+        const I = m.getMap(S);
+        if (S === "profile")
+          L(I, M);
+        else
+          for (const [P, me] of Object.entries(M)) {
+            const se = new d.Map();
+            I.set(P, se), L(se, me);
+          }
+      }
+    }, "local"), u.destroy(), h = m;
+    const w = d.encodeStateAsUpdate(h).byteLength;
+    console.debug(`[yjs-personal-doc] Migration: rebuilt doc without outbox (${(p / 1024).toFixed(0)}KB → ${(w / 1024).toFixed(0)}KB)`);
+    const b = d.encodeStateAsUpdate(h);
+    if (await U.save(H, b), _ && j)
+      try {
+        const S = await D.encryptChange(
+          b,
+          j,
+          V,
+          0,
+          ""
+        );
+        N++, await _.putSnapshot(V, S.ciphertext, S.nonce, N), console.debug(`[yjs-personal-doc] Migration: vault updated (${(w / 1024).toFixed(0)}KB)`);
+      } catch (S) {
+        console.warn("[yjs-personal-doc] Migration vault push failed:", S);
+      }
+  }
+  if (A = new q({
+    pushFn: Q,
+    getHeadsFn: E,
+    debounceMs: 2e3
+  }), o === "compact-store" && A.setLastPushedHeads(E()), _ && (C = new q({
+    pushFn: X,
+    getHeadsFn: E,
+    debounceMs: 5e3
+  }), o === "vault" && C.setLastPushedHeads(E()), o === "compact-store" && C.pushDebounced()), h.on("update", (u, p) => {
+    if (p !== "local") {
+      const l = h.getMap("outbox");
+      l.size > 0 && h.transact(() => {
+        for (const g of Array.from(l.keys()))
+          l.delete(g);
+      }, "local"), fe(), A == null || A.pushDebounced();
+    }
+  }), e && j) {
+    const u = a.getDid();
+    k = new Ae(h, e, j, u, (p) => a.sign(p)), k.start();
+  }
+  return o === "new" && i.logLoad("new", 0, 0), console.debug(`[yjs-personal-doc] Initialized in ${Date.now() - n}ms (loaded from: ${o})`), G();
+}
+function v() {
+  if (!h) throw new Error("Yjs personal doc not initialized. Call initYjsPersonalDoc() first.");
+  return G();
+}
+function x(a, e) {
+  if (!h) throw new Error("Yjs personal doc not initialized. Call initYjsPersonalDoc() first.");
+  return h.transact(() => {
+    const t = Ke();
+    a(t);
+  }, "local"), fe(), e != null && e.background ? (A == null || A.pushDebounced(), C == null || C.pushDebounced()) : (A == null || A.pushImmediate(), C == null || C.pushImmediate()), G();
+}
+function T(a) {
+  return $.add(a), () => {
+    $.delete(a);
+  };
+}
+async function Ne() {
+  await Q(), await X();
+}
+async function Pe() {
+  return he();
+}
+async function Ce() {
+  k && (k.destroy(), k = null), h == null || h.destroy(), h = null, A && (A.destroy(), A = null), C && (C.destroy(), C = null), U && (U.close(), U = null), _ = null, j = null, N = 0, $.clear();
+}
+async function Fe() {
+  await Ce(), await new Promise((a) => {
+    const e = indexedDB.deleteDatabase(ie);
+    e.onsuccess = () => a(), e.onerror = () => a();
+  });
+}
+class Oe {
+  constructor(e, t) {
+    y(this, "id");
+    y(this, "closed", !1);
+    y(this, "remoteUpdateCallbacks", /* @__PURE__ */ new Set());
+    y(this, "unsubChange", null);
+    this.spaceState = e, this.adapter = t, this.id = e.info.id;
+    const s = (n, i) => {
+      if (i === "remote" && !this.closed)
+        for (const o of this.remoteUpdateCallbacks)
+          try {
+            o();
+          } catch (r) {
+            console.error("[YjsSpaceHandle] Remote update callback error:", r);
+          }
+    };
+    this.spaceState.doc.on("update", s), this.unsubChange = () => this.spaceState.doc.off("update", s), this.spaceState.handles.add(this);
+  }
+  info() {
+    return this.spaceState.info;
+  }
+  getDoc() {
+    return ge(this.spaceState.doc.getMap("data"));
+  }
+  getMeta() {
+    const e = this.spaceState.doc.getMap("_meta");
+    return {
+      name: e.get("name"),
+      description: e.get("description"),
+      image: e.get("image")
+    };
+  }
+  transact(e, t) {
+    this.closed || (this.spaceState.doc.transact(() => {
+      const s = ye(this.spaceState.doc.getMap("data"));
+      e(s);
+    }, "local"), t != null && t.stream ? (this.adapter._scheduleCompactDebounced(this.spaceState), this.adapter._scheduleVaultDebounced(this.spaceState)) : (this.adapter._scheduleCompactImmediate(this.spaceState), this.adapter._scheduleVaultImmediate(this.spaceState)));
+  }
+  onRemoteUpdate(e) {
+    return this.remoteUpdateCallbacks.add(e), () => {
+      this.remoteUpdateCallbacks.delete(e);
+    };
+  }
+  close() {
+    var e;
+    this.closed = !0, (e = this.unsubChange) == null || e.call(this), this.remoteUpdateCallbacks.clear(), this.spaceState.handles.delete(this);
+  }
+}
+function ge(a) {
+  const e = {};
+  return a.forEach((t, s) => {
+    t instanceof d.Map ? e[s] = ge(t) : t instanceof d.Array ? e[s] = t.toArray() : e[s] = t;
+  }), e;
+}
+function ye(a) {
+  return new Proxy({}, {
+    get(e, t) {
+      const s = a.get(t);
+      return s instanceof d.Map ? ye(s) : s instanceof d.Array ? Ue(s) : s;
+    },
+    set(e, t, s) {
+      if (Array.isArray(s)) {
+        const n = new d.Array();
+        n.push(s), a.set(t, n);
+      } else if (s && typeof s == "object") {
+        let n = a.get(t);
+        n instanceof d.Map || (n = new d.Map(), a.set(t, n)), te(n, s);
+      } else
+        a.set(t, s);
+      return !0;
+    },
+    deleteProperty(e, t) {
+      return a.delete(t), !0;
+    },
+    has(e, t) {
+      return a.has(t);
+    },
+    ownKeys() {
+      return Array.from(a.keys());
+    },
+    getOwnPropertyDescriptor(e, t) {
+      if (a.has(t))
+        return { configurable: !0, enumerable: !0, writable: !0, value: a.get(t) };
+    }
+  });
+}
+function Ue(a) {
+  return new Proxy([], {
+    get(e, t) {
+      if (t === "push")
+        return (...i) => (a.push(i), a.length);
+      if (t === "length") return a.length;
+      if (t === Symbol.iterator) return () => a.toArray()[Symbol.iterator]();
+      if (typeof t == "string" && !isNaN(Number(t)))
+        return a.get(Number(t));
+      const s = a.toArray(), n = s[t];
+      return typeof n == "function" ? n.bind(s) : n;
+    }
+  });
+}
+function te(a, e) {
+  for (const [t, s] of Object.entries(e))
+    if (Array.isArray(s)) {
+      const n = new d.Array();
+      n.push(s), a.set(t, n);
+    } else if (s && typeof s == "object") {
+      let n = a.get(t);
+      n instanceof d.Map || (n = new d.Map(), a.set(t, n)), te(n, s);
+    } else
+      a.set(t, s);
+}
+function je(a, e) {
+  const t = a.getMap("data");
+  te(t, e);
+}
+const K = class K {
+  constructor(e) {
+    y(this, "identity");
+    y(this, "messaging");
+    y(this, "groupKeyService");
+    y(this, "metadataStorage");
+    y(this, "compactStore");
+    y(this, "vault");
+    y(this, "spaceFilter");
+    y(this, "spaces", /* @__PURE__ */ new Map());
+    y(this, "spaceListeners", /* @__PURE__ */ new Set());
+    y(this, "memberChangeListeners", /* @__PURE__ */ new Set());
+    y(this, "vaultSchedulers", /* @__PURE__ */ new Map());
+    y(this, "compactSchedulers", /* @__PURE__ */ new Map());
+    y(this, "vaultSeqs", /* @__PURE__ */ new Map());
+    /** Cache 404 responses from Vault to avoid repeated requests for non-existent docs */
+    y(this, "vault404Cache", /* @__PURE__ */ new Map());
+    // 5 minutes
+    y(this, "unsubMessage", null);
+    y(this, "unsubStateChange", null);
+    y(this, "started", !1);
+    y(this, "sentMessageIds", /* @__PURE__ */ new Set());
+    // Buffer for content messages that arrive before the space is known (multi-device timing)
+    y(this, "pendingMessages", /* @__PURE__ */ new Map());
+    // 60s
+    y(this, "flushPersonalDoc");
+    y(this, "refreshPersonalDocFromVault");
+    this.identity = e.identity, this.messaging = e.messaging, this.groupKeyService = e.groupKeyService, this.metadataStorage = e.metadataStorage, this.compactStore = e.compactStore, this.spaceFilter = e.spaceFilter, this.flushPersonalDoc = e.flushPersonalDoc, this.refreshPersonalDocFromVault = e.refreshPersonalDocFromVault, e.vault ? this.vault = e.vault : e.vaultUrl && (this.vault = new ae(e.vaultUrl, e.identity));
+  }
+  async start() {
+    this.started || (this.started = !0, this.unsubMessage = this.messaging.onMessage(async (e) => {
+      if (this.sentMessageIds.has(e.id)) {
+        this.sentMessageIds.delete(e.id);
+        return;
+      }
+      if (e.signature && !await Me(e)) {
+        console.warn("[YjsReplication] Rejected message with invalid signature from", e.fromDid);
+        return;
+      }
+      switch (e.type) {
+        case "content":
+          await this.handleContentMessage(e);
+          break;
+        case "space-invite":
+          await this.handleSpaceInvite(e);
+          break;
+        case "member-update":
+          await this.handleMemberUpdate(e);
+          break;
+        case "group-key-rotation":
+          await this.handleGroupKeyRotation(e);
+          break;
+        case "space-sync-request":
+          await this.handleSpaceSyncRequest(e);
+          break;
+      }
+    }), await this.restoreSpacesFromMetadata(), console.debug(`[YjsReplication] after restoreSpacesFromMetadata: ${this.spaces.size} spaces`, Array.from(this.spaces.keys())), await this._sendFullStateAllSpaces(), console.debug(`[YjsReplication] before _pullAllFromVault: ${this.spaces.size} spaces`), await this._pullAllFromVault(), console.debug(`[YjsReplication] after _pullAllFromVault: ${this.spaces.size} spaces`), "onStateChange" in this.messaging && typeof this.messaging.onStateChange == "function" && (this.unsubStateChange = this.messaging.onStateChange((e) => {
+      e === "connected" && this.started && (this._sendFullStateAllSpaces().catch(() => {
+      }), this._pullAllFromVault().catch(() => {
+      }));
+    })));
+  }
+  async stop() {
+    var e, t, s;
+    (e = this.unsubMessage) == null || e.call(this), this.unsubMessage = null, (t = this.unsubStateChange) == null || t.call(this), this.unsubStateChange = null, this.pendingMessages.clear();
+    for (const [, n] of this.vaultSchedulers) n.destroy();
+    for (const [, n] of this.compactSchedulers) n.destroy();
+    this.vaultSchedulers.clear(), this.compactSchedulers.clear();
+    for (const [, n] of this.spaces) {
+      (s = n.unsubUpdate) == null || s.call(n);
+      for (const i of n.handles) i.close();
+      n.doc.destroy();
+    }
+    this.spaces.clear(), this.started = !1;
+  }
+  getState() {
+    return this.started ? "syncing" : "idle";
+  }
+  async createSpace(e, t, s) {
+    const n = crypto.randomUUID(), i = (/* @__PURE__ */ new Date()).toISOString(), o = this.identity.getDid(), r = {
+      id: n,
+      type: e,
+      name: s == null ? void 0 : s.name,
+      description: s == null ? void 0 : s.description,
+      modules: s == null ? void 0 : s.modules,
+      appTag: s == null ? void 0 : s.appTag,
+      members: [o],
+      createdAt: i
+    }, c = new d.Doc();
+    c.transact(() => {
+      if (je(c, t), s != null && s.name || s != null && s.description || s != null && s.modules) {
+        const l = c.getMap("_meta");
+        s.name && l.set("name", s.name), s.description && l.set("description", s.description), s.modules && l.set("modules", s.modules);
+      }
+    }, "local"), await this.groupKeyService.createKey(n);
+    const f = await this.identity.getEncryptionPublicKeyBytes(), u = {
+      info: r,
+      doc: c,
+      handles: /* @__PURE__ */ new Set(),
+      memberEncryptionKeys: /* @__PURE__ */ new Map([[this.identity.getDid(), f]]),
+      unsubUpdate: null
+    };
+    if (this.spaces.set(n, u), this.setupSpaceSync(u), await this._saveToCompactStore(u), this.metadataStorage) {
+      await this.metadataStorage.saveSpaceMetadata({
+        info: r,
+        documentId: n,
+        documentUrl: `yjs:${n}`,
+        memberEncryptionKeys: {}
+      });
+      const l = this.groupKeyService.getCurrentKey(n), g = this.groupKeyService.getCurrentGeneration(n);
+      l && await this.metadataStorage.saveGroupKey({ spaceId: n, generation: g, key: l });
+    }
+    this.notifySpaceListeners();
+    const p = this.groupKeyService.getCurrentKey(n);
+    if (p) {
+      const l = this.identity.getDid(), g = d.encodeStateAsUpdate(c), m = this.groupKeyService.getCurrentGeneration(n), w = await D.encryptChange(
+        g,
+        p,
+        n,
+        m,
+        l
+      ), b = {
+        spaceId: n,
+        generation: m,
+        ciphertext: Array.from(w.ciphertext),
+        nonce: Array.from(w.nonce)
+      }, S = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "content",
+        fromDid: l,
+        toDid: l,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: JSON.stringify(b),
+        signature: ""
+      }, M = await O(S, (I) => this.identity.sign(I));
+      this.sentMessageIds.add(M.id), setTimeout(() => this.sentMessageIds.delete(M.id), 3e4);
+      try {
+        await this.messaging.send(M);
+      } catch {
+      }
+    }
+    return this._scheduleVaultImmediate(u), r;
+  }
+  async openSpace(e) {
+    const t = this.spaces.get(e);
+    if (!t) throw new Error(`Space ${e} not found`);
+    return this.ensureSchedulers(t), new Oe(t, this);
+  }
+  async getSpace(e) {
+    var t;
+    return ((t = this.spaces.get(e)) == null ? void 0 : t.info) ?? null;
+  }
+  async getSpaces() {
+    return Array.from(this.spaces.values()).map((e) => e.info);
+  }
+  watchSpaces() {
+    let e = Array.from(this.spaces.values()).map((t) => t.info);
+    return {
+      subscribe: (t) => {
+        const s = (n) => {
+          e = n, t(n);
+        };
+        return this.spaceListeners.add(s), () => {
+          this.spaceListeners.delete(s);
+        };
+      },
+      getValue: () => e
+    };
+  }
+  async addMember(e, t, s) {
+    const n = this.spaces.get(e);
+    if (!n) throw new Error(`Space ${e} not found`);
+    const i = this.identity.getDid();
+    n.memberEncryptionKeys.set(t, s), n.info.members.includes(t) || (n.info.members = [...n.info.members, t]);
+    const o = this.groupKeyService.getCurrentKey(e);
+    if (!o) throw new Error(`No group key for space ${e}`);
+    const r = this.groupKeyService.getCurrentGeneration(e), c = await this.identity.encryptForRecipient(o, s), f = d.encodeStateAsUpdate(n.doc), u = await D.encryptChange(f, o, e, r, i), p = {
+      spaceId: e,
+      spaceInfo: n.info,
+      documentUrl: `yjs:${e}`,
+      encryptedGroupKey: {
+        ciphertext: Array.from(c.ciphertext),
+        nonce: Array.from(c.nonce),
+        ephemeralPublicKey: Array.from(c.ephemeralPublicKey)
+      },
+      generation: r,
+      encryptedDoc: {
+        ciphertext: Array.from(u.ciphertext),
+        nonce: Array.from(u.nonce)
+      }
+    }, l = {
+      v: 1,
+      id: crypto.randomUUID(),
+      type: "space-invite",
+      fromDid: i,
+      toDid: t,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      encoding: "json",
+      payload: JSON.stringify(p),
+      signature: ""
+    }, g = await O(l, (m) => this.identity.sign(m));
+    this.sentMessageIds.add(g.id), setTimeout(() => this.sentMessageIds.delete(g.id), 3e4), await this.messaging.send(g), await this.sendMemberUpdate(e, t, "added"), await this.saveSpaceMetadata(n);
+    for (const m of this.memberChangeListeners)
+      m({ spaceId: e, did: t, action: "added" });
+    this.notifySpaceListeners();
+  }
+  async removeMember(e, t) {
+    const s = this.spaces.get(e);
+    if (!s) return;
+    const n = this.identity.getDid();
+    s.memberEncryptionKeys.delete(t), s.info.members = s.info.members.filter((p) => p !== t), await this.groupKeyService.rotateKey(e);
+    const i = this.groupKeyService.getCurrentKey(e), o = this.groupKeyService.getCurrentGeneration(e);
+    this.metadataStorage && await this.metadataStorage.saveGroupKey({
+      spaceId: e,
+      generation: o,
+      key: i
+    }), this.flushPersonalDoc && await this.flushPersonalDoc();
+    for (const [p, l] of s.memberEncryptionKeys) {
+      const g = await this.identity.encryptForRecipient(i, l), m = {
+        spaceId: e,
+        encryptedGroupKey: {
+          ciphertext: Array.from(g.ciphertext),
+          nonce: Array.from(g.nonce),
+          ephemeralPublicKey: Array.from(g.ephemeralPublicKey)
+        },
+        generation: o
+      }, w = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "group-key-rotation",
+        fromDid: this.identity.getDid(),
+        toDid: p,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: JSON.stringify(m),
+        signature: ""
+      }, b = await O(w, (S) => this.identity.sign(S));
+      this.sentMessageIds.add(b.id), setTimeout(() => this.sentMessageIds.delete(b.id), 3e4), await this.messaging.send(b);
+    }
+    const r = o - 1, c = this.groupKeyService.getKeyByGeneration(e, r), f = [...s.info.members, t], u = {
+      spaceId: e,
+      memberDid: t,
+      action: "removed",
+      members: s.info.members
+    };
+    for (const p of f) {
+      if (p === n) continue;
+      let l;
+      if (c) {
+        const w = new TextEncoder().encode(JSON.stringify(u)), b = await D.encryptChange(
+          w,
+          c,
+          e,
+          r,
+          n
+        );
+        l = JSON.stringify({
+          encrypted: !0,
+          spaceId: e,
+          generation: r,
+          ciphertext: Array.from(b.ciphertext),
+          nonce: Array.from(b.nonce)
+        });
+      } else
+        l = JSON.stringify(u);
+      const g = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "member-update",
+        fromDid: n,
+        toDid: p,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: l,
+        signature: ""
+      }, m = await O(g, (w) => this.identity.sign(w));
+      try {
+        await this.messaging.send(m);
+      } catch {
+      }
+    }
+    await this.saveSpaceMetadata(s), this._scheduleVaultImmediate(s);
+    for (const p of this.memberChangeListeners)
+      p({ spaceId: e, did: t, action: "removed" });
+    this.notifySpaceListeners();
+  }
+  onMemberChange(e) {
+    return this.memberChangeListeners.add(e), () => {
+      this.memberChangeListeners.delete(e);
+    };
+  }
+  /** Leave a space: clean up local state, metadata, group keys, compact store */
+  async leaveSpace(e) {
+    var s, n, i;
+    const t = this.spaces.get(e);
+    t && ((s = t.unsubUpdate) == null || s.call(t), t.doc.destroy(), this.spaces.delete(e)), (n = this.vaultSchedulers.get(e)) == null || n.destroy(), this.vaultSchedulers.delete(e), (i = this.compactSchedulers.get(e)) == null || i.destroy(), this.compactSchedulers.delete(e), this.metadataStorage && (await this.metadataStorage.deleteSpaceMetadata(e), await this.metadataStorage.deleteGroupKeys(e)), this.compactStore && "delete" in this.compactStore && await this.compactStore.delete(e), this.vault && await this.vault.deleteDoc(e).catch(() => {
+    }), this.flushPersonalDoc && await this.flushPersonalDoc(), this.notifySpaceListeners();
+  }
+  async requestSync(e) {
+    if (e === "__all__") {
+      await this.restoreSpacesFromMetadata();
+      for (const [t, s] of this.pendingMessages)
+        if (this.spaces.has(t) && s.length > 0) {
+          this.pendingMessages.delete(t);
+          const n = Date.now();
+          for (const { envelope: i, receivedAt: o } of s)
+            n - o < K.PENDING_TTL && await this.handleContentMessage(i).catch(() => {
+            });
+        }
+      await this._pullAllFromVault(), await this._sendFullStateAllSpaces();
+    } else {
+      const t = this.spaces.get(e);
+      t && await this._pullFromVault(t).catch(
+        (s) => console.warn(`[YjsReplication] Vault pull failed for ${e}:`, s)
+      );
+    }
+  }
+  /** Pull from Vault for all spaces with concurrency limit */
+  async _pullAllFromVault() {
+    const e = Array.from(this.spaces.entries());
+    await this._runWithConcurrency(e, async ([t, s]) => {
+      await this._pullFromVault(s).catch(
+        (n) => console.warn(`[YjsReplication] Vault pull failed for ${t}:`, n)
+      );
+    }, K.VAULT_PULL_CONCURRENCY);
+  }
+  /**
+   * Pull the latest snapshot from the Vault and merge into the local Y.Doc.
+   * This ensures multi-device sync even when devices were not online simultaneously.
+   * If decryption fails (missing key after rotation), tries to refresh the PersonalDoc
+   * from the Vault to get the new key, then retries.
+   */
+  async _pullFromVault(e, t = !1) {
+    if (!this.vault) return;
+    const s = this.vault404Cache.get(e.info.id);
+    if (s && Date.now() - s < K.VAULT_404_TTL)
+      return;
+    const n = this.groupKeyService.getCurrentKey(e.info.id);
+    if (!n)
+      return !t && this.refreshPersonalDocFromVault && await this.refreshPersonalDocFromVault() ? (await this._reloadGroupKeys(e.info.id), this._pullFromVault(e, !0)) : void 0;
+    const i = await this.vault.getDocInfo(e.info.id);
+    if (!i) {
+      this.vault404Cache.set(e.info.id, Date.now());
+      return;
+    }
+    if (i.snapshotSeq !== null) {
+      const l = this.vaultSeqs.get(e.info.id) ?? -1;
+      if (i.snapshotSeq === l) return;
+      this.vaultSeqs.set(e.info.id, i.snapshotSeq);
+    }
+    const o = await this.vault.getChanges(e.info.id);
+    if (!o.snapshot) return;
+    const r = B(o.snapshot.data), c = r[0], f = r.slice(1, 1 + c), u = r.slice(1 + c), p = this.groupKeyService.getCurrentGeneration(e.info.id);
+    try {
+      const l = await D.decryptChange({
+        ciphertext: u,
+        nonce: f,
+        spaceId: e.info.id,
+        generation: p,
+        fromDid: this.identity.getDid()
+      }, n);
+      d.applyUpdate(e.doc, l, "remote"), this.vaultSeqs.set(e.info.id, o.snapshot.upToSeq);
+    } catch {
+      if (this.vaultSeqs.delete(e.info.id), !t && this.refreshPersonalDocFromVault && await this.refreshPersonalDocFromVault())
+        return await this._reloadGroupKeys(e.info.id), this._pullFromVault(e, !0);
+    }
+  }
+  /** Reload group keys from metadata storage into the GroupKeyService */
+  async _reloadGroupKeys(e) {
+    if (!this.metadataStorage) return;
+    const t = await this.metadataStorage.loadGroupKeys(e);
+    for (const s of t)
+      this.groupKeyService.importKey(s.spaceId, s.key, s.generation);
+  }
+  /**
+   * Send full Y.Doc state of all spaces to own DID (multi-device sync).
+   * Other devices of the same identity merge the state via Y.applyUpdate.
+   * Analogous to YjsPersonalSyncAdapter.sendFullState().
+   */
+  async _sendFullStateAllSpaces() {
+    const e = this.identity.getDid();
+    for (const [t, s] of this.spaces) {
+      const n = this.groupKeyService.getCurrentKey(t);
+      if (!n) continue;
+      const i = d.encodeStateAsUpdate(s.doc);
+      if (i.length <= 2) continue;
+      const o = this.groupKeyService.getCurrentGeneration(t), r = await D.encryptChange(
+        i,
+        n,
+        t,
+        o,
+        e
+      ), c = {
+        spaceId: t,
+        generation: o,
+        ciphertext: Array.from(r.ciphertext),
+        nonce: Array.from(r.nonce)
+      }, f = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "content",
+        fromDid: e,
+        toDid: e,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: JSON.stringify(c),
+        signature: ""
+      }, u = await O(f, (p) => this.identity.sign(p));
+      this.sentMessageIds.add(u.id), setTimeout(() => this.sentMessageIds.delete(u.id), 3e4);
+      try {
+        await this.messaging.send(u);
+      } catch {
+      }
+    }
+  }
+  getKeyGeneration(e) {
+    return this.groupKeyService.getCurrentGeneration(e);
+  }
+  async updateSpace(e, t) {
+    const s = this.spaces.get(e);
+    if (!s) throw new Error(`Space ${e} not found`);
+    s.doc.transact(() => {
+      const n = s.doc.getMap("_meta");
+      t.name !== void 0 && n.set("name", t.name), t.description !== void 0 && n.set("description", t.description), t.image !== void 0 && n.set("image", t.image), t.modules !== void 0 && n.set("modules", t.modules);
+    }, "local"), this._scheduleCompactImmediate(s), this._scheduleVaultImmediate(s);
+  }
+  // --- Restore from metadata ---
+  async restoreSpacesFromMetadata() {
+    if (!this.metadataStorage) return;
+    const e = await this.metadataStorage.loadAllSpaceMetadata();
+    console.debug(`[YjsReplication] restoreSpacesFromMetadata: ${e.length} spaces from metadata, ${this.spaces.size} already loaded`);
+    for (const s of e) {
+      if (console.debug(`[YjsReplication]   space: ${s.info.id} name=${s.info.name} type=${s.info.type}`), this.spaces.has(s.info.id) || this.spaceFilter && !this.spaceFilter(s.info)) continue;
+      const n = await this.metadataStorage.loadGroupKeys(s.info.id);
+      for (const S of n)
+        this.groupKeyService.importKey(S.spaceId, S.key, S.generation);
+      let i = null;
+      this.compactStore && (i = await this.compactStore.load(s.info.id));
+      const o = !i || i.length <= 2, r = this.groupKeyService.getCurrentKey(s.info.id) !== null, c = s.info.createdAt ? Date.now() - new Date(s.info.createdAt).getTime() : 0;
+      if (!r && o && c > 10 * 6e4) {
+        console.debug(`[YjsReplication] Removing ghost space ${s.info.id} (no key, empty doc, age ${(c / 6e4).toFixed(0)}min)`), await this.metadataStorage.deleteSpaceMetadata(s.info.id), await this.metadataStorage.deleteGroupKeys(s.info.id), this.compactStore && "delete" in this.compactStore && await this.compactStore.delete(s.info.id);
+        continue;
+      }
+      const f = new d.Doc();
+      i && d.applyUpdate(f, i);
+      const u = f.getMap("_meta"), p = u.get("name"), l = u.get("description"), g = u.get("image"), m = u.get("modules");
+      p !== void 0 && (s.info.name = p), l !== void 0 && (s.info.description = l), g !== void 0 && (s.info.image = g), m !== void 0 && (s.info.modules = m);
+      const w = {
+        info: s.info,
+        doc: f,
+        handles: /* @__PURE__ */ new Set(),
+        memberEncryptionKeys: new Map(
+          Object.entries(s.memberEncryptionKeys).map(([S, M]) => [S, new Uint8Array(M)])
+        ),
+        unsubUpdate: null
+      };
+      this.spaces.set(s.info.id, w), this.setupSpaceSync(w);
+      const b = this.pendingMessages.get(s.info.id);
+      if (b) {
+        this.pendingMessages.delete(s.info.id);
+        const S = Date.now();
+        for (const { envelope: M, receivedAt: I } of b)
+          S - I < K.PENDING_TTL && await this.handleContentMessage(M).catch(() => {
+          });
+      }
+      this.sendSpaceSyncRequest(s.info.id).catch(() => {
+      });
+    }
+    const t = Date.now();
+    for (const [s, n] of this.pendingMessages) {
+      const i = n.filter((o) => t - o.receivedAt < K.PENDING_TTL);
+      i.length === 0 ? this.pendingMessages.delete(s) : this.pendingMessages.set(s, i);
+    }
+    this.notifySpaceListeners();
+  }
+  // --- Internal: Encrypted Space Sync ---
+  setupSpaceSync(e) {
+    const t = (i, o) => {
+      o !== "remote" && this.sendEncryptedUpdate(e.info.id, i);
+    };
+    e.doc.on("update", t);
+    const s = e.doc.getMap("_meta"), n = () => {
+      const i = s.get("name"), o = s.get("description"), r = s.get("image");
+      let c = !1;
+      i !== void 0 && i !== e.info.name && (e.info = { ...e.info, name: i }, c = !0), o !== void 0 && o !== e.info.description && (e.info = { ...e.info, description: o }, c = !0), r !== void 0 && r !== e.info.image && (e.info = { ...e.info, image: r }, c = !0);
+      const f = s.get("modules");
+      f !== void 0 && JSON.stringify(f) !== JSON.stringify(e.info.modules) && (e.info = { ...e.info, modules: f }, c = !0), c && (this.saveSpaceMetadata(e), this.notifySpaceListeners());
+    };
+    s.observe(n), e.unsubUpdate = () => {
+      e.doc.off("update", t), s.unobserve(n);
+    };
+  }
+  async sendEncryptedUpdate(e, t) {
+    const s = this.groupKeyService.getCurrentKey(e);
+    if (!s) return;
+    const n = this.groupKeyService.getCurrentGeneration(e), i = this.identity.getDid(), o = await D.encryptChange(t, s, e, n, i), r = {
+      spaceId: e,
+      generation: n,
+      ciphertext: Array.from(o.ciphertext),
+      nonce: Array.from(o.nonce)
+    }, c = this.spaces.get(e);
+    if (c)
+      for (const f of c.info.members) {
+        const u = {
+          v: 1,
+          id: crypto.randomUUID(),
+          type: "content",
+          fromDid: i,
+          toDid: f,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          encoding: "json",
+          payload: JSON.stringify(r),
+          signature: ""
+        }, p = await O(u, (l) => this.identity.sign(l));
+        this.sentMessageIds.add(p.id), setTimeout(() => this.sentMessageIds.delete(p.id), 3e4);
+        try {
+          await this.messaging.send(p);
+        } catch {
+        }
+      }
+  }
+  async handleContentMessage(e) {
+    try {
+      const t = JSON.parse(e.payload), s = t.spaceId, n = this.spaces.get(s);
+      if (!n) {
+        const r = this.pendingMessages.get(s) ?? [];
+        r.push({ envelope: e, receivedAt: Date.now() }), this.pendingMessages.set(s, r);
+        return;
+      }
+      const i = this.groupKeyService.getKeyByGeneration(s, t.generation);
+      if (!i) {
+        const r = this.pendingMessages.get(s) ?? [];
+        r.push({ envelope: e, receivedAt: Date.now() }), this.pendingMessages.set(s, r);
+        return;
+      }
+      const o = await D.decryptChange({
+        ciphertext: new Uint8Array(t.ciphertext),
+        nonce: new Uint8Array(t.nonce),
+        spaceId: s,
+        generation: t.generation,
+        fromDid: e.fromDid
+      }, i);
+      d.applyUpdate(n.doc, o, "remote"), this._scheduleCompactDebounced(n);
+    } catch (t) {
+      console.debug("[YjsReplication] Failed to handle content message:", t);
+    }
+  }
+  async handleSpaceInvite(e) {
+    try {
+      const t = JSON.parse(e.payload), s = t.spaceId, n = await this.identity.decryptForMe({
+        ciphertext: new Uint8Array(t.encryptedGroupKey.ciphertext),
+        nonce: new Uint8Array(t.encryptedGroupKey.nonce),
+        ephemeralPublicKey: new Uint8Array(t.encryptedGroupKey.ephemeralPublicKey)
+      });
+      this.groupKeyService.importKey(s, n, t.generation);
+      const i = await D.decryptChange({
+        ciphertext: new Uint8Array(t.encryptedDoc.ciphertext),
+        nonce: new Uint8Array(t.encryptedDoc.nonce),
+        spaceId: s,
+        generation: t.generation,
+        fromDid: e.fromDid
+      }, n), o = this.spaces.get(s);
+      if (o) {
+        d.applyUpdate(o.doc, i, "remote"), this._scheduleCompactDebounced(o);
+        return;
+      }
+      const r = new d.Doc();
+      d.applyUpdate(r, i, "remote");
+      const c = t.spaceInfo || {
+        id: s,
+        type: "shared",
+        members: [e.fromDid, this.identity.getDid()],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      c.members.includes(this.identity.getDid()) || (c.members = [...c.members, this.identity.getDid()]);
+      const f = r.getMap("_meta"), u = f.get("name"), p = f.get("description"), l = f.get("image");
+      u && (c.name = u), p && (c.description = p), l && (c.image = l);
+      const g = {
+        info: c,
+        doc: r,
+        handles: /* @__PURE__ */ new Set(),
+        memberEncryptionKeys: /* @__PURE__ */ new Map(),
+        unsubUpdate: null
+      };
+      this.spaces.set(s, g), this.setupSpaceSync(g), await this._saveToCompactStore(g), await this.saveSpaceMetadata(g), this.metadataStorage && await this.metadataStorage.saveGroupKey({
+        spaceId: s,
+        generation: t.generation,
+        key: n
+      });
+      const m = this.pendingMessages.get(s);
+      if (m) {
+        this.pendingMessages.delete(s);
+        for (const { envelope: w, receivedAt: b } of m)
+          Date.now() - b < K.PENDING_TTL && await this.handleContentMessage(w).catch(() => {
+          });
+      }
+      this.notifySpaceListeners();
+    } catch (t) {
+      console.debug("[YjsReplication] Failed to handle space invite:", t);
+    }
+  }
+  async handleMemberUpdate(e) {
+    var t, s, n;
+    try {
+      let i = JSON.parse(e.payload);
+      if (i.encrypted && i.ciphertext) {
+        const f = this.groupKeyService.getKeyByGeneration(i.spaceId ?? "", i.generation);
+        if (f) {
+          const u = await D.decryptChange({
+            ciphertext: new Uint8Array(i.ciphertext),
+            nonce: new Uint8Array(i.nonce),
+            spaceId: i.spaceId ?? "",
+            generation: i.generation,
+            fromDid: e.fromDid
+          }, f);
+          i = JSON.parse(new TextDecoder().decode(u));
+        } else {
+          console.debug("[YjsReplication] Cannot decrypt member-update: no key for gen", i.generation);
+          return;
+        }
+      }
+      const o = this.spaces.get(i.spaceId);
+      if (!o) return;
+      if (i.action === "removed") {
+        if (e.fromDid !== o.info.members[0]) {
+          console.warn("[YjsReplication] Rejected member removal from non-creator:", e.fromDid);
+          return;
+        }
+      } else if (!o.info.members.includes(e.fromDid)) {
+        console.warn("[YjsReplication] Rejected member-update from non-member:", e.fromDid);
+        return;
+      }
+      const r = this.identity.getDid();
+      if (i.action === "removed" && i.memberDid === r && i.members && !i.members.includes(r)) {
+        for (const f of o.handles) f.close();
+        (t = o.unsubUpdate) == null || t.call(o), o.doc.destroy(), this.spaces.delete(i.spaceId), (s = this.compactSchedulers.get(i.spaceId)) == null || s.destroy(), this.compactSchedulers.delete(i.spaceId), (n = this.vaultSchedulers.get(i.spaceId)) == null || n.destroy(), this.vaultSchedulers.delete(i.spaceId), this.metadataStorage && (await this.metadataStorage.deleteSpaceMetadata(i.spaceId), await this.metadataStorage.deleteGroupKeys(i.spaceId));
+      } else i.action === "added" && !o.info.members.includes(i.memberDid) ? (o.info.members = [...o.info.members, i.memberDid], await this.saveSpaceMetadata(o)) : i.action === "removed" && (o.info.members = o.info.members.filter((f) => f !== i.memberDid), await this.saveSpaceMetadata(o));
+      for (const f of this.memberChangeListeners)
+        f({ spaceId: i.spaceId, did: i.memberDid, action: i.action });
+      this.notifySpaceListeners();
+    } catch (i) {
+      console.debug("[YjsReplication] Failed to handle member update:", i);
+    }
+  }
+  async handleGroupKeyRotation(e) {
+    try {
+      const t = JSON.parse(e.payload), s = await this.identity.decryptForMe({
+        ciphertext: new Uint8Array(t.encryptedGroupKey.ciphertext),
+        nonce: new Uint8Array(t.encryptedGroupKey.nonce),
+        ephemeralPublicKey: new Uint8Array(t.encryptedGroupKey.ephemeralPublicKey)
+      });
+      this.groupKeyService.importKey(t.spaceId, s, t.generation), this.metadataStorage && await this.metadataStorage.saveGroupKey({
+        spaceId: t.spaceId,
+        generation: t.generation,
+        key: s
+      });
+      const n = this.pendingMessages.get(t.spaceId);
+      if (n && n.length > 0) {
+        this.pendingMessages.delete(t.spaceId);
+        for (const { envelope: i, receivedAt: o } of n)
+          Date.now() - o < K.PENDING_TTL && await this.handleContentMessage(i).catch(() => {
+          });
+      }
+    } catch (t) {
+      console.debug("[YjsReplication] Failed to handle group key rotation:", t);
+    }
+  }
+  /**
+   * Handle sync request from another device: respond with full state for the requested space.
+   */
+  async handleSpaceSyncRequest(e) {
+    try {
+      const s = JSON.parse(e.payload).spaceId, n = this.spaces.get(s);
+      if (!n) return;
+      const i = this.groupKeyService.getCurrentKey(s);
+      if (!i) return;
+      const o = d.encodeStateAsUpdate(n.doc), r = this.groupKeyService.getCurrentGeneration(s), c = this.identity.getDid(), f = await D.encryptChange(
+        o,
+        i,
+        s,
+        r,
+        c
+      ), u = {
+        spaceId: s,
+        generation: r,
+        ciphertext: Array.from(f.ciphertext),
+        nonce: Array.from(f.nonce)
+      }, p = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "content",
+        fromDid: c,
+        toDid: c,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: JSON.stringify(u),
+        signature: ""
+      }, l = await O(p, (g) => this.identity.sign(g));
+      this.sentMessageIds.add(l.id), setTimeout(() => this.sentMessageIds.delete(l.id), 3e4);
+      try {
+        await this.messaging.send(l);
+      } catch {
+      }
+    } catch (t) {
+      console.debug("[YjsReplication] Failed to handle space-sync-request:", t);
+    }
+  }
+  /**
+   * Send a sync request for a specific space to own DID (multi-device).
+   * Other devices that have this space will respond with their full state.
+   */
+  async sendSpaceSyncRequest(e) {
+    const t = this.identity.getDid(), s = {
+      v: 1,
+      id: crypto.randomUUID(),
+      type: "space-sync-request",
+      fromDid: t,
+      toDid: t,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      encoding: "json",
+      payload: JSON.stringify({ spaceId: e }),
+      signature: ""
+    }, n = await O(s, (i) => this.identity.sign(i));
+    this.sentMessageIds.add(n.id), setTimeout(() => this.sentMessageIds.delete(n.id), 3e4);
+    try {
+      await this.messaging.send(n);
+    } catch {
+    }
+  }
+  // --- Persistence ---
+  async _saveToCompactStore(e) {
+    if (!this.compactStore) return;
+    const t = d.encodeStateAsUpdate(e.doc);
+    t.length <= 2 || await this.compactStore.save(e.info.id, t);
+  }
+  async _pushSnapshotToVault(e) {
+    if (!this.vault) return;
+    const t = this.groupKeyService.getCurrentKey(e.info.id);
+    if (!t) return;
+    const s = d.encodeStateAsUpdate(e.doc);
+    if (s.length <= 2) return;
+    const n = this.groupKeyService.getCurrentGeneration(e.info.id), i = await D.encryptChange(
+      s,
+      t,
+      e.info.id,
+      n,
+      this.identity.getDid()
+    ), r = (this.vaultSeqs.get(e.info.id) ?? 0) + 1;
+    await this.vault.putSnapshot(e.info.id, i.ciphertext, i.nonce, r), this.vaultSeqs.set(e.info.id, r), this.vault404Cache.delete(e.info.id);
+  }
+  ensureSchedulers(e) {
+    const t = e.info.id;
+    this.compactSchedulers.has(t) || this.compactSchedulers.set(t, new q({
+      pushFn: () => this._saveToCompactStore(e),
+      getHeadsFn: () => {
+        const s = d.encodeStateVector(e.doc);
+        return Array.from(s).join(",");
+      },
+      debounceMs: 2e3
+    })), this.vault && !this.vaultSchedulers.has(t) && this.vaultSchedulers.set(t, new q({
+      pushFn: () => this._pushSnapshotToVault(e),
+      getHeadsFn: () => {
+        const s = d.encodeStateVector(e.doc);
+        return Array.from(s).join(",");
+      },
+      debounceMs: 5e3
+    }));
+  }
+  // Public for YjsSpaceHandle
+  _scheduleCompactImmediate(e) {
+    var t;
+    this.ensureSchedulers(e), (t = this.compactSchedulers.get(e.info.id)) == null || t.pushImmediate();
+  }
+  _scheduleCompactDebounced(e) {
+    var t;
+    this.ensureSchedulers(e), (t = this.compactSchedulers.get(e.info.id)) == null || t.pushDebounced();
+  }
+  _scheduleVaultImmediate(e) {
+    var t;
+    this.ensureSchedulers(e), (t = this.vaultSchedulers.get(e.info.id)) == null || t.pushImmediate();
+  }
+  _scheduleVaultDebounced(e) {
+    var t;
+    this.ensureSchedulers(e), (t = this.vaultSchedulers.get(e.info.id)) == null || t.pushDebounced();
+  }
+  // --- Helpers ---
+  /** Run async tasks with a concurrency limit */
+  async _runWithConcurrency(e, t, s) {
+    let n = 0;
+    const i = async () => {
+      for (; n < e.length; ) {
+        const o = e[n++];
+        await t(o);
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(s, e.length) }, () => i()));
+  }
+  async sendMemberUpdate(e, t, s) {
+    const n = this.spaces.get(e);
+    if (!n) return;
+    const i = this.identity.getDid(), o = this.groupKeyService.getCurrentKey(e), r = this.groupKeyService.getCurrentGeneration(e), c = { spaceId: e, memberDid: t, action: s };
+    for (const f of n.info.members) {
+      if (f === i || f === t) continue;
+      let u;
+      if (o) {
+        const g = new TextEncoder().encode(JSON.stringify(c)), m = await D.encryptChange(
+          g,
+          o,
+          e,
+          r,
+          i
+        );
+        u = JSON.stringify({
+          encrypted: !0,
+          spaceId: e,
+          generation: r,
+          ciphertext: Array.from(m.ciphertext),
+          nonce: Array.from(m.nonce)
+        });
+      } else
+        u = JSON.stringify(c);
+      const p = {
+        v: 1,
+        id: crypto.randomUUID(),
+        type: "member-update",
+        fromDid: i,
+        toDid: f,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        encoding: "json",
+        payload: u,
+        signature: ""
+      }, l = await O(p, (g) => this.identity.sign(g));
+      try {
+        await this.messaging.send(l);
+      } catch {
+      }
+    }
+  }
+  async saveSpaceMetadata(e) {
+    this.metadataStorage && await this.metadataStorage.saveSpaceMetadata({
+      info: e.info,
+      documentId: e.info.id,
+      documentUrl: `yjs:${e.info.id}`,
+      memberEncryptionKeys: Object.fromEntries(
+        Array.from(e.memberEncryptionKeys.entries()).map(([t, s]) => [t, s])
+      )
+    });
+  }
+  notifySpaceListeners() {
+    const e = Array.from(this.spaces.values()).map((t) => t.info);
+    for (const t of this.spaceListeners)
+      try {
+        t(e);
+      } catch (s) {
+        console.error("[YjsReplication] Space listener error:", s);
+      }
+  }
+};
+// spaceId → timestamp
+y(K, "VAULT_404_TTL", 5 * 6e4), y(K, "PENDING_TTL", 6e4), y(K, "VAULT_PULL_CONCURRENCY", 3);
+let ne = K;
+function z(a) {
+  return {
+    did: a.did,
+    publicKey: a.publicKey,
+    ...a.name != null ? { name: a.name } : {},
+    ...a.avatar != null ? { avatar: a.avatar } : {},
+    ...a.bio != null ? { bio: a.bio } : {},
+    status: a.status,
+    ...a.verifiedAt != null ? { verifiedAt: a.verifiedAt } : {},
+    createdAt: a.createdAt,
+    updatedAt: a.updatedAt
+  };
+}
+function R(a) {
+  return {
+    id: a.id,
+    from: a.fromDid,
+    to: a.toDid,
+    timestamp: a.timestamp,
+    proof: JSON.parse(a.proofJson),
+    ...a.locationJson != null ? { location: JSON.parse(a.locationJson) } : {}
+  };
+}
+function Y(a) {
+  return {
+    id: a.attestationId ?? a.id,
+    from: a.fromDid,
+    to: a.toDid,
+    claim: a.claim,
+    ...a.tagsJson != null ? { tags: JSON.parse(a.tagsJson) } : {},
+    ...a.context != null ? { context: a.context } : {},
+    createdAt: a.createdAt,
+    proof: JSON.parse(a.proofJson)
+  };
+}
+class Je {
+  constructor(e) {
+    y(this, "cachedIdentity", null);
+    this.did = e;
+  }
+  // --- Identity ---
+  async createIdentity(e, t) {
+    const s = (/* @__PURE__ */ new Date()).toISOString(), n = { did: e, profile: t, createdAt: s, updatedAt: s };
+    return x((i) => {
+      var o, r;
+      i.profile = {
+        did: e,
+        name: t.name || null,
+        bio: t.bio || null,
+        avatar: t.avatar || null,
+        offersJson: (o = t.offers) != null && o.length ? JSON.stringify(t.offers) : null,
+        needsJson: (r = t.needs) != null && r.length ? JSON.stringify(t.needs) : null,
+        createdAt: s,
+        updatedAt: s
+      };
+    }), this.cachedIdentity = n, n;
+  }
+  async getIdentity() {
+    if (this.cachedIdentity) return this.cachedIdentity;
+    const e = v();
+    if (!e.profile) return null;
+    const t = this.profileFromDoc(e), s = {
+      did: this.did,
+      profile: t,
+      createdAt: e.profile.createdAt ?? "",
+      updatedAt: e.profile.updatedAt ?? ""
+    };
+    return this.cachedIdentity = s, s;
+  }
+  async updateIdentity(e) {
+    e.updatedAt = (/* @__PURE__ */ new Date()).toISOString(), x((t) => {
+      var s, n, i;
+      t.profile = {
+        did: e.did,
+        name: e.profile.name || null,
+        bio: e.profile.bio || null,
+        avatar: e.profile.avatar || null,
+        offersJson: (s = e.profile.offers) != null && s.length ? JSON.stringify(e.profile.offers) : null,
+        needsJson: (n = e.profile.needs) != null && n.length ? JSON.stringify(e.profile.needs) : null,
+        createdAt: ((i = t.profile) == null ? void 0 : i.createdAt) ?? e.createdAt,
+        updatedAt: e.updatedAt
+      };
+    }), this.cachedIdentity = e;
+  }
+  profileFromDoc(e) {
+    return e.profile ? {
+      name: e.profile.name ?? "",
+      ...e.profile.bio != null ? { bio: e.profile.bio } : {},
+      ...e.profile.avatar != null ? { avatar: e.profile.avatar } : {},
+      ...e.profile.offersJson != null ? { offers: JSON.parse(e.profile.offersJson) } : {},
+      ...e.profile.needsJson != null ? { needs: JSON.parse(e.profile.needsJson) } : {}
+    } : { name: "" };
+  }
+  // --- Contacts ---
+  async addContact(e) {
+    x((t) => {
+      t.contacts[e.did] = {
+        did: e.did,
+        publicKey: e.publicKey,
+        name: e.name || null,
+        avatar: e.avatar || null,
+        bio: e.bio || null,
+        status: e.status,
+        verifiedAt: e.verifiedAt || null,
+        createdAt: e.createdAt,
+        updatedAt: e.updatedAt
+      };
+    });
+  }
+  async getContacts() {
+    const e = v();
+    return Object.values(e.contacts).map(z);
+  }
+  async getContact(e) {
+    const s = v().contacts[e];
+    return s ? z(s) : null;
+  }
+  async updateContact(e) {
+    x((t) => {
+      var s;
+      t.contacts[e.did] = {
+        did: e.did,
+        publicKey: e.publicKey,
+        name: e.name || null,
+        avatar: e.avatar || null,
+        bio: e.bio || null,
+        status: e.status,
+        verifiedAt: e.verifiedAt || null,
+        createdAt: ((s = t.contacts[e.did]) == null ? void 0 : s.createdAt) ?? e.createdAt,
+        updatedAt: e.updatedAt
+      };
+    }, { background: !0 });
+  }
+  async removeContact(e) {
+    x((t) => {
+      delete t.contacts[e];
+    });
+  }
+  // --- Verifications ---
+  async saveVerification(e) {
+    x((t) => {
+      for (const [s, n] of Object.entries(t.verifications))
+        n.fromDid === e.from && n.toDid === e.to && s !== e.id && delete t.verifications[s];
+      t.verifications[e.id] = {
+        id: e.id,
+        fromDid: e.from,
+        toDid: e.to,
+        timestamp: e.timestamp,
+        proofJson: JSON.stringify(e.proof),
+        locationJson: e.location ? JSON.stringify(e.location) : null
+      };
+    });
+  }
+  async getReceivedVerifications() {
+    const e = v();
+    return Object.values(e.verifications).filter((t) => t.toDid === this.did).map(R);
+  }
+  async getAllVerifications() {
+    const e = v();
+    return Object.values(e.verifications).filter((t) => t.fromDid === this.did || t.toDid === this.did).map(R);
+  }
+  async getVerification(e) {
+    const s = v().verifications[e];
+    return s ? R(s) : null;
+  }
+  // --- Attestations ---
+  async saveAttestation(e) {
+    x((t) => {
+      t.attestations[e.id] = {
+        id: e.id,
+        attestationId: e.id,
+        fromDid: e.from,
+        toDid: e.to,
+        claim: e.claim,
+        tagsJson: e.tags ? JSON.stringify(e.tags) : null,
+        context: e.context || null,
+        createdAt: e.createdAt,
+        proofJson: JSON.stringify(e.proof)
+      }, t.attestationMetadata[e.id] || (t.attestationMetadata[e.id] = {
+        attestationId: e.id,
+        accepted: !1,
+        acceptedAt: null,
+        deliveryStatus: null
+      });
+    });
+  }
+  async getReceivedAttestations() {
+    const e = v();
+    return Object.values(e.attestations).filter((t) => t.toDid === this.did).map(Y);
+  }
+  async getAttestation(e) {
+    const s = v().attestations[e];
+    return s ? Y(s) : null;
+  }
+  // --- Attestation Metadata ---
+  async getAttestationMetadata(e) {
+    const s = v().attestationMetadata[e];
+    return s ? {
+      attestationId: s.attestationId,
+      accepted: s.accepted,
+      ...s.acceptedAt != null ? { acceptedAt: s.acceptedAt } : {}
+    } : null;
+  }
+  async setAttestationAccepted(e, t) {
+    x((s) => {
+      s.attestationMetadata[e] ? (s.attestationMetadata[e].accepted = t, s.attestationMetadata[e].acceptedAt = t ? (/* @__PURE__ */ new Date()).toISOString() : null) : s.attestationMetadata[e] = {
+        attestationId: e,
+        accepted: t,
+        acceptedAt: t ? (/* @__PURE__ */ new Date()).toISOString() : null,
+        deliveryStatus: null
+      };
+    });
+  }
+  async setDeliveryStatus(e, t) {
+    x((s) => {
+      s.attestationMetadata[e] ? s.attestationMetadata[e].deliveryStatus = t : s.attestationMetadata[e] = {
+        attestationId: e,
+        accepted: !1,
+        acceptedAt: null,
+        deliveryStatus: t
+      };
+    }, { background: !0 });
+  }
+  async getAllDeliveryStatuses() {
+    const e = v(), t = /* @__PURE__ */ new Map();
+    for (const s of Object.values(e.attestationMetadata))
+      s.deliveryStatus && t.set(s.attestationId, s.deliveryStatus);
+    return t;
+  }
+  // --- Lifecycle ---
+  async init() {
+  }
+  async clear() {
+    this.cachedIdentity = null;
+  }
+  // --- Reactive (ReactiveStorageAdapter) ---
+  watchIdentity() {
+    const e = this.did, t = this, s = () => {
+      const o = v();
+      if (!o.profile) return null;
+      const r = t.profileFromDoc(o), c = t.cachedIdentity;
+      return {
+        did: e,
+        profile: r,
+        createdAt: (c == null ? void 0 : c.createdAt) ?? o.profile.createdAt ?? "",
+        updatedAt: (c == null ? void 0 : c.updatedAt) ?? o.profile.updatedAt ?? ""
+      };
+    };
+    let n = s(), i = JSON.stringify(n == null ? void 0 : n.profile);
+    return {
+      subscribe: (o) => T(() => {
+        const r = s(), c = JSON.stringify(r == null ? void 0 : r.profile);
+        c !== i && (n = r, i = c, n && (t.cachedIdentity = n), o(n));
+      }),
+      getValue: () => n
+    };
+  }
+  watchContacts() {
+    const e = () => {
+      const n = v();
+      return Object.values(n.contacts).map(z);
+    };
+    let t = e(), s = JSON.stringify(t);
+    return {
+      subscribe: (n) => T(() => {
+        const i = e(), o = JSON.stringify(i);
+        o !== s && (t = i, s = o, n(t));
+      }),
+      getValue: () => t
+    };
+  }
+  watchAllVerifications() {
+    const e = this.did, t = () => {
+      const i = v();
+      return Object.values(i.verifications).filter((o) => o.fromDid === e || o.toDid === e).map(R);
+    };
+    let s = t(), n = JSON.stringify(s);
+    return {
+      subscribe: (i) => T(() => {
+        const o = t(), r = JSON.stringify(o);
+        r !== n && (s = o, n = r, i(s));
+      }),
+      getValue: () => s
+    };
+  }
+  watchReceivedVerifications() {
+    const e = this.did, t = () => {
+      const i = v();
+      return Object.values(i.verifications).filter((o) => o.toDid === e).map(R);
+    };
+    let s = t(), n = JSON.stringify(s);
+    return {
+      subscribe: (i) => T(() => {
+        const o = t(), r = JSON.stringify(o);
+        r !== n && (s = o, n = r, i(s));
+      }),
+      getValue: () => s
+    };
+  }
+  watchAllAttestations() {
+    const e = this.did, t = () => {
+      const i = v();
+      return Object.values(i.attestations).filter((o) => o.fromDid === e || o.toDid === e).map(Y);
+    };
+    let s = t(), n = JSON.stringify(s);
+    return {
+      subscribe: (i) => T(() => {
+        const o = t(), r = JSON.stringify(o);
+        r !== n && (s = o, n = r, i(s));
+      }),
+      getValue: () => s
+    };
+  }
+  watchReceivedAttestations() {
+    const e = this.did, t = () => {
+      const i = v();
+      return Object.values(i.attestations).filter((o) => o.toDid === e).map(Y);
+    };
+    let s = t(), n = JSON.stringify(s);
+    return {
+      subscribe: (i) => T(() => {
+        const o = t(), r = JSON.stringify(o);
+        r !== n && (s = o, n = r, i(s));
+      }),
+      getValue: () => s
+    };
+  }
+}
+export {
+  Ae as YjsPersonalSyncAdapter,
+  ne as YjsReplicationAdapter,
+  Je as YjsStorageAdapter,
+  x as changeYjsPersonalDoc,
+  Fe as deleteYjsPersonalDocDB,
+  Ne as flushYjsPersonalDoc,
+  v as getYjsPersonalDoc,
+  Ie as initYjsPersonalDoc,
+  T as onYjsPersonalDocChange,
+  Pe as refreshYjsPersonalDocFromVault,
+  Ce as resetYjsPersonalDoc
+};