@quilibrium/quorum-shared 2.1.0-1 → 2.1.0-2

package/dist/index.d.mts

@@ -2133,7 +2133,8 @@ declare function computeMemberHash(member: SpaceMember): {
 };
 /**
  * Compute manifest hash for quick comparison.
- * Hash of sorted message IDs.
+ * Uses XOR of SHA-256 hashes of message IDs for O(1) incremental updates.
+ * XOR is order-independent, so same message set = same hash regardless of order.
  */
 declare function computeManifestHash(digests: MessageDigest[]): string;
 /**
@@ -2283,27 +2284,51 @@ declare class SyncService {
      */
     private getPayloadCache;
     /**
-     * Build the payload cache from messages and members
+     * Hash a message ID to bytes for XOR-based manifest hash
+     */
+    private hashMessageId;
+    /**
+     * XOR hash bytes into the accumulator - O(1)
+     */
+    private xorIntoHash;
+    /**
+     * Build the payload cache from messages and members - O(n) initial build
      */
     private buildPayloadCache;
     /**
-     * Rebuild derived fields (manifest, digests, summary) from the maps
+     * Get manifest hash as hex string - O(1)
+     */
+    private getManifestHash;
+    /**
+     * Get the manifest from cache - builds it on demand
      */
-    private rebuildPayloadCache;
+    private getManifest;
+    /**
+     * Get the summary from cache - O(1)
+     */
+    private getSummary;
+    /**
+     * Get member digests from cache - O(m)
+     */
+    private getMemberDigests;
     /**
      * Invalidate cache for a space/channel (forces reload from storage on next access)
      */
     invalidateCache(spaceId: string, channelId?: string): void;
     /**
-     * Update cache with a new/updated message (incremental update - no storage query)
+     * Update cache with a new/updated message - O(1) incremental update
      */
     updateCacheWithMessage(spaceId: string, channelId: string, message: Message): void;
     /**
-     * Remove a message from cache (incremental update - no storage query)
+     * Remove a message from cache - O(1) for removal, but may need O(n) for timestamp recalc
      */
     removeCacheMessage(spaceId: string, channelId: string, messageId: string): void;
     /**
-     * Update cache with a new/updated member (incremental update - no storage query)
+     * Recalculate timestamps from scratch - O(n), only called when necessary
+     */
+    private recalculateTimestamps;
+    /**
+     * Update cache with a new/updated member - O(1) incremental update
      */
     updateCacheWithMember(spaceId: string, channelId: string, member: SpaceMember): void;
     /**

package/dist/index.d.ts

@@ -2133,7 +2133,8 @@ declare function computeMemberHash(member: SpaceMember): {
 };
 /**
  * Compute manifest hash for quick comparison.
- * Hash of sorted message IDs.
+ * Uses XOR of SHA-256 hashes of message IDs for O(1) incremental updates.
+ * XOR is order-independent, so same message set = same hash regardless of order.
  */
 declare function computeManifestHash(digests: MessageDigest[]): string;
 /**
@@ -2283,27 +2284,51 @@ declare class SyncService {
      */
     private getPayloadCache;
     /**
-     * Build the payload cache from messages and members
+     * Hash a message ID to bytes for XOR-based manifest hash
+     */
+    private hashMessageId;
+    /**
+     * XOR hash bytes into the accumulator - O(1)
+     */
+    private xorIntoHash;
+    /**
+     * Build the payload cache from messages and members - O(n) initial build
      */
     private buildPayloadCache;
     /**
-     * Rebuild derived fields (manifest, digests, summary) from the maps
+     * Get manifest hash as hex string - O(1)
+     */
+    private getManifestHash;
+    /**
+     * Get the manifest from cache - builds it on demand
      */
-    private rebuildPayloadCache;
+    private getManifest;
+    /**
+     * Get the summary from cache - O(1)
+     */
+    private getSummary;
+    /**
+     * Get member digests from cache - O(m)
+     */
+    private getMemberDigests;
     /**
      * Invalidate cache for a space/channel (forces reload from storage on next access)
      */
     invalidateCache(spaceId: string, channelId?: string): void;
     /**
-     * Update cache with a new/updated message (incremental update - no storage query)
+     * Update cache with a new/updated message - O(1) incremental update
      */
     updateCacheWithMessage(spaceId: string, channelId: string, message: Message): void;
     /**
-     * Remove a message from cache (incremental update - no storage query)
+     * Remove a message from cache - O(1) for removal, but may need O(n) for timestamp recalc
      */
     removeCacheMessage(spaceId: string, channelId: string, messageId: string): void;
     /**
-     * Update cache with a new/updated member (incremental update - no storage query)
+     * Recalculate timestamps from scratch - O(n), only called when necessary
+     */
+    private recalculateTimestamps;
+    /**
+     * Update cache with a new/updated member - O(1) incremental update
      */
     updateCacheWithMember(spaceId: string, channelId: string, member: SpaceMember): void;
     /**

package/dist/index.js

@@ -1917,13 +1917,18 @@ function computeMemberHash(member) {
   const iconHash = computeHash(member.profile_image || "");
   return { displayNameHash, iconHash };
 }
+function xorBuffers(a, b) {
+  for (let i = 0; i < 32; i++) {
+    a[i] ^= b[i];
+  }
+}
 function computeManifestHash(digests) {
-  if (digests.length === 0) {
-    return computeHash("");
+  const result = new Uint8Array(32);
+  for (const digest of digests) {
+    const idHash = (0, import_sha2.sha256)(new TextEncoder().encode(digest.messageId));
+    xorBuffers(result, idHash);
   }
-  const sorted = [...digests].sort((a, b) => a.messageId.localeCompare(b.messageId));
-  const ids = sorted.map((d) => d.messageId).join(":");
-  return computeHash(ids);
+  return bytesToHex(result);
 }
 function createMessageDigest(message) {
   return {
@@ -2153,6 +2158,7 @@ function createSyncSummary(messages, memberCount) {
 }
 
 // src/sync/service.ts
+var import_sha22 = require("@noble/hashes/sha2");
 var SyncService = class {
   constructor(config2) {
     /** Active sync sessions by spaceId */
@@ -2192,25 +2198,96 @@ var SyncService = class {
     return payload;
   }
   /**
-   * Build the payload cache from messages and members
+   * Hash a message ID to bytes for XOR-based manifest hash
+   */
+  hashMessageId(messageId) {
+    return (0, import_sha22.sha256)(new TextEncoder().encode(messageId));
+  }
+  /**
+   * XOR hash bytes into the accumulator - O(1)
+   */
+  xorIntoHash(accumulator, hash) {
+    for (let i = 0; i < 32; i++) {
+      accumulator[i] ^= hash[i];
+    }
+  }
+  /**
+   * Build the payload cache from messages and members - O(n) initial build
    */
   buildPayloadCache(spaceId, channelId, messages, members) {
     const messageMap = new Map(messages.map((m) => [m.messageId, m]));
     const memberMap = new Map(members.map((m) => [m.address, m]));
-    const manifest = createManifest(spaceId, channelId, messages);
-    const memberDigests = members.map(createMemberDigest);
-    const summary = createSyncSummary(messages, members.length);
-    return { manifest, memberDigests, summary, messageMap, memberMap };
+    const digestMap = new Map(messages.map((m) => [m.messageId, createMessageDigest(m)]));
+    const memberDigestMap = new Map(members.map((m) => [m.address, createMemberDigest(m)]));
+    let oldestTimestamp = Infinity;
+    let newestTimestamp = 0;
+    for (const msg of messages) {
+      if (msg.createdDate < oldestTimestamp) oldestTimestamp = msg.createdDate;
+      if (msg.createdDate > newestTimestamp) newestTimestamp = msg.createdDate;
+    }
+    if (messages.length === 0) {
+      oldestTimestamp = 0;
+    }
+    const manifestHashBytes = new Uint8Array(32);
+    for (const msg of messages) {
+      this.xorIntoHash(manifestHashBytes, this.hashMessageId(msg.messageId));
+    }
+    return {
+      spaceId,
+      channelId,
+      messageMap,
+      memberMap,
+      digestMap,
+      memberDigestMap,
+      oldestTimestamp,
+      newestTimestamp,
+      manifestHashBytes
+    };
+  }
+  /**
+   * Get manifest hash as hex string - O(1)
+   */
+  getManifestHash(cache) {
+    return bytesToHex(cache.manifestHashBytes);
   }
   /**
-   * Rebuild derived fields (manifest, digests, summary) from the maps
+   * Get the manifest from cache - builds it on demand
    */
-  rebuildPayloadCache(spaceId, channelId, cache) {
-    const messages = [...cache.messageMap.values()];
-    const members = [...cache.memberMap.values()];
-    cache.manifest = createManifest(spaceId, channelId, messages);
-    cache.memberDigests = members.map(createMemberDigest);
-    cache.summary = createSyncSummary(messages, members.length);
+  getManifest(cache) {
+    const digests = [...cache.digestMap.values()].sort((a, b) => a.createdDate - b.createdDate);
+    const reactionDigests = [];
+    for (const msg of cache.messageMap.values()) {
+      if (msg.reactions && msg.reactions.length > 0) {
+        reactionDigests.push(...createReactionDigest(msg.messageId, msg.reactions));
+      }
+    }
+    return {
+      spaceId: cache.spaceId,
+      channelId: cache.channelId,
+      messageCount: cache.digestMap.size,
+      oldestTimestamp: cache.oldestTimestamp,
+      newestTimestamp: cache.newestTimestamp,
+      digests,
+      reactionDigests
+    };
+  }
+  /**
+   * Get the summary from cache - O(1)
+   */
+  getSummary(cache) {
+    return {
+      memberCount: cache.memberDigestMap.size,
+      messageCount: cache.digestMap.size,
+      newestMessageTimestamp: cache.newestTimestamp,
+      oldestMessageTimestamp: cache.oldestTimestamp,
+      manifestHash: this.getManifestHash(cache)
+    };
+  }
+  /**
+   * Get member digests from cache - O(m)
+   */
+  getMemberDigests(cache) {
+    return [...cache.memberDigestMap.values()];
   }
   /**
    * Invalidate cache for a space/channel (forces reload from storage on next access)
@@ -2230,39 +2307,68 @@ var SyncService = class {
     }
   }
   /**
-   * Update cache with a new/updated message (incremental update - no storage query)
+   * Update cache with a new/updated message - O(1) incremental update
    */
   updateCacheWithMessage(spaceId, channelId, message) {
     const key = this.getCacheKey(spaceId, channelId);
     const cached = this.payloadCache.get(key);
     if (cached) {
+      const isNew = !cached.messageMap.has(message.messageId);
       cached.messageMap.set(message.messageId, message);
-      this.rebuildPayloadCache(spaceId, channelId, cached);
-      logger.log(`[SyncService] Updated cache with message ${message.messageId.substring(0, 12)}`);
+      cached.digestMap.set(message.messageId, createMessageDigest(message));
+      if (message.createdDate < cached.oldestTimestamp) {
+        cached.oldestTimestamp = message.createdDate;
+      }
+      if (message.createdDate > cached.newestTimestamp) {
+        cached.newestTimestamp = message.createdDate;
+      }
+      if (isNew) {
+        this.xorIntoHash(cached.manifestHashBytes, this.hashMessageId(message.messageId));
+      }
+      logger.log(`[SyncService] Updated cache with message ${message.messageId.substring(0, 12)} (O(1))`);
     }
   }
   /**
-   * Remove a message from cache (incremental update - no storage query)
+   * Remove a message from cache - O(1) for removal, but may need O(n) for timestamp recalc
    */
   removeCacheMessage(spaceId, channelId, messageId) {
     const key = this.getCacheKey(spaceId, channelId);
     const cached = this.payloadCache.get(key);
     if (cached) {
+      const message = cached.messageMap.get(messageId);
+      if (!message) return;
       cached.messageMap.delete(messageId);
-      this.rebuildPayloadCache(spaceId, channelId, cached);
+      cached.digestMap.delete(messageId);
+      this.xorIntoHash(cached.manifestHashBytes, this.hashMessageId(messageId));
+      if (message.createdDate === cached.oldestTimestamp || message.createdDate === cached.newestTimestamp) {
+        this.recalculateTimestamps(cached);
+      }
       logger.log(`[SyncService] Removed message ${messageId.substring(0, 12)} from cache`);
     }
   }
   /**
-   * Update cache with a new/updated member (incremental update - no storage query)
+   * Recalculate timestamps from scratch - O(n), only called when necessary
+   */
+  recalculateTimestamps(cache) {
+    let oldestTimestamp = Infinity;
+    let newestTimestamp = 0;
+    for (const msg of cache.messageMap.values()) {
+      if (msg.createdDate < oldestTimestamp) oldestTimestamp = msg.createdDate;
+      if (msg.createdDate > newestTimestamp) newestTimestamp = msg.createdDate;
+    }
+    cache.oldestTimestamp = cache.messageMap.size === 0 ? 0 : oldestTimestamp;
+    cache.newestTimestamp = newestTimestamp;
+  }
+  /**
+   * Update cache with a new/updated member - O(1) incremental update
    */
   updateCacheWithMember(spaceId, channelId, member) {
     const key = this.getCacheKey(spaceId, channelId);
     const cached = this.payloadCache.get(key);
     if (cached) {
       cached.memberMap.set(member.address, member);
-      this.rebuildPayloadCache(spaceId, channelId, cached);
-      logger.log(`[SyncService] Updated cache with member ${member.address.substring(0, 12)}`);
+      cached.memberDigestMap.set(member.address, createMemberDigest(member));
+      logger.log(`[SyncService] Updated cache with member ${member.address.substring(0, 12)} (O(1))`);
     }
   }
   /**
@@ -2334,7 +2440,7 @@ var SyncService = class {
       type: "sync-request",
       inboxAddress,
       expiry,
-      summary: cache.summary
+      summary: this.getSummary(cache)
     };
   }
   /**
@@ -2358,7 +2464,7 @@ var SyncService = class {
   async buildSyncInfo(spaceId, channelId, inboxAddress, theirSummary) {
     logger.log(`[SyncService] buildSyncInfo called for space=${spaceId.substring(0, 12)}, channel=${channelId.substring(0, 12)}`);
     const cache = await this.getPayloadCache(spaceId, channelId);
-    const ourSummary = cache.summary;
+    const ourSummary = this.getSummary(cache);
     logger.log(`[SyncService] buildSyncInfo: our data - ${cache.messageMap.size} messages, ${cache.memberMap.size} members`);
     logger.log(`[SyncService] buildSyncInfo: their summary:`, theirSummary);
     if (cache.messageMap.size === 0 && cache.memberMap.size === 0) {
@@ -2451,8 +2557,8 @@ var SyncService = class {
       payload: {
         type: "sync-initiate",
         inboxAddress,
-        manifest: cache.manifest,
-        memberDigests: cache.memberDigests,
+        manifest: this.getManifest(cache),
+        memberDigests: this.getMemberDigests(cache),
         peerIds
       }
     };
@@ -2466,8 +2572,8 @@ var SyncService = class {
     return {
       type: "sync-manifest",
       inboxAddress,
-      manifest: cache.manifest,
-      memberDigests: cache.memberDigests,
+      manifest: this.getManifest(cache),
+      memberDigests: this.getMemberDigests(cache),
       peerIds
     };
   }
@@ -2479,8 +2585,10 @@ var SyncService = class {
   async buildSyncDelta(spaceId, channelId, theirManifest, theirMemberDigests, theirPeerIds, ourPeerEntries) {
     const cache = await this.getPayloadCache(spaceId, channelId);
     const ourPeerIds = [...ourPeerEntries.keys()];
-    const messageDiff = computeMessageDiff(cache.manifest, theirManifest);
-    const memberDiff = computeMemberDiff(theirMemberDigests, cache.memberDigests);
+    const ourManifest = this.getManifest(cache);
+    const ourMemberDigests = this.getMemberDigests(cache);
+    const messageDiff = computeMessageDiff(ourManifest, theirManifest);
+    const memberDiff = computeMemberDiff(theirMemberDigests, ourMemberDigests);
     const peerDiff = computePeerDiff(theirPeerIds, ourPeerIds);
     const messageDelta = buildMessageDelta(
       spaceId,

package/dist/index.mjs

@@ -1808,13 +1808,18 @@ function computeMemberHash(member) {
   const iconHash = computeHash(member.profile_image || "");
   return { displayNameHash, iconHash };
 }
+function xorBuffers(a, b) {
+  for (let i = 0; i < 32; i++) {
+    a[i] ^= b[i];
+  }
+}
 function computeManifestHash(digests) {
-  if (digests.length === 0) {
-    return computeHash("");
+  const result = new Uint8Array(32);
+  for (const digest of digests) {
+    const idHash = sha256(new TextEncoder().encode(digest.messageId));
+    xorBuffers(result, idHash);
   }
-  const sorted = [...digests].sort((a, b) => a.messageId.localeCompare(b.messageId));
-  const ids = sorted.map((d) => d.messageId).join(":");
-  return computeHash(ids);
+  return bytesToHex(result);
 }
 function createMessageDigest(message) {
   return {
@@ -2044,6 +2049,7 @@ function createSyncSummary(messages, memberCount) {
 }
 
 // src/sync/service.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha2";
 var SyncService = class {
   constructor(config2) {
     /** Active sync sessions by spaceId */
@@ -2083,25 +2089,96 @@ var SyncService = class {
     return payload;
   }
   /**
-   * Build the payload cache from messages and members
+   * Hash a message ID to bytes for XOR-based manifest hash
+   */
+  hashMessageId(messageId) {
+    return sha2562(new TextEncoder().encode(messageId));
+  }
+  /**
+   * XOR hash bytes into the accumulator - O(1)
+   */
+  xorIntoHash(accumulator, hash) {
+    for (let i = 0; i < 32; i++) {
+      accumulator[i] ^= hash[i];
+    }
+  }
+  /**
+   * Build the payload cache from messages and members - O(n) initial build
    */
   buildPayloadCache(spaceId, channelId, messages, members) {
     const messageMap = new Map(messages.map((m) => [m.messageId, m]));
     const memberMap = new Map(members.map((m) => [m.address, m]));
-    const manifest = createManifest(spaceId, channelId, messages);
-    const memberDigests = members.map(createMemberDigest);
-    const summary = createSyncSummary(messages, members.length);
-    return { manifest, memberDigests, summary, messageMap, memberMap };
+    const digestMap = new Map(messages.map((m) => [m.messageId, createMessageDigest(m)]));
+    const memberDigestMap = new Map(members.map((m) => [m.address, createMemberDigest(m)]));
+    let oldestTimestamp = Infinity;
+    let newestTimestamp = 0;
+    for (const msg of messages) {
+      if (msg.createdDate < oldestTimestamp) oldestTimestamp = msg.createdDate;
+      if (msg.createdDate > newestTimestamp) newestTimestamp = msg.createdDate;
+    }
+    if (messages.length === 0) {
+      oldestTimestamp = 0;
+    }
+    const manifestHashBytes = new Uint8Array(32);
+    for (const msg of messages) {
+      this.xorIntoHash(manifestHashBytes, this.hashMessageId(msg.messageId));
+    }
+    return {
+      spaceId,
+      channelId,
+      messageMap,
+      memberMap,
+      digestMap,
+      memberDigestMap,
+      oldestTimestamp,
+      newestTimestamp,
+      manifestHashBytes
+    };
+  }
+  /**
+   * Get manifest hash as hex string - O(1)
+   */
+  getManifestHash(cache) {
+    return bytesToHex(cache.manifestHashBytes);
   }
   /**
-   * Rebuild derived fields (manifest, digests, summary) from the maps
+   * Get the manifest from cache - builds it on demand
    */
-  rebuildPayloadCache(spaceId, channelId, cache) {
-    const messages = [...cache.messageMap.values()];
-    const members = [...cache.memberMap.values()];
-    cache.manifest = createManifest(spaceId, channelId, messages);
-    cache.memberDigests = members.map(createMemberDigest);
-    cache.summary = createSyncSummary(messages, members.length);
+  getManifest(cache) {
+    const digests = [...cache.digestMap.values()].sort((a, b) => a.createdDate - b.createdDate);
+    const reactionDigests = [];
+    for (const msg of cache.messageMap.values()) {
+      if (msg.reactions && msg.reactions.length > 0) {
+        reactionDigests.push(...createReactionDigest(msg.messageId, msg.reactions));
+      }
+    }
+    return {
+      spaceId: cache.spaceId,
+      channelId: cache.channelId,
+      messageCount: cache.digestMap.size,
+      oldestTimestamp: cache.oldestTimestamp,
+      newestTimestamp: cache.newestTimestamp,
+      digests,
+      reactionDigests
+    };
+  }
+  /**
+   * Get the summary from cache - O(1)
+   */
+  getSummary(cache) {
+    return {
+      memberCount: cache.memberDigestMap.size,
+      messageCount: cache.digestMap.size,
+      newestMessageTimestamp: cache.newestTimestamp,
+      oldestMessageTimestamp: cache.oldestTimestamp,
+      manifestHash: this.getManifestHash(cache)
+    };
+  }
+  /**
+   * Get member digests from cache - O(m)
+   */
+  getMemberDigests(cache) {
+    return [...cache.memberDigestMap.values()];
   }
   /**
    * Invalidate cache for a space/channel (forces reload from storage on next access)
@@ -2121,39 +2198,68 @@ var SyncService = class {
     }
   }
   /**
-   * Update cache with a new/updated message (incremental update - no storage query)
+   * Update cache with a new/updated message - O(1) incremental update
    */
   updateCacheWithMessage(spaceId, channelId, message) {
     const key = this.getCacheKey(spaceId, channelId);
     const cached = this.payloadCache.get(key);
     if (cached) {
+      const isNew = !cached.messageMap.has(message.messageId);
       cached.messageMap.set(message.messageId, message);
-      this.rebuildPayloadCache(spaceId, channelId, cached);
-      logger.log(`[SyncService] Updated cache with message ${message.messageId.substring(0, 12)}`);
+      cached.digestMap.set(message.messageId, createMessageDigest(message));
+      if (message.createdDate < cached.oldestTimestamp) {
+        cached.oldestTimestamp = message.createdDate;
+      }
+      if (message.createdDate > cached.newestTimestamp) {
+        cached.newestTimestamp = message.createdDate;
+      }
+      if (isNew) {
+        this.xorIntoHash(cached.manifestHashBytes, this.hashMessageId(message.messageId));
+      }
+      logger.log(`[SyncService] Updated cache with message ${message.messageId.substring(0, 12)} (O(1))`);
     }
   }
   /**
-   * Remove a message from cache (incremental update - no storage query)
+   * Remove a message from cache - O(1) for removal, but may need O(n) for timestamp recalc
    */
   removeCacheMessage(spaceId, channelId, messageId) {
     const key = this.getCacheKey(spaceId, channelId);
     const cached = this.payloadCache.get(key);
     if (cached) {
+      const message = cached.messageMap.get(messageId);
+      if (!message) return;
       cached.messageMap.delete(messageId);
-      this.rebuildPayloadCache(spaceId, channelId, cached);
+      cached.digestMap.delete(messageId);
+      this.xorIntoHash(cached.manifestHashBytes, this.hashMessageId(messageId));
+      if (message.createdDate === cached.oldestTimestamp || message.createdDate === cached.newestTimestamp) {
+        this.recalculateTimestamps(cached);
+      }
       logger.log(`[SyncService] Removed message ${messageId.substring(0, 12)} from cache`);
     }
   }
   /**
-   * Update cache with a new/updated member (incremental update - no storage query)
+   * Recalculate timestamps from scratch - O(n), only called when necessary
+   */
+  recalculateTimestamps(cache) {
+    let oldestTimestamp = Infinity;
+    let newestTimestamp = 0;
+    for (const msg of cache.messageMap.values()) {
+      if (msg.createdDate < oldestTimestamp) oldestTimestamp = msg.createdDate;
+      if (msg.createdDate > newestTimestamp) newestTimestamp = msg.createdDate;
+    }
+    cache.oldestTimestamp = cache.messageMap.size === 0 ? 0 : oldestTimestamp;
+    cache.newestTimestamp = newestTimestamp;
+  }
+  /**
+   * Update cache with a new/updated member - O(1) incremental update
    */
   updateCacheWithMember(spaceId, channelId, member) {
     const key = this.getCacheKey(spaceId, channelId);
     const cached = this.payloadCache.get(key);
     if (cached) {
       cached.memberMap.set(member.address, member);
-      this.rebuildPayloadCache(spaceId, channelId, cached);
-      logger.log(`[SyncService] Updated cache with member ${member.address.substring(0, 12)}`);
+      cached.memberDigestMap.set(member.address, createMemberDigest(member));
+      logger.log(`[SyncService] Updated cache with member ${member.address.substring(0, 12)} (O(1))`);
     }
   }
   /**
@@ -2225,7 +2331,7 @@ var SyncService = class {
       type: "sync-request",
       inboxAddress,
       expiry,
-      summary: cache.summary
+      summary: this.getSummary(cache)
     };
   }
   /**
@@ -2249,7 +2355,7 @@ var SyncService = class {
   async buildSyncInfo(spaceId, channelId, inboxAddress, theirSummary) {
     logger.log(`[SyncService] buildSyncInfo called for space=${spaceId.substring(0, 12)}, channel=${channelId.substring(0, 12)}`);
     const cache = await this.getPayloadCache(spaceId, channelId);
-    const ourSummary = cache.summary;
+    const ourSummary = this.getSummary(cache);
     logger.log(`[SyncService] buildSyncInfo: our data - ${cache.messageMap.size} messages, ${cache.memberMap.size} members`);
     logger.log(`[SyncService] buildSyncInfo: their summary:`, theirSummary);
     if (cache.messageMap.size === 0 && cache.memberMap.size === 0) {
@@ -2342,8 +2448,8 @@ var SyncService = class {
       payload: {
         type: "sync-initiate",
         inboxAddress,
-        manifest: cache.manifest,
-        memberDigests: cache.memberDigests,
+        manifest: this.getManifest(cache),
+        memberDigests: this.getMemberDigests(cache),
         peerIds
       }
     };
@@ -2357,8 +2463,8 @@ var SyncService = class {
     return {
       type: "sync-manifest",
       inboxAddress,
-      manifest: cache.manifest,
-      memberDigests: cache.memberDigests,
+      manifest: this.getManifest(cache),
+      memberDigests: this.getMemberDigests(cache),
       peerIds
     };
   }
@@ -2370,8 +2476,10 @@ var SyncService = class {
   async buildSyncDelta(spaceId, channelId, theirManifest, theirMemberDigests, theirPeerIds, ourPeerEntries) {
     const cache = await this.getPayloadCache(spaceId, channelId);
     const ourPeerIds = [...ourPeerEntries.keys()];
-    const messageDiff = computeMessageDiff(cache.manifest, theirManifest);
-    const memberDiff = computeMemberDiff(theirMemberDigests, cache.memberDigests);
+    const ourManifest = this.getManifest(cache);
+    const ourMemberDigests = this.getMemberDigests(cache);
+    const messageDiff = computeMessageDiff(ourManifest, theirManifest);
+    const memberDiff = computeMemberDiff(theirMemberDigests, ourMemberDigests);
     const peerDiff = computePeerDiff(theirPeerIds, ourPeerIds);
     const messageDelta = buildMessageDelta(
       spaceId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quilibrium/quorum-shared",
-  "version": "2.1.0-1",
+  "version": "2.1.0-2",
   "description": "Shared types, hooks, and utilities for Quorum mobile and desktop apps",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/sync/service.ts

@@ -16,6 +16,7 @@ import type { Message, SpaceMember } from '../types';
 import { logger } from '../utils/logger';
 import type {
   SyncManifest,
+  MessageDigest,
   MessageDelta,
   ReactionDelta,
   MemberDigest,

package/src/sync/utils.ts

@@ -146,19 +146,29 @@ export function computeMemberHash(member: SpaceMember): {
   return { displayNameHash, iconHash };
 }
 
+/**
+ * XOR two Uint8Array buffers together (modifies first buffer in place)
+ */
+function xorBuffers(a: Uint8Array, b: Uint8Array): void {
+  for (let i = 0; i < 32; i++) {
+    a[i] ^= b[i];
+  }
+}
+
 /**
  * Compute manifest hash for quick comparison.
- * Hash of sorted message IDs.
+ * Uses XOR of SHA-256 hashes of message IDs for O(1) incremental updates.
+ * XOR is order-independent, so same message set = same hash regardless of order.
  */
 export function computeManifestHash(digests: MessageDigest[]): string {
-  if (digests.length === 0) {
-    return computeHash('');
+  const result = new Uint8Array(32);
+
+  for (const digest of digests) {
+    const idHash = sha256(new TextEncoder().encode(digest.messageId));
+    xorBuffers(result, idHash);
   }
 
-  // Sort by messageId for deterministic hash
-  const sorted = [...digests].sort((a, b) => a.messageId.localeCompare(b.messageId));
-  const ids = sorted.map((d) => d.messageId).join(':');
-  return computeHash(ids);
+  return bytesToHex(result);
 }
 
 // ============ Digest Creation ============