dignity.js 0.5.3 → 0.6.0

package/dist/dignity.esm.js

@@ -16,43 +16,6 @@ var __commonJS = (cb, mod) => function __require2() {
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 
-// src/utils/event-emitter.js
-var require_event_emitter = __commonJS({
-  "src/utils/event-emitter.js"(exports, module) {
-    var EventEmitter = class {
-      constructor() {
-        this.handlers = /* @__PURE__ */ new Map();
-      }
-      on(eventName, handler) {
-        if (!this.handlers.has(eventName)) {
-          this.handlers.set(eventName, /* @__PURE__ */ new Set());
-        }
-        this.handlers.get(eventName).add(handler);
-      }
-      off(eventName, handler) {
-        const eventHandlers = this.handlers.get(eventName);
-        if (!eventHandlers) {
-          return;
-        }
-        eventHandlers.delete(handler);
-        if (eventHandlers.size === 0) {
-          this.handlers.delete(eventName);
-        }
-      }
-      emit(eventName, payload) {
-        const eventHandlers = this.handlers.get(eventName);
-        if (!eventHandlers) {
-          return;
-        }
-        for (const handler of eventHandlers) {
-          handler(payload);
-        }
-      }
-    };
-    module.exports = EventEmitter;
-  }
-});
-
 // (disabled):crypto
 var require_crypto = __commonJS({
   "(disabled):crypto"() {
@@ -2349,6 +2312,43 @@ var require_nacl_util = __commonJS({
   }
 });
 
+// src/utils/event-emitter.js
+var require_event_emitter = __commonJS({
+  "src/utils/event-emitter.js"(exports, module) {
+    var EventEmitter = class {
+      constructor() {
+        this.handlers = /* @__PURE__ */ new Map();
+      }
+      on(eventName, handler) {
+        if (!this.handlers.has(eventName)) {
+          this.handlers.set(eventName, /* @__PURE__ */ new Set());
+        }
+        this.handlers.get(eventName).add(handler);
+      }
+      off(eventName, handler) {
+        const eventHandlers = this.handlers.get(eventName);
+        if (!eventHandlers) {
+          return;
+        }
+        eventHandlers.delete(handler);
+        if (eventHandlers.size === 0) {
+          this.handlers.delete(eventName);
+        }
+      }
+      emit(eventName, payload) {
+        const eventHandlers = this.handlers.get(eventName);
+        if (!eventHandlers) {
+          return;
+        }
+        for (const handler of eventHandlers) {
+          handler(payload);
+        }
+      }
+    };
+    module.exports = EventEmitter;
+  }
+});
+
 // src/security/sloth-vdf.js
 var require_sloth_vdf = __commonJS({
   "src/security/sloth-vdf.js"(exports, module) {
@@ -2361,25 +2361,25 @@ var require_sloth_vdf = __commonJS({
         let powBase = base % modulus;
         let powExponent = exponent;
         while (powExponent > 0) {
-          if (powExponent % BigInt(2) === BigInt(1)) {
+          if ((powExponent & BigInt(1)) === BigInt(1)) {
             result = result * powBase % modulus;
           }
-          powExponent = powExponent / BigInt(2);
+          powExponent = powExponent >> BigInt(1);
           powBase = powBase * powBase % modulus;
         }
         return result;
       }
       quadRes(x) {
-        return this.fastPow(x, (_SlothPermutation.p - BigInt(1)) / BigInt(2), _SlothPermutation.p) === BigInt(1);
+        return this.fastPow(x, _SlothPermutation.pHalf, _SlothPermutation.p) === BigInt(1);
       }
       modSqrtOp(x) {
         let y;
         let value = x;
         if (this.quadRes(value)) {
-          y = this.fastPow(value, (_SlothPermutation.p + BigInt(1)) / BigInt(4), _SlothPermutation.p);
+          y = this.fastPow(value, _SlothPermutation.pQuarter, _SlothPermutation.p);
         } else {
           value = (-value + _SlothPermutation.p) % _SlothPermutation.p;
-          y = this.fastPow(value, (_SlothPermutation.p + BigInt(1)) / BigInt(4), _SlothPermutation.p);
+          y = this.fastPow(value, _SlothPermutation.pQuarter, _SlothPermutation.p);
         }
         return y;
       }
@@ -2411,6 +2411,12 @@ var require_sloth_vdf = __commonJS({
     __publicField(_SlothPermutation, "p", BigInt(
       "170082004324204494273811327264862981553264701145937538369570764779791492622392118654022654452947093285873855529044371650895045691292912712699015605832276411308653107069798639938826015099738961427172366594187783204437869906954750443653318078358839409699824714551430573905637228307966826784684174483831608534979"
     ));
+    // precompute values for optimization:
+    // (p - 1) / 2
+    __publicField(_SlothPermutation, "pHalf", _SlothPermutation.p - BigInt(1) >> BigInt(1));
+    // (p + 1) / 4
+    // p ≡ 3 (mod 4) ⇒ (p+1) divisible by 4
+    __publicField(_SlothPermutation, "pQuarter", _SlothPermutation.p + BigInt(1) >> BigInt(2));
     var SlothPermutation = _SlothPermutation;
     module.exports = SlothPermutation;
   }
@@ -2763,8 +2769,14 @@ var require_message_security_service = __commonJS({
           const nonce = naclUtil.decodeBase64(encryption.nonce);
           let key;
           if (encryption.kdf === "pbkdf2") {
-            const iterations = encryption.kdfIterations || DEFAULT_SECURITY_OPTIONS.kdfIterations;
-            key = await deriveBroadcastKey(password, salt, iterations);
+            const configuredIterations = this.options.kdfIterations || DEFAULT_SECURITY_OPTIONS.kdfIterations;
+            const requestedIterations = encryption.kdfIterations || configuredIterations;
+            const minIterations = Math.max(1e3, Math.floor(configuredIterations * 0.1));
+            const maxIterations = configuredIterations * 2;
+            if (requestedIterations < minIterations || requestedIterations > maxIterations) {
+              throw new Error(`Invalid kdfIterations: ${requestedIterations}`);
+            }
+            key = await deriveBroadcastKey(password, salt, requestedIterations);
           } else {
             key = legacyBroadcastKey(password, salt);
           }
@@ -2868,11 +2880,84 @@ var require_message_security_service = __commonJS({
   }
 });
 
+// src/gossip/peer-group.js
+var require_peer_group = __commonJS({
+  "src/gossip/peer-group.js"(exports, module) {
+    var PEER_GROUP_SCOPE_PREFIX = "gossip:";
+    var DEFAULT_PEER_GROUP_OPTIONS = {
+      fanout: 3,
+      maxActivePeers: 8,
+      maxHops: 6,
+      relayEnabled: true
+    };
+    function peerGroupScope(groupId) {
+      if (!groupId) {
+        throw new Error("peerGroupScope requires groupId");
+      }
+      return `${PEER_GROUP_SCOPE_PREFIX}${groupId}`;
+    }
+    function parsePeerGroupScope(scope) {
+      if (!scope || !scope.startsWith(PEER_GROUP_SCOPE_PREFIX)) {
+        return null;
+      }
+      return scope.slice(PEER_GROUP_SCOPE_PREFIX.length);
+    }
+    function shufflePeerIds(peerIds, randomFn = Math.random) {
+      const list = [...peerIds];
+      for (let i = list.length - 1; i > 0; i -= 1) {
+        const j = Math.floor(randomFn() * (i + 1));
+        [list[i], list[j]] = [list[j], list[i]];
+      }
+      return list;
+    }
+    function selectFanoutPeers({
+      peers,
+      count,
+      excludePeerIds = [],
+      connectedPeerIds = [],
+      randomFn = Math.random
+    }) {
+      const excluded = new Set(excludePeerIds.filter(Boolean));
+      const candidates = peers.map((entry) => entry.peerId || entry).filter((peerId) => peerId && !excluded.has(peerId));
+      const connected = new Set(connectedPeerIds.filter(Boolean));
+      const preferred = candidates.filter((peerId) => connected.has(peerId));
+      const others = candidates.filter((peerId) => !connected.has(peerId));
+      const ordered = [
+        ...shufflePeerIds(preferred, randomFn),
+        ...shufflePeerIds(others, randomFn)
+      ];
+      return ordered.slice(0, Math.max(0, count));
+    }
+    module.exports = {
+      PEER_GROUP_SCOPE_PREFIX,
+      DEFAULT_PEER_GROUP_OPTIONS,
+      peerGroupScope,
+      parsePeerGroupScope,
+      shufflePeerIds,
+      selectFanoutPeers
+    };
+  }
+});
+
 // src/core/dignity-p2p.js
 var require_dignity_p2p = __commonJS({
   "src/core/dignity-p2p.js"(exports, module) {
+    var nacl = require_nacl_fast();
+    var naclUtil = require_nacl_util();
     var EventEmitter = require_event_emitter();
-    var { MessageSecurityService } = require_message_security_service();
+    var { MessageSecurityService, stableStringify } = require_message_security_service();
+    var {
+      DEFAULT_PEER_GROUP_OPTIONS,
+      peerGroupScope,
+      selectFanoutPeers
+    } = require_peer_group();
+    function computeContentHash(data) {
+      const canonical = stableStringify(data || {});
+      const bytes = naclUtil.decodeUTF8(canonical);
+      const hash = nacl.hash(bytes);
+      const hex = Array.from(hash, (b) => b.toString(16).padStart(2, "0")).join("");
+      return `sha512:${hex}`;
+    }
     var DignityP2P = class extends EventEmitter {
       constructor({ nodeId, networkAdapter, idGenerator, now, security } = {}) {
         super();
@@ -2898,8 +2983,16 @@ var require_dignity_p2p = __commonJS({
         this.defaultPresenceTtlMs = security && typeof security.presenceTtlMs === "number" ? security.presenceTtlMs : 45e3;
         this.discoveryRooms = /* @__PURE__ */ new Map();
         this.presenceByScope = /* @__PURE__ */ new Map();
+        this.peerGroups = /* @__PURE__ */ new Map();
+        this.seenGossipIds = /* @__PURE__ */ new Map();
+        this.defaultPeerGroupFanout = security && typeof security.peerGroupFanout === "number" ? security.peerGroupFanout : DEFAULT_PEER_GROUP_OPTIONS.fanout;
+        this.defaultPeerGroupMaxActivePeers = security && typeof security.peerGroupMaxActivePeers === "number" ? security.peerGroupMaxActivePeers : DEFAULT_PEER_GROUP_OPTIONS.maxActivePeers;
+        this.defaultGossipMaxHops = security && typeof security.gossipMaxHops === "number" ? security.gossipMaxHops : DEFAULT_PEER_GROUP_OPTIONS.maxHops;
+        this.globalMaxOpenConnections = security && typeof security.globalMaxOpenConnections === "number" ? security.globalMaxOpenConnections : 32;
+        this.gossipIdTtlMs = security && typeof security.gossipIdTtlMs === "number" ? security.gossipIdTtlMs : 5 * 60 * 1e3;
+        this.maxAppliedOperations = security && typeof security.maxAppliedOperations === "number" ? security.maxAppliedOperations : 5e4;
         this.state = /* @__PURE__ */ new Map();
-        this.appliedOperations = /* @__PURE__ */ new Set();
+        this.appliedOperations = /* @__PURE__ */ new Map();
         this.boundMessageHandler = this.handleIncomingMessage.bind(this);
       }
       async start() {
@@ -2907,6 +3000,14 @@ var require_dignity_p2p = __commonJS({
         await this.networkAdapter.start(this.nodeId);
       }
       async stop() {
+        const joinedGroups = Array.from(this.peerGroups.keys());
+        for (const groupId of joinedGroups) {
+          try {
+            await this.leavePeerGroup(groupId);
+          } catch (error) {
+            this.emit("warning", { type: "peer-group-leave-failed", groupId, error });
+          }
+        }
         const joinedScopes = Array.from(this.discoveryRooms.keys());
         for (const scope of joinedScopes) {
           try {
@@ -2931,6 +3032,7 @@ var require_dignity_p2p = __commonJS({
         if (!record || record.deletedAt) {
           return null;
         }
+        const normalizedData = { ...record.data || {} };
         return {
           id: record.id,
           ownerId: record.ownerId,
@@ -2938,7 +3040,8 @@ var require_dignity_p2p = __commonJS({
           createdAt: record.createdAt,
           updatedAt: record.updatedAt,
           version: record.version,
-          data: { ...record.data }
+          hash: record.hash || computeContentHash(normalizedData),
+          data: normalizedData
         };
       }
       canUpdateRecord(record, actorId) {
@@ -3016,7 +3119,7 @@ var require_dignity_p2p = __commonJS({
           ownerId: this.nodeId,
           collaboratorIds,
           timestamp,
-          payload: { ...data }
+          payload: { ...data || {} }
         };
         this.applyOperation(operation);
         await this.broadcastMessage("operation", operation, {
@@ -3253,6 +3356,7 @@ var require_dignity_p2p = __commonJS({
         const connectToPeers = securityContext.connectToPeers;
         if (Array.isArray(connectToPeers) && connectToPeers.length > 0) {
           await this.ensureConnectedToPeers(connectToPeers);
+          await this.enforceConnectionBudget();
         }
         const envelope = await this.securityService.secureOutgoingMessage({
           messageType,
@@ -3260,6 +3364,11 @@ var require_dignity_p2p = __commonJS({
           targetId: null,
           securityContext
         });
+        const fanoutPeerIds = securityContext.fanoutPeerIds;
+        if (Array.isArray(fanoutPeerIds) && fanoutPeerIds.length > 0 && typeof this.networkAdapter.sendToPeers === "function") {
+          await this.networkAdapter.sendToPeers(envelope, fanoutPeerIds);
+          return;
+        }
         await this.networkAdapter.broadcast(envelope);
       }
       async sendDirectMessage(targetId, messageType, payload) {
@@ -3275,8 +3384,280 @@ var require_dignity_p2p = __commonJS({
           payload,
           targetId
         });
+        if (targetId && typeof this.networkAdapter.sendToPeers === "function") {
+          await this.networkAdapter.sendToPeers(envelope, [targetId]);
+          return;
+        }
         await this.networkAdapter.broadcast(envelope);
       }
+      peerGroupScopeFor(groupId) {
+        return peerGroupScope(groupId);
+      }
+      getPeerGroupConfig(groupId) {
+        return this.peerGroups.get(groupId) || null;
+      }
+      listPeerGroupMembers(groupId, options = {}) {
+        return this.listPeers(this.peerGroupScopeFor(groupId), options);
+      }
+      getPeerGroupStats() {
+        const adapter = this.networkAdapter;
+        const openPeerIds = typeof adapter.listOpenPeerIds === "function" ? adapter.listOpenPeerIds() : [];
+        return {
+          joinedGroups: Array.from(this.peerGroups.keys()),
+          seenGossipCount: this.seenGossipIds.size,
+          openConnectionCount: openPeerIds.length,
+          globalMaxOpenConnections: this.globalMaxOpenConnections
+        };
+      }
+      pruneSeenGossip() {
+        const now = this.now();
+        for (const [gossipId, expiresAt] of this.seenGossipIds.entries()) {
+          if (expiresAt <= now) {
+            this.seenGossipIds.delete(gossipId);
+          }
+        }
+      }
+      hasSeenGossip(gossipId) {
+        if (!gossipId) {
+          return false;
+        }
+        this.pruneSeenGossip();
+        return this.seenGossipIds.has(gossipId);
+      }
+      markSeenGossip(gossipId) {
+        if (!gossipId) {
+          return;
+        }
+        this.seenGossipIds.set(gossipId, this.now() + this.gossipIdTtlMs);
+      }
+      listConnectedPeerIds() {
+        if (typeof this.networkAdapter.listOpenPeerIds === "function") {
+          return this.networkAdapter.listOpenPeerIds();
+        }
+        return [];
+      }
+      selectPeerGroupFanout(groupId, count, excludePeerIds = []) {
+        const scope = this.peerGroupScopeFor(groupId);
+        const peers = this.listPeers(scope, { includeSelf: false });
+        return selectFanoutPeers({
+          peers,
+          count,
+          excludePeerIds: [...excludePeerIds, this.nodeId],
+          connectedPeerIds: this.listConnectedPeerIds()
+        });
+      }
+      async enforceConnectionBudget() {
+        const adapter = this.networkAdapter;
+        if (typeof adapter.listOpenPeerIds !== "function" || typeof adapter.disconnectPeer !== "function") {
+          return;
+        }
+        const openPeerIds = adapter.listOpenPeerIds();
+        if (openPeerIds.length <= this.globalMaxOpenConnections) {
+          return;
+        }
+        const excess = openPeerIds.length - this.globalMaxOpenConnections;
+        const toClose = openPeerIds.slice(0, excess);
+        for (const peerId of toClose) {
+          try {
+            await adapter.disconnectPeer(peerId);
+          } catch (error) {
+            this.emit("warning", { type: "peer-disconnect-failed", peerId, error });
+          }
+        }
+      }
+      async joinPeerGroup(groupId, options = {}) {
+        if (!groupId) {
+          throw new Error("joinPeerGroup requires groupId");
+        }
+        const scope = this.peerGroupScopeFor(groupId);
+        const config = {
+          fanout: typeof options.fanout === "number" ? options.fanout : this.defaultPeerGroupFanout,
+          maxActivePeers: typeof options.maxActivePeers === "number" ? options.maxActivePeers : this.defaultPeerGroupMaxActivePeers,
+          maxHops: typeof options.maxHops === "number" ? options.maxHops : this.defaultGossipMaxHops,
+          relayEnabled: options.relayEnabled !== false
+        };
+        await this.joinDiscovery(scope, {
+          metadata: {
+            peerGroup: groupId,
+            ...options.metadata || {}
+          },
+          bootstrapPeerIds: options.bootstrapPeerIds,
+          heartbeatIntervalMs: options.heartbeatIntervalMs,
+          ttlMs: options.ttlMs
+        });
+        this.peerGroups.set(groupId, config);
+        this.emit("peergroupjoined", { groupId, config });
+        return config;
+      }
+      async leavePeerGroup(groupId) {
+        if (!groupId) {
+          return;
+        }
+        const scope = this.peerGroupScopeFor(groupId);
+        await this.leaveDiscovery(scope);
+        this.peerGroups.delete(groupId);
+        this.emit("peergroupleft", { groupId });
+      }
+      async publishToPeerGroup(groupId, innerMessageType, innerPayload, options = {}) {
+        if (!groupId) {
+          throw new Error("publishToPeerGroup requires groupId");
+        }
+        const group = this.peerGroups.get(groupId);
+        if (!group && options.allowUnjoined !== true) {
+          throw new Error(`PeerGroup ${groupId} has not been joined`);
+        }
+        const fanout = typeof options.fanout === "number" ? options.fanout : group ? group.fanout : this.defaultPeerGroupFanout;
+        const maxActivePeers = group ? group.maxActivePeers : this.defaultPeerGroupMaxActivePeers;
+        const maxHop = typeof options.maxHops === "number" ? options.maxHops : group ? group.maxHops : this.defaultGossipMaxHops;
+        const fanoutPeerIds = this.selectPeerGroupFanout(groupId, fanout, [this.nodeId]);
+        if (fanoutPeerIds.length > 0) {
+          await this.ensureConnectedToPeers(fanoutPeerIds.slice(0, maxActivePeers));
+          await this.enforceConnectionBudget();
+        }
+        const gossipId = options.gossipId || this.idGenerator();
+        this.markSeenGossip(gossipId);
+        await this.broadcastMessage("peer-group:gossip", {
+          groupId,
+          gossipId,
+          publisherId: this.nodeId,
+          hop: 0,
+          maxHop,
+          innerMessageType,
+          innerPayload
+        }, {
+          broadcastScope: this.peerGroupScopeFor(groupId),
+          fanoutPeerIds
+        });
+        return { gossipId, fanoutPeerIds };
+      }
+      async publishRecordToPeerGroup(groupId, collectionName, id, options = {}) {
+        const collection = this.getCollection(collectionName);
+        const raw = collection.get(id);
+        if (!raw || raw.deletedAt) {
+          throw new Error(`Object ${id} does not exist in ${collectionName}`);
+        }
+        const record = this.normalizeRecord(raw);
+        return this.publishToPeerGroup(groupId, "record:snapshot", {
+          collectionName,
+          record
+        }, options);
+      }
+      async handlePeerGroupGossip(decrypted) {
+        const payload = decrypted.payload || {};
+        const {
+          groupId,
+          gossipId,
+          publisherId = decrypted.senderId,
+          hop = 0,
+          maxHop: payloadMaxHop,
+          innerMessageType,
+          innerPayload
+        } = payload;
+        if (!groupId || !innerMessageType || !gossipId) {
+          return;
+        }
+        if (!this.peerGroups.has(groupId)) {
+          return;
+        }
+        if (this.hasSeenGossip(gossipId)) {
+          return;
+        }
+        this.markSeenGossip(gossipId);
+        await this.dispatchPeerGroupInnerMessage(innerMessageType, innerPayload, {
+          groupId,
+          senderId: decrypted.senderId,
+          publisherId
+        });
+        const group = this.peerGroups.get(groupId);
+        const configuredMaxHop = group ? group.maxHops : this.defaultGossipMaxHops;
+        const maxHop = typeof payloadMaxHop === "number" ? Math.min(payloadMaxHop, configuredMaxHop) : configuredMaxHop;
+        if (!group || group.relayEnabled === false || hop >= maxHop) {
+          return;
+        }
+        const relayPeers = this.selectPeerGroupFanout(groupId, group.fanout, [
+          decrypted.senderId,
+          this.nodeId
+        ]);
+        if (relayPeers.length === 0) {
+          return;
+        }
+        await this.ensureConnectedToPeers(relayPeers.slice(0, group.maxActivePeers));
+        await this.enforceConnectionBudget();
+        await this.broadcastMessage("peer-group:gossip", {
+          groupId,
+          gossipId,
+          publisherId,
+          hop: hop + 1,
+          maxHop,
+          innerMessageType,
+          innerPayload
+        }, {
+          broadcastScope: this.peerGroupScopeFor(groupId),
+          fanoutPeerIds: relayPeers
+        });
+      }
+      normalizeGossipOperation(operation, publisherId) {
+        if (!operation || !publisherId) {
+          return null;
+        }
+        if (operation.actorId && operation.actorId !== publisherId) {
+          this.emit("warning", {
+            type: "gossip-operation-actor-mismatch",
+            publisherId,
+            actorId: operation.actorId,
+            kind: operation.kind,
+            collection: operation.collectionName,
+            id: operation.id
+          });
+          return null;
+        }
+        const normalized = {
+          ...operation,
+          actorId: publisherId
+        };
+        if (normalized.kind === "create") {
+          normalized.ownerId = publisherId;
+        }
+        return normalized;
+      }
+      async dispatchPeerGroupInnerMessage(innerMessageType, innerPayload, context = {}) {
+        if (innerMessageType === "operation") {
+          const operation = this.normalizeGossipOperation(
+            innerPayload,
+            context.publisherId || context.senderId
+          );
+          if (operation) {
+            this.applyOperation(operation);
+          }
+          return;
+        }
+        if (innerMessageType === "record:snapshot") {
+          const { collectionName, record } = innerPayload || {};
+          if (collectionName && record) {
+            const applied = this.restoreRecord(collectionName, record, {
+              rejectOnHashMismatch: true,
+              rejectOnOwnershipMismatch: true,
+              via: "peer-group"
+            });
+            if (applied) {
+              this.emit("change", {
+                kind: "snapshot",
+                collection: collectionName,
+                id: record.id,
+                via: "peer-group",
+                groupId: context.groupId
+              });
+            }
+          }
+          return;
+        }
+        this.emit("peergroupmessage", {
+          groupId: context.groupId,
+          senderId: context.senderId,
+          type: innerMessageType,
+          payload: innerPayload
+        });
+      }
       getPresenceMap(scope) {
         if (!this.presenceByScope.has(scope)) {
           this.presenceByScope.set(scope, /* @__PURE__ */ new Map());
@@ -3407,6 +3788,13 @@ var require_dignity_p2p = __commonJS({
       }
       async handleIncomingMessage(message) {
         if (message && message.opId && message.kind) {
+          if (this.securityService.options.enabled) {
+            this.emit("messageignored", {
+              reason: "raw-operation-rejected",
+              hint: "Unsigned raw operations are disabled when security is enabled"
+            });
+            return;
+          }
           this.applyOperation(message);
           return;
         }
@@ -3417,9 +3805,6 @@ var require_dignity_p2p = __commonJS({
           });
           return;
         }
-        if (message && message.senderId && message.senderPublicKey) {
-          this.trustPeerPublicKey(message.senderId, message.senderPublicKey);
-        }
         let decrypted;
         try {
           decrypted = await this.securityService.decryptIncomingMessage(message);
@@ -3437,6 +3822,9 @@ var require_dignity_p2p = __commonJS({
         if (!decrypted || decrypted.ignored) {
           return;
         }
+        if (message && message.senderId && message.senderPublicKey) {
+          this.trustPeerPublicKey(message.senderId, message.senderPublicKey);
+        }
         if (decrypted.messageType === "operation") {
           this.applyOperation(decrypted.payload);
           return;
@@ -3460,18 +3848,27 @@ var require_dignity_p2p = __commonJS({
           const payload = decrypted.payload || {};
           const scope = payload.scope || "main";
           const peerId = payload.peerId || decrypted.senderId;
-          if (!peerId) {
+          if (!peerId || peerId !== decrypted.senderId) {
             return;
           }
+          if (!this.discoveryRooms.has(scope)) {
+            return;
+          }
+          const room = this.discoveryRooms.get(scope);
           const presenceMap = this.getPresenceMap(scope);
           const isNewPeerInScope = !presenceMap.has(peerId);
+          const requestedTtl = typeof payload.ttlMs === "number" ? payload.ttlMs : room.ttlMs;
+          const ttlMs = Math.min(requestedTtl, room.ttlMs);
           this.upsertPresence(
             scope,
             peerId,
             payload.metadata || {},
-            payload.ttlMs || this.defaultPresenceTtlMs,
-            payload.announcedAt || this.now()
+            ttlMs,
+            this.now()
           );
+          if (payload.metadata && payload.metadata.publicKey) {
+            this.trustPeerPublicKey(peerId, payload.metadata.publicKey);
+          }
           if (isNewPeerInScope && peerId !== this.nodeId && this.discoveryRooms.has(scope)) {
             if (typeof this.networkAdapter.connectToPeer === "function") {
               Promise.resolve(this.connectToPeer(peerId)).catch((error) => {
@@ -3488,6 +3885,9 @@ var require_dignity_p2p = __commonJS({
           const payload = decrypted.payload || {};
           const scope = payload.scope || "main";
           const peerId = payload.peerId || decrypted.senderId;
+          if (!peerId || peerId !== decrypted.senderId) {
+            return;
+          }
           const map = this.presenceByScope.get(scope);
           if (map && peerId && map.has(peerId)) {
             map.delete(peerId);
@@ -3495,6 +3895,10 @@ var require_dignity_p2p = __commonJS({
           }
           return;
         }
+        if (decrypted.messageType === "peer-group:gossip") {
+          await this.handlePeerGroupGossip(decrypted);
+          return;
+        }
         this.emit("message", {
           senderId: decrypted.senderId,
           targetId: decrypted.targetId,
@@ -3540,7 +3944,7 @@ var require_dignity_p2p = __commonJS({
       emitConflict(details) {
         this.emit("conflict", details);
       }
-      restoreRecord(collectionName, record) {
+      restoreRecord(collectionName, record, options = {}) {
         if (!record || !record.id) {
           return false;
         }
@@ -3549,11 +3953,51 @@ var require_dignity_p2p = __commonJS({
         if (current && current.version >= record.version) {
           return false;
         }
+        const restoredData = { ...record.data || {} };
+        const computedHash = computeContentHash(restoredData);
+        const rejectOnHashMismatch = options.rejectOnHashMismatch === true;
+        const rejectOnOwnershipMismatch = options.rejectOnOwnershipMismatch === true;
+        if (rejectOnOwnershipMismatch && current && record.ownerId && current.ownerId !== record.ownerId) {
+          this.emit("warning", {
+            type: "ownership-mismatch",
+            collection: collectionName,
+            id: record.id,
+            currentOwnerId: current.ownerId,
+            advertisedOwnerId: record.ownerId,
+            via: options.via || null
+          });
+          return false;
+        }
+        if (!record.hash) {
+          const warning = {
+            type: "content-hash-missing",
+            collection: collectionName,
+            id: record.id,
+            via: options.via || null
+          };
+          this.emit("warning", warning);
+          if (rejectOnHashMismatch) {
+            return false;
+          }
+        } else if (record.hash !== computedHash) {
+          this.emit("warning", {
+            type: "content-hash-mismatch",
+            collection: collectionName,
+            id: record.id,
+            advertisedHash: record.hash,
+            computedHash,
+            via: options.via || null
+          });
+          if (rejectOnHashMismatch) {
+            return false;
+          }
+        }
         collection.set(record.id, {
           id: record.id,
           ownerId: record.ownerId,
           collaboratorIds: this.normalizeCollaboratorIds(record.collaboratorIds),
-          data: { ...record.data || {} },
+          data: restoredData,
+          hash: computedHash,
           createdAt: record.createdAt,
           updatedAt: record.updatedAt,
           deletedAt: record.deletedAt || null,
@@ -3571,7 +4015,8 @@ var require_dignity_p2p = __commonJS({
           id: raw.id,
           ownerId: raw.ownerId,
           collaboratorIds: Array.isArray(raw.collaboratorIds) ? [...raw.collaboratorIds] : [],
-          data: { ...raw.data },
+          data: { ...raw.data || {} },
+          hash: raw.hash || computeContentHash(raw.data || {}),
           createdAt: raw.createdAt,
           updatedAt: raw.updatedAt,
           deletedAt: raw.deletedAt || null,
@@ -3587,6 +4032,15 @@ var require_dignity_p2p = __commonJS({
         });
         return record;
       }
+      pruneAppliedOperations() {
+        while (this.appliedOperations.size > this.maxAppliedOperations) {
+          const oldestOpId = this.appliedOperations.keys().next().value;
+          if (!oldestOpId) {
+            break;
+          }
+          this.appliedOperations.delete(oldestOpId);
+        }
+      }
       applyOperation(operation) {
         if (!operation || !operation.opId || this.appliedOperations.has(operation.opId)) {
           return false;
@@ -3601,13 +4055,15 @@ var require_dignity_p2p = __commonJS({
             id: operation.id,
             ownerId: operation.ownerId,
             collaboratorIds: this.normalizeCollaboratorIds(operation.collaboratorIds),
-            data: { ...operation.payload },
+            data: { ...operation.payload || {} },
+            hash: computeContentHash(operation.payload || {}),
             createdAt: operation.timestamp,
             updatedAt: operation.timestamp,
             deletedAt: null,
             version: 1
           });
-          this.appliedOperations.add(operation.opId);
+          this.appliedOperations.set(operation.opId, this.now());
+          this.pruneAppliedOperations();
           this.emit("change", { kind: "create", collection: operation.collectionName, id: operation.id });
           return true;
         }
@@ -3651,7 +4107,8 @@ var require_dignity_p2p = __commonJS({
           }
           current.updatedAt = operation.timestamp;
           current.version += 1;
-          this.appliedOperations.add(operation.opId);
+          this.appliedOperations.set(operation.opId, this.now());
+          this.pruneAppliedOperations();
           this.emit("change", {
             kind: "transfer-ownership",
             collection: operation.collectionName,
@@ -3680,7 +4137,8 @@ var require_dignity_p2p = __commonJS({
           current.deletedAt = operation.timestamp;
           current.updatedAt = operation.timestamp;
           current.version += 1;
-          this.appliedOperations.add(operation.opId);
+          this.appliedOperations.set(operation.opId, this.now());
+          this.pruneAppliedOperations();
           this.emit("change", { kind: "delete", collection: operation.collectionName, id: operation.id });
           return true;
         }
@@ -3704,12 +4162,14 @@ var require_dignity_p2p = __commonJS({
             ...current.data,
             ...operation.payload
           };
+          current.hash = computeContentHash(current.data);
           if (Array.isArray(operation.collaboratorIds) && operation.actorId === current.ownerId) {
             current.collaboratorIds = this.normalizeCollaboratorIds(operation.collaboratorIds);
           }
           current.updatedAt = operation.timestamp;
           current.version += 1;
-          this.appliedOperations.add(operation.opId);
+          this.appliedOperations.set(operation.opId, this.now());
+          this.pruneAppliedOperations();
           this.emit("change", { kind: "update", collection: operation.collectionName, id: operation.id });
           return true;
         }
@@ -3789,6 +4249,14 @@ var require_signaling_pool = __commonJS({
 // src/signaling/websocket-signaling-provider.js
 var require_websocket_signaling_provider = __commonJS({
   "src/signaling/websocket-signaling-provider.js"(exports, module) {
+    function randomBase36(length) {
+      let value = "";
+      while (value.length < length) {
+        const chunk = Math.random().toString(36).slice(2);
+        value += chunk.length > 0 ? chunk : "0";
+      }
+      return value.slice(0, length);
+    }
     var WebSocketSignalingProvider = class {
       constructor({ id, url, WebSocketImpl, priority = 0 }) {
         if (!url) {
@@ -3832,8 +4300,8 @@ var require_websocket_signaling_provider = __commonJS({
         if (!peerJsHostPattern.test(this.url)) {
           return this.url;
         }
-        const connectionId = `dignityjs_${Math.random().toString(36).slice(2, 12)}`;
-        const token = Math.random().toString(36).slice(2, 12);
+        const connectionId = `dignityjs_${randomBase36(10)}`;
+        const token = randomBase36(10);
         const hasQuery = this.url.includes("?");
         const hasId = /[?&]id=/.test(this.url);
         const hasToken = /[?&]token=/.test(this.url);
@@ -10749,6 +11217,16 @@ var require_in_memory_network = __commonJS({
         }
         await Promise.all(deliveries);
       }
+      async sendToPeers(senderId, message, peerIds = []) {
+        const targets = new Set((peerIds || []).filter((peerId) => peerId && peerId !== senderId));
+        const deliveries = [];
+        for (const [nodeId, adapter] of this.adapters.entries()) {
+          if (nodeId !== senderId && targets.has(nodeId)) {
+            deliveries.push(adapter.receive(message));
+          }
+        }
+        await Promise.all(deliveries);
+      }
     };
     var InMemoryNetworkAdapter = class {
       constructor(hub) {
@@ -10758,6 +11236,7 @@ var require_in_memory_network = __commonJS({
         this.hub = hub;
         this.nodeId = null;
         this.messageHandlers = /* @__PURE__ */ new Set();
+        this.connectedPeers = /* @__PURE__ */ new Set();
       }
       async start(nodeId) {
         this.nodeId = nodeId;
@@ -10768,6 +11247,13 @@ var require_in_memory_network = __commonJS({
           this.hub.unregister(this.nodeId);
         }
         this.nodeId = null;
+        this.connectedPeers.clear();
+      }
+      async connectToPeer(remotePeerId) {
+        if (!remotePeerId || remotePeerId === this.nodeId) {
+          return;
+        }
+        this.connectedPeers.add(remotePeerId);
       }
       async broadcast(message) {
         if (!this.nodeId) {
@@ -10775,6 +11261,21 @@ var require_in_memory_network = __commonJS({
         }
         await this.hub.broadcast(this.nodeId, message);
       }
+      async sendToPeers(message, peerIds = []) {
+        if (!this.nodeId) {
+          throw new Error("Network adapter has not been started");
+        }
+        await this.hub.sendToPeers(this.nodeId, message, peerIds);
+      }
+      listOpenPeerIds() {
+        return [...this.connectedPeers];
+      }
+      getOpenConnectionCount() {
+        return this.connectedPeers.size;
+      }
+      isConnectedTo(remotePeerId) {
+        return this.connectedPeers.has(remotePeerId);
+      }
       onMessage(handler) {
         this.messageHandlers.add(handler);
       }
@@ -10953,6 +11454,29 @@ var require_peerjs_network = __commonJS({
         }
         await Promise.all(deliveries);
       }
+      async sendToPeers(message, peerIds = []) {
+        if (!this.peer) {
+          throw new Error("PeerJS network adapter has not been started");
+        }
+        const targets = new Set((peerIds || []).filter(Boolean));
+        if (targets.size === 0) {
+          return;
+        }
+        const deliveries = [];
+        for (const [peerId, connection] of this.connections.entries()) {
+          if (targets.has(peerId) && connection.open) {
+            deliveries.push(connection.send(message));
+          }
+        }
+        await Promise.all(deliveries);
+      }
+      async disconnectPeer(remotePeerId) {
+        const connection = this.connections.get(remotePeerId);
+        if (connection && typeof connection.close === "function") {
+          connection.close();
+        }
+        this.connections.delete(remotePeerId);
+      }
       getOpenConnectionCount() {
         return this.listOpenPeerIds().length;
       }
@@ -11059,6 +11583,7 @@ var require_indexeddb_persistence = __commonJS({
           ownerId: record.ownerId,
           collaboratorIds: Array.isArray(record.collaboratorIds) ? [...record.collaboratorIds] : [],
           data: { ...record.data },
+          hash: record.hash || null,
           createdAt: record.createdAt,
           updatedAt: record.updatedAt,
           deletedAt: record.deletedAt,
@@ -11119,6 +11644,7 @@ var require_indexeddb_persistence = __commonJS({
             ownerId: stored.ownerId,
             collaboratorIds: stored.collaboratorIds,
             data: stored.data,
+            hash: stored.hash || null,
             createdAt: stored.createdAt,
             updatedAt: stored.updatedAt,
             deletedAt: stored.deletedAt,
@@ -11181,6 +11707,13 @@ var require_index = __commonJS({
       MessageSecurityService,
       DEFAULT_SECURITY_OPTIONS
     } = require_message_security_service();
+    var {
+      PEER_GROUP_SCOPE_PREFIX,
+      DEFAULT_PEER_GROUP_OPTIONS,
+      peerGroupScope,
+      parsePeerGroupScope,
+      selectFanoutPeers
+    } = require_peer_group();
     module.exports = {
       DignityP2P,
       createDefaultSignalingPool,
@@ -11197,7 +11730,12 @@ var require_index = __commonJS({
       VDF,
       SlothPermutation,
       MessageSecurityService,
-      DEFAULT_SECURITY_OPTIONS
+      DEFAULT_SECURITY_OPTIONS,
+      PEER_GROUP_SCOPE_PREFIX,
+      DEFAULT_PEER_GROUP_OPTIONS,
+      peerGroupScope,
+      parsePeerGroupScope,
+      selectFanoutPeers
     };
   }
 });