dignity.js 0.5.4 → 0.6.0

package/dist/dignity.esm.js

@@ -2769,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);
           }
@@ -2874,6 +2880,65 @@ 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) {
@@ -2881,6 +2946,11 @@ var require_dignity_p2p = __commonJS({
     var naclUtil = require_nacl_util();
     var EventEmitter = require_event_emitter();
     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);
@@ -2913,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() {
@@ -2922,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 {
@@ -3270,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,
@@ -3277,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) {
@@ -3292,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());
@@ -3424,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;
         }
@@ -3434,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);
@@ -3454,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;
@@ -3477,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) => {
@@ -3505,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);
@@ -3512,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,
@@ -3557,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;
         }
@@ -3568,14 +3955,42 @@ var require_dignity_p2p = __commonJS({
         }
         const restoredData = { ...record.data || {} };
         const computedHash = computeContentHash(restoredData);
-        if (record.hash && record.hash !== computedHash) {
+        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
+            computedHash,
+            via: options.via || null
           });
+          if (rejectOnHashMismatch) {
+            return false;
+          }
         }
         collection.set(record.id, {
           id: record.id,
@@ -3617,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;
@@ -3638,7 +4062,8 @@ var require_dignity_p2p = __commonJS({
             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;
         }
@@ -3682,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,
@@ -3711,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;
         }
@@ -3741,7 +4168,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: "update", collection: operation.collectionName, id: operation.id });
           return true;
         }
@@ -10789,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) {
@@ -10798,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;
@@ -10808,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) {
@@ -10815,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);
       }
@@ -10993,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;
       }
@@ -11223,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,
@@ -11239,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
     };
   }
 });