dignity.js 0.4.0 → 0.5.1

package/dist/dignity.cjs.js

@@ -2914,12 +2914,71 @@ var require_dignity_p2p = __commonJS({
         return {
           id: record.id,
           ownerId: record.ownerId,
+          collaboratorIds: Array.isArray(record.collaboratorIds) ? [...record.collaboratorIds] : [],
           createdAt: record.createdAt,
           updatedAt: record.updatedAt,
           version: record.version,
           data: { ...record.data }
         };
       }
+      canUpdateRecord(record, actorId) {
+        if (!record || !actorId) {
+          return false;
+        }
+        if (record.ownerId === actorId) {
+          return true;
+        }
+        return Array.isArray(record.collaboratorIds) && record.collaboratorIds.includes(actorId);
+      }
+      normalizeCollaboratorIds(collaborators) {
+        if (!Array.isArray(collaborators)) {
+          return [];
+        }
+        return [...new Set(collaborators.filter(Boolean))];
+      }
+      getRecordPeerIds(collectionName, id, options = {}) {
+        const record = options.fromRecord || this.getCollection(collectionName).get(id);
+        if (!record) {
+          return [];
+        }
+        const includeSelf = options.includeSelf === true;
+        const peerIds = [record.ownerId, ...record.collaboratorIds || []];
+        return [...new Set(peerIds.filter(Boolean).filter((peerId) => includeSelf || peerId !== this.nodeId))];
+      }
+      resolveReplicationPeers(collectionName, id, options = {}, hints = {}) {
+        if (options.connectToPeers === false) {
+          return void 0;
+        }
+        if (Array.isArray(options.connectToPeers)) {
+          return options.connectToPeers;
+        }
+        const peerIds = /* @__PURE__ */ new Set();
+        if (hints.fromRecord) {
+          for (const peerId of this.getRecordPeerIds(collectionName, id, {
+            fromRecord: hints.fromRecord,
+            includeSelf: true
+          })) {
+            peerIds.add(peerId);
+          }
+        } else if (id) {
+          for (const peerId of this.getRecordPeerIds(collectionName, id, { includeSelf: true })) {
+            peerIds.add(peerId);
+          }
+        }
+        if (Array.isArray(options.collaborators)) {
+          for (const peerId of this.normalizeCollaboratorIds(options.collaborators)) {
+            peerIds.add(peerId);
+          }
+        }
+        if (Array.isArray(hints.extraPeerIds)) {
+          for (const peerId of hints.extraPeerIds) {
+            if (peerId) {
+              peerIds.add(peerId);
+            }
+          }
+        }
+        return [...peerIds].filter((peerId) => peerId && peerId !== this.nodeId);
+      }
       async create(collectionName, data, options = {}) {
         const collection = this.getCollection(collectionName);
         const id = options.id || this.idGenerator();
@@ -2927,6 +2986,7 @@ var require_dignity_p2p = __commonJS({
           throw new Error(`Object ${id} already exists in ${collectionName}`);
         }
         const timestamp = this.now();
+        const collaboratorIds = this.normalizeCollaboratorIds(options.collaborators);
         const operation = {
           opId: this.idGenerator(),
           kind: "create",
@@ -2934,6 +2994,7 @@ var require_dignity_p2p = __commonJS({
           id,
           actorId: this.nodeId,
           ownerId: this.nodeId,
+          collaboratorIds,
           timestamp,
           payload: { ...data }
         };
@@ -2943,6 +3004,9 @@ var require_dignity_p2p = __commonJS({
             messageType: "operation",
             operation,
             collectionName
+          }),
+          connectToPeers: this.resolveReplicationPeers(collectionName, null, options, {
+            extraPeerIds: options.collaborators
           })
         });
         return this.read(collectionName, id);
@@ -2977,8 +3041,11 @@ var require_dignity_p2p = __commonJS({
         if (!existing || existing.deletedAt) {
           throw new Error(`Object ${id} does not exist in ${collectionName}`);
         }
-        if (existing.ownerId !== this.nodeId) {
-          throw new Error(`Only owner ${existing.ownerId} can update object ${id}`);
+        if (!this.canUpdateRecord(existing, this.nodeId)) {
+          throw new Error(`Only owner ${existing.ownerId} or collaborators can update object ${id}`);
+        }
+        if (options.collaborators !== void 0 && existing.ownerId !== this.nodeId) {
+          throw new Error(`Only owner ${existing.ownerId} can change collaborators on object ${id}`);
         }
         if (typeof options.expectedVersion === "number" && existing.version !== options.expectedVersion) {
           this.emitConflict({
@@ -3005,13 +3072,17 @@ var require_dignity_p2p = __commonJS({
           baseVersion: existing.version,
           payload: { ...partialData }
         };
+        if (options.collaborators !== void 0) {
+          operation.collaboratorIds = this.normalizeCollaboratorIds(options.collaborators);
+        }
         this.applyOperation(operation);
         await this.broadcastMessage("operation", operation, {
           broadcastScope: options.broadcastScope || this.resolveBroadcastScope({
             messageType: "operation",
             operation,
             collectionName
-          })
+          }),
+          connectToPeers: this.resolveReplicationPeers(collectionName, id, options, { fromRecord: existing })
         });
         return this.read(collectionName, id);
       }
@@ -3036,6 +3107,42 @@ var require_dignity_p2p = __commonJS({
         }
         throw new Error(`Unable to update ${collectionName}/${id} after ${maxAttempts} attempts`);
       }
+      async transferOwnership(collectionName, id, newOwnerId, options = {}) {
+        if (!newOwnerId) {
+          throw new Error("newOwnerId is required");
+        }
+        const existing = this.getCollection(collectionName).get(id);
+        if (!existing || existing.deletedAt) {
+          throw new Error(`Object ${id} does not exist in ${collectionName}`);
+        }
+        if (existing.ownerId !== this.nodeId) {
+          throw new Error(`Only owner ${existing.ownerId} can transfer object ${id}`);
+        }
+        const operation = {
+          opId: this.idGenerator(),
+          kind: "transfer-ownership",
+          collectionName,
+          id,
+          actorId: this.nodeId,
+          timestamp: this.now(),
+          baseVersion: existing.version,
+          newOwnerId,
+          keepPreviousOwnerAsCollaborator: options.keepAsCollaborator !== false
+        };
+        this.applyOperation(operation);
+        await this.broadcastMessage("operation", operation, {
+          broadcastScope: options.broadcastScope || this.resolveBroadcastScope({
+            messageType: "operation",
+            operation,
+            collectionName
+          }),
+          connectToPeers: this.resolveReplicationPeers(collectionName, id, options, {
+            fromRecord: existing,
+            extraPeerIds: [newOwnerId]
+          })
+        });
+        return this.read(collectionName, id);
+      }
       async remove(collectionName, id, options = {}) {
         const existing = this.getCollection(collectionName).get(id);
         if (!existing || existing.deletedAt) {
@@ -3059,16 +3166,74 @@ var require_dignity_p2p = __commonJS({
             messageType: "operation",
             operation,
             collectionName
-          })
+          }),
+          connectToPeers: this.resolveReplicationPeers(collectionName, id, options, { fromRecord: existing })
         });
       }
       registerPeerPublicKey(peerId, publicKey) {
         this.securityService.registerPeerPublicKey(peerId, publicKey);
       }
+      trustPeerPublicKey(peerId, publicKey) {
+        if (!peerId || !publicKey) {
+          return false;
+        }
+        try {
+          this.registerPeerPublicKey(peerId, publicKey);
+          return true;
+        } catch (error) {
+          this.emit("warning", { type: "peer-key-trust-failed", peerId, error });
+          return false;
+        }
+      }
+      trustPeerFromMetadata(peerId, metadata) {
+        if (!metadata || !metadata.publicKey) {
+          return false;
+        }
+        return this.trustPeerPublicKey(peerId, metadata.publicKey);
+      }
       getPublicKey() {
         return this.securityService.getPublicKey();
       }
+      async connectToPeer(peerId) {
+        if (!peerId || peerId === this.nodeId) {
+          return null;
+        }
+        if (typeof this.networkAdapter.connectToPeer !== "function") {
+          throw new Error("Network adapter does not support connectToPeer");
+        }
+        return this.networkAdapter.connectToPeer(peerId);
+      }
+      getConnectionStats() {
+        const adapter = this.networkAdapter;
+        if (!adapter) {
+          return { openCount: 0, peerIds: [] };
+        }
+        const peerIds = typeof adapter.listOpenPeerIds === "function" ? adapter.listOpenPeerIds() : [];
+        const openCount = typeof adapter.getOpenConnectionCount === "function" ? adapter.getOpenConnectionCount() : peerIds.length;
+        return { openCount, peerIds };
+      }
+      async ensureConnectedToPeers(peerIds = []) {
+        const normalized = [...new Set((peerIds || []).filter(Boolean))];
+        const results = [];
+        for (const peerId of normalized) {
+          if (peerId === this.nodeId) {
+            continue;
+          }
+          try {
+            await this.connectToPeer(peerId);
+            results.push({ peerId, ok: true });
+          } catch (error) {
+            this.emit("warning", { type: "peer-connect-failed", peerId, error });
+            results.push({ peerId, ok: false, error });
+          }
+        }
+        return results;
+      }
       async broadcastMessage(messageType, payload, securityContext = {}) {
+        const connectToPeers = securityContext.connectToPeers;
+        if (Array.isArray(connectToPeers) && connectToPeers.length > 0) {
+          await this.ensureConnectedToPeers(connectToPeers);
+        }
         const envelope = await this.securityService.secureOutgoingMessage({
           messageType,
           payload,
@@ -3078,6 +3243,13 @@ var require_dignity_p2p = __commonJS({
         await this.networkAdapter.broadcast(envelope);
       }
       async sendDirectMessage(targetId, messageType, payload) {
+        if (targetId) {
+          try {
+            await this.connectToPeer(targetId);
+          } catch (error) {
+            this.emit("warning", { type: "direct-message-connect-failed", targetId, error });
+          }
+        }
         const envelope = await this.securityService.secureOutgoingMessage({
           messageType,
           payload,
@@ -3102,6 +3274,7 @@ var require_dignity_p2p = __commonJS({
           expiresAt: announcedAt + ttlMs
         };
         map.set(peerId, next);
+        this.trustPeerFromMetadata(peerId, next.metadata);
         if (!existing) {
           this.emit("peerdiscovered", { scope, peerId, metadata: next.metadata });
         }
@@ -3124,11 +3297,18 @@ var require_dignity_p2p = __commonJS({
         const normalizedScope = scope || "main";
         const heartbeatIntervalMs = options.heartbeatIntervalMs || this.defaultDiscoveryHeartbeatMs;
         const ttlMs = options.ttlMs || this.defaultPresenceTtlMs;
-        const metadata = options.metadata || {};
+        const metadata = {
+          publicKey: this.getPublicKey(),
+          ...options.metadata || {}
+        };
+        const bootstrapPeerIds = Array.isArray(options.bootstrapPeerIds) ? [...new Set(options.bootstrapPeerIds.filter(Boolean))] : [];
         const existing = this.discoveryRooms.get(normalizedScope);
         if (existing && existing.timer) {
           clearInterval(existing.timer);
         }
+        if (bootstrapPeerIds.length > 0) {
+          await this.ensureConnectedToPeers(bootstrapPeerIds);
+        }
         const timer = setInterval(() => {
           this.announcePresence(normalizedScope).catch((error) => {
             this.emit("warning", { type: "presence-heartbeat-failed", scope: normalizedScope, error });
@@ -3136,6 +3316,7 @@ var require_dignity_p2p = __commonJS({
         }, heartbeatIntervalMs);
         this.discoveryRooms.set(normalizedScope, {
           metadata,
+          bootstrapPeerIds,
           heartbeatIntervalMs,
           ttlMs,
           timer
@@ -3216,6 +3397,9 @@ 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);
@@ -3237,6 +3421,21 @@ var require_dignity_p2p = __commonJS({
           this.applyOperation(decrypted.payload);
           return;
         }
+        if (decrypted.messageType === "record:snapshot") {
+          const payload = decrypted.payload || {};
+          const { collectionName, record } = payload;
+          if (collectionName && record) {
+            const applied = this.restoreRecord(collectionName, record);
+            if (applied) {
+              this.emit("change", {
+                kind: "snapshot",
+                collection: collectionName,
+                id: record.id
+              });
+            }
+          }
+          return;
+        }
         if (decrypted.messageType === "presence:announce") {
           const payload = decrypted.payload || {};
           const scope = payload.scope || "main";
@@ -3254,6 +3453,11 @@ var require_dignity_p2p = __commonJS({
             payload.announcedAt || this.now()
           );
           if (isNewPeerInScope && peerId !== this.nodeId && this.discoveryRooms.has(scope)) {
+            if (typeof this.networkAdapter.connectToPeer === "function") {
+              Promise.resolve(this.connectToPeer(peerId)).catch((error) => {
+                this.emit("warning", { type: "peer-connect-failed", scope, peerId, error });
+              });
+            }
             this.announcePresence(scope).catch((error) => {
               this.emit("warning", { type: "presence-handshake-failed", scope, error });
             });
@@ -3328,6 +3532,7 @@ var require_dignity_p2p = __commonJS({
         collection.set(record.id, {
           id: record.id,
           ownerId: record.ownerId,
+          collaboratorIds: this.normalizeCollaboratorIds(record.collaboratorIds),
           data: { ...record.data || {} },
           createdAt: record.createdAt,
           updatedAt: record.updatedAt,
@@ -3336,6 +3541,32 @@ var require_dignity_p2p = __commonJS({
         });
         return true;
       }
+      async pushRecordSnapshot(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 = {
+          id: raw.id,
+          ownerId: raw.ownerId,
+          collaboratorIds: Array.isArray(raw.collaboratorIds) ? [...raw.collaboratorIds] : [],
+          data: { ...raw.data },
+          createdAt: raw.createdAt,
+          updatedAt: raw.updatedAt,
+          deletedAt: raw.deletedAt || null,
+          version: raw.version
+        };
+        await this.broadcastMessage("record:snapshot", { collectionName, record }, {
+          broadcastScope: options.broadcastScope || this.resolveBroadcastScope({
+            messageType: "record:snapshot",
+            collectionName,
+            id
+          }),
+          connectToPeers: this.resolveReplicationPeers(collectionName, id, options, { fromRecord: raw })
+        });
+        return record;
+      }
       applyOperation(operation) {
         if (!operation || !operation.opId || this.appliedOperations.has(operation.opId)) {
           return false;
@@ -3349,6 +3580,7 @@ var require_dignity_p2p = __commonJS({
           collection.set(operation.id, {
             id: operation.id,
             ownerId: operation.ownerId,
+            collaboratorIds: this.normalizeCollaboratorIds(operation.collaboratorIds),
             data: { ...operation.payload },
             createdAt: operation.timestamp,
             updatedAt: operation.timestamp,
@@ -3360,9 +3592,79 @@ var require_dignity_p2p = __commonJS({
           return true;
         }
         if (!current || current.deletedAt) {
+          if (operation.kind !== "create") {
+            this.emit("warning", {
+              type: "orphan-operation",
+              kind: operation.kind,
+              collection: operation.collectionName,
+              id: operation.id,
+              actorId: operation.actorId,
+              hint: "Peer is missing the record; pushRecordSnapshot from the owner to catch up."
+            });
+          }
           return false;
         }
-        if (operation.actorId !== current.ownerId) {
+        if (operation.kind === "transfer-ownership") {
+          if (operation.actorId !== current.ownerId) {
+            return false;
+          }
+          if (typeof operation.baseVersion === "number" && operation.baseVersion !== current.version) {
+            this.emitConflict({
+              kind: operation.kind,
+              collection: operation.collectionName,
+              id: operation.id,
+              expectedVersion: operation.baseVersion,
+              currentVersion: current.version,
+              phase: "remote",
+              operation
+            });
+            return false;
+          }
+          const previousOwnerId = current.ownerId;
+          current.ownerId = operation.newOwnerId;
+          if (operation.keepPreviousOwnerAsCollaborator !== false) {
+            const collaborators = this.normalizeCollaboratorIds(current.collaboratorIds);
+            if (!collaborators.includes(previousOwnerId)) {
+              collaborators.push(previousOwnerId);
+            }
+            current.collaboratorIds = collaborators.filter((peerId) => peerId !== operation.newOwnerId);
+          }
+          current.updatedAt = operation.timestamp;
+          current.version += 1;
+          this.appliedOperations.add(operation.opId);
+          this.emit("change", {
+            kind: "transfer-ownership",
+            collection: operation.collectionName,
+            id: operation.id,
+            previousOwnerId,
+            newOwnerId: operation.newOwnerId
+          });
+          return true;
+        }
+        if (operation.kind === "delete") {
+          if (operation.actorId !== current.ownerId) {
+            return false;
+          }
+          if (typeof operation.baseVersion === "number" && operation.baseVersion !== current.version) {
+            this.emitConflict({
+              kind: operation.kind,
+              collection: operation.collectionName,
+              id: operation.id,
+              expectedVersion: operation.baseVersion,
+              currentVersion: current.version,
+              phase: "remote",
+              operation
+            });
+            return false;
+          }
+          current.deletedAt = operation.timestamp;
+          current.updatedAt = operation.timestamp;
+          current.version += 1;
+          this.appliedOperations.add(operation.opId);
+          this.emit("change", { kind: "delete", collection: operation.collectionName, id: operation.id });
+          return true;
+        }
+        if (!this.canUpdateRecord(current, operation.actorId)) {
           return false;
         }
         if (typeof operation.baseVersion === "number" && operation.baseVersion !== current.version) {
@@ -3382,20 +3684,15 @@ var require_dignity_p2p = __commonJS({
             ...current.data,
             ...operation.payload
           };
+          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.emit("change", { kind: "update", collection: operation.collectionName, id: operation.id });
           return true;
         }
-        if (operation.kind === "delete") {
-          current.deletedAt = operation.timestamp;
-          current.updatedAt = operation.timestamp;
-          current.version += 1;
-          this.appliedOperations.add(operation.opId);
-          this.emit("change", { kind: "delete", collection: operation.collectionName, id: operation.id });
-          return true;
-        }
         return false;
       }
     };
@@ -3550,6 +3847,28 @@ var require_websocket_signaling_provider = __commonJS({
   }
 });
 
+// src/signaling/parse-peerjs-url.js
+var require_parse_peerjs_url = __commonJS({
+  "src/signaling/parse-peerjs-url.js"(exports2, module2) {
+    function parsePeerJsServerUrl(url) {
+      const parsed = new URL(url);
+      const secure = parsed.protocol === "wss:";
+      const host = parsed.hostname;
+      const port = parsed.port ? Number(parsed.port) : secure ? 443 : 80;
+      const key = parsed.searchParams.get("key") || "peerjs";
+      let path = parsed.pathname || "/";
+      if (path.endsWith("/peerjs")) {
+        path = path.slice(0, -"/peerjs".length) || "/";
+      }
+      if (path !== "/" && !path.endsWith("/")) {
+        path += "/";
+      }
+      return { secure, host, port, path, key };
+    }
+    module2.exports = parsePeerJsServerUrl;
+  }
+});
+
 // node_modules/peerjs-js-binarypack/dist/binarypack.cjs
 var require_binarypack = __commonJS({
   "node_modules/peerjs-js-binarypack/dist/binarypack.cjs"(exports2, module2) {
@@ -10139,6 +10458,7 @@ var require_bundler = __commonJS({
 var require_peerjs_signaling_provider = __commonJS({
   "src/signaling/peerjs-signaling-provider.js"(exports2, module2) {
     var WebSocketSignalingProvider2 = require_websocket_signaling_provider();
+    var parsePeerJsServerUrl = require_parse_peerjs_url();
     var PeerJSSignalingProvider2 = class {
       constructor({ id, url, PeerImpl, WebSocketImpl, priority = 0, connectTimeoutMs = 1e4 }) {
         if (!url) {
@@ -10166,13 +10486,7 @@ var require_peerjs_signaling_provider = __commonJS({
         }
       }
       parsePeerJsServerUrl() {
-        const parsed = new URL(this.url);
-        const secure = parsed.protocol === "wss:";
-        const host = parsed.hostname;
-        const port = parsed.port ? Number(parsed.port) : secure ? 443 : 80;
-        const path = parsed.pathname || "/";
-        const key = parsed.searchParams.get("key") || "peerjs";
-        return { secure, host, port, path, key };
+        return parsePeerJsServerUrl(this.url);
       }
       shouldUseWebSocketFallback() {
         return !this.isCustomPeerImpl && typeof globalThis.RTCPeerConnection !== "function";
@@ -10452,6 +10766,205 @@ var require_in_memory_network = __commonJS({
   }
 });
 
+// src/network/peerjs-network.js
+var require_peerjs_network = __commonJS({
+  "src/network/peerjs-network.js"(exports2, module2) {
+    var { DEFAULT_CLOUDFLARE_SIGNALING_URLS: DEFAULT_CLOUDFLARE_SIGNALING_URLS2 } = require_default_signaling_config();
+    var parsePeerJsServerUrl = require_parse_peerjs_url();
+    function resolvePeerImplementation(PeerImpl) {
+      if (PeerImpl) {
+        return PeerImpl;
+      }
+      try {
+        const peerjs = require_bundler();
+        return peerjs.Peer || peerjs;
+      } catch (error) {
+        return null;
+      }
+    }
+    var PeerJSNetworkAdapter2 = class {
+      constructor({
+        url,
+        urls,
+        PeerImpl,
+        connectTimeoutMs = 12e3
+      } = {}) {
+        this.urls = urls || (url ? [url] : [...DEFAULT_CLOUDFLARE_SIGNALING_URLS2]);
+        this.url = this.urls[0];
+        this.PeerImpl = resolvePeerImplementation(PeerImpl);
+        this.connectTimeoutMs = connectTimeoutMs;
+        this.nodeId = null;
+        this.peer = null;
+        this.connections = /* @__PURE__ */ new Map();
+        this.pendingConnections = /* @__PURE__ */ new Map();
+        this.messageHandlers = /* @__PURE__ */ new Set();
+      }
+      async start(nodeId) {
+        if (!nodeId) {
+          throw new Error("PeerJSNetworkAdapter requires nodeId on start");
+        }
+        if (!this.PeerImpl) {
+          throw new Error("PeerJS implementation is not available");
+        }
+        if (this.peer) {
+          await this.stop();
+        }
+        let lastError;
+        for (const candidateUrl of this.urls) {
+          try {
+            await this.startWithUrl(nodeId, candidateUrl);
+            this.url = candidateUrl;
+            return;
+          } catch (error) {
+            lastError = error;
+          }
+        }
+        throw lastError || new Error("Unable to connect PeerJS network adapter");
+      }
+      async startWithUrl(nodeId, url) {
+        this.nodeId = nodeId;
+        const server = parsePeerJsServerUrl(url);
+        await new Promise((resolve, reject) => {
+          const peer = new this.PeerImpl(nodeId, {
+            host: server.host,
+            port: server.port,
+            path: server.path,
+            secure: server.secure,
+            key: server.key
+          });
+          const timeout = setTimeout(() => {
+            peer.destroy?.();
+            reject(new Error(`Unable to connect PeerJS network adapter to ${url}`));
+          }, this.connectTimeoutMs);
+          peer.on("open", () => {
+            clearTimeout(timeout);
+            this.peer = peer;
+            resolve();
+          });
+          peer.on("connection", (connection) => {
+            this.attachConnectionHandlers(connection);
+          });
+          peer.on("error", (error) => {
+            clearTimeout(timeout);
+            peer.destroy?.();
+            reject(error || new Error(`Unable to connect PeerJS network adapter to ${url}`));
+          });
+        });
+      }
+      attachConnectionHandlers(connection) {
+        const remoteId = connection.peer;
+        if (!remoteId) {
+          return;
+        }
+        this.connections.set(remoteId, connection);
+        connection.on("data", (payload) => {
+          const deliveries = [];
+          for (const handler of this.messageHandlers) {
+            deliveries.push(handler(payload));
+          }
+          return Promise.all(deliveries);
+        });
+        connection.on("close", () => {
+          this.connections.delete(remoteId);
+        });
+      }
+      async connectToPeer(remotePeerId) {
+        if (!remotePeerId || remotePeerId === this.nodeId) {
+          return null;
+        }
+        const existing = this.connections.get(remotePeerId);
+        if (existing && existing.open) {
+          return existing;
+        }
+        if (this.pendingConnections.has(remotePeerId)) {
+          return this.pendingConnections.get(remotePeerId);
+        }
+        if (!this.peer) {
+          throw new Error("PeerJS network adapter has not been started");
+        }
+        const pending = new Promise((resolve, reject) => {
+          const connection = this.peer.connect(remotePeerId, {
+            reliable: true,
+            serialization: "json"
+          });
+          const timeout = setTimeout(() => {
+            reject(new Error(`Unable to connect to peer ${remotePeerId}`));
+          }, this.connectTimeoutMs);
+          connection.on("open", () => {
+            clearTimeout(timeout);
+            this.attachConnectionHandlers(connection);
+            resolve(connection);
+          });
+          connection.on("error", () => {
+            clearTimeout(timeout);
+            reject(new Error(`Unable to connect to peer ${remotePeerId}`));
+          });
+        }).finally(() => {
+          this.pendingConnections.delete(remotePeerId);
+        });
+        this.pendingConnections.set(remotePeerId, pending);
+        return pending;
+      }
+      onMessage(handler) {
+        this.messageHandlers.add(handler);
+      }
+      offMessage(handler) {
+        this.messageHandlers.delete(handler);
+      }
+      async broadcast(message) {
+        if (!this.peer) {
+          throw new Error("PeerJS network adapter has not been started");
+        }
+        const deliveries = [];
+        for (const connection of this.connections.values()) {
+          if (connection.open) {
+            deliveries.push(connection.send(message));
+          }
+        }
+        await Promise.all(deliveries);
+      }
+      getOpenConnectionCount() {
+        return this.listOpenPeerIds().length;
+      }
+      listOpenPeerIds() {
+        const ids = [];
+        for (const [peerId, connection] of this.connections.entries()) {
+          if (connection.open) {
+            ids.push(peerId);
+          }
+        }
+        return ids;
+      }
+      isConnectedTo(remotePeerId) {
+        const connection = this.connections.get(remotePeerId);
+        return Boolean(connection && connection.open);
+      }
+      async stop() {
+        for (const connection of this.connections.values()) {
+          if (typeof connection.close === "function") {
+            connection.close();
+          }
+        }
+        this.connections.clear();
+        this.pendingConnections.clear();
+        if (this.peer && typeof this.peer.destroy === "function") {
+          this.peer.destroy();
+        }
+        this.peer = null;
+        this.nodeId = null;
+      }
+    };
+    function createPeerJSNetworkAdapter2(options = {}) {
+      return new PeerJSNetworkAdapter2(options);
+    }
+    module2.exports = {
+      PeerJSNetworkAdapter: PeerJSNetworkAdapter2,
+      createPeerJSNetworkAdapter: createPeerJSNetworkAdapter2,
+      parsePeerJsServerUrl
+    };
+  }
+});
+
 // src/persistence/indexeddb-persistence.js
 var require_indexeddb_persistence = __commonJS({
   "src/persistence/indexeddb-persistence.js"(exports2, module2) {
@@ -10514,6 +11027,7 @@ var require_indexeddb_persistence = __commonJS({
           collection,
           id,
           ownerId: record.ownerId,
+          collaboratorIds: Array.isArray(record.collaboratorIds) ? [...record.collaboratorIds] : [],
           data: { ...record.data },
           createdAt: record.createdAt,
           updatedAt: record.updatedAt,
@@ -10573,6 +11087,7 @@ var require_indexeddb_persistence = __commonJS({
           this.node.restoreRecord(stored.collection, {
             id: stored.id,
             ownerId: stored.ownerId,
+            collaboratorIds: stored.collaboratorIds,
             data: stored.data,
             createdAt: stored.createdAt,
             updatedAt: stored.updatedAt,
@@ -10619,6 +11134,10 @@ var {
   InMemoryNetworkHub,
   InMemoryNetworkAdapter
 } = require_in_memory_network();
+var {
+  PeerJSNetworkAdapter,
+  createPeerJSNetworkAdapter
+} = require_peerjs_network();
 var IndexedDBPersistence = require_indexeddb_persistence();
 var {
   DEFAULT_CLOUDFLARE_SIGNALING_URLS,
@@ -10638,6 +11157,8 @@ module.exports = {
   PeerJSSignalingProvider,
   InMemoryNetworkHub,
   InMemoryNetworkAdapter,
+  PeerJSNetworkAdapter,
+  createPeerJSNetworkAdapter,
   IndexedDBPersistence,
   DEFAULT_CLOUDFLARE_SIGNALING_URLS,
   DEFAULT_SIGNALING_FALLBACK_URLS,