dignity.js 0.3.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,26 @@ 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({
+            kind: "update",
+            collection: collectionName,
+            id,
+            expectedVersion: options.expectedVersion,
+            currentVersion: existing.version,
+            phase: "local"
+          });
+          const error = new Error(
+            `Version conflict on ${collectionName}/${id}: expected ${options.expectedVersion}, current ${existing.version}`
+          );
+          error.code = "VERSION_CONFLICT";
+          throw error;
         }
         const operation = {
           opId: this.idGenerator(),
@@ -2990,12 +3072,73 @@ 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);
+      }
+      async updateWithRetry(collectionName, id, patchFn, options = {}) {
+        const maxAttempts = typeof options.maxAttempts === "number" ? options.maxAttempts : 5;
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+          const current = this.read(collectionName, id);
+          if (!current) {
+            throw new Error(`Object ${id} does not exist in ${collectionName}`);
+          }
+          const patch = await patchFn(current);
+          try {
+            return await this.update(collectionName, id, patch, {
+              ...options,
+              expectedVersion: current.version
+            });
+          } catch (error) {
+            if (error.code !== "VERSION_CONFLICT" || attempt === maxAttempts - 1) {
+              throw error;
+            }
+          }
+        }
+        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);
@@ -3023,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,
@@ -3042,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,
@@ -3066,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 });
         }
@@ -3088,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 });
@@ -3100,6 +3316,7 @@ var require_dignity_p2p = __commonJS({
         }, heartbeatIntervalMs);
         this.discoveryRooms.set(normalizedScope, {
           metadata,
+          bootstrapPeerIds,
           heartbeatIntervalMs,
           ttlMs,
           timer
@@ -3180,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);
@@ -3201,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";
@@ -3218,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 });
             });
@@ -3277,6 +3517,56 @@ var require_dignity_p2p = __commonJS({
       isPeerBanned(peerId) {
         return this.getBanInfo(peerId) !== null;
       }
+      emitConflict(details) {
+        this.emit("conflict", details);
+      }
+      restoreRecord(collectionName, record) {
+        if (!record || !record.id) {
+          return false;
+        }
+        const collection = this.getCollection(collectionName);
+        const current = collection.get(record.id);
+        if (current && current.version >= record.version) {
+          return false;
+        }
+        collection.set(record.id, {
+          id: record.id,
+          ownerId: record.ownerId,
+          collaboratorIds: this.normalizeCollaboratorIds(record.collaboratorIds),
+          data: { ...record.data || {} },
+          createdAt: record.createdAt,
+          updatedAt: record.updatedAt,
+          deletedAt: record.deletedAt || null,
+          version: record.version
+        });
+        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;
@@ -3290,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,
@@ -3301,12 +3592,91 @@ 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) {
+          this.emitConflict({
+            kind: operation.kind,
+            collection: operation.collectionName,
+            id: operation.id,
+            expectedVersion: operation.baseVersion,
+            currentVersion: current.version,
+            phase: "remote",
+            operation
+          });
           return false;
         }
         if (operation.kind === "update") {
@@ -3314,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;
       }
     };
@@ -3482,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) {
@@ -10071,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) {
@@ -10098,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";
@@ -10384,6 +10766,364 @@ 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) {
+    var IndexedDBPersistence2 = class {
+      constructor({
+        dbName = "dignity",
+        storeName = "records",
+        collections = null,
+        indexedDB = typeof globalThis !== "undefined" ? globalThis.indexedDB : null
+      } = {}) {
+        this.dbName = dbName;
+        this.storeName = storeName;
+        this.collections = collections;
+        this.indexedDB = indexedDB;
+        this.node = null;
+        this.changeHandler = null;
+      }
+      recordKey(collection, id) {
+        return `${collection}:${id}`;
+      }
+      shouldPersist(collection) {
+        if (!this.collections) {
+          return true;
+        }
+        return this.collections.includes(collection);
+      }
+      openDb() {
+        if (!this.indexedDB) {
+          return Promise.reject(new Error("IndexedDB is not available"));
+        }
+        return new Promise((resolve, reject) => {
+          const request = this.indexedDB.open(this.dbName, 1);
+          request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(this.storeName)) {
+              db.createObjectStore(this.storeName, { keyPath: "key" });
+            }
+          };
+          request.onsuccess = () => resolve(request.result);
+          request.onerror = () => reject(request.error || new Error("Unable to open IndexedDB"));
+        });
+      }
+      runTransaction(mode, handler) {
+        return this.openDb().then((db) => new Promise((resolve, reject) => {
+          const transaction = db.transaction(this.storeName, mode);
+          const store = transaction.objectStore(this.storeName);
+          Promise.resolve(handler(store)).then(resolve).catch(reject);
+          transaction.oncomplete = () => db.close();
+          transaction.onerror = () => reject(transaction.error || new Error("IndexedDB transaction failed"));
+          transaction.onabort = () => reject(transaction.error || new Error("IndexedDB transaction aborted"));
+        }));
+      }
+      serializeRecord(collection, id) {
+        const record = this.node.getCollection(collection).get(id);
+        if (!record) {
+          return null;
+        }
+        return {
+          key: this.recordKey(collection, id),
+          collection,
+          id,
+          ownerId: record.ownerId,
+          collaboratorIds: Array.isArray(record.collaboratorIds) ? [...record.collaboratorIds] : [],
+          data: { ...record.data },
+          createdAt: record.createdAt,
+          updatedAt: record.updatedAt,
+          deletedAt: record.deletedAt,
+          version: record.version
+        };
+      }
+      async persistRecord(collection, id) {
+        if (!this.node || !this.shouldPersist(collection)) {
+          return;
+        }
+        const serialized = this.serializeRecord(collection, id);
+        const key = this.recordKey(collection, id);
+        if (!serialized) {
+          await this.runTransaction("readwrite", (store) => new Promise((resolve, reject) => {
+            const request = store.delete(key);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+          }));
+          return;
+        }
+        await this.runTransaction("readwrite", (store) => new Promise((resolve, reject) => {
+          const request = store.put(serialized);
+          request.onsuccess = () => resolve();
+          request.onerror = () => reject(request.error);
+        }));
+      }
+      persistChange(event) {
+        if (!event || !event.collection || !event.id) {
+          return;
+        }
+        this.persistRecord(event.collection, event.id).catch((error) => {
+          this.node.emit("warning", {
+            type: "persistence-failed",
+            collection: event.collection,
+            id: event.id,
+            error
+          });
+        });
+      }
+      async loadAllRecords() {
+        return this.runTransaction("readonly", (store) => new Promise((resolve, reject) => {
+          const request = store.getAll();
+          request.onsuccess = () => resolve(request.result || []);
+          request.onerror = () => reject(request.error);
+        }));
+      }
+      async hydrate() {
+        if (!this.node) {
+          throw new Error("IndexedDBPersistence requires an attached node before hydrate");
+        }
+        const storedRecords = await this.loadAllRecords();
+        for (const stored of storedRecords) {
+          if (!this.shouldPersist(stored.collection)) {
+            continue;
+          }
+          this.node.restoreRecord(stored.collection, {
+            id: stored.id,
+            ownerId: stored.ownerId,
+            collaboratorIds: stored.collaboratorIds,
+            data: stored.data,
+            createdAt: stored.createdAt,
+            updatedAt: stored.updatedAt,
+            deletedAt: stored.deletedAt,
+            version: stored.version
+          });
+        }
+      }
+      async attach(node) {
+        if (!node) {
+          throw new Error("IndexedDBPersistence.attach requires a DignityP2P node");
+        }
+        this.node = node;
+        await this.hydrate();
+        this.changeHandler = (event) => this.persistChange(event);
+        node.on("change", this.changeHandler);
+      }
+      async detach() {
+        if (this.node && this.changeHandler) {
+          this.node.off("change", this.changeHandler);
+        }
+        this.changeHandler = null;
+        this.node = null;
+      }
+      async clear() {
+        await this.runTransaction("readwrite", (store) => new Promise((resolve, reject) => {
+          const request = store.clear();
+          request.onsuccess = () => resolve();
+          request.onerror = () => reject(request.error);
+        }));
+      }
+    };
+    module2.exports = IndexedDBPersistence2;
+  }
+});
+
 // src/index.js
 var DignityP2P = require_dignity_p2p();
 var createDefaultSignalingPool = require_create_default_signaling_pool();
@@ -10394,6 +11134,11 @@ var {
   InMemoryNetworkHub,
   InMemoryNetworkAdapter
 } = require_in_memory_network();
+var {
+  PeerJSNetworkAdapter,
+  createPeerJSNetworkAdapter
+} = require_peerjs_network();
+var IndexedDBPersistence = require_indexeddb_persistence();
 var {
   DEFAULT_CLOUDFLARE_SIGNALING_URLS,
   DEFAULT_SIGNALING_FALLBACK_URLS
@@ -10412,6 +11157,9 @@ module.exports = {
   PeerJSSignalingProvider,
   InMemoryNetworkHub,
   InMemoryNetworkAdapter,
+  PeerJSNetworkAdapter,
+  createPeerJSNetworkAdapter,
+  IndexedDBPersistence,
   DEFAULT_CLOUDFLARE_SIGNALING_URLS,
   DEFAULT_SIGNALING_FALLBACK_URLS,
   VDF,