cojson 0.13.16 → 0.13.18

package/src/tests/priority.test.ts

@@ -2,7 +2,11 @@ import { describe, expect, test } from "vitest";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { CO_VALUE_PRIORITY, getPriorityFromHeader } from "../priority.js";
-import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import {
+  createAccountInNode,
+  nodeWithRandomAgentAndSessionID,
+  randomAgentAndSessionID,
+} from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -14,7 +18,7 @@ describe("getPriorityFromHeader", () => {
   });
 
   test("returns MEDIUM priority for costream type", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const costream = node.createCoValue({
       type: "costream",
       ruleset: { type: "unsafeAllowAll" },
@@ -22,13 +26,13 @@ describe("getPriorityFromHeader", () => {
       ...Crypto.createdNowUnique(),
     });
 
-    expect(getPriorityFromHeader(costream.header)).toEqual(
+    expect(getPriorityFromHeader(costream.verified.header)).toEqual(
       CO_VALUE_PRIORITY.MEDIUM,
     );
   });
 
   test("returns LOW priority for binary costream type", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const costream = node.createCoValue({
       type: "costream",
       ruleset: { type: "unsafeAllowAll" },
@@ -36,32 +40,32 @@ describe("getPriorityFromHeader", () => {
       ...Crypto.createdNowUnique(),
     });
 
-    expect(getPriorityFromHeader(costream.header)).toEqual(
+    expect(getPriorityFromHeader(costream.verified.header)).toEqual(
       CO_VALUE_PRIORITY.LOW,
     );
   });
 
   test("returns HIGH priority for account type", async () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
 
-    const account = node.createAccount(node.crypto.newRandomAgentSecret());
+    const account = createAccountInNode(node);
 
-    expect(getPriorityFromHeader(account.core.header)).toEqual(
+    expect(getPriorityFromHeader(account.account.core.verified.header)).toEqual(
       CO_VALUE_PRIORITY.HIGH,
     );
   });
 
   test("returns HIGH priority for group type", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const group = node.createGroup();
 
-    expect(getPriorityFromHeader(group.core.header)).toEqual(
+    expect(getPriorityFromHeader(group.core.verified.header)).toEqual(
       CO_VALUE_PRIORITY.HIGH,
     );
   });
 
   test("returns MEDIUM priority for other types", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
 
     const comap = node.createCoValue({
       type: "comap",
@@ -77,10 +81,10 @@ describe("getPriorityFromHeader", () => {
       ...Crypto.createdNowUnique(),
     });
 
-    expect(getPriorityFromHeader(comap.header)).toEqual(
+    expect(getPriorityFromHeader(comap.verified.header)).toEqual(
       CO_VALUE_PRIORITY.MEDIUM,
     );
-    expect(getPriorityFromHeader(colist.header)).toEqual(
+    expect(getPriorityFromHeader(colist.verified.header)).toEqual(
       CO_VALUE_PRIORITY.MEDIUM,
     );
   });

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

@@ -0,0 +1,188 @@
+import { assert, beforeEach, describe, expect, test } from "vitest";
+
+import { expectMap } from "../coValue";
+import { expectAccount } from "../coValues/account";
+import { WasmCrypto } from "../crypto/WasmCrypto";
+import { LocalNode } from "../localNode";
+import { toSimplifiedMessages } from "./messagesTestUtils";
+import {
+  SyncMessagesLog,
+  getSyncServerConnectedPeer,
+  loadCoValueOrFail,
+  setupTestNode,
+  waitFor,
+} from "./testUtils";
+
+const Crypto = await WasmCrypto.create();
+let jazzCloud = setupTestNode({ isSyncServer: true });
+
+beforeEach(async () => {
+  SyncMessagesLog.clear();
+  jazzCloud = setupTestNode({ isSyncServer: true });
+});
+
+describe("LocalNode auth sync", () => {
+  test("create a new account", async () => {
+    const { peer } = getSyncServerConnectedPeer({
+      peerId: "new-account",
+    });
+
+    const { accountID, node } = await LocalNode.withNewlyCreatedAccount({
+      creationProps: {
+        name: "new-account",
+      },
+      peersToLoadFrom: [peer],
+      crypto: Crypto,
+    });
+
+    const account = node.expectCurrentAccount("after login");
+    await account.core.waitForSync();
+
+    const profileID = account.get("profile")!;
+
+    const profileCoreOnSyncServer = jazzCloud.node.getCoValue(profileID);
+
+    expect(profileCoreOnSyncServer.isAvailable()).toBe(true);
+
+    assert(profileCoreOnSyncServer.isAvailable());
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: account.core,
+        Profile: profileCoreOnSyncServer,
+        ProfileGroup: profileCoreOnSyncServer.getGroup().core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | CONTENT Account header: true new: After: 0 New: 4",
+        "server -> client | KNOWN Account sessions: header/4",
+        "client -> server | CONTENT ProfileGroup header: true new: After: 0 New: 5",
+        "server -> client | KNOWN ProfileGroup sessions: header/5",
+        "client -> server | CONTENT Profile header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Profile sessions: header/1",
+      ]
+    `);
+  });
+
+  test("create a new account with a migration", async () => {
+    const { peer } = getSyncServerConnectedPeer({
+      peerId: "new-account",
+    });
+
+    const { node } = await LocalNode.withNewlyCreatedAccount({
+      creationProps: {
+        name: "new-account",
+      },
+      peersToLoadFrom: [peer],
+      crypto: Crypto,
+      async migration(account) {
+        const root = account.createMap();
+        const profile = account.createMap();
+
+        root.set("hello", "world");
+        profile.set("name", "new-account");
+
+        account.set("root", root.id);
+        account.set("profile", profile.id);
+
+        await root.core.waitForSync();
+        await profile.core.waitForSync();
+      },
+    });
+
+    const account = node.expectCurrentAccount("after login");
+    await account.core.waitForSync();
+
+    const rootID = account.get("root")!;
+    const profileID = account.get("profile")!;
+
+    const rootCoreOnSyncServer = jazzCloud.node.getCoValue(rootID);
+    expect(rootCoreOnSyncServer.isAvailable()).toBe(true);
+
+    const profileCoreOnSyncServer = jazzCloud.node.getCoValue(profileID);
+
+    expect(profileCoreOnSyncServer.isAvailable()).toBe(true);
+
+    assert(profileCoreOnSyncServer.isAvailable());
+    assert(rootCoreOnSyncServer.isAvailable());
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: account.core,
+        Root: rootCoreOnSyncServer,
+        Profile: profileCoreOnSyncServer,
+        ProfileGroup: profileCoreOnSyncServer.getGroup().core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | CONTENT Account header: true new: After: 0 New: 5",
+        "server -> client | KNOWN Account sessions: header/5",
+        "client -> server | CONTENT Root header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Root sessions: header/1",
+        "client -> server | CONTENT Profile header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Profile sessions: header/1",
+      ]
+    `);
+  });
+
+  test("authenticate to an existing account", async () => {
+    const { peer: newAccountPeer } = getSyncServerConnectedPeer({
+      peerId: "new-account",
+    });
+
+    const { accountID, accountSecret } =
+      await LocalNode.withNewlyCreatedAccount({
+        creationProps: {
+          name: "new-account",
+        },
+        peersToLoadFrom: [newAccountPeer],
+        crypto: Crypto,
+      });
+
+    const { peer: existingAccountPeer } = getSyncServerConnectedPeer({
+      peerId: "existing-account",
+    });
+
+    SyncMessagesLog.clear();
+
+    const node = await LocalNode.withLoadedAccount({
+      accountID,
+      accountSecret,
+      peersToLoadFrom: [existingAccountPeer],
+      sessionID: undefined,
+      crypto: Crypto,
+    });
+
+    const account = node.expectCurrentAccount("after login");
+    const profile = node.getCoValue(account.get("profile")!);
+
+    assert(profile.isAvailable());
+
+    expect(account.id).toBe(accountID);
+    expect(node.agentSecret).toBe(accountSecret);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: account.core,
+        Profile: profile,
+        ProfileGroup: profile.getGroup().core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Account sessions: empty",
+        "server -> client | KNOWN Account sessions: header/4",
+        "client -> server | CONTENT ProfileGroup header: true new: After: 0 New: 5",
+        "server -> client | CONTENT Account header: true new: After: 0 New: 4",
+        "server -> client | KNOWN ProfileGroup sessions: header/5",
+        "client -> server | CONTENT Profile header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Account sessions: header/4",
+        "server -> client | KNOWN Profile sessions: header/1",
+        "client -> server | LOAD Profile sessions: empty",
+        "server -> client | CONTENT ProfileGroup header: true new: After: 0 New: 5",
+        "client -> server | KNOWN ProfileGroup sessions: header/5",
+        "server -> client | CONTENT Profile header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Profile sessions: header/1",
+      ]
+    `);
+  });
+});

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

@@ -45,6 +45,53 @@ describe("loading coValues from server", () => {
     `);
   });
 
+  test("unavailable coValue retry", async () => {
+    const client = setupTestNode();
+    const client2 = setupTestNode();
+
+    client2.connectToSyncServer({
+      ourName: "client2",
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    const promise = loadCoValueOrFail(client2.node, map.id);
+
+    await new Promise((resolve) => setTimeout(resolve, 1));
+
+    client.connectToSyncServer();
+
+    const mapOnClient2 = await promise;
+
+    expect(mapOnClient2.get("hello")).toEqual("world");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client2 -> server | LOAD Map sessions: empty",
+        "server -> client2 | KNOWN Map sessions: empty",
+        "client -> server | LOAD Group sessions: header/3",
+        "server -> client | KNOWN Group sessions: empty",
+        "client -> server | LOAD Map sessions: header/1",
+        "server -> client | KNOWN Map sessions: empty",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN Group sessions: header/3",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Map sessions: header/1",
+        "server -> client2 | CONTENT Group header: true new: After: 0 New: 3",
+        "client2 -> server | KNOWN Group sessions: header/3",
+        "server -> client2 | CONTENT Map header: true new: After: 0 New: 1",
+        "client2 -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
   test("coValue with parent groups loading", async () => {
     const client = setupTestNode({
       connected: true,
@@ -189,7 +236,7 @@ describe("loading coValues from server", () => {
     await loadCoValueOrFail(client.node, map.id);
 
     // Forcefully delete the coValue from the client (simulating some data loss)
-    client.node.coValuesStore.coValues.delete(map.id);
+    client.node.internalDeleteCoValue(map.id);
 
     map.set("fromServer", "updated", "trusting");
 
@@ -327,5 +374,35 @@ describe("loading coValues from server", () => {
     `);
   });
 
-  test.todo("should mark the coValue as unavailable if the peer is closed");
+  test("should mark the coValue as unavailable if the peer is closed", async () => {
+    const client = setupTestNode();
+    const { peerState } = client.connectToSyncServer();
+
+    const group = jazzCloud.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const map = group.createMap({
+      test: "value",
+    });
+
+    const promise = client.node.load(map.id);
+
+    // Close the peer connection
+    peerState.gracefulShutdown();
+
+    expect(await promise).toEqual("unavailable");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+      ]
+    `);
+  });
 });

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

@@ -3,6 +3,7 @@ import { beforeEach, describe, expect, test, vi } from "vitest";
 import { expectMap } from "../coValue";
 import {
   SyncMessagesLog,
+  blockMessageTypeOnOutgoingPeer,
   loadCoValueOrFail,
   setupTestNode,
   waitFor,
@@ -66,9 +67,13 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       [
         "edge-france -> core | CONTENT Group header: true new: After: 0 New: 3",
         "core -> edge-france | KNOWN Group sessions: header/3",
+        "core -> storage | LOAD Group sessions: header/3",
         "edge-france -> core | CONTENT Map header: true new: After: 0 New: 1",
-        "core -> storage | CONTENT Group header: true new: After: 0 New: 3",
+        "storage -> core | KNOWN Group sessions: empty",
         "core -> edge-france | KNOWN Map sessions: header/1",
+        "core -> storage | LOAD Map sessions: header/1",
+        "storage -> core | KNOWN Map sessions: empty",
+        "core -> storage | CONTENT Group header: true new: After: 0 New: 3",
         "storage -> core | KNOWN Group sessions: header/3",
         "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
         "storage -> core | KNOWN Map sessions: header/1",
@@ -118,13 +123,19 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       [
         "edge-france -> core | CONTENT ParentGroup header: true new: After: 0 New: 6",
         "core -> edge-france | KNOWN ParentGroup sessions: header/6",
+        "core -> storage | LOAD ParentGroup sessions: header/6",
         "edge-france -> core | CONTENT Group header: true new: After: 0 New: 5",
-        "core -> storage | CONTENT ParentGroup header: true new: After: 0 New: 6",
+        "storage -> core | KNOWN ParentGroup sessions: empty",
         "core -> edge-france | KNOWN Group sessions: header/5",
+        "core -> storage | LOAD Group sessions: header/5",
         "edge-france -> core | CONTENT Map header: true new: After: 0 New: 1",
+        "storage -> core | KNOWN Group sessions: empty",
+        "core -> storage | CONTENT ParentGroup header: true new: After: 0 New: 6",
+        "core -> edge-france | KNOWN Map sessions: header/1",
         "storage -> core | KNOWN ParentGroup sessions: header/6",
+        "core -> storage | LOAD Map sessions: header/1",
+        "storage -> core | KNOWN Map sessions: empty",
         "core -> storage | CONTENT Group header: true new: After: 0 New: 5",
-        "core -> edge-france | KNOWN Map sessions: header/1",
         "storage -> core | KNOWN Group sessions: header/5",
         "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
         "storage -> core | KNOWN Map sessions: header/1",
@@ -214,7 +225,7 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
     );
 
     // Forcefully delete the coValue from the edge (simulating some data loss)
-    mesh.edgeItaly.node.coValuesStore.coValues.delete(map.id);
+    mesh.edgeItaly.node.internalDeleteCoValue(map.id);
 
     mapOnClient.set("fromClient", "updated", "trusting");
     mapOnCoreServer.set("fromServer", "updated", "trusting");
@@ -238,12 +249,16 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "edge-italy -> core | CONTENT Group header: true new: After: 0 New: 5",
         "edge-italy -> client | CONTENT Group header: true new: After: 0 New: 5",
         "core -> edge-italy | KNOWN Group sessions: header/5",
+        "core -> storage | LOAD Group sessions: header/5",
         "edge-italy -> core | CONTENT Map header: true new: After: 0 New: 1",
         "client -> edge-italy | KNOWN Group sessions: header/5",
         "edge-italy -> client | CONTENT Map header: true new: After: 0 New: 1",
-        "core -> storage | CONTENT Group header: true new: After: 0 New: 5",
-        "core -> edge-italy | KNOWN Map sessions: header/1",
+        "storage -> core | KNOWN Group sessions: empty",
+        "core -> edge-italy | KNOWN Map sessions: header/3",
+        "core -> storage | LOAD Map sessions: header/3",
         "client -> edge-italy | KNOWN Map sessions: header/1",
+        "storage -> core | KNOWN Map sessions: empty",
+        "core -> storage | CONTENT Group header: true new: After: 0 New: 5",
         "storage -> core | KNOWN Group sessions: header/5",
         "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
         "storage -> core | KNOWN Map sessions: header/1",
@@ -256,12 +271,12 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "client -> edge-italy | CONTENT Map header: true new: After: 0 New: 1 | After: 0 New: 1",
         "core -> edge-italy | CONTENT Map header: true new: After: 0 New: 1 | After: 0 New: 1",
         "edge-italy -> client | KNOWN Map sessions: header/2",
-        "edge-italy -> core | KNOWN Map sessions: header/3",
-        "edge-italy -> client | CONTENT Map header: false new: After: 0 New: 1",
         "edge-italy -> core | CONTENT Map header: false new: After: 0 New: 1",
-        "client -> edge-italy | KNOWN Map sessions: header/3",
+        "edge-italy -> client | CONTENT Map header: false new: After: 0 New: 1",
         "core -> edge-italy | KNOWN Map sessions: header/3",
         "core -> storage | CONTENT Map header: false new: After: 0 New: 1",
+        "edge-italy -> core | KNOWN Map sessions: header/3",
+        "client -> edge-italy | KNOWN Map sessions: header/3",
         "storage -> core | KNOWN Map sessions: header/3",
       ]
     `);
@@ -322,4 +337,69 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       ]
     `);
   });
+
+  test("load returns the coValue as soon as one of the peers return the content", async () => {
+    const client = setupTestNode();
+    const coreServer = setupTestNode({
+      isSyncServer: true,
+    });
+
+    const { peerOnServer } = client.connectToSyncServer({
+      syncServerName: "core",
+    });
+
+    const storage = setupTestNode();
+
+    const { peer: storagePeer } = client.connectToSyncServer({
+      syncServerName: "storage",
+      syncServer: storage.node,
+    });
+
+    storagePeer.priority = 100;
+
+    const group = coreServer.node.createGroup();
+    const map = group.createMap();
+
+    map.set("hello", "world", "trusting");
+
+    const { peerState } = storage.connectToSyncServer({
+      ourName: "storage-of-client",
+      syncServerName: "core",
+    });
+
+    await loadCoValueOrFail(storage.node, map.id);
+
+    peerState.gracefulShutdown();
+
+    SyncMessagesLog.clear();
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    map.set("hello", "updated", "trusting");
+
+    // Block the content message from the core peer to simulate the delay on response
+    blockMessageTypeOnOutgoingPeer(peerOnServer, "content");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> storage | LOAD Map sessions: empty",
+        "storage -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> storage | KNOWN Group sessions: header/3",
+        "client -> core | LOAD Group sessions: header/3",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "core -> client | KNOWN Group sessions: header/3",
+        "client -> storage | KNOWN Map sessions: header/1",
+        "client -> core | LOAD Map sessions: header/1",
+      ]
+    `);
+
+    expect(mapOnClient.get("hello")).toEqual("world");
+  });
 });

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

@@ -31,12 +31,12 @@ describe("peer reconciliation", () => {
     ).toMatchInlineSnapshot(`
       [
         "client -> server | LOAD Group sessions: header/3",
-        "client -> server | LOAD Map sessions: header/1",
         "server -> client | KNOWN Group sessions: empty",
-        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> server | LOAD Map sessions: header/1",
         "server -> client | KNOWN Map sessions: empty",
-        "client -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
         "server -> client | KNOWN Group sessions: header/3",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 1",
         "server -> client | KNOWN Map sessions: header/1",
       ]
     `);
@@ -64,13 +64,13 @@ describe("peer reconciliation", () => {
 
     await map.core.waitForSync();
 
-    const mapOnSyncServer = jazzCloud.node.coValuesStore.get(map.id);
+    const mapOnSyncServer = jazzCloud.node.getCoValue(map.id);
 
     assert(mapOnSyncServer.isAvailable());
 
-    expect(
-      expectMap(mapOnSyncServer.core.getCurrentContent()).get("hello"),
-    ).toEqual("updated");
+    expect(expectMap(mapOnSyncServer.getCurrentContent()).get("hello")).toEqual(
+      "updated",
+    );
 
     expect(
       SyncMessagesLog.getMessages({
@@ -80,10 +80,10 @@ describe("peer reconciliation", () => {
     ).toMatchInlineSnapshot(`
       [
         "client -> server | LOAD Group sessions: header/3",
-        "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Group sessions: header/3",
-        "client -> server | CONTENT Map header: false new: After: 1 New: 1",
+        "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Map sessions: header/1",
+        "client -> server | CONTENT Map header: false new: After: 1 New: 1",
         "server -> client | KNOWN Map sessions: header/2",
       ]
     `);
@@ -111,13 +111,13 @@ describe("peer reconciliation", () => {
 
     await map.core.waitForSync();
 
-    const mapOnSyncServer = jazzCloud.node.coValuesStore.get(map.id);
+    const mapOnSyncServer = jazzCloud.node.getCoValue(map.id);
 
     assert(mapOnSyncServer.isAvailable());
 
-    expect(
-      expectMap(mapOnSyncServer.core.getCurrentContent()).get("hello"),
-    ).toEqual("updated");
+    expect(expectMap(mapOnSyncServer.getCurrentContent()).get("hello")).toEqual(
+      "updated",
+    );
 
     expect(peer.outgoing).toMatchObject({
       closed: true,
@@ -136,10 +136,10 @@ describe("peer reconciliation", () => {
       [
         "client -> server | LOAD Group sessions: header/3",
         "client -> server | LOAD Group sessions: header/3",
-        "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Group sessions: header/3",
-        "client -> server | CONTENT Map header: false new: After: 1 New: 1",
+        "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Map sessions: header/1",
+        "client -> server | CONTENT Map header: false new: After: 1 New: 1",
         "server -> client | KNOWN Map sessions: header/2",
       ]
     `);
@@ -166,9 +166,9 @@ describe("peer reconciliation", () => {
     client.connectToSyncServer();
 
     await waitFor(() => {
-      const mapOnSyncServer = jazzCloud.node.coValuesStore.get(map.id);
+      const mapOnSyncServer = jazzCloud.node.getCoValue(map.id);
 
-      expect(mapOnSyncServer.highLevelState).toBe("available");
+      expect(mapOnSyncServer.loadingState).toBe("available");
     });
 
     expect(
@@ -179,16 +179,16 @@ describe("peer reconciliation", () => {
     ).toMatchInlineSnapshot(`
       [
         "client -> server | LOAD Group sessions: header/3",
-        "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Group sessions: empty",
-        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Map sessions: empty",
-        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
         "server -> client | KNOWN Group sessions: header/3",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
         "server -> client | KNOWN Map sessions: header/2",
         "client -> server | LOAD Group sessions: header/3",
-        "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Group sessions: header/3",
+        "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Map sessions: header/2",
       ]
     `);
@@ -210,7 +210,7 @@ describe("peer reconciliation", () => {
 
     SyncMessagesLog.clear();
     client.connectToSyncServer();
-    const mapOnSyncServer = jazzCloud.node.coValuesStore.get(map.id);
+    const mapOnSyncServer = jazzCloud.node.getCoValue(map.id);
 
     await waitFor(() => {
       expect(mapOnSyncServer.isAvailable()).toBe(true);
@@ -232,8 +232,8 @@ describe("peer reconciliation", () => {
       ]
     `);
 
-    expect(
-      expectMap(mapOnSyncServer.core.getCurrentContent()).get("hello"),
-    ).toEqual("updated");
+    expect(expectMap(mapOnSyncServer.getCurrentContent()).get("hello")).toEqual(
+      "updated",
+    );
   });
 });