cojson 0.13.17 → 0.13.20

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,246 @@
+import { assert, beforeEach, describe, expect, test } from "vitest";
+
+import { WasmCrypto } from "../crypto/WasmCrypto";
+import { LocalNode } from "../localNode";
+import {
+  SyncMessagesLog,
+  getSyncServerConnectedPeer,
+  setupTestNode,
+} 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 { 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",
+      ourName: "creation-node",
+    });
+
+    const { accountID, accountSecret } =
+      await LocalNode.withNewlyCreatedAccount({
+        creationProps: {
+          name: "new-account",
+        },
+        peersToLoadFrom: [newAccountPeer],
+        crypto: Crypto,
+      });
+
+    const { peer: existingAccountPeer } = getSyncServerConnectedPeer({
+      peerId: "existing-account",
+      ourName: "auth-node",
+    });
+
+    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(`
+      [
+        "creation-node -> server | CONTENT Account header: true new: After: 0 New: 4",
+        "auth-node -> server | LOAD Account sessions: empty",
+        "server -> creation-node | KNOWN Account sessions: header/4",
+        "creation-node -> server | CONTENT ProfileGroup header: true new: After: 0 New: 5",
+        "server -> auth-node | CONTENT Account header: true new: After: 0 New: 4",
+        "server -> creation-node | KNOWN ProfileGroup sessions: header/5",
+        "creation-node -> server | CONTENT Profile header: true new: After: 0 New: 1",
+        "auth-node -> server | KNOWN Account sessions: header/4",
+        "server -> creation-node | KNOWN Profile sessions: header/1",
+        "auth-node -> server | LOAD Profile sessions: empty",
+        "server -> auth-node | CONTENT ProfileGroup header: true new: After: 0 New: 5",
+        "auth-node -> server | KNOWN ProfileGroup sessions: header/5",
+        "server -> auth-node | CONTENT Profile header: true new: After: 0 New: 1",
+        "auth-node -> server | KNOWN Profile sessions: header/1",
+      ]
+    `);
+  });
+
+  test("authenticate to an existing account after immediately close the creation node", async () => {
+    const { peer: newAccountPeer } = getSyncServerConnectedPeer({
+      peerId: "new-account",
+      ourName: "creation-node",
+    });
+
+    const {
+      accountID,
+      accountSecret,
+      node: creationNode,
+    } = await LocalNode.withNewlyCreatedAccount({
+      creationProps: {
+        name: "new-account",
+      },
+      peersToLoadFrom: [newAccountPeer],
+      crypto: Crypto,
+    });
+
+    creationNode.gracefulShutdown();
+
+    const { peer: existingAccountPeer } = getSyncServerConnectedPeer({
+      peerId: "existing-account",
+      ourName: "auth-node",
+    });
+
+    const node = await LocalNode.withLoadedAccount({
+      accountID,
+      accountSecret,
+      peersToLoadFrom: [existingAccountPeer],
+      sessionID: undefined,
+      crypto: Crypto,
+    });
+
+    const account = node.expectCurrentAccount("after login");
+    const profile = creationNode.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(`
+      [
+        "creation-node -> server | CONTENT Account header: true new: After: 0 New: 4",
+        "auth-node -> server | LOAD Account sessions: empty",
+        "server -> creation-node | KNOWN Account sessions: header/4",
+        "server -> auth-node | CONTENT Account header: true new: After: 0 New: 4",
+        "auth-node -> server | KNOWN Account sessions: header/4",
+        "auth-node -> server | LOAD Profile sessions: empty",
+        "server -> auth-node | KNOWN Profile sessions: empty",
+        "auth-node -> server | LOAD Profile sessions: empty",
+        "server -> auth-node | KNOWN Profile sessions: empty",
+      ]
+    `);
+  });
+});

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

@@ -77,12 +77,12 @@ describe("loading coValues from server", () => {
         "client2 -> server | LOAD Map sessions: empty",
         "server -> client2 | KNOWN Map sessions: empty",
         "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",
         "server -> client2 | CONTENT Group header: true new: After: 0 New: 3",
         "client2 -> server | KNOWN Group sessions: header/3",
@@ -197,8 +197,6 @@ describe("loading coValues from server", () => {
     await map.core.waitForSync();
     await mapOnClient.core.waitForSync();
 
-    expect(mapOnClient.get("fromServer")).toEqual("updated");
-    expect(mapOnClient.get("fromClient")).toEqual("updated");
     expect(
       SyncMessagesLog.getMessages({
         Group: group.core,
@@ -217,6 +215,9 @@ describe("loading coValues from server", () => {
         "client -> server | KNOWN Map sessions: header/3",
       ]
     `);
+
+    expect(mapOnClient.get("fromServer")).toEqual("updated");
+    expect(mapOnClient.get("fromClient")).toEqual("updated");
   });
 
   test("wrong optimistic known state should be corrected", async () => {
@@ -236,7 +237,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");
 

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

@@ -67,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",
@@ -119,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",
@@ -215,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");
@@ -239,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",
@@ -257,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",
       ]
     `);
@@ -378,12 +392,11 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "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",
-        "client -> core | CONTENT Group header: true new: After: 0 New: 3",
-        "client -> storage | KNOWN Map sessions: header/1",
         "core -> client | KNOWN Group sessions: header/3",
+        "client -> storage | KNOWN Map sessions: header/1",
         "client -> core | LOAD Map sessions: header/1",
-        "client -> core | CONTENT Map header: true new: After: 0 New: 1",
       ]
     `);
 

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",
+    );
   });
 });