cojson 0.7.35-unique.2 → 0.8.0

package/dist/tests/priority.test.js

@@ -0,0 +1,61 @@
+import { expect, test, describe } from "vitest";
+import { WasmCrypto } from "../index.js";
+import { LocalNode } from "../localNode.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { getPriorityFromHeader, CO_VALUE_PRIORITY } from "../priority.js";
+const Crypto = await WasmCrypto.create();
+describe("getPriorityFromHeader", () => {
+    test("returns MEDIUM priority for boolean or undefined headers", () => {
+        expect(getPriorityFromHeader(true)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+        expect(getPriorityFromHeader(false)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+        expect(getPriorityFromHeader(undefined)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+    });
+    test("returns MEDIUM priority for costream type", () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        const costream = node.createCoValue({
+            type: "costream",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: null,
+            ...Crypto.createdNowUnique(),
+        });
+        expect(getPriorityFromHeader(costream.header)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+    });
+    test("returns LOW priority for binary costream type", () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        const costream = node.createCoValue({
+            type: "costream",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: { type: "binary" },
+            ...Crypto.createdNowUnique(),
+        });
+        expect(getPriorityFromHeader(costream.header)).toEqual(CO_VALUE_PRIORITY.LOW);
+    });
+    test("returns HIGH priority for account type", async () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        const account = node.createAccount(node.crypto.newRandomAgentSecret());
+        expect(getPriorityFromHeader(account.core.header)).toEqual(CO_VALUE_PRIORITY.HIGH);
+    });
+    test("returns HIGH priority for group type", () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        const group = node.createGroup();
+        expect(getPriorityFromHeader(group.core.header)).toEqual(CO_VALUE_PRIORITY.HIGH);
+    });
+    test("returns MEDIUM priority for other types", () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        const comap = node.createCoValue({
+            type: "comap",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: null,
+            ...Crypto.createdNowUnique(),
+        });
+        const colist = node.createCoValue({
+            type: "colist",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: null,
+            ...Crypto.createdNowUnique(),
+        });
+        expect(getPriorityFromHeader(comap.header)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+        expect(getPriorityFromHeader(colist.header)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+    });
+});
+//# sourceMappingURL=priority.test.js.map

package/dist/tests/priority.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority.test.js","sourceRoot":"","sources":["../../src/tests/priority.test.ts"],"names":[],"mappings":"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"}

package/dist/tests/sync.test.js

@@ -1,11 +1,12 @@
-import { expect, test } from "vitest";
+import { expect, test, describe } from "vitest";
 import { LocalNode } from "../localNode.js";
+import { RawCoMap } from "../coValues/coMap.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
 import { connectedPeers, newQueuePair } from "../streamUtils.js";
 import { stableStringify } from "../jsonStringify.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { expectMap } from "../coValue.js";
-import { newRandomSessionID } from "../coValueCore.js";
+import { getPriorityFromHeader } from "../priority.js";
 const Crypto = await WasmCrypto.create();
 test("Node replies with initial tx and header to empty subscribe", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
@@ -39,16 +40,17 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
     // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
     expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
     const newContentMsg = (await outRxQ.next()).value;
+    const expectedHeader = {
+        type: "comap",
+        ruleset: { type: "ownedByGroup", group: group.id },
+        meta: null,
+        createdAt: map.core.header.createdAt,
+        uniqueness: map.core.header.uniqueness,
+    };
     expect(newContentMsg).toEqual({
         action: "content",
         id: map.core.id,
-        header: {
-            type: "comap",
-            ruleset: { type: "ownedByGroup", group: group.id },
-            meta: null,
-            createdAt: map.core.header.createdAt,
-            uniqueness: map.core.header.uniqueness,
-        },
+        header: expectedHeader,
         new: {
             [node.currentSessionID]: {
                 after: 0,
@@ -70,6 +72,7 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
                     .lastSignature,
             },
         },
+        priority: getPriorityFromHeader(map.core.header),
     });
 });
 test("Node replies with only new tx to subscribe with some known state", async () => {
@@ -132,6 +135,7 @@ test("Node replies with only new tx to subscribe with some known state", async (
                     .lastSignature,
             },
         },
+        priority: getPriorityFromHeader(map.core.header),
     });
 });
 test.todo("TODO: node only replies with new tx to subscribe with some known state, even in the depended on coValues");
@@ -173,6 +177,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
         id: map.core.id,
         header: map.core.header,
         new: {},
+        priority: getPriorityFromHeader(map.core.header),
     });
     map.set("hello", "world", "trusting");
     const mapEditMsg1 = (await outRxQ.next()).value;
@@ -200,6 +205,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
                     .lastSignature,
             },
         },
+        priority: getPriorityFromHeader(map.core.header),
     });
     map.set("goodbye", "world", "trusting");
     const mapEditMsg2 = (await outRxQ.next()).value;
@@ -227,6 +233,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
                     .lastSignature,
             },
         },
+        priority: getPriorityFromHeader(map.core.header),
     });
 });
 test("Client replies with known new content to tellKnownState from server", async () => {
@@ -289,6 +296,7 @@ test("Client replies with known new content to tellKnownState from server", asyn
                     .lastSignature,
             },
         },
+        priority: getPriorityFromHeader(map.core.header),
     });
 });
 test("No matter the optimistic known state, node respects invalid known state messages and resyncs", async () => {
@@ -329,6 +337,7 @@ test("No matter the optimistic known state, node respects invalid known state me
         id: map.core.id,
         header: map.core.header,
         new: {},
+        priority: getPriorityFromHeader(map.core.header),
     });
     map.set("hello", "world", "trusting");
     map.set("goodbye", "world", "trusting");
@@ -369,6 +378,7 @@ test("No matter the optimistic known state, node respects invalid known state me
                     .lastSignature,
             },
         },
+        priority: getPriorityFromHeader(map.core.header),
     });
 });
 test("If we add a peer, but it never subscribes to a coValue, it won't get any messages", async () => {
@@ -451,6 +461,7 @@ test.todo("If we add a server peer, all updates to all coValues are sent to it,
                 lastSignature: map.core.sessionLogs.get(node.currentSessionID).lastSignature,
             },
         },
+        priority: getPriorityFromHeader(map.core.header),
     });
 });
 test.skip("If we add a server peer, newly created coValues are auto-subscribed to", async () => {
@@ -489,6 +500,7 @@ test.skip("If we add a server peer, newly created coValues are auto-subscribed t
         id: map.core.id,
         header: map.core.header,
         new: {},
+        priority: getPriorityFromHeader(map.core.header),
     });
 });
 test.todo("TODO: when receiving a subscribe response that is behind our optimistic state (due to already sent content), we ignore it");
@@ -565,7 +577,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
         role: "server",
         crashOnClose: true,
     });
-    const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
+    const node2 = new LocalNode(admin, Crypto.newRandomSessionID(admin.id), Crypto);
     const [inRx2, inTx2] = newQueuePair();
     const [outRx2, outTx2] = newQueuePair();
     const outRxQ2 = outRx2[Symbol.asyncIterator]();
@@ -613,6 +625,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
         id: map.core.id,
         header: map.core.header,
         new: {},
+        priority: getPriorityFromHeader(map.core.header),
     });
     await inTx2.push(mapSubscriptionMsg);
     const mapTellKnownStateMsg = (await outRxQ2.next()).value;
@@ -666,14 +679,14 @@ test("Can sync a coValue through a server to another client", async () => {
     map.set("hello", "world", "trusting");
     const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
     const server = new LocalNode(serverUser, serverSession, Crypto);
-    const [serverAsPeerForClient1, client1AsPeer] = await connectedPeers("serverFor1", "client1", {
+    const [serverAsPeerForClient1, client1AsPeer] = connectedPeers("serverFor1", "client1", {
         peer1role: "server",
         peer2role: "client",
         trace: true,
     });
     client1.syncManager.addPeer(serverAsPeerForClient1);
     server.syncManager.addPeer(client1AsPeer);
-    const client2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
+    const client2 = new LocalNode(admin, Crypto.newRandomSessionID(admin.id), Crypto);
     const [serverAsPeerForClient2, client2AsPeer] = connectedPeers("serverFor2", "client2", {
         peer1role: "server",
         peer2role: "client",
@@ -695,15 +708,15 @@ test("Can sync a coValue with private transactions through a server to another c
     map.set("hello", "world", "private");
     const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
     const server = new LocalNode(serverUser, serverSession, Crypto);
-    const [serverAsPeer, client1AsPeer] = await connectedPeers("server", "client1", {
+    const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
         trace: true,
         peer1role: "server",
         peer2role: "client",
     });
     client1.syncManager.addPeer(serverAsPeer);
     server.syncManager.addPeer(client1AsPeer);
-    const client2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
-    const [serverAsOtherPeer, client2AsPeer] = await connectedPeers("server", "client2", {
+    const client2 = new LocalNode(admin, client1.crypto.newRandomSessionID(admin.id), Crypto);
+    const [serverAsOtherPeer, client2AsPeer] = connectedPeers("server", "client2", {
         trace: true,
         peer1role: "server",
         peer2role: "client",
@@ -833,8 +846,8 @@ test("If we start loading a coValue before connecting to a peer that has it, it
     const group = node1.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
-    const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
-    const [node1asPeer, node2asPeer] = await connectedPeers("peer1", "peer2", {
+    const node2 = new LocalNode(admin, Crypto.newRandomSessionID(admin.id), Crypto);
+    const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2", {
         peer1role: "server",
         peer2role: "client",
         trace: true,
@@ -849,6 +862,303 @@ test("If we start loading a coValue before connecting to a peer that has it, it
     }
     expect(expectMap(mapOnNode2.getCurrentContent()).get("hello")).toEqual("world");
 });
+describe("sync - extra tests", () => {
+    test("Node handles disconnection and reconnection of a peer gracefully", async () => {
+        // Create two nodes
+        const [admin1, session1] = randomAnonymousAccountAndSessionID();
+        const node1 = new LocalNode(admin1, session1, Crypto);
+        const [admin2, session2] = randomAnonymousAccountAndSessionID();
+        const node2 = new LocalNode(admin2, session2, Crypto);
+        // Create a group and a map on node1
+        const group = node1.createGroup();
+        group.addMember("everyone", "writer");
+        const map = group.createMap();
+        map.set("key1", "value1", "trusting");
+        // Connect the nodes
+        const [node1AsPeer, node2AsPeer] = connectedPeers("node1", "node2", {
+            peer1role: "server",
+            peer2role: "client",
+        });
+        node1.syncManager.addPeer(node2AsPeer);
+        node2.syncManager.addPeer(node1AsPeer);
+        // Wait for initial sync
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // Verify that node2 has received the map
+        const mapOnNode2 = await node2.loadCoValueCore(map.core.id);
+        if (mapOnNode2 === "unavailable") {
+            throw new Error("Map is unavailable on node2");
+        }
+        expect(expectMap(mapOnNode2.getCurrentContent()).get("key1")).toEqual("value1");
+        // Simulate disconnection
+        node1.syncManager.gracefulShutdown();
+        node2.syncManager.gracefulShutdown();
+        // Make changes on node1 while disconnected
+        map.set("key2", "value2", "trusting");
+        // Simulate reconnection
+        const [newNode1AsPeer, newNode2AsPeer] = connectedPeers("node11", "node22", {
+            peer1role: "server",
+            peer2role: "client",
+            // trace: true,
+        });
+        node1.syncManager.addPeer(newNode2AsPeer);
+        node2.syncManager.addPeer(newNode1AsPeer);
+        // Wait for re-sync
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // Verify that node2 has received the changes made during disconnection
+        const updatedMapOnNode2 = await node2.loadCoValueCore(map.core.id);
+        if (updatedMapOnNode2 === "unavailable") {
+            throw new Error("Updated map is unavailable on node2");
+        }
+        expect(expectMap(updatedMapOnNode2.getCurrentContent()).get("key2")).toEqual("value2");
+        // Make a new change on node2 to verify two-way sync
+        const mapOnNode2ForEdit = await node2.loadCoValueCore(map.core.id);
+        if (mapOnNode2ForEdit === "unavailable") {
+            throw new Error("Updated map is unavailable on node2");
+        }
+        const success = mapOnNode2ForEdit.makeTransaction([
+            {
+                op: "set",
+                key: "key3",
+                value: "value3",
+            },
+        ], "trusting");
+        if (!success) {
+            throw new Error("Failed to make transaction");
+        }
+        // Wait for sync back to node1
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const mapOnNode1 = await node1.loadCoValueCore(map.core.id);
+        if (mapOnNode1 === "unavailable") {
+            throw new Error("Updated map is unavailable on node1");
+        }
+        // Verify that node1 has received the change from node2
+        expect(expectMap(mapOnNode1.getCurrentContent()).get("key3")).toEqual("value3");
+    });
+    test("Concurrent modifications on multiple nodes are resolved correctly", async () => {
+        // Create three nodes
+        const [admin1, session1] = randomAnonymousAccountAndSessionID();
+        const node1 = new LocalNode(admin1, session1, Crypto);
+        const [admin2, session2] = randomAnonymousAccountAndSessionID();
+        const node2 = new LocalNode(admin2, session2, Crypto);
+        const [admin3, session3] = randomAnonymousAccountAndSessionID();
+        const node3 = new LocalNode(admin3, session3, Crypto);
+        // Create a group and a map on node1
+        const group = node1.createGroup();
+        group.addMember("everyone", "writer");
+        const map = group.createMap();
+        // Connect the nodes in a triangle topology
+        const [node1AsPeerFor2, node2AsPeerFor1] = connectedPeers("node1", "node2", {
+            peer1role: "server",
+            peer2role: "client",
+            // trace: true,
+        });
+        const [node2AsPeerFor3, node3AsPeerFor2] = connectedPeers("node2", "node3", {
+            peer1role: "server",
+            peer2role: "client",
+            // trace: true,
+        });
+        const [node3AsPeerFor1, node1AsPeerFor3] = connectedPeers("node3", "node1", {
+            peer1role: "server",
+            peer2role: "client",
+            // trace: true,
+        });
+        node1.syncManager.addPeer(node2AsPeerFor1);
+        node1.syncManager.addPeer(node3AsPeerFor1);
+        node2.syncManager.addPeer(node1AsPeerFor2);
+        node2.syncManager.addPeer(node3AsPeerFor2);
+        node3.syncManager.addPeer(node1AsPeerFor3);
+        node3.syncManager.addPeer(node2AsPeerFor3);
+        // Wait for initial sync
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // Verify that all nodes have the map
+        const mapOnNode1 = await node1.loadCoValueCore(map.core.id);
+        const mapOnNode2 = await node2.loadCoValueCore(map.core.id);
+        const mapOnNode3 = await node3.loadCoValueCore(map.core.id);
+        if (mapOnNode1 === "unavailable" ||
+            mapOnNode2 === "unavailable" ||
+            mapOnNode3 === "unavailable") {
+            throw new Error("Map is unavailable on node2 or node3");
+        }
+        // Perform concurrent modifications
+        map.set("key1", "value1", "trusting");
+        new RawCoMap(mapOnNode2).set("key2", "value2", "trusting");
+        new RawCoMap(mapOnNode3).set("key3", "value3", "trusting");
+        // Wait for sync to complete
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Verify that all nodes have the same final state
+        const finalStateNode1 = expectMap(mapOnNode1.getCurrentContent());
+        const finalStateNode2 = expectMap(mapOnNode2.getCurrentContent());
+        const finalStateNode3 = expectMap(mapOnNode3.getCurrentContent());
+        const expectedState = {
+            key1: "value1",
+            key2: "value2",
+            key3: "value3",
+        };
+        expect(finalStateNode1.toJSON()).toEqual(expectedState);
+        expect(finalStateNode2.toJSON()).toEqual(expectedState);
+        expect(finalStateNode3.toJSON()).toEqual(expectedState);
+    });
+    test.skip("Large coValues are synced efficiently in chunks", async () => {
+        // Create two nodes
+        const [admin1, session1] = randomAnonymousAccountAndSessionID();
+        const node1 = new LocalNode(admin1, session1, Crypto);
+        const [admin2, session2] = randomAnonymousAccountAndSessionID();
+        const node2 = new LocalNode(admin2, session2, Crypto);
+        // Create a group and a large map on node1
+        const group = node1.createGroup();
+        group.addMember("everyone", "writer");
+        const largeMap = group.createMap();
+        // Generate a large amount of data (about 10MB)
+        const dataSize = 1 * 1024 * 1024;
+        const chunkSize = 1024; // 1KB chunks
+        const chunks = dataSize / chunkSize;
+        for (let i = 0; i < chunks; i++) {
+            const key = `key${i}`;
+            const value = Buffer.alloc(chunkSize, `value${i}`).toString("base64");
+            largeMap.set(key, value, "trusting");
+        }
+        // Connect the nodes
+        const [node1AsPeer, node2AsPeer] = connectedPeers("node1", "node2", {
+            peer1role: "server",
+            peer2role: "client",
+        });
+        node1.syncManager.addPeer(node2AsPeer);
+        node2.syncManager.addPeer(node1AsPeer);
+        await new Promise((resolve) => setTimeout(resolve, 4000));
+        // Measure sync time
+        const startSync = performance.now();
+        // Load the large map on node2
+        const largeMapOnNode2 = await node2.loadCoValueCore(largeMap.core.id);
+        if (largeMapOnNode2 === "unavailable") {
+            throw new Error("Large map is unavailable on node2");
+        }
+        const endSync = performance.now();
+        const syncTime = endSync - startSync;
+        // Verify that all data was synced correctly
+        const syncedMap = new RawCoMap(largeMapOnNode2);
+        expect(Object.keys(largeMapOnNode2.getCurrentContent().toJSON() || {})
+            .length).toBe(chunks);
+        for (let i = 0; i < chunks; i++) {
+            const key = `key${i}`;
+            const expectedValue = Buffer.alloc(chunkSize, `value${i}`).toString("base64");
+            expect(syncedMap.get(key)).toBe(expectedValue);
+        }
+        // Check that sync time is reasonable (this threshold may need adjustment)
+        const reasonableSyncTime = 10; // 30 seconds
+        expect(syncTime).toBeLessThan(reasonableSyncTime);
+        // Check memory usage (this threshold may need adjustment)
+        const memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024; // in MB
+        const reasonableMemoryUsage = 1; // 500 MB
+        expect(memoryUsage).toBeLessThan(reasonableMemoryUsage);
+    });
+    test("Node correctly handles and recovers from network partitions", async () => {
+        // Create three nodes
+        const [admin1, session1] = randomAnonymousAccountAndSessionID();
+        const node1 = new LocalNode(admin1, session1, Crypto);
+        const [admin2, session2] = randomAnonymousAccountAndSessionID();
+        const node2 = new LocalNode(admin2, session2, Crypto);
+        const [admin3, session3] = randomAnonymousAccountAndSessionID();
+        const node3 = new LocalNode(admin3, session3, Crypto);
+        // Create a group and a map on node1
+        const group = node1.createGroup();
+        group.addMember("everyone", "writer");
+        const map = group.createMap();
+        map.set("initial", "value", "trusting");
+        // Connect all nodes
+        const [node1AsPeerFor2, node2AsPeerFor1] = connectedPeers("node1", "node2", {
+            peer1role: "server",
+            peer2role: "client",
+            // trace: true,
+        });
+        const [node2AsPeerFor3, node3AsPeerFor2] = connectedPeers("node2", "node3", {
+            peer1role: "server",
+            peer2role: "client",
+            // trace: true,
+        });
+        const [node3AsPeerFor1, node1AsPeerFor3] = connectedPeers("node3", "node1", {
+            peer1role: "server",
+            peer2role: "client",
+            // trace: true,
+        });
+        node1.syncManager.addPeer(node2AsPeerFor1);
+        node1.syncManager.addPeer(node3AsPeerFor1);
+        node2.syncManager.addPeer(node1AsPeerFor2);
+        node2.syncManager.addPeer(node3AsPeerFor2);
+        node3.syncManager.addPeer(node1AsPeerFor3);
+        node3.syncManager.addPeer(node2AsPeerFor3);
+        // Wait for initial sync
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // Verify initial state
+        const mapOnNode1Core = await node1.loadCoValueCore(map.core.id);
+        const mapOnNode2Core = await node2.loadCoValueCore(map.core.id);
+        const mapOnNode3Core = await node3.loadCoValueCore(map.core.id);
+        if (mapOnNode1Core === "unavailable" ||
+            mapOnNode2Core === "unavailable" ||
+            mapOnNode3Core === "unavailable") {
+            throw new Error("Map is unavailable on node2 or node3");
+        }
+        // const mapOnNode1 = new RawCoMap(mapOnNode1Core);
+        const mapOnNode2 = new RawCoMap(mapOnNode2Core);
+        const mapOnNode3 = new RawCoMap(mapOnNode3Core);
+        expect(mapOnNode2.get("initial")).toBe("value");
+        expect(mapOnNode3.get("initial")).toBe("value");
+        // Simulate network partition: disconnect node3 from node1 and node2
+        node1.syncManager.peers["node3"]?.gracefulShutdown();
+        delete node1.syncManager.peers["node3"];
+        node2.syncManager.peers["node3"]?.gracefulShutdown();
+        delete node2.syncManager.peers["node3"];
+        node3.syncManager.peers["node1"]?.gracefulShutdown();
+        delete node3.syncManager.peers["node1"];
+        node3.syncManager.peers["node2"]?.gracefulShutdown();
+        delete node3.syncManager.peers["node2"];
+        // Make changes on both sides of the partition
+        map.set("node1", "partition", "trusting");
+        mapOnNode2.set("node2", "partition", "trusting");
+        mapOnNode3.set("node3", "partition", "trusting");
+        // Wait for sync between node1 and node2
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        // Verify that node1 and node2 are in sync, but node3 is not
+        expect(expectMap(mapOnNode1Core.getCurrentContent()).get("node1")).toBe("partition");
+        expect(expectMap(mapOnNode1Core.getCurrentContent()).get("node2")).toBe("partition");
+        expect(expectMap(mapOnNode1Core.getCurrentContent()).toJSON()?.node3).toBe(undefined);
+        expect(expectMap(mapOnNode2Core.getCurrentContent()).get("node1")).toBe("partition");
+        expect(expectMap(mapOnNode2Core.getCurrentContent()).get("node2")).toBe("partition");
+        expect(expectMap(mapOnNode2Core.getCurrentContent()).toJSON()?.node3).toBe(undefined);
+        expect(expectMap(mapOnNode3Core.getCurrentContent()).toJSON()?.node1).toBe(undefined);
+        expect(expectMap(mapOnNode3Core.getCurrentContent()).toJSON()?.node2).toBe(undefined);
+        expect(expectMap(mapOnNode3Core.getCurrentContent()).toJSON()?.node3).toBe("partition");
+        // Restore connectivity
+        const [newNode3AsPeerFor1, newNode1AsPeerFor3] = connectedPeers("node3", "node1", {
+            peer1role: "server",
+            peer2role: "client",
+            trace: true,
+        });
+        const [newNode3AsPeerFor2, newNode2AsPeerFor3] = connectedPeers("node3", "node2", {
+            peer1role: "server",
+            peer2role: "client",
+            trace: true,
+        });
+        node1.syncManager.addPeer(newNode3AsPeerFor1);
+        node2.syncManager.addPeer(newNode3AsPeerFor2);
+        node3.syncManager.addPeer(newNode1AsPeerFor3);
+        node3.syncManager.addPeer(newNode2AsPeerFor3);
+        // Wait for re-sync
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        // Verify final state: all nodes should have all changes
+        const finalStateNode1 = expectMap(mapOnNode1Core.getCurrentContent()).toJSON();
+        const finalStateNode2 = expectMap(mapOnNode2Core.getCurrentContent()).toJSON();
+        const finalStateNode3 = expectMap(mapOnNode3Core.getCurrentContent()).toJSON();
+        const expectedFinalState = {
+            initial: "value",
+            node1: "partition",
+            node2: "partition",
+            node3: "partition",
+        };
+        expect(finalStateNode1).toEqual(expectedFinalState);
+        expect(finalStateNode2).toEqual(expectedFinalState);
+        expect(finalStateNode3).toEqual(expectedFinalState);
+    });
+});
 function groupContentEx(group) {
     return {
         action: "content",