cojson 0.19.19 → 0.19.20

package/src/tests/SyncManager.processQueues.test.ts

@@ -0,0 +1,287 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { CO_VALUE_PRIORITY } from "../priority.js";
+import { StorageStreamingQueue } from "../queue/StorageStreamingQueue.js";
+import {
+  SyncMessagesLog,
+  loadCoValueOrFail,
+  setupTestNode,
+  waitFor,
+} from "./testUtils.js";
+
+describe("SyncManager.processQueues", () => {
+  let jazzCloud: ReturnType<typeof setupTestNode>;
+
+  beforeEach(async () => {
+    SyncMessagesLog.clear();
+    jazzCloud = setupTestNode({
+      isSyncServer: true,
+    });
+  });
+
+  describe("incoming messages processing", () => {
+    test("should process incoming messages from peers", async () => {
+      const client = setupTestNode();
+      client.connectToSyncServer();
+
+      const group = jazzCloud.node.createGroup();
+      const map = group.createMap();
+      map.set("hello", "world", "trusting");
+
+      const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+      expect(mapOnClient.get("hello")).toEqual("world");
+    });
+
+    test("should process multiple messages in sequence", async () => {
+      const client = setupTestNode();
+      client.connectToSyncServer();
+
+      const group = jazzCloud.node.createGroup();
+      const map1 = group.createMap();
+      const map2 = group.createMap();
+      const map3 = group.createMap();
+
+      map1.set("key", "value1", "trusting");
+      map2.set("key", "value2", "trusting");
+      map3.set("key", "value3", "trusting");
+
+      const [loadedMap1, loadedMap2, loadedMap3] = await Promise.all([
+        loadCoValueOrFail(client.node, map1.id),
+        loadCoValueOrFail(client.node, map2.id),
+        loadCoValueOrFail(client.node, map3.id),
+      ]);
+
+      expect(loadedMap1.get("key")).toEqual("value1");
+      expect(loadedMap2.get("key")).toEqual("value2");
+      expect(loadedMap3.get("key")).toEqual("value3");
+    });
+  });
+
+  describe("storage streaming processing", () => {
+    test("should process storage streaming callbacks", async () => {
+      const client = setupTestNode();
+      client.connectToSyncServer();
+      const { storage } = client.addStorage();
+
+      const group = jazzCloud.node.createGroup();
+      const map = group.createMap();
+      map.set("hello", "world", "trusting");
+
+      // First load to populate storage
+      await loadCoValueOrFail(client.node, map.id);
+
+      // Restart and load from storage
+      client.restart();
+      client.connectToSyncServer();
+      client.addStorage({ storage });
+
+      SyncMessagesLog.clear();
+
+      const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+      expect(mapOnClient.get("hello")).toEqual("world");
+
+      // Verify content came from storage
+      const storageMessages = SyncMessagesLog.messages.filter(
+        (msg) => msg.from === "storage" || msg.to === "storage",
+      );
+      expect(storageMessages.length).toBeGreaterThan(0);
+    });
+
+    test("should invoke streaming callbacks when pulled", async () => {
+      const client = setupTestNode();
+      const { storage } = client.addStorage();
+
+      const callback = vi.fn();
+      storage.streamingQueue?.push(callback, CO_VALUE_PRIORITY.MEDIUM);
+      storage.streamingQueue?.emit();
+
+      // Wait for processQueues to run
+      await waitFor(() => callback.mock.calls.length > 0);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    test("should process MEDIUM priority before LOW priority", async () => {
+      const client = setupTestNode();
+      const { storage } = client.addStorage();
+
+      const order: string[] = [];
+      const lowCallback = () => order.push("low");
+      const mediumCallback = () => order.push("medium");
+      const highCallback = () => order.push("high");
+
+      // Push LOW first, then MEDIUM
+      storage.streamingQueue?.push(lowCallback, CO_VALUE_PRIORITY.LOW);
+      storage.streamingQueue?.push(mediumCallback, CO_VALUE_PRIORITY.MEDIUM);
+      storage.streamingQueue?.push(highCallback, CO_VALUE_PRIORITY.HIGH);
+      storage.streamingQueue?.emit();
+
+      // Wait for both to be processed
+      await waitFor(() => order.length === 3);
+
+      // MEDIUM should be processed first
+      expect(order).toEqual(["high", "medium", "low"]);
+    });
+  });
+
+  describe("unified scheduling", () => {
+    test("should process both incoming messages and storage streaming", async () => {
+      const client = setupTestNode();
+      client.connectToSyncServer();
+      const { storage } = client.addStorage();
+
+      const group = jazzCloud.node.createGroup();
+      const map = group.createMap();
+      map.set("hello", "world", "trusting");
+
+      // Queue a storage streaming callback
+      const streamingCallback = vi.fn();
+      storage.streamingQueue?.push(streamingCallback, CO_VALUE_PRIORITY.MEDIUM);
+      storage.streamingQueue?.emit();
+
+      // Load from server (incoming messages)
+      const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+
+      expect(mapOnClient.get("hello")).toEqual("world");
+      expect(streamingCallback).toHaveBeenCalled();
+    });
+
+    test("should alternate between message queue and storage queue", async () => {
+      const client = setupTestNode();
+      const { storage } = client.addStorage();
+
+      const order: string[] = [];
+
+      // Push multiple storage callbacks
+      storage.streamingQueue?.push(
+        () => order.push("storage1"),
+        CO_VALUE_PRIORITY.MEDIUM,
+      );
+      storage.streamingQueue?.push(
+        () => order.push("storage2"),
+        CO_VALUE_PRIORITY.MEDIUM,
+      );
+      storage.streamingQueue?.emit();
+
+      // Wait for processing
+      await waitFor(() => order.length === 2);
+
+      expect(order).toContain("storage1");
+      expect(order).toContain("storage2");
+    });
+  });
+
+  describe("processing flag", () => {
+    test("should prevent concurrent processQueues calls", async () => {
+      const client = setupTestNode();
+      const { storage } = client.addStorage();
+
+      let concurrentCalls = 0;
+      let maxConcurrentCalls = 0;
+
+      const callback = () => {
+        concurrentCalls++;
+        maxConcurrentCalls = Math.max(maxConcurrentCalls, concurrentCalls);
+        // Simulate some work
+        for (let i = 0; i < 1000; i++) {
+          Math.random();
+        }
+        concurrentCalls--;
+      };
+
+      // Push multiple callbacks
+      for (let i = 0; i < 10; i++) {
+        storage.streamingQueue?.push(callback, CO_VALUE_PRIORITY.MEDIUM);
+      }
+
+      // Emit multiple times to trigger multiple processQueues calls
+      storage.streamingQueue?.emit();
+      storage.streamingQueue?.emit();
+      storage.streamingQueue?.emit();
+
+      // Wait for all to complete
+      await waitFor(() => storage.streamingQueue?.isEmpty());
+
+      // Should never have more than 1 concurrent call
+      expect(maxConcurrentCalls).toBe(1);
+    });
+  });
+
+  describe("error handling", () => {
+    test("should continue processing after storage callback error", async () => {
+      const client = setupTestNode();
+      const { storage } = client.addStorage();
+
+      const processed: string[] = [];
+
+      storage.streamingQueue?.push(() => {
+        processed.push("before");
+      }, CO_VALUE_PRIORITY.MEDIUM);
+
+      storage.streamingQueue?.push(() => {
+        throw new Error("Test error");
+      }, CO_VALUE_PRIORITY.MEDIUM);
+
+      storage.streamingQueue?.push(() => {
+        processed.push("after");
+      }, CO_VALUE_PRIORITY.MEDIUM);
+
+      storage.streamingQueue?.emit();
+
+      // Wait for processing to complete
+      await waitFor(() => storage.streamingQueue?.isEmpty());
+
+      // Both before and after should be processed despite error
+      expect(processed).toContain("before");
+      expect(processed).toContain("after");
+    });
+  });
+
+  describe("queue triggers", () => {
+    test("IncomingMessagesQueue.push should trigger processQueues", async () => {
+      const client = setupTestNode();
+      client.connectToSyncServer();
+
+      const group = jazzCloud.node.createGroup();
+      const map = group.createMap();
+      map.set("hello", "world", "trusting");
+
+      // Loading should trigger message processing automatically
+      const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+      expect(mapOnClient.get("hello")).toEqual("world");
+    });
+
+    test("StorageStreamingQueue.emit should trigger processQueues", async () => {
+      const client = setupTestNode();
+      const { storage } = client.addStorage();
+
+      const callback = vi.fn();
+      storage.streamingQueue?.push(callback, CO_VALUE_PRIORITY.MEDIUM);
+
+      // Before emit, callback should not be called
+      expect(callback).not.toHaveBeenCalled();
+
+      // After emit, processQueues should be triggered
+      storage.streamingQueue?.emit();
+
+      await waitFor(() => callback.mock.calls.length > 0);
+      expect(callback).toHaveBeenCalled();
+    });
+
+    test("setStorage should connect queue listener", async () => {
+      const client = setupTestNode();
+
+      // Before adding storage, there's no queue
+      const queueBefore = (
+        client.node.syncManager as any
+      ).getStorageStreamingQueue?.();
+      expect(queueBefore).toBeUndefined();
+
+      // After adding storage, queue should be available
+      const { storage } = client.addStorage();
+      const queueAfter = (
+        client.node.syncManager as any
+      ).getStorageStreamingQueue?.();
+      expect(queueAfter).toBe(storage.streamingQueue);
+    });
+  });
+});

package/src/tests/setup.ts

@@ -0,0 +1,4 @@
+import { cojsonInternals } from "../exports.js";
+
+// Use a very high budget to avoid that slow tests fail due to the budget being exceeded.
+cojsonInternals.setIncomingMessagesTimeBudget(10000); // 10 seconds

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

@@ -1,13 +1,11 @@
-import { assert, beforeEach, describe, expect, test, vi } from "vitest";
+import { beforeEach, describe, expect, test } from "vitest";
 
 import { setGarbageCollectorMaxAge } from "../config";
-import { emptyKnownState } from "../exports";
 import {
   SyncMessagesLog,
   TEST_NODE_CONFIG,
   loadCoValueOrFail,
   setupTestNode,
-  waitFor,
 } from "./testUtils";
 
 // We want to simulate a real world communication that happens asynchronously

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

@@ -553,6 +553,14 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "edge -> core | LOAD Map sessions: header/100",
         "edge -> client | CONTENT Group header: true new: After: 0 New: 5",
         "edge -> client | CONTENT Map header: true new: After: 0 New: 21 expectContentUntil: header/100",
+        "storage -> edge | CONTENT Map header: true new: After: 21 New: 21",
+        "edge -> client | CONTENT Map header: false new: After: 21 New: 21 expectContentUntil: header/100",
+        "storage -> edge | CONTENT Map header: true new: After: 42 New: 21",
+        "edge -> client | CONTENT Map header: false new: After: 42 New: 21 expectContentUntil: header/100",
+        "storage -> edge | CONTENT Map header: true new: After: 63 New: 21",
+        "edge -> client | CONTENT Map header: false new: After: 63 New: 21 expectContentUntil: header/100",
+        "storage -> edge | CONTENT Map header: true new: After: 84 New: 16",
+        "edge -> client | CONTENT Map header: false new: After: 84 New: 16",
         "core -> storage | LOAD Group sessions: empty",
         "storage -> core | KNOWN Group sessions: empty",
         "core -> edge | KNOWN Group sessions: empty",
@@ -563,16 +571,20 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "client -> storage | CONTENT Group header: true new: After: 0 New: 5",
         "client -> edge | KNOWN Map sessions: header/21",
         "client -> storage | CONTENT Map header: true new: After: 0 New: 21",
-        "storage -> edge | CONTENT Map header: true new: After: 21 New: 21",
-        "edge -> client | CONTENT Map header: false new: After: 21 New: 21 expectContentUntil: header/100",
+        "client -> edge | KNOWN Map sessions: header/42",
+        "client -> storage | CONTENT Map header: false new: After: 21 New: 21",
+        "client -> edge | KNOWN Map sessions: header/63",
+        "client -> storage | CONTENT Map header: false new: After: 42 New: 21",
+        "client -> edge | KNOWN Map sessions: header/84",
+        "client -> storage | CONTENT Map header: false new: After: 63 New: 21",
+        "client -> edge | KNOWN Map sessions: header/100",
+        "client -> storage | CONTENT Map header: false new: After: 84 New: 16",
         "edge -> core | CONTENT Group header: true new: After: 0 New: 5",
         "edge -> core | CONTENT Map header: true new: After: 0 New: 21 expectContentUntil: header/100",
         "edge -> core | CONTENT Map header: false new: After: 21 New: 21",
-        "client -> edge | KNOWN Map sessions: header/42",
-        "client -> storage | CONTENT Map header: false new: After: 21 New: 21",
-        "storage -> edge | CONTENT Map header: true new: After: 42 New: 21",
-        "edge -> core | CONTENT Map header: false new: After: 42 New: 21 expectContentUntil: header/100",
-        "edge -> client | CONTENT Map header: false new: After: 42 New: 21 expectContentUntil: header/100",
+        "edge -> core | CONTENT Map header: false new: After: 42 New: 21",
+        "edge -> core | CONTENT Map header: false new: After: 63 New: 21",
+        "edge -> core | CONTENT Map header: false new: After: 84 New: 16",
         "core -> edge | KNOWN Group sessions: header/5",
         "core -> storage | CONTENT Group header: true new: After: 0 New: 5",
         "core -> edge | KNOWN Map sessions: header/21",
@@ -581,22 +593,10 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "core -> storage | CONTENT Map header: false new: After: 21 New: 21",
         "core -> edge | KNOWN Map sessions: header/63",
         "core -> storage | CONTENT Map header: false new: After: 42 New: 21",
-        "client -> edge | KNOWN Map sessions: header/63",
-        "client -> storage | CONTENT Map header: false new: After: 42 New: 21",
-        "storage -> edge | CONTENT Map header: true new: After: 63 New: 21",
-        "edge -> core | CONTENT Map header: false new: After: 63 New: 21 expectContentUntil: header/100",
-        "edge -> client | CONTENT Map header: false new: After: 63 New: 21 expectContentUntil: header/100",
         "core -> edge | KNOWN Map sessions: header/84",
         "core -> storage | CONTENT Map header: false new: After: 63 New: 21",
-        "client -> edge | KNOWN Map sessions: header/84",
-        "client -> storage | CONTENT Map header: false new: After: 63 New: 21",
-        "storage -> edge | CONTENT Map header: true new: After: 84 New: 16",
-        "edge -> core | CONTENT Map header: false new: After: 84 New: 16",
-        "edge -> client | CONTENT Map header: false new: After: 84 New: 16",
         "core -> edge | KNOWN Map sessions: header/100",
         "core -> storage | CONTENT Map header: false new: After: 84 New: 16",
-        "client -> edge | KNOWN Map sessions: header/100",
-        "client -> storage | CONTENT Map header: false new: After: 84 New: 16",
       ]
     `);
 

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

@@ -8,7 +8,7 @@ import {
   vi,
 } from "vitest";
 
-import { emptyKnownState } from "../exports";
+import { cojsonInternals, emptyKnownState } from "../exports";
 import {
   SyncMessagesLog,
   TEST_NODE_CONFIG,
@@ -24,6 +24,10 @@ import { stableStringify } from "../jsonStringify";
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
 
+beforeEach(() => {
+  cojsonInternals.setIncomingMessagesTimeBudget(10_000);
+});
+
 describe("client with storage syncs with server", () => {
   let jazzCloud: ReturnType<typeof setupTestNode>;
 
@@ -356,13 +360,6 @@ describe("client syncs with a server with storage", () => {
 
     await largeMap.core.waitForSync();
 
-    // Test streaming counter during initial sync
-    // The streaming counter should be 0 after the sync is complete
-    const streamingCounterAfterSync = await metricReader.getMetricValue(
-      "jazz.storage.streaming",
-    );
-    expect(streamingCounterAfterSync).toBe(0);
-
     expect(
       SyncMessagesLog.getMessages({
         Group: group.core,
@@ -403,31 +400,11 @@ describe("client syncs with a server with storage", () => {
       storage,
     });
 
-    // Test streaming counter before loading the large coValue
-    const streamingCounterBeforeLoad = await metricReader.getMetricValue(
-      "jazz.storage.streaming",
-    );
-    expect(streamingCounterBeforeLoad).toBe(0);
-
     const promise = loadCoValueOrFail(client.node, largeMap.id);
 
-    // Test streaming counter during loading (should be 1 during streaming)
-    const streamingCounterDuringLoad = await metricReader.getMetricValue(
-      "jazz.storage.streaming",
-    );
-    expect(streamingCounterDuringLoad).toBe(1);
-
     const mapOnClient2 = await promise;
     await mapOnClient2.core.waitForFullStreaming();
 
-    // Test streaming counter after loading is complete (should be 0)
-    await waitFor(async () => {
-      const streamingCounterAfterLoad = await metricReader.getMetricValue(
-        "jazz.storage.streaming",
-      );
-      expect(streamingCounterAfterLoad).toBe(0);
-    });
-
     expect(
       SyncMessagesLog.getMessages({
         Group: group.core,
@@ -440,8 +417,6 @@ describe("client syncs with a server with storage", () => {
         "client -> server | LOAD Group sessions: header/5",
         "storage -> client | CONTENT Map header: true new: After: 0 New: 73 expectContentUntil: header/200",
         "client -> server | LOAD Map sessions: header/200",
-        "server -> client | KNOWN Group sessions: header/5",
-        "server -> client | KNOWN Map sessions: header/200",
         "storage -> client | CONTENT Map header: true new: After: 73 New: 73",
         "storage -> client | CONTENT Map header: true new: After: 146 New: 54",
       ]
@@ -830,16 +805,233 @@ describe("client syncs with a server with storage", () => {
         "server -> bob | CONTENT Map header: true new: After: 0 New: 1",
         "storage -> syncServer | CONTENT ParentGroup header: true new: After: 76 New: 73",
         "server -> bob | CONTENT ParentGroup header: false new: After: 76 New: 73 expectContentUntil: header/205",
+        "storage -> syncServer | CONTENT ParentGroup header: true new: After: 149 New: 56",
+        "server -> bob | CONTENT ParentGroup header: false new: After: 149 New: 56",
         "bob -> server | KNOWN ParentGroup sessions: header/76",
         "bob -> server | KNOWN Group sessions: header/5",
         "bob -> server | KNOWN Map sessions: header/1",
         "bob -> server | KNOWN ParentGroup sessions: header/149",
-        "storage -> syncServer | CONTENT ParentGroup header: true new: After: 149 New: 56",
-        "server -> bob | CONTENT ParentGroup header: false new: After: 149 New: 56",
         "bob -> server | KNOWN ParentGroup sessions: header/205",
       ]
     `);
 
     expect(mapOnBob.get("hello")).toEqual("world");
   });
+
+  describe("storage content streaming queue", () => {
+    test("multiple CoValues can stream concurrently", async () => {
+      cojsonInternals.setIncomingMessagesTimeBudget(0); // Should force the queue processing to be async
+
+      const client = setupTestNode();
+      client.connectToSyncServer();
+      const { storage } = client.addStorage();
+
+      const group = jazzCloud.node.createGroup();
+      const map1 = group.createMap();
+      const map2 = group.createMap();
+      const map3 = group.createMap();
+
+      fillCoMapWithLargeData(map1);
+      fillCoMapWithLargeData(map2);
+      fillCoMapWithLargeData(map3);
+
+      // Load all and sync to storage
+      await Promise.all([
+        loadCoValueOrFail(client.node, map1.id),
+        loadCoValueOrFail(client.node, map2.id),
+        loadCoValueOrFail(client.node, map3.id),
+      ]);
+      await Promise.all([
+        map1.core.waitForSync(),
+        map2.core.waitForSync(),
+        map3.core.waitForSync(),
+      ]);
+
+      // Restart to load from storage
+      client.restart();
+      client.addStorage({ storage });
+
+      // Load all maps concurrently from storage
+      const [loadedMap1, loadedMap2, loadedMap3] = await Promise.all([
+        loadCoValueOrFail(client.node, map1.id),
+        loadCoValueOrFail(client.node, map2.id),
+        loadCoValueOrFail(client.node, map3.id),
+      ]);
+
+      // Wait for all to complete streaming
+      await Promise.all([
+        loadedMap1.core.waitForAsync((value) => value.isCompletelyDownloaded()),
+        loadedMap2.core.waitForAsync((value) => value.isCompletelyDownloaded()),
+        loadedMap3.core.waitForAsync((value) => value.isCompletelyDownloaded()),
+      ]);
+
+      // All content should be loaded
+      expect(loadedMap1.core.isCompletelyDownloaded()).toBe(true);
+      expect(loadedMap2.core.isCompletelyDownloaded()).toBe(true);
+      expect(loadedMap3.core.isCompletelyDownloaded()).toBe(true);
+
+      // Queue should be empty
+      expect(storage.streamingQueue?.isEmpty()).toBe(true);
+    });
+
+    test("large content streaming interleaved with incoming messages", async () => {
+      cojsonInternals.setIncomingMessagesTimeBudget(0); // Should force the queue processing to be async
+
+      const client = setupTestNode();
+      client.connectToSyncServer();
+      const { storage } = client.addStorage();
+
+      // Create a large map on the server and sync to client storage
+      const group = jazzCloud.node.createGroup();
+      const largeMap = group.createMap();
+      fillCoMapWithLargeData(largeMap);
+
+      await loadCoValueOrFail(client.node, largeMap.id);
+      await largeMap.core.waitForSync();
+
+      SyncMessagesLog.clear();
+
+      // Restart client with storage
+      client.restart();
+      client.connectToSyncServer();
+      client.addStorage({ storage });
+
+      // Create a new small map on the server (will come as incoming message)
+      const smallMap = group.createMap();
+      smallMap.set("hello", "world", "trusting");
+
+      // Load both simultaneously - large from storage, small from server
+      const [loadedLargeMap, loadedSmallMap] = await Promise.all([
+        loadCoValueOrFail(client.node, largeMap.id),
+        loadCoValueOrFail(client.node, smallMap.id),
+      ]);
+
+      // Wait for complete download
+      await Promise.all([
+        loadedLargeMap.core.waitForAsync((value) =>
+          value.isCompletelyDownloaded(),
+        ),
+        loadedSmallMap.core.waitForAsync((value) =>
+          value.isCompletelyDownloaded(),
+        ),
+      ]);
+
+      // Both should be loaded correctly
+      expect(loadedLargeMap.core.isCompletelyDownloaded()).toBe(true);
+      expect(loadedSmallMap.get("hello")).toEqual("world");
+    });
+
+    test("large parent group streaming from storage", async () => {
+      cojsonInternals.setIncomingMessagesTimeBudget(0);
+
+      const syncServer = setupTestNode({
+        isSyncServer: true,
+      });
+      const { storage } = syncServer.addStorage({
+        ourName: "syncServer",
+      });
+
+      const alice = setupTestNode();
+      alice.connectToSyncServer({
+        syncServer: syncServer.node,
+      });
+
+      const parentGroup = alice.node.createGroup();
+      const group = alice.node.createGroup();
+      group.extend(parentGroup);
+
+      const map = group.createMap();
+
+      fillCoMapWithLargeData(parentGroup);
+
+      parentGroup.addMember("everyone", "reader");
+
+      map.set("hello", "world");
+
+      await map.core.waitForSync();
+      await parentGroup.core.waitForSync();
+
+      expect(
+        SyncMessagesLog.getMessages({
+          Group: group.core,
+          ParentGroup: parentGroup.core,
+          Map: map.core,
+        }),
+      ).toMatchInlineSnapshot(`
+      [
+        "client -> server | CONTENT ParentGroup header: true new: After: 0 New: 3",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 5",
+        "client -> server | CONTENT Map header: true new: ",
+        "client -> server | CONTENT ParentGroup header: false new: After: 3 New: 73 expectContentUntil: header/205",
+        "client -> server | CONTENT ParentGroup header: false new: After: 76 New: 73",
+        "client -> server | CONTENT ParentGroup header: false new: After: 149 New: 56",
+        "client -> server | CONTENT Map header: false new: After: 0 New: 1",
+        "server -> client | KNOWN ParentGroup sessions: header/3",
+        "syncServer -> storage | CONTENT ParentGroup header: true new: After: 0 New: 3",
+        "server -> client | KNOWN Group sessions: header/5",
+        "syncServer -> storage | CONTENT Group header: true new: After: 0 New: 5",
+        "server -> client | KNOWN Map sessions: header/0",
+        "syncServer -> storage | CONTENT Map header: true new: ",
+        "server -> client | KNOWN ParentGroup sessions: header/76",
+        "syncServer -> storage | CONTENT ParentGroup header: false new: After: 3 New: 73",
+        "server -> client | KNOWN ParentGroup sessions: header/149",
+        "syncServer -> storage | CONTENT ParentGroup header: false new: After: 76 New: 73",
+        "server -> client | KNOWN ParentGroup sessions: header/205",
+        "syncServer -> storage | CONTENT ParentGroup header: false new: After: 149 New: 56",
+        "server -> client | KNOWN Map sessions: header/1",
+        "syncServer -> storage | CONTENT Map header: false new: After: 0 New: 1",
+      ]
+    `);
+
+      SyncMessagesLog.clear();
+
+      syncServer.restart();
+      syncServer.addStorage({
+        ourName: "syncServer",
+        storage,
+      });
+
+      const bob = setupTestNode();
+      bob.connectToSyncServer({
+        syncServer: syncServer.node,
+        ourName: "bob",
+      });
+
+      let mapOnBob = await loadCoValueOrFail(bob.node, map.id);
+
+      await mapOnBob.core.waitForAsync((value) =>
+        value.isCompletelyDownloaded(),
+      );
+
+      expect(
+        SyncMessagesLog.getMessages({
+          ParentGroup: parentGroup.core,
+          Group: group.core,
+          Map: map.core,
+        }),
+      ).toMatchInlineSnapshot(`
+        [
+          "bob -> server | LOAD Map sessions: empty",
+          "syncServer -> storage | LOAD Map sessions: empty",
+          "storage -> syncServer | CONTENT ParentGroup header: true new: After: 0 New: 76 expectContentUntil: header/205",
+          "storage -> syncServer | CONTENT Group header: true new: After: 0 New: 5",
+          "storage -> syncServer | CONTENT Map header: true new: After: 0 New: 1",
+          "server -> bob | CONTENT ParentGroup header: true new: After: 0 New: 76 expectContentUntil: header/205",
+          "server -> bob | CONTENT Group header: true new: After: 0 New: 5",
+          "server -> bob | CONTENT Map header: true new: After: 0 New: 1",
+          "storage -> syncServer | CONTENT ParentGroup header: true new: After: 76 New: 73",
+          "server -> bob | CONTENT ParentGroup header: false new: After: 76 New: 73 expectContentUntil: header/205",
+          "bob -> server | KNOWN ParentGroup sessions: header/76",
+          "storage -> syncServer | CONTENT ParentGroup header: true new: After: 149 New: 56",
+          "server -> bob | CONTENT ParentGroup header: false new: After: 149 New: 56",
+          "bob -> server | KNOWN Group sessions: header/5",
+          "bob -> server | KNOWN Map sessions: header/1",
+          "bob -> server | KNOWN ParentGroup sessions: header/149",
+          "bob -> server | KNOWN ParentGroup sessions: header/205",
+        ]
+      `);
+
+      expect(mapOnBob.get("hello")).toEqual("world");
+    });
+  });
 });