cojson 0.20.9 → 0.20.10

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

@@ -1,6 +1,8 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import {
   CO_VALUE_LOADING_CONFIG,
+  GARBAGE_COLLECTOR_CONFIG,
+  setGarbageCollectorMaxAge,
   setMaxInFlightLoadsPerPeer,
 } from "../config.js";
 import {
@@ -19,6 +21,7 @@ let jazzCloud: ReturnType<typeof setupTestNode>;
 // Store original config values
 let originalMaxInFlightLoads: number;
 let originalTimeout: number;
+let originalGarbageCollectorMaxAge: number;
 
 beforeEach(async () => {
   // We want to simulate a real world communication that happens asynchronously
@@ -27,6 +30,7 @@ beforeEach(async () => {
   originalMaxInFlightLoads =
     CO_VALUE_LOADING_CONFIG.MAX_IN_FLIGHT_LOADS_PER_PEER;
   originalTimeout = CO_VALUE_LOADING_CONFIG.TIMEOUT;
+  originalGarbageCollectorMaxAge = GARBAGE_COLLECTOR_CONFIG.MAX_AGE;
 
   SyncMessagesLog.clear();
   jazzCloud = setupTestNode({ isSyncServer: true });
@@ -36,6 +40,7 @@ afterEach(() => {
   // Restore original config
   setMaxInFlightLoadsPerPeer(originalMaxInFlightLoads);
   CO_VALUE_LOADING_CONFIG.TIMEOUT = originalTimeout;
+  setGarbageCollectorMaxAge(originalGarbageCollectorMaxAge);
   vi.useRealTimers();
 });
 
@@ -474,6 +479,88 @@ describe("concurrent load", () => {
     `);
   });
 
+  test("should forward client LOAD to core even when edge is at concurrency limit", async () => {
+    setMaxInFlightLoadsPerPeer(1);
+    CO_VALUE_LOADING_CONFIG.TIMEOUT = 60_000;
+
+    const core = jazzCloud;
+    const edge = setupTestNode({ connected: false });
+
+    const { peerOnServer: edgePeerOnCore, peerState: corePeerOnEdge } =
+      edge.connectToSyncServer({
+        ourName: "edge",
+        syncServerName: "core",
+        syncServer: core.node,
+        persistent: true,
+      });
+
+    const client = setupTestNode({ connected: false });
+    client.connectToSyncServer({
+      ourName: "client",
+      syncServerName: "edge",
+      syncServer: edge.node,
+    });
+
+    // Create two CoValues on core so edge has to forward LOADs to core.
+    const group = core.node.createGroup();
+    const map1 = group.createMap();
+    const map2 = group.createMap();
+
+    map1.set("key", "value1", "trusting");
+    map2.set("key", "value2", "trusting");
+
+    // Keep the first edge->core load in-flight to saturate the concurrency limit.
+    const blocker = blockMessageTypeOnOutgoingPeer(
+      edgePeerOnCore,
+      "content",
+      {},
+    );
+
+    const edgeLoadPromise = edge.node.loadCoValueCore(map1.id);
+
+    await waitFor(() => {
+      const simplified = SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map1: map1.core,
+        Map2: map2.core,
+      });
+      return simplified.some(
+        (m) => m === "edge -> core | LOAD Map1 sessions: empty",
+      );
+    });
+
+    // Ensure the edge->core peer is already at its concurrency limit (1 in-flight load).
+    // @ts-expect-error loadQueue is private
+    expect(corePeerOnEdge.loadQueue.inFlightCount).toBe(1);
+
+    SyncMessagesLog.clear();
+
+    // Now the client asks the edge for map2. Edge must forward the LOAD to core
+    // even though it already has an in-flight load to core and the limit is 1.
+    const clientLoadPromise = client.node.loadCoValueCore(map2.id);
+
+    await waitFor(() => {
+      const simplified = SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map1: map1.core,
+        Map2: map2.core,
+      });
+      expect(simplified).toContain("edge -> core | LOAD Map2 sessions: empty");
+      return true;
+    });
+
+    blocker.unblock();
+    blocker.sendBlockedMessages();
+
+    const [map1OnEdge, map2OnClient] = await Promise.all([
+      edgeLoadPromise,
+      clientLoadPromise,
+    ]);
+
+    expect(map1OnEdge.isAvailable()).toBe(true);
+    expect(map2OnClient.isAvailable()).toBe(true);
+  });
+
   test("should keep load slot occupied while streaming large CoValues", async () => {
     setMaxInFlightLoadsPerPeer(1);
 
@@ -647,4 +734,408 @@ describe("concurrent load", () => {
       ]
     `);
   });
+
+  test("should consider garbageCollected load requests processed when server replies with KNOWN", async () => {
+    setMaxInFlightLoadsPerPeer(1);
+    setGarbageCollectorMaxAge(-1);
+
+    const client = setupTestNode({
+      connected: false,
+    });
+    client.addStorage({ ourName: "client" });
+    client.node.enableGarbageCollector();
+
+    const group = client.node.createGroup();
+    const map1 = group.createMap();
+    const map2 = group.createMap();
+
+    map1.set("key", "value1", "trusting");
+    map2.set("key", "value2", "trusting");
+
+    const { peerState } = client.connectToSyncServer();
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // Disconnect and GC so the node keeps only garbageCollected shells with cached knownState.
+    peerState.gracefulShutdown();
+    client.node.garbageCollector?.collect();
+    client.node.garbageCollector?.collect();
+
+    const gcGroup = client.node.getCoValue(group.id);
+    const gcMap1 = client.node.getCoValue(map1.id);
+    const gcMap2 = client.node.getCoValue(map2.id);
+
+    expect(gcGroup.loadingState).toBe("garbageCollected");
+    expect(gcMap1.loadingState).toBe("garbageCollected");
+    expect(gcMap2.loadingState).toBe("garbageCollected");
+
+    SyncMessagesLog.clear();
+
+    client.connectToSyncServer();
+
+    await waitFor(() => {
+      const messages = SyncMessagesLog.getMessages({
+        Group: gcGroup,
+        Map1: gcMap1,
+        Map2: gcMap2,
+      });
+
+      expect(messages).toMatchInlineSnapshot(`
+        [
+          "client -> server | LOAD Group sessions: header/4",
+          "server -> client | KNOWN Group sessions: header/4",
+          "client -> server | LOAD Map1 sessions: header/1",
+          "server -> client | KNOWN Map1 sessions: header/1",
+          "client -> server | LOAD Map2 sessions: header/1",
+          "server -> client | KNOWN Map2 sessions: header/1",
+        ]
+      `);
+      return true;
+    });
+
+    // Create a new group to test that the load queue is now empty
+    const groupToTestTheLoadQueue = await loadCoValueOrFail(
+      client.node,
+      jazzCloud.node.createGroup().id,
+    );
+    expect(groupToTestTheLoadQueue.core.isAvailable()).toBe(true);
+  });
+
+  test("should load garbageCollected CoValues when receiving KNOWN from a peer", async () => {
+    setGarbageCollectorMaxAge(-1);
+
+    const client = setupTestNode({
+      connected: false,
+    });
+    client.addStorage({ ourName: "client" });
+    client.node.enableGarbageCollector();
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("key", "value", "trusting");
+
+    client.node.garbageCollector?.collect();
+    client.node.garbageCollector?.collect();
+
+    const gcMap = client.node.getCoValue(map.id);
+    expect(gcMap.loadingState).toBe("garbageCollected");
+
+    const { peerState } = client.connectToSyncServer({
+      skipReconciliation: true,
+    });
+
+    const loadSpy = vi.spyOn(client.node, "loadCoValueCore");
+
+    client.node.syncManager.handleKnownState(
+      {
+        action: "known",
+        id: map.id,
+        header: false,
+        sessions: {},
+      },
+      peerState,
+    );
+
+    expect(loadSpy).toHaveBeenCalledWith(map.id);
+
+    loadSpy.mockRestore();
+  });
+
+  test("should consider onlyKnownState load requests processed when server replies with KNOWN", async () => {
+    setMaxInFlightLoadsPerPeer(1);
+
+    const client = setupTestNode({
+      connected: false,
+    });
+    const { storage } = client.addStorage({ ourName: "client" });
+
+    const group = client.node.createGroup();
+    const map1 = group.createMap();
+    const map2 = group.createMap();
+
+    map1.set("key", "value1", "trusting");
+    map2.set("key", "value2", "trusting");
+
+    const { peerState } = client.connectToSyncServer();
+    await client.node.syncManager.waitForAllCoValuesSync();
+    peerState.gracefulShutdown();
+
+    await client.restart();
+    client.addStorage({ storage });
+
+    const onlyKnownGroup = client.node.getCoValue(group.id);
+    const onlyKnownMap1 = client.node.getCoValue(map1.id);
+    const onlyKnownMap2 = client.node.getCoValue(map2.id);
+
+    await Promise.all([
+      new Promise<void>((resolve) =>
+        onlyKnownGroup.getKnownStateFromStorage(() => resolve()),
+      ),
+      new Promise<void>((resolve) =>
+        onlyKnownMap1.getKnownStateFromStorage(() => resolve()),
+      ),
+      new Promise<void>((resolve) =>
+        onlyKnownMap2.getKnownStateFromStorage(() => resolve()),
+      ),
+    ]);
+
+    expect(onlyKnownGroup.loadingState).toBe("onlyKnownState");
+    expect(onlyKnownMap1.loadingState).toBe("onlyKnownState");
+    expect(onlyKnownMap2.loadingState).toBe("onlyKnownState");
+
+    SyncMessagesLog.clear();
+
+    client.connectToSyncServer();
+
+    await waitFor(() => {
+      const messages = SyncMessagesLog.getMessages({
+        Group: onlyKnownGroup,
+        Map1: onlyKnownMap1,
+        Map2: onlyKnownMap2,
+      });
+
+      expect(messages).toMatchInlineSnapshot(`
+        [
+          "client -> server | LOAD Group sessions: header/4",
+          "server -> client | KNOWN Group sessions: header/4",
+          "client -> server | LOAD Map1 sessions: header/1",
+          "server -> client | KNOWN Map1 sessions: header/1",
+          "client -> server | LOAD Map2 sessions: header/1",
+          "server -> client | KNOWN Map2 sessions: header/1",
+        ]
+      `);
+      return true;
+    });
+
+    // Create a new group to test that the load queue is now empty
+    const groupToTestTheLoadQueue = await loadCoValueOrFail(
+      client.node,
+      jazzCloud.node.createGroup().id,
+    );
+    expect(groupToTestTheLoadQueue.core.isAvailable()).toBe(true);
+  });
+
+  test("should keep onlyKnownState while peer load is pending and KNOWN replies arrive", async () => {
+    const client = setupTestNode({
+      connected: false,
+    });
+    const { storage } = client.addStorage({ ourName: "client" });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("key", "value", "trusting");
+
+    const initialConnection = client.connectToSyncServer();
+    await client.node.syncManager.waitForAllCoValuesSync();
+    initialConnection.peerState.gracefulShutdown();
+
+    await client.restart();
+    client.addStorage({ storage });
+
+    const onlyKnownMap = client.node.getCoValue(map.id);
+    await new Promise<void>((resolve) =>
+      onlyKnownMap.getKnownStateFromStorage(() => resolve()),
+    );
+    expect(onlyKnownMap.loadingState).toBe("onlyKnownState");
+
+    // Force explicit loads to use peers (not local full-content storage).
+    vi.spyOn(storage, "load").mockImplementation(
+      async (_id: unknown, _cb: unknown, done: (result: boolean) => void) =>
+        done(false),
+    );
+
+    const { peerState } = client.connectToSyncServer({
+      skipReconciliation: true,
+    });
+
+    SyncMessagesLog.clear();
+
+    onlyKnownMap.load([peerState]);
+
+    await waitFor(() => {
+      const messages = SyncMessagesLog.getMessages({
+        Group: client.node.getCoValue(group.id),
+        Map: onlyKnownMap,
+      });
+
+      expect(messages).toContain(
+        "client -> server | LOAD Map sessions: header/1",
+      );
+      expect(messages).toContain(
+        "server -> client | KNOWN Map sessions: header/1",
+      );
+      return true;
+    });
+
+    expect(onlyKnownMap.getLoadingStateForPeer(peerState.id)).toBe("pending");
+    expect(onlyKnownMap.loadingState).toBe("onlyKnownState");
+  });
+
+  /**
+   * This test covers the case where the client is streaming a value from storage and since the value is already on the server
+   * the server sends only a KNOWN message.
+   *
+   * Without a specialized logic the value results inStreaming and the "load" would be considered in-flight indefinitely.
+   */
+  test("should process queued loads when KNOWN arrives while first CoValue is streaming from storage", async () => {
+    setMaxInFlightLoadsPerPeer(1);
+
+    const client = setupTestNode({
+      connected: true,
+    });
+    const { storage } = await client.addAsyncStorage({ ourName: "client" });
+
+    const group = jazzCloud.node.createGroup();
+    const streamingMap = group.createMap();
+    fillCoMapWithLargeData(streamingMap);
+
+    const queuedMap = group.createMap();
+    queuedMap.set("key", "value", "trusting");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, streamingMap.id);
+    await mapOnClient.core.waitForFullStreaming();
+
+    await client.restart();
+    client.addStorage({ storage });
+    client.connectToSyncServer();
+
+    SyncMessagesLog.clear();
+
+    const originalLoad = storage.load.bind(storage);
+    let firstChunk = true;
+    const pausedOps: (() => void)[] = [];
+
+    vi.spyOn(storage, "load").mockImplementation(async (id, callback, done) => {
+      if (id !== streamingMap.id) {
+        return originalLoad(id, callback, done);
+      }
+
+      return originalLoad(
+        id,
+        (chunk) => {
+          if (firstChunk) {
+            firstChunk = false;
+            callback(chunk);
+          } else {
+            pausedOps.push(() => callback(chunk));
+          }
+        },
+        (found) => {
+          pausedOps.push(() => done(found));
+        },
+      );
+    });
+
+    const streamingMapOnClientPromise = client.node.loadCoValueCore(
+      streamingMap.id,
+    );
+
+    await waitFor(() => {
+      expect(firstChunk).toBe(false);
+    });
+
+    const queuedMapOnClient = await client.node.loadCoValueCore(queuedMap.id);
+
+    expect(queuedMapOnClient.isAvailable()).toBe(true);
+
+    for (const op of pausedOps) {
+      op();
+    }
+
+    const streamingMapOnClient = await streamingMapOnClientPromise;
+    expect(streamingMapOnClient.isStreaming()).toBe(false);
+  });
+
+  test("should process queued loads when CoValue instance changes while in-flight", async () => {
+    setMaxInFlightLoadsPerPeer(1);
+
+    const client = setupTestNode({
+      connected: false,
+    });
+    const { storage } = client.addStorage({ ourName: "client" });
+
+    const { peerOnServer } = client.connectToSyncServer();
+
+    const group = jazzCloud.node.createGroup();
+    const map1 = group.createMap();
+    const map2 = group.createMap();
+
+    map1.set("key", "value1", "trusting");
+    map2.set("key", "value2", "trusting");
+
+    // Prime map1 locally so GC leaves a shell with knownState.
+    await loadCoValueOrFail(client.node, map1.id);
+
+    // Force load attempts to go through peers instead of satisfying from storage.
+    vi.spyOn(storage, "load").mockImplementation(
+      async (_id: unknown, _cb: unknown, done: (result: boolean) => void) =>
+        done(false),
+    );
+
+    const unmounted = client.node.internalUnmountCoValue(map1.id);
+    expect(unmounted).toBe(true);
+    expect(client.node.getCoValue(map1.id).loadingState).toBe(
+      "garbageCollected",
+    );
+
+    const blockedKnown = blockMessageTypeOnOutgoingPeer(peerOnServer, "known", {
+      id: map1.id,
+    });
+
+    SyncMessagesLog.clear();
+
+    const map1LoadPromise = client.node.loadCoValueCore(map1.id);
+    const map2LoadPromise = client.node.loadCoValueCore(map2.id);
+
+    await waitFor(() => {
+      expect(
+        SyncMessagesLog.messages.some(
+          (m) => m.msg.action === "load" && m.msg.id === map1.id,
+        ),
+      ).toBe(true);
+      return true;
+    });
+
+    // Queue is saturated by map1 while KNOWN(Map1) is blocked.
+    expect(
+      SyncMessagesLog.messages.some(
+        (m) => m.msg.action === "load" && m.msg.id === map2.id,
+      ),
+    ).toBe(false);
+
+    // Replace the in-flight CoValue instance with a new one (same id).
+    const oldMap1Core = client.node.getCoValue(map1.id);
+    const oldMap1KnownState = oldMap1Core.knownState();
+    client.node.internalDeleteCoValue(map1.id);
+
+    const newMap1Core = client.node.getCoValue(map1.id);
+    expect(newMap1Core).not.toBe(oldMap1Core);
+    newMap1Core.setGarbageCollectedState(oldMap1KnownState);
+    expect(newMap1Core.loadingState).toBe("garbageCollected");
+
+    // Deliver KNOWN(Map1). With ID-based tracking, this should free the slot and send LOAD(Map2).
+    blockedKnown.unblock();
+    blockedKnown.sendBlockedMessages();
+
+    await waitFor(() => {
+      expect(
+        SyncMessagesLog.messages.some(
+          (m) => m.msg.action === "known" && m.msg.id === map1.id,
+        ),
+      ).toBe(true);
+      expect(
+        SyncMessagesLog.messages.some(
+          (m) => m.msg.action === "load" && m.msg.id === map2.id,
+        ),
+      ).toBe(true);
+      return true;
+    });
+
+    // The critical behavior is that map2 starts loading after KNOWN(map1).
+    const map2OnClient = await loadCoValueOrFail(client.node, map2.id);
+    expect(map2OnClient.get("key")).toBe("value2");
+
+    // Avoid unhandled promise rejection in case these earlier promises resolve later.
+    void map1LoadPromise;
+    void map2LoadPromise;
+  });
 });

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

@@ -63,6 +63,7 @@ describe("sync after the garbage collector has run", () => {
         "storage -> server | CONTENT Map header: true new: After: 0 New: 1",
         "server -> client | CONTENT Group header: true new: After: 0 New: 4",
         "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Map sessions: header/1",
         "client -> server | KNOWN Group sessions: header/4",
         "client -> server | KNOWN Map sessions: header/1",
       ]
@@ -105,6 +106,7 @@ describe("sync after the garbage collector has run", () => {
         "storage -> server | CONTENT Map header: true new: After: 0 New: 1",
         "server -> client | CONTENT Group header: true new: After: 0 New: 4",
         "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Map sessions: header/1",
         "client -> server | KNOWN Group sessions: header/4",
         "client -> server | KNOWN Map sessions: header/1",
       ]
@@ -203,6 +205,8 @@ describe("sync after the garbage collector has run", () => {
         "server -> storage | CONTENT Group header: true new: After: 0 New: 4",
         "server -> client | KNOWN Map sessions: header/1",
         "server -> storage | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> storage | LOAD Map sessions: empty",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 1",
       ]
     `);
   });

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

@@ -656,6 +656,31 @@ describe("loading coValues from server", () => {
     `);
   });
 
+  test("should mark closed persistent peers as unavailable after grace timeout", async () => {
+    vi.useFakeTimers();
+
+    const client = setupTestNode();
+    const connection = client.connectToSyncServer({
+      persistent: true,
+    });
+    connection.peerState.gracefulShutdown();
+
+    const group = jazzCloud.node.createGroup();
+    group.addMember("everyone", "writer");
+    const map = group.createMap({
+      test: "value",
+    });
+
+    const loadPromise = client.node.load(map.id, true);
+
+    await vi.advanceTimersByTimeAsync(CO_VALUE_LOADING_CONFIG.TIMEOUT + 10);
+
+    const coValue = await loadPromise;
+    expect(coValue).toBe("unavailable");
+
+    vi.useRealTimers();
+  });
+
   test("should handle reconnections in the middle of a load with a persistent peer", async () => {
     TEST_NODE_CONFIG.withAsyncPeers = false; // To avoid flakiness
 
@@ -1550,6 +1575,7 @@ describe("lazy storage load optimization", () => {
         "storage -> server | CONTENT Map header: true new: After: 0 New: 1",
         "server -> client | CONTENT Group header: true new: After: 0 New: 4",
         "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Map sessions: header/1",
         "client -> server | KNOWN Group sessions: header/4",
         "client -> server | KNOWN Map sessions: header/1",
       ]

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

@@ -556,6 +556,7 @@ 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: 6",
         "edge -> client | CONTENT Map header: true new: After: 0 New: 21 expectContentUntil: header/100",
+        "edge -> client | KNOWN Map sessions: 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",

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

@@ -2,9 +2,11 @@ import { assert, beforeEach, describe, expect, test } from "vitest";
 
 import { expectList, expectMap } from "../coValue";
 import { WasmCrypto } from "../crypto/WasmCrypto";
+import { CO_VALUE_LOADING_CONFIG, setCoValueLoadingTimeout } from "../config";
 import {
   SyncMessagesLog,
   TEST_NODE_CONFIG,
+  blockMessageTypeOnOutgoingPeer,
   fillCoMapWithLargeData,
   loadCoValueOrFail,
   setupTestNode,
@@ -26,16 +28,18 @@ beforeEach(async () => {
 });
 
 function connectServers(client: ReturnType<typeof setupTestNode>) {
-  client.connectToSyncServer({
+  const server1Connection = client.connectToSyncServer({
     ourName: "client",
     syncServerName: "server1",
     syncServer: server1.node,
   });
-  client.connectToSyncServer({
+  const server2Connection = client.connectToSyncServer({
     ourName: "client",
     syncServerName: "server2",
     syncServer: server2.node,
   });
+
+  return { server1Connection, server2Connection };
 }
 
 describe("multiple servers peers", () => {
@@ -394,6 +398,7 @@ describe("multiple servers peers", () => {
         "client -> server2 | KNOWN Group sessions: header/6",
         "client -> server2 | CONTENT Group header: false new: After: 0 New: 6",
         "client -> server2 | KNOWN Map sessions: header/0",
+        "server2 -> client | KNOWN Group sessions: header/6",
         "server2 -> client | KNOWN Map sessions: header/0",
         "server1 -> client | KNOWN Map sessions: header/73",
         "server1 -> client | CONTENT Map header: false new: After: 0 New: 73",
@@ -423,4 +428,57 @@ describe("multiple servers peers", () => {
       ]
     `);
   });
+
+  test("coValue loading times out on both servers", async () => {
+    const previousTimeout = CO_VALUE_LOADING_CONFIG.TIMEOUT;
+    setCoValueLoadingTimeout(20);
+
+    try {
+      const creator = setupTestNode();
+      connectServers(creator);
+
+      const group = creator.node.createGroup();
+      const map = group.createMap();
+      map.set("hello", "world", "trusting");
+      await map.core.waitForSync();
+
+      const client = setupTestNode();
+      const { server1Connection, server2Connection } = connectServers(client);
+
+      blockMessageTypeOnOutgoingPeer(
+        server1Connection.peerOnServer,
+        "content",
+        {
+          id: map.id,
+        },
+      );
+      blockMessageTypeOnOutgoingPeer(
+        server2Connection.peerOnServer,
+        "content",
+        {
+          id: map.id,
+        },
+      );
+
+      const loadedMap = await client.node.load(map.id, true);
+
+      expect(loadedMap).toBe("unavailable");
+    } finally {
+      setCoValueLoadingTimeout(previousTimeout);
+    }
+  });
+
+  test("coValue loading is unavailable on both servers", async () => {
+    const disconnectedNode = setupTestNode();
+    const group = disconnectedNode.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    const client = setupTestNode();
+    connectServers(client);
+
+    const loadedMap = await client.node.load(map.id, true);
+
+    expect(loadedMap).toBe("unavailable");
+  });
 });