cojson 0.19.18 → 0.19.19

package/src/sync.ts

@@ -2,6 +2,7 @@ import { md5 } from "@noble/hashes/legacy";
 import { Histogram, ValueType, metrics } from "@opentelemetry/api";
 import { PeerState } from "./PeerState.js";
 import { SyncStateManager } from "./SyncStateManager.js";
+import { UnsyncedCoValuesTracker } from "./UnsyncedCoValuesTracker.js";
 import {
   getContenDebugInfo,
   getNewTransactionsFromContentMessage,
@@ -23,6 +24,7 @@ import {
   knownStateFrom,
   KnownStateSessions,
 } from "./knownState.js";
+import { StorageAPI } from "./storage/index.js";
 
 export type SyncMessage =
   | LoadMessage
@@ -63,6 +65,15 @@ export type DoneMessage = {
   id: RawCoID;
 };
 
+/**
+ * Determines when network sync is enabled.
+ * - "always": sync is enabled for both Anonymous Authentication and Authenticated Account
+ * - "signedUp": sync is enabled when the user is authenticated
+ * - "never": sync is disabled, content stays local
+ * Can be dynamically modified to control sync behavior at runtime.
+ */
+export type SyncWhen = "always" | "signedUp" | "never";
+
 export type PeerID = string;
 
 export type DisconnectedError = "Disconnected";
@@ -121,6 +132,7 @@ export class SyncManager {
   constructor(local: LocalNode) {
     this.local = local;
     this.syncState = new SyncStateManager(this);
+    this.unsyncedTracker = new UnsyncedCoValuesTracker();
 
     this.transactionsSizeHistogram = metrics
       .getMeter("cojson")
@@ -132,6 +144,7 @@ export class SyncManager {
   }
 
   syncState: SyncStateManager;
+  unsyncedTracker: UnsyncedCoValuesTracker;
 
   disableTransactionVerification() {
     this.skipVerify = true;
@@ -154,6 +167,10 @@ export class SyncManager {
       : serverPeers;
   }
 
+  getPersistentServerPeers(id: RawCoID): PeerState[] {
+    return this.getServerPeers(id).filter((peer) => peer.persistent);
+  }
+
   handleSyncMessage(msg: SyncMessage, peer: PeerState) {
     if (!isRawCoID(msg.id)) {
       const errorType = msg.id ? "invalid" : "undefined";
@@ -259,7 +276,88 @@ export class SyncManager {
     }
   }
 
+  async resumeUnsyncedCoValues(): Promise<void> {
+    if (!this.local.storage) {
+      // No storage available, skip resumption
+      return;
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      // Load all persisted unsynced CoValues from storage
+      this.local.storage?.getUnsyncedCoValueIDs((unsyncedCoValueIDs) => {
+        const coValuesToLoad = unsyncedCoValueIDs.filter(
+          (coValueId) => !this.local.hasCoValue(coValueId),
+        );
+        if (coValuesToLoad.length === 0) {
+          resolve();
+          return;
+        }
+
+        const BATCH_SIZE = 10;
+        let processed = 0;
+
+        const processBatch = async () => {
+          const batch = coValuesToLoad.slice(processed, processed + BATCH_SIZE);
+
+          await Promise.all(
+            batch.map(
+              async (coValueId) =>
+                new Promise<void>((resolve) => {
+                  try {
+                    // Clear previous tracking (as it may include outdated peers)
+                    this.local.storage?.stopTrackingSyncState(coValueId);
+
+                    // Resume tracking sync state for this CoValue
+                    // This will add it back to the tracker and set up subscriptions
+                    this.trackSyncState(coValueId);
+
+                    // Load the CoValue from storage (this will trigger sync if peers are connected)
+                    const coValue = this.local.getCoValue(coValueId);
+                    coValue.loadFromStorage((found) => {
+                      if (!found) {
+                        // CoValue could not be loaded from storage, stop tracking
+                        this.unsyncedTracker.removeAll(coValueId);
+                      }
+                      resolve();
+                    });
+                  } catch (error) {
+                    // Handle errors gracefully - log but don't fail the entire resumption
+                    logger.warn(
+                      `Failed to resume sync for CoValue ${coValueId}:`,
+                      {
+                        err: error,
+                        coValueId,
+                      },
+                    );
+                    this.unsyncedTracker.removeAll(coValueId);
+                    resolve();
+                  }
+                }),
+            ),
+          );
+
+          processed += batch.length;
+
+          if (processed < coValuesToLoad.length) {
+            processBatch().catch(reject);
+          } else {
+            resolve();
+          }
+        };
+
+        processBatch().catch(reject);
+      });
+    });
+  }
+
   startPeerReconciliation(peer: PeerState) {
+    if (peer.role === "server" && peer.persistent) {
+      // Resume syncing unsynced CoValues asynchronously
+      this.resumeUnsyncedCoValues().catch((error) => {
+        logger.warn("Failed to resume unsynced CoValues:", error);
+      });
+    }
+
     const coValuesOrderedByDependency: CoValueCore[] = [];
 
     const seen = new Set<string>();
@@ -732,6 +830,9 @@ export class SyncManager {
 
     if (from !== "storage" && hasNewContent) {
       this.storeContent(validNewContent);
+      if (from === "import") {
+        this.trackSyncState(coValue.id);
+      }
     }
 
     for (const peer of this.getPeers(coValue.id)) {
@@ -787,6 +888,8 @@ export class SyncManager {
 
     this.storeContent(content);
 
+    this.trackSyncState(coValue.id);
+
     const contentKnownState = knownStateFromContent(content);
 
     for (const peer of this.getPeers(coValue.id)) {
@@ -811,6 +914,37 @@ export class SyncManager {
     }
   }
 
+  private trackSyncState(coValueId: RawCoID): void {
+    const peers = this.getPersistentServerPeers(coValueId);
+
+    const isSyncRequired = this.local.syncWhen !== "never";
+    if (isSyncRequired && peers.length === 0) {
+      this.unsyncedTracker.add(coValueId);
+      return;
+    }
+
+    for (const peer of peers) {
+      if (this.syncState.isSynced(peer, coValueId)) {
+        continue;
+      }
+      const alreadyTracked = this.unsyncedTracker.add(coValueId, peer.id);
+      if (alreadyTracked) {
+        continue;
+      }
+
+      const unsubscribe = this.syncState.subscribeToPeerUpdates(
+        peer.id,
+        coValueId,
+        (_knownState, syncState) => {
+          if (syncState.uploaded) {
+            this.unsyncedTracker.remove(coValueId, peer.id);
+            unsubscribe();
+          }
+        },
+      );
+    }
+  }
+
   private storeContent(content: NewContentMessage) {
     const storage = this.local.storage;
 
@@ -860,8 +994,9 @@ export class SyncManager {
     return new Promise((resolve, reject) => {
       const unsubscribe = this.syncState.subscribeToPeerUpdates(
         peerId,
-        (knownState, syncState) => {
-          if (syncState.uploaded && knownState.id === id) {
+        id,
+        (_knownState, syncState) => {
+          if (syncState.uploaded) {
             resolve(true);
             unsubscribe?.();
             clearTimeout(timeoutId);
@@ -916,10 +1051,23 @@ export class SyncManager {
     );
   }
 
-  gracefulShutdown() {
+  setStorage(storage: StorageAPI) {
+    this.unsyncedTracker.setStorage(storage);
+  }
+
+  removeStorage() {
+    this.unsyncedTracker.removeStorage();
+  }
+
+  /**
+   * Closes all the peer connections and ensures the list of unsynced coValues is persisted to storage.
+   * @returns Promise of the current pending store operation, if any.
+   */
+  gracefulShutdown(): Promise<void> | undefined {
     for (const peer of Object.values(this.peers)) {
       peer.gracefulShutdown();
     }
+    return this.unsyncedTracker.forcePersist();
   }
 }
 

package/src/tests/SyncStateManager.test.ts

@@ -78,10 +78,12 @@ describe("SyncStateManager", () => {
     const updateToStorageSpy: PeerSyncStateListenerCallback = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToPeerUpdates(
       peerState.id,
+      map.core.id,
       updateToJazzCloudSpy,
     );
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
       serverPeer.id,
+      group.core.id,
       updateToStorageSpy,
     );
 
@@ -141,6 +143,7 @@ describe("SyncStateManager", () => {
     const unsubscribe1 = subscriptionManager.subscribeToUpdates(anyUpdateSpy);
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
       peerState.id,
+      map.core.id,
       anyUpdateSpy,
     );
 

package/src/tests/coValueCore.loadFromStorage.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { RawCoID } from "../ids";
+import { PeerID } from "../sync";
 import { StorageAPI } from "../storage/types";
 import {
   createTestMetricReader,
@@ -36,6 +37,13 @@ function createMockStorage(
     store?: (data: any, correctionCallback: any) => void;
     getKnownState?: (id: RawCoID) => any;
     waitForSync?: (id: string, coValue: any) => Promise<void>;
+    trackCoValuesSyncState?: (
+      operations: Array<{ id: RawCoID; peerId: PeerID; synced: boolean }>,
+    ) => void;
+    getUnsyncedCoValueIDs?: (
+      callback: (unsyncedCoValueIDs: RawCoID[]) => void,
+    ) => void;
+    stopTrackingSyncState?: (id: RawCoID) => void;
     close?: () => Promise<unknown> | undefined;
   } = {},
 ): StorageAPI {
@@ -44,6 +52,9 @@ function createMockStorage(
     store: opts.store || vi.fn(),
     getKnownState: opts.getKnownState || vi.fn(),
     waitForSync: opts.waitForSync || vi.fn().mockResolvedValue(undefined),
+    trackCoValuesSyncState: opts.trackCoValuesSyncState || vi.fn(),
+    getUnsyncedCoValueIDs: opts.getUnsyncedCoValueIDs || vi.fn(),
+    stopTrackingSyncState: opts.stopTrackingSyncState || vi.fn(),
     close: opts.close || vi.fn().mockResolvedValue(undefined),
   };
 }

package/src/tests/sync.tracking.test.ts

@@ -0,0 +1,396 @@
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { setSyncStateTrackingBatchDelay } from "../UnsyncedCoValuesTracker";
+import {
+  blockMessageTypeOnOutgoingPeer,
+  SyncMessagesLog,
+  TEST_NODE_CONFIG,
+  setupTestNode,
+  waitFor,
+} from "./testUtils";
+
+let jazzCloud: ReturnType<typeof setupTestNode>;
+
+beforeEach(async () => {
+  // We want to simulate a real world communication that happens asynchronously
+  TEST_NODE_CONFIG.withAsyncPeers = true;
+
+  SyncMessagesLog.clear();
+  jazzCloud = setupTestNode({ isSyncServer: true });
+
+  setSyncStateTrackingBatchDelay(0);
+});
+
+afterEach(() => {
+  setSyncStateTrackingBatchDelay(1000);
+});
+
+describe("coValue sync state tracking", () => {
+  test("coValues with unsynced local changes are tracked as unsynced", async () => {
+    const { node: client } = setupTestNode({ connected: true });
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Wait for local transaction to trigger sync
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    const unsyncedTracker = client.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+  });
+
+  test("coValue is marked as synced when all persistent server peers have received the content", async () => {
+    const { node: client } = setupTestNode({ connected: true });
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Wait for local transaction to trigger sync
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    const unsyncedTracker = client.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+
+    const serverPeer =
+      client.syncManager.peers[jazzCloud.node.currentSessionID]!;
+    await waitFor(() =>
+      client.syncManager.syncState.isSynced(serverPeer, map.id),
+    );
+    expect(unsyncedTracker.has(map.id)).toBe(false);
+  });
+
+  test("coValues are tracked as unsynced even if there are no persistent server peers", async () => {
+    const { node: client } = setupTestNode({ connected: false });
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    const unsyncedTracker = client.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+  });
+
+  test("only tracks sync state for persistent servers peers", async () => {
+    const { node: client, connectToSyncServer } = setupTestNode({
+      connected: true,
+    });
+
+    // Add a second server peer that is NOT persistent
+    const server2 = setupTestNode({ isSyncServer: true });
+    const { peer: server2PeerOnClient, peerState: server2PeerStateOnClient } =
+      connectToSyncServer({
+        syncServer: server2.node,
+        syncServerName: "server2",
+        persistent: false,
+      });
+
+    // Do not deliver new content messages to the second server peer
+    blockMessageTypeOnOutgoingPeer(server2PeerOnClient, "content", {});
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    const unsyncedTracker = client.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+
+    const serverPeer =
+      client.syncManager.peers[jazzCloud.node.currentSessionID]!;
+    await waitFor(() =>
+      client.syncManager.syncState.isSynced(serverPeer, map.id),
+    );
+
+    expect(
+      client.syncManager.syncState.isSynced(server2PeerStateOnClient, map.id),
+    ).toBe(false);
+    expect(unsyncedTracker.has(map.id)).toBe(false);
+  });
+
+  test("coValues are not tracked as unsynced if sync is disabled", async () => {
+    const { node: client } = setupTestNode({
+      connected: false,
+      syncWhen: "never",
+    });
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    const unsyncedTracker = client.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(false);
+  });
+
+  test("already synced coValues are not tracked as unsynced when trackSyncState is called", async () => {
+    const { node: client } = setupTestNode({ connected: true });
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    const unsyncedTracker = client.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+
+    const serverPeer =
+      client.syncManager.peers[jazzCloud.node.currentSessionID]!;
+    await waitFor(() =>
+      client.syncManager.syncState.isSynced(serverPeer, map.id),
+    );
+    expect(unsyncedTracker.has(map.id)).toBe(false);
+
+    // @ts-expect-error trackSyncState is private
+    client.syncManager.trackSyncState(map.id);
+    expect(unsyncedTracker.has(map.id)).toBe(false);
+  });
+
+  test("imported coValue content is tracked as unsynced", async () => {
+    const { node: client } = setupTestNode({ connected: true });
+    const { node: client2 } = setupTestNode({ connected: false });
+
+    const group = client2.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Export the content from client2 to client
+    const groupContent = group.core.newContentSince()![0]!;
+    const mapContent = map.core.newContentSince()![0]!;
+    client.syncManager.handleNewContent(groupContent, "import");
+    client.syncManager.handleNewContent(mapContent, "import");
+
+    const unsyncedTracker = client.syncManager.unsyncedTracker;
+
+    // The imported coValue should be tracked as unsynced since it hasn't been synced to the server yet
+    expect(unsyncedTracker.has(group.id)).toBe(true);
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+
+    // Wait for the map to sync
+    const serverPeer =
+      client.syncManager.peers[jazzCloud.node.currentSessionID]!;
+    await waitFor(() =>
+      client.syncManager.syncState.isSynced(serverPeer, map.id),
+    );
+    expect(unsyncedTracker.has(map.id)).toBe(false);
+  });
+});
+
+describe("sync state persistence", () => {
+  test("unsynced coValues are asynchronously persisted to storage", async () => {
+    const { node: client, addStorage } = setupTestNode({ connected: false });
+    addStorage();
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Wait for the unsynced coValues to be persisted to storage
+    await new Promise<void>((resolve) => setTimeout(resolve, 100));
+
+    const unsyncedCoValueIDs = await new Promise((resolve) =>
+      client.storage?.getUnsyncedCoValueIDs(resolve),
+    );
+    expect(unsyncedCoValueIDs).toHaveLength(2);
+    expect(unsyncedCoValueIDs).toContain(map.id);
+    expect(unsyncedCoValueIDs).toContain(group.id);
+  });
+
+  test("synced coValues are removed from storage", async () => {
+    const { node: client, addStorage } = setupTestNode({ connected: true });
+    addStorage();
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Wait enough time for the coValue to be synced
+    await new Promise<void>((resolve) => setTimeout(resolve, 100));
+
+    const unsyncedCoValueIDs = await new Promise((resolve) =>
+      client.storage?.getUnsyncedCoValueIDs(resolve),
+    );
+    expect(unsyncedCoValueIDs).toHaveLength(0);
+    expect(client.syncManager.unsyncedTracker.has(map.id)).toBe(false);
+  });
+
+  test("unsynced coValues are persisted to storage when the node is shutdown", async () => {
+    const { node: client, addStorage } = setupTestNode({ connected: false });
+    addStorage();
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Wait for local transaction to trigger sync
+    await new Promise<void>((resolve) => queueMicrotask(resolve));
+
+    await client.gracefulShutdown();
+
+    const unsyncedCoValueIDs = await new Promise((resolve) =>
+      client.storage?.getUnsyncedCoValueIDs(resolve),
+    );
+    expect(unsyncedCoValueIDs).toHaveLength(2);
+    expect(unsyncedCoValueIDs).toContain(map.id);
+    expect(unsyncedCoValueIDs).toContain(group.id);
+  });
+});
+
+describe("sync resumption", () => {
+  test("unsynced coValues are resumed when the node is restarted", async () => {
+    const client = setupTestNode({ connected: false });
+    const { storage } = client.addStorage();
+
+    const getUnsyncedCoValueIDsFromStorage = async () =>
+      new Promise<string[]>((resolve) =>
+        client.node.storage?.getUnsyncedCoValueIDs(resolve),
+      );
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Wait for the unsynced coValues to be persisted to storage
+    await new Promise<void>((resolve) => setTimeout(resolve, 100));
+
+    const unsyncedTracker = client.node.syncManager.unsyncedTracker;
+    expect(unsyncedTracker.has(map.id)).toBe(true);
+    expect(await getUnsyncedCoValueIDsFromStorage()).toHaveLength(2);
+
+    client.restart();
+    client.addStorage({ storage });
+    const { peerState: serverPeerState } = client.connectToSyncServer();
+
+    // Wait for sync to resume & complete
+    await waitFor(
+      async () => (await getUnsyncedCoValueIDsFromStorage()).length === 0,
+    );
+    expect(
+      client.node.syncManager.syncState.isSynced(serverPeerState, map.id),
+    ).toBe(true);
+  });
+
+  test("lots of unsynced coValues are resumed in batches when the node is restarted", async () => {
+    const client = setupTestNode({ connected: false });
+    const { storage } = client.addStorage();
+
+    const getUnsyncedCoValueIDsFromStorage = async () =>
+      new Promise<string[]>((resolve) =>
+        client.node.storage?.getUnsyncedCoValueIDs(resolve),
+      );
+
+    const group = client.node.createGroup();
+    const maps = Array.from({ length: 100 }, () => {
+      const map = group.createMap();
+      map.set("key", "value");
+      return map;
+    });
+
+    // Wait for the unsynced coValues to be persisted to storage
+    await new Promise<void>((resolve) => setTimeout(resolve, 100));
+
+    const unsyncedTracker = client.node.syncManager.unsyncedTracker;
+    for (const map of maps) {
+      expect(unsyncedTracker.has(map.id)).toBe(true);
+    }
+    expect(await getUnsyncedCoValueIDsFromStorage()).toHaveLength(101);
+
+    client.restart();
+    client.addStorage({ storage });
+    const { peerState: serverPeerState } = client.connectToSyncServer();
+
+    // Wait for sync to resume & complete
+    await waitFor(
+      async () => (await getUnsyncedCoValueIDsFromStorage()).length === 0,
+    );
+    for (const map of maps) {
+      expect(
+        client.node.syncManager.syncState.isSynced(serverPeerState, map.id),
+      ).toBe(true);
+    }
+  });
+
+  test("old peer entries are removed from storage when restarting with new peers", async () => {
+    const client = setupTestNode();
+    const { peer: serverPeer } = client.connectToSyncServer({
+      persistent: true,
+    });
+    const { storage } = client.addStorage();
+
+    // Do not deliver new content messages to the sync server
+    blockMessageTypeOnOutgoingPeer(serverPeer, "content", {});
+
+    const getUnsyncedCoValueIDsFromStorage = async () =>
+      new Promise<string[]>((resolve) =>
+        client.node.storage?.getUnsyncedCoValueIDs(resolve),
+      );
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Wait for the unsynced coValues to be persisted to storage
+    await new Promise<void>((resolve) => setTimeout(resolve, 100));
+
+    expect(await getUnsyncedCoValueIDsFromStorage()).toHaveLength(2);
+
+    client.restart();
+    client.addStorage({ storage });
+    const newSyncServer = setupTestNode({ isSyncServer: true });
+    const { peerState: newServerPeerState } = client.connectToSyncServer({
+      syncServer: newSyncServer.node,
+      persistent: true,
+    });
+
+    // Wait for sync to resume & complete
+    await waitFor(
+      async () => (await getUnsyncedCoValueIDsFromStorage()).length === 0,
+    );
+    expect(
+      client.node.syncManager.syncState.isSynced(newServerPeerState, map.id),
+    ).toBe(true);
+  });
+
+  test("sync resumption is skipped when adding a peer that is not a persistent server", async () => {
+    const client = setupTestNode({ connected: false });
+    const { storage } = client.addStorage();
+
+    const getUnsyncedCoValueIDsFromStorage = async () =>
+      new Promise<string[]>((resolve) =>
+        client.node.storage?.getUnsyncedCoValueIDs(resolve),
+      );
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("key", "value");
+
+    // Wait for the unsynced coValues to be persisted to storage
+    await new Promise<void>((resolve) => setTimeout(resolve, 100));
+
+    let unsyncedCoValueIDs = await getUnsyncedCoValueIDsFromStorage();
+    expect(unsyncedCoValueIDs).toHaveLength(2);
+    expect(unsyncedCoValueIDs).toContain(map.id);
+    expect(unsyncedCoValueIDs).toContain(group.id);
+
+    client.restart();
+    client.addStorage({ storage });
+    const newPeer = setupTestNode({ isSyncServer: true });
+    client.connectToSyncServer({
+      syncServer: newPeer.node,
+      persistent: false,
+    });
+
+    // Wait to confirm sync is not resumed
+    await new Promise<void>((resolve) => setTimeout(resolve, 100));
+
+    unsyncedCoValueIDs = await getUnsyncedCoValueIDsFromStorage();
+    expect(unsyncedCoValueIDs).toHaveLength(2);
+    expect(unsyncedCoValueIDs).toContain(map.id);
+    expect(unsyncedCoValueIDs).toContain(group.id);
+  });
+});