cojson 0.0.10 → 0.0.12

package/src/sync.test.ts

@@ -1,115 +1,102 @@
-import {
-    getAgent,
-    getAgentID,
-    newRandomAgentCredential,
-    newRandomSessionID,
-} from './coValue.js';
-import { LocalNode } from './node.js';
-import { Peer, PeerID, SyncMessage } from './sync.js';
-import { expectMap } from './contentType.js';
-import { MapOpPayload } from './contentTypes/coMap.js';
-import { Team } from './permissions.js';
+import { newRandomSessionID } from "./coValue.js";
+import { LocalNode } from "./node.js";
+import { Peer, PeerID, SyncMessage } from "./sync.js";
+import { expectMap } from "./contentType.js";
+import { MapOpPayload } from "./contentTypes/coMap.js";
+import { Team } from "./permissions.js";
 import {
     ReadableStream,
     WritableStream,
     TransformStream,
 } from "isomorphic-streams";
-import { AgentID } from './ids.js';
-
-test(
-    "Node replies with initial tx and header to empty subscribe",
-    async () => {
-        const admin = newRandomAgentCredential("admin");
-        const adminID = getAgentID(getAgent(admin));
-
-        const node = new LocalNode(admin, newRandomSessionID(adminID));
+import { connectedPeers, newStreamPair, randomAnonymousAccountAndSessionID, shouldNotResolve } from "./testUtils.js";
+import { AccountID } from "./account.js";
 
-        const team = node.createTeam();
+test("Node replies with initial tx and header to empty subscribe", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
-        const map = team.createMap();
+    const team = node.createTeam();
 
-        map.edit((editable) => {
-            editable.set("hello", "world", "trusting");
-        });
+    const map = team.createMap();
 
-        const [inRx, inTx] = newStreamPair<SyncMessage>();
-        const [outRx, outTx] = newStreamPair<SyncMessage>();
+    map.edit((editable) => {
+        editable.set("hello", "world", "trusting");
+    });
 
-        node.sync.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "peer",
-        });
+    const [inRx, inTx] = newStreamPair<SyncMessage>();
+    const [outRx, outTx] = newStreamPair<SyncMessage>();
 
-        const writer = inTx.getWriter();
+    node.sync.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "peer",
+    });
 
-        await writer.write({
-            action: "subscribe",
-            coValueID: map.coValue.id,
-            header: false,
-            sessions: {},
-        });
+    const writer = inTx.getWriter();
 
-        const reader = outRx.getReader();
+    await writer.write({
+        action: "load",
+        id: map.coValue.id,
+        header: false,
+        sessions: {},
+    });
 
-        expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
-        expect((await reader.read()).value).toMatchObject(teamStateEx(team));
+    const reader = outRx.getReader();
 
-        const mapTellKnownStateMsg = await reader.read();
-        expect(mapTellKnownStateMsg.value).toEqual({
-            action: "tellKnownState",
-            ...map.coValue.knownState(),
-        } satisfies SyncMessage);
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
+    expect((await reader.read()).value).toMatchObject(teamStateEx(team));
 
-        expect((await reader.read()).value).toMatchObject(admContEx(adminID));
-        expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    const mapTellKnownStateMsg = await reader.read();
+    expect(mapTellKnownStateMsg.value).toEqual({
+        action: "known",
+        ...map.coValue.knownState(),
+    } satisfies SyncMessage);
 
-        const newContentMsg = await reader.read();
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
+    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
-        expect(newContentMsg.value).toEqual({
-            action: "newContent",
-            coValueID: map.coValue.id,
-            header: {
-                type: "comap",
-                ruleset: { type: "ownedByTeam", team: team.id },
-                meta: null,
-                createdAt: map.coValue.header.createdAt,
-                uniqueness: map.coValue.header.uniqueness,
-                publicNickname: "map",
-            },
-            newContent: {
-                [node.ownSessionID]: {
-                    after: 0,
-                    newTransactions: [
-                        {
-                            privacy: "trusting",
-                            madeAt: map.coValue.sessions[node.ownSessionID]!
-                                .transactions[0]!.madeAt,
-                            changes: [
-                                {
-                                    op: "insert",
-                                    key: "hello",
-                                    value: "world",
-                                } satisfies MapOpPayload<string, string>,
-                            ],
-                        },
-                    ],
-                    lastHash:
-                        map.coValue.sessions[node.ownSessionID]!.lastHash!,
-                    lastSignature:
-                        map.coValue.sessions[node.ownSessionID]!.lastSignature!,
-                },
+    const newContentMsg = await reader.read();
+
+    expect(newContentMsg.value).toEqual({
+        action: "content",
+        id: map.coValue.id,
+        header: {
+            type: "comap",
+            ruleset: { type: "ownedByTeam", team: team.id },
+            meta: null,
+            createdAt: map.coValue.header.createdAt,
+            uniqueness: map.coValue.header.uniqueness,
+        },
+        new: {
+            [node.ownSessionID]: {
+                after: 0,
+                newTransactions: [
+                    {
+                        privacy: "trusting" as const,
+                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                            .transactions[0]!.madeAt,
+                        changes: [
+                            {
+                                op: "insert",
+                                key: "hello",
+                                value: "world",
+                            } satisfies MapOpPayload<string, string>,
+                        ],
+                    },
+                ],
+                lastHash: map.coValue.sessions[node.ownSessionID]!.lastHash!,
+                lastSignature:
+                    map.coValue.sessions[node.ownSessionID]!.lastSignature!,
             },
-        } satisfies SyncMessage);
-    },
-);
+        },
+    } satisfies SyncMessage);
+});
 
 test("Node replies with only new tx to subscribe with some known state", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -133,8 +120,8 @@ test("Node replies with only new tx to subscribe with some known state", async (
     const writer = inTx.getWriter();
 
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: true,
         sessions: {
             [node.ownSessionID]: 1,
@@ -143,30 +130,30 @@ test("Node replies with only new tx to subscribe with some known state", async (
 
     const reader = outRx.getReader();
 
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
     const mapNewContentMsg = await reader.read();
 
     expect(mapNewContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: undefined,
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
-                        privacy: "trusting",
+                        privacy: "trusting" as const,
                         madeAt: map.coValue.sessions[node.ownSessionID]!
                             .transactions[1]!.madeAt,
                         changes: [
@@ -187,14 +174,12 @@ test("Node replies with only new tx to subscribe with some known state", async (
 });
 
 test.todo(
-    "TODO: node only replies with new tx to subscribe with some known state, even in the depended on coValues",
+    "TODO: node only replies with new tx to subscribe with some known state, even in the depended on coValues"
 );
 
 test("After subscribing, node sends own known state and new txs to peer", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -213,8 +198,8 @@ test("After subscribing, node sends own known state and new txs to peer", async
     const writer = inTx.getWriter();
 
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: false,
         sessions: {
             [node.ownSessionID]: 0,
@@ -223,25 +208,25 @@ test("After subscribing, node sends own known state and new txs to peer", async
 
     const reader = outRx.getReader();
 
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
     const mapNewContentHeaderOnlyMsg = await reader.read();
 
     expect(mapNewContentHeaderOnlyMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     } satisfies SyncMessage);
 
     map.edit((editable) => {
@@ -251,14 +236,14 @@ test("After subscribing, node sends own known state and new txs to peer", async
     const mapEditMsg1 = await reader.read();
 
     expect(mapEditMsg1.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
-        newContent: {
+        action: "content",
+        id: map.coValue.id,
+        new: {
             [node.ownSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
-                        privacy: "trusting",
+                        privacy: "trusting" as const,
                         madeAt: map.coValue.sessions[node.ownSessionID]!
                             .transactions[0]!.madeAt,
                         changes: [
@@ -284,14 +269,14 @@ test("After subscribing, node sends own known state and new txs to peer", async
     const mapEditMsg2 = await reader.read();
 
     expect(mapEditMsg2.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
-        newContent: {
+        action: "content",
+        id: map.coValue.id,
+        new: {
             [node.ownSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
-                        privacy: "trusting",
+                        privacy: "trusting" as const,
                         madeAt: map.coValue.sessions[node.ownSessionID]!
                             .transactions[1]!.madeAt,
                         changes: [
@@ -312,10 +297,8 @@ test("After subscribing, node sends own known state and new txs to peer", async
 });
 
 test("Client replies with known new content to tellKnownState from server", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -342,38 +325,38 @@ test("Client replies with known new content to tellKnownState from server", asyn
     const writer = inTx.getWriter();
 
     await writer.write({
-        action: "tellKnownState",
-        coValueID: map.coValue.id,
+        action: "known",
+        id: map.coValue.id,
         header: false,
         sessions: {
             [node.ownSessionID]: 0,
         },
     });
 
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
     const mapNewContentMsg = await reader.read();
 
     expect(mapNewContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
-                        privacy: "trusting",
+                        privacy: "trusting" as const,
                         madeAt: map.coValue.sessions[node.ownSessionID]!
                             .transactions[0]!.madeAt,
                         changes: [
@@ -394,10 +377,8 @@ test("Client replies with known new content to tellKnownState from server", asyn
 });
 
 test("No matter the optimistic known state, node respects invalid known state messages and resyncs", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -416,8 +397,8 @@ test("No matter the optimistic known state, node respects invalid known state me
     const writer = inTx.getWriter();
 
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: false,
         sessions: {
             [node.ownSessionID]: 0,
@@ -426,25 +407,25 @@ test("No matter the optimistic known state, node respects invalid known state me
 
     const reader = outRx.getReader();
 
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
     const mapNewContentHeaderOnlyMsg = await reader.read();
 
     expect(mapNewContentHeaderOnlyMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     } satisfies SyncMessage);
 
     map.edit((editable) => {
@@ -459,8 +440,9 @@ test("No matter the optimistic known state, node respects invalid known state me
     const _mapEditMsg2 = await reader.read();
 
     await writer.write({
-        action: "wrongAssumedKnownState",
-        coValueID: map.coValue.id,
+        action: "known",
+        isCorrection: true,
+        id: map.coValue.id,
         header: true,
         sessions: {
             [node.ownSessionID]: 1,
@@ -470,15 +452,15 @@ test("No matter the optimistic known state, node respects invalid known state me
     const newContentAfterWrongAssumedState = await reader.read();
 
     expect(newContentAfterWrongAssumedState.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: undefined,
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
-                        privacy: "trusting",
+                        privacy: "trusting" as const,
                         madeAt: map.coValue.sessions[node.ownSessionID]!
                             .transactions[1]!.madeAt,
                         changes: [
@@ -499,10 +481,8 @@ test("No matter the optimistic known state, node respects invalid known state me
 });
 
 test("If we add a peer, but it never subscribes to a coValue, it won't get any messages", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -524,14 +504,14 @@ test("If we add a peer, but it never subscribes to a coValue, it won't get any m
 
     const reader = outRx.getReader();
 
-    await expect(shouldNotResolve(reader.read(), {timeout: 100})).resolves.toBeUndefined();
+    await expect(
+        shouldNotResolve(reader.read(), { timeout: 100 })
+    ).resolves.toBeUndefined();
 });
 
 test("If we add a server peer, all updates to all coValues are sent to it, even if it doesn't subscribe", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -548,20 +528,20 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
     });
 
     const reader = outRx.getReader();
+    // expect((await reader.read()).value).toMatchObject({
+    //     action: "load",
+    //     id: adminID,
+    // });
     expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
-    });
-    expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
 
     const mapSubscribeMsg = await reader.read();
 
     expect(mapSubscribeMsg.value).toEqual({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: true,
         sessions: {},
     } satisfies SyncMessage);
@@ -570,21 +550,21 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
         editable.set("hello", "world", "trusting");
     });
 
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
     const mapNewContentMsg = await reader.read();
 
     expect(mapNewContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {
+        new: {
             [node.ownSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
-                        privacy: "trusting",
+                        privacy: "trusting" as const,
                         madeAt: map.coValue.sessions[node.ownSessionID]!
                             .transactions[0]!.madeAt,
                         changes: [
@@ -605,10 +585,8 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
 });
 
 test("If we add a server peer, newly created coValues are auto-subscribed to", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -623,13 +601,13 @@ test("If we add a server peer, newly created coValues are auto-subscribed to", a
     });
 
     const reader = outRx.getReader();
+    // expect((await reader.read()).value).toMatchObject({
+    //     action: "load",
+    //     id: admin.id,
+    // });
     expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
-    });
-    expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
 
     const map = team.createMap();
@@ -637,32 +615,30 @@ test("If we add a server peer, newly created coValues are auto-subscribed to", a
     const mapSubscribeMsg = await reader.read();
 
     expect(mapSubscribeMsg.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(adminID));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
     const mapContentMsg = await reader.read();
 
     expect(mapContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     } satisfies SyncMessage);
 });
 
 test.todo(
-    "TODO: when receiving a subscribe response that is behind our optimistic state (due to already sent content), we ignore it",
+    "TODO: when receiving a subscribe response that is behind our optimistic state (due to already sent content), we ignore it"
 );
 
 test("When we connect a new server peer, we try to sync all existing coValues to it", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -680,27 +656,25 @@ test("When we connect a new server peer, we try to sync all existing coValues to
 
     const reader = outRx.getReader();
 
-    const _adminSubscribeMessage = await reader.read();
+    // const _adminSubscribeMessage = await reader.read();
     const teamSubscribeMessage = await reader.read();
 
     expect(teamSubscribeMessage.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...team.teamMap.coValue.knownState(),
     } satisfies SyncMessage);
 
     const secondMessage = await reader.read();
 
     expect(secondMessage.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 });
 
 test("When receiving a subscribe with a known state that is ahead of our own, peers should respond with a corresponding subscribe response message", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -719,8 +693,8 @@ test("When receiving a subscribe with a known state that is ahead of our own, pe
     const writer = inTx.getWriter();
 
     await writer.write({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
         header: true,
         sessions: {
             [node.ownSessionID]: 1,
@@ -729,22 +703,21 @@ test("When receiving a subscribe with a known state that is ahead of our own, pe
 
     const reader = outRx.getReader();
 
-    expect((await reader.read()).value).toMatchObject(admStateEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamStateEx(team));
     const mapTellKnownState = await reader.read();
 
     expect(mapTellKnownState.value).toEqual({
-        action: "tellKnownState",
+        action: "known",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 });
 
 test.skip("When replaying creation and transactions of a coValue as new content, the receiving peer integrates this information", async () => {
     // TODO: this test is mostly correct but also slightly unrealistic, make sure we pass all messages back and forth as expected and then it should work
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const node1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const node1 = new LocalNode(admin, session);
 
     const team = node1.createTeam();
 
@@ -761,7 +734,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
     const to1 = inTx1.getWriter();
     const from1 = outRx1.getReader();
 
-    const node2 = new LocalNode(admin, newRandomSessionID(adminID));
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
 
     const [inRx2, inTx2] = newStreamPair<SyncMessage>();
     const [outRx2, outTx2] = newStreamPair<SyncMessage>();
@@ -778,20 +751,20 @@ test.skip("When replaying creation and transactions of a coValue as new content,
 
     const adminSubscribeMessage = await from1.read();
     expect(adminSubscribeMessage.value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
+        action: "load",
+        id: admin.id,
     });
     const teamSubscribeMsg = await from1.read();
     expect(teamSubscribeMsg.value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
 
     await to2.write(adminSubscribeMessage.value!);
     await to2.write(teamSubscribeMsg.value!);
 
-    const adminTellKnownStateMsg = await from2.read();
-    expect(adminTellKnownStateMsg.value).toMatchObject(admStateEx(adminID));
+    // const adminTellKnownStateMsg = await from2.read();
+    // expect(adminTellKnownStateMsg.value).toMatchObject(admStateEx(admin.id));
 
     const teamTellKnownStateMsg = await from2.read();
     expect(teamTellKnownStateMsg.value).toMatchObject(teamStateEx(team));
@@ -802,40 +775,40 @@ test.skip("When replaying creation and transactions of a coValue as new content,
         ]
     ).toBeDefined();
 
-    await to1.write(adminTellKnownStateMsg.value!);
+    // await to1.write(adminTellKnownStateMsg.value!);
     await to1.write(teamTellKnownStateMsg.value!);
 
-    const adminContentMsg = await from1.read();
-    expect(adminContentMsg.value).toMatchObject(admContEx(adminID));
+    // const adminContentMsg = await from1.read();
+    // expect(adminContentMsg.value).toMatchObject(admContEx(admin.id));
 
     const teamContentMsg = await from1.read();
     expect(teamContentMsg.value).toMatchObject(teamContentEx(team));
 
-    await to2.write(adminContentMsg.value!);
+    // await to2.write(adminContentMsg.value!);
     await to2.write(teamContentMsg.value!);
 
     const map = team.createMap();
 
     const mapSubscriptionMsg = await from1.read();
     expect(mapSubscriptionMsg.value).toMatchObject({
-        action: "subscribe",
-        coValueID: map.coValue.id,
+        action: "load",
+        id: map.coValue.id,
     });
 
     const mapNewContentMsg = await from1.read();
     expect(mapNewContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     } satisfies SyncMessage);
 
     await to2.write(mapSubscriptionMsg.value!);
 
     const mapTellKnownStateMsg = await from2.read();
     expect(mapTellKnownStateMsg.value).toEqual({
-        action: "tellKnownState",
-        coValueID: map.coValue.id,
+        action: "known",
+        id: map.coValue.id,
         header: false,
         sessions: {},
     } satisfies SyncMessage);
@@ -863,10 +836,9 @@ test.skip("When replaying creation and transactions of a coValue as new content,
 
 test.skip("When loading a coValue on one node, the server node it is requested from replies with all the necessary depended on coValues to make it work", async () => {
     // TODO: this test is mostly correct but also slightly unrealistic, make sure we pass all messages back and forth as expected and then it should work
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const node1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const node1 = new LocalNode(admin, session);
 
     const team = node1.createTeam();
 
@@ -875,7 +847,7 @@ test.skip("When loading a coValue on one node, the server node it is requested f
         editable.set("hello", "world", "trusting");
     });
 
-    const node2 = new LocalNode(admin, newRandomSessionID(adminID));
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
 
     const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2");
 
@@ -892,10 +864,9 @@ test.skip("When loading a coValue on one node, the server node it is requested f
 });
 
 test("Can sync a coValue through a server to another client", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const client1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const client1 = new LocalNode(admin, session);
 
     const team = client1.createTeam();
 
@@ -904,10 +875,9 @@ test("Can sync a coValue through a server to another client", async () => {
         editable.set("hello", "world", "trusting");
     });
 
-    const serverUser = newRandomAgentCredential("serverUser");
-    const serverUserID = getAgentID(getAgent(serverUser));
+    const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
 
-    const server = new LocalNode(serverUser, newRandomSessionID(serverUserID));
+    const server = new LocalNode(serverUser, serverSession);
 
     const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
         peer1role: "server",
@@ -917,7 +887,7 @@ test("Can sync a coValue through a server to another client", async () => {
     client1.sync.addPeer(serverAsPeer);
     server.sync.addPeer(client1AsPeer);
 
-    const client2 = new LocalNode(admin, newRandomSessionID(adminID));
+    const client2 = new LocalNode(admin, newRandomSessionID(admin.id));
 
     const [serverAsOtherPeer, client2AsPeer] = connectedPeers(
         "server",
@@ -936,10 +906,9 @@ test("Can sync a coValue through a server to another client", async () => {
 });
 
 test("Can sync a coValue with private transactions through a server to another client", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const client1 = new LocalNode(admin, newRandomSessionID(adminID));
+    const client1 = new LocalNode(admin, session);
 
     const team = client1.createTeam();
 
@@ -948,10 +917,9 @@ test("Can sync a coValue with private transactions through a server to another c
         editable.set("hello", "world", "private");
     });
 
-    const serverUser = newRandomAgentCredential("serverUser");
-    const serverUserID = getAgentID(getAgent(serverUser));
+    const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
 
-    const server = new LocalNode(serverUser, newRandomSessionID(serverUserID));
+    const server = new LocalNode(serverUser, serverSession);
 
     const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
         trace: true,
@@ -962,7 +930,7 @@ test("Can sync a coValue with private transactions through a server to another c
     client1.sync.addPeer(serverAsPeer);
     server.sync.addPeer(client1AsPeer);
 
-    const client2 = new LocalNode(admin, newRandomSessionID(adminID));
+    const client2 = new LocalNode(admin, newRandomSessionID(admin.id));
 
     const [serverAsOtherPeer, client2AsPeer] = connectedPeers(
         "server",
@@ -981,10 +949,8 @@ test("Can sync a coValue with private transactions through a server to another c
 });
 
 test("When a peer's incoming/readable stream closes, we remove the peer", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -999,13 +965,13 @@ test("When a peer's incoming/readable stream closes, we remove the peer", async
     });
 
     const reader = outRx.getReader();
+    // expect((await reader.read()).value).toMatchObject({
+    //     action: "load",
+    //     id: admin.id,
+    // });
     expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
-    });
-    expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
 
     const map = team.createMap();
@@ -1013,20 +979,20 @@ test("When a peer's incoming/readable stream closes, we remove the peer", async
     const mapSubscribeMsg = await reader.read();
 
     expect(mapSubscribeMsg.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
     const mapContentMsg = await reader.read();
 
     expect(mapContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     } satisfies SyncMessage);
 
     await inTx.abort();
@@ -1037,10 +1003,8 @@ test("When a peer's incoming/readable stream closes, we remove the peer", async
 });
 
 test("When a peer's outgoing/writable stream closes, we remove the peer", async () => {
-    const admin = newRandomAgentCredential("admin");
-    const adminID = getAgentID(getAgent(admin));
-
-    const node = new LocalNode(admin, newRandomSessionID(adminID));
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session);
 
     const team = node.createTeam();
 
@@ -1055,13 +1019,13 @@ test("When a peer's outgoing/writable stream closes, we remove the peer", async
     });
 
     const reader = outRx.getReader();
+    // expect((await reader.read()).value).toMatchObject({
+    //     action: "load",
+    //     id: admin.id,
+    // });
     expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: adminID,
-    });
-    expect((await reader.read()).value).toMatchObject({
-        action: "subscribe",
-        coValueID: team.teamMap.coValue.id,
+        action: "load",
+        id: team.teamMap.coValue.id,
     });
 
     const map = team.createMap();
@@ -1069,20 +1033,20 @@ test("When a peer's outgoing/writable stream closes, we remove the peer", async
     const mapSubscribeMsg = await reader.read();
 
     expect(mapSubscribeMsg.value).toEqual({
-        action: "subscribe",
+        action: "load",
         ...map.coValue.knownState(),
     } satisfies SyncMessage);
 
-    expect((await reader.read()).value).toMatchObject(admContEx(adminID));
+    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
     expect((await reader.read()).value).toMatchObject(teamContentEx(team));
 
     const mapContentMsg = await reader.read();
 
     expect(mapContentMsg.value).toEqual({
-        action: "newContent",
-        coValueID: map.coValue.id,
+        action: "content",
+        id: map.coValue.id,
         header: map.coValue.header,
-        newContent: {},
+        new: {},
     } satisfies SyncMessage);
 
     reader.releaseLock();
@@ -1095,175 +1059,69 @@ test("When a peer's outgoing/writable stream closes, we remove the peer", async
     await new Promise((resolve) => setTimeout(resolve, 100));
 
     expect(node.sync.peers["test"]).toBeUndefined();
-})
+});
+
+test("If we start loading a coValue before connecting to a peer that has it, it will load it once we connect", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+
+    const node1 = new LocalNode(admin, session);
+
+    const team = node1.createTeam();
+
+    const map = team.createMap();
+    map.edit((editable) => {
+        editable.set("hello", "world", "trusting");
+    });
+
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
+
+    const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2", {
+        peer1role: "server",
+        peer2role: "client",
+        trace: true,
+    });
+
+    node1.sync.addPeer(node2asPeer);
+
+    const mapOnNode2Promise = node2.loadCoValue(map.coValue.id);
+
+    expect(node2.coValues[map.coValue.id]?.state).toEqual("loading");
+
+    node2.sync.addPeer(node1asPeer);
+
+    const mapOnNode2 = await mapOnNode2Promise;
+
+    expect(expectMap(mapOnNode2.getCurrentContent()).get("hello")).toEqual(
+        "world"
+    );
+});
 
 function teamContentEx(team: Team) {
     return {
-        action: "newContent",
-        coValueID: team.teamMap.coValue.id,
+        action: "content",
+        id: team.teamMap.coValue.id,
     };
 }
 
-function admContEx(adminID: AgentID) {
+function admContEx(adminID: AccountID) {
     return {
-        action: "newContent",
-        coValueID: adminID,
+        action: "content",
+        id: adminID,
     };
 }
 
 function teamStateEx(team: Team) {
     return {
-        action: "tellKnownState",
-        coValueID: team.teamMap.coValue.id,
+        action: "known",
+        id: team.teamMap.coValue.id,
     };
 }
 
-function admStateEx(adminID: AgentID) {
+function admStateEx(adminID: AccountID) {
     return {
-        action: "tellKnownState",
-        coValueID: adminID,
+        action: "known",
+        id: adminID,
     };
 }
 
-function newStreamPair<T>(): [ReadableStream<T>, WritableStream<T>] {
-    const queue: T[] = [];
-    let resolveNextItemReady: () => void = () => {};
-    let nextItemReady: Promise<void> = new Promise((resolve) => {
-        resolveNextItemReady = resolve;
-    });
-
-    let writerClosed = false;
-    let readerClosed = false;
-
-    const readable = new ReadableStream<T>({
-        async pull(controller) {
-            let retriesLeft = 3;
-            while (retriesLeft > 0) {
-                if (writerClosed) {
-                    controller.close();
-                    return;
-                }
-                retriesLeft--;
-                if (queue.length > 0) {
-                    controller.enqueue(queue.shift()!);
-                    if (queue.length === 0) {
-                        nextItemReady = new Promise((resolve) => {
-                            resolveNextItemReady = resolve;
-                        });
-                    }
-                    return;
-                } else {
-                    await nextItemReady;
-                }
-            }
-            throw new Error("Should only use one retry to get next item in queue.")
-        },
-
-        cancel(reason) {
-            console.log("Manually closing reader")
-            readerClosed = true;
-        },
-    });
-
-    const writable = new WritableStream<T>({
-        write(chunk, controller) {
-            if (readerClosed) {
-                console.log("Reader closed, not writing chunk", chunk);
-                throw new Error("Reader closed, not writing chunk");
-            }
-            queue.push(chunk);
-            if (queue.length === 1) {
-                // make sure that await write resolves before corresponding read
-                process.nextTick(() => resolveNextItemReady());
-            }
-        },
-        abort(reason) {
-            console.log("Manually closing writer")
-            writerClosed = true;
-            resolveNextItemReady();
-            return Promise.resolve();
-        },
-    });
-
-    return [readable, writable];
-}
-
-function shouldNotResolve<T>(promise: Promise<T>, ops: { timeout: number }): Promise<void> {
-    return new Promise((resolve, reject) => {
-        promise
-            .then((v) =>
-                reject(
-                    new Error(
-                        "Should not have resolved, but resolved to " +
-                            JSON.stringify(v)
-                    )
-                )
-            )
-            .catch(reject);
-        setTimeout(resolve, ops.timeout);
-    });
-}
-
-function connectedPeers(
-    peer1id: PeerID,
-    peer2id: PeerID,
-    {
-        trace = false,
-        peer1role = "peer",
-        peer2role = "peer",
-    }: {
-        trace?: boolean;
-        peer1role?: Peer["role"];
-        peer2role?: Peer["role"];
-    } = {}
-): [Peer, Peer] {
-    const [inRx1, inTx1] = newStreamPair<SyncMessage>();
-    const [outRx1, outTx1] = newStreamPair<SyncMessage>();
-
-    const [inRx2, inTx2] = newStreamPair<SyncMessage>();
-    const [outRx2, outTx2] = newStreamPair<SyncMessage>();
-
-    void outRx2
-        .pipeThrough(
-            new TransformStream({
-                transform(
-                    chunk: SyncMessage,
-                    controller: { enqueue: (msg: SyncMessage) => void }
-                ) {
-                    trace && console.log(`${peer2id} -> ${peer1id}`, chunk);
-                    controller.enqueue(chunk);
-                },
-            })
-        )
-        .pipeTo(inTx1);
-
-    void outRx1
-        .pipeThrough(
-            new TransformStream({
-                transform(
-                    chunk: SyncMessage,
-                    controller: { enqueue: (msg: SyncMessage) => void }
-                ) {
-                    trace && console.log(`${peer1id} -> ${peer2id}`, chunk);
-                    controller.enqueue(chunk);
-                },
-            })
-        )
-        .pipeTo(inTx2);
-
-    const peer2AsPeer: Peer = {
-        id: peer2id,
-        incoming: inRx1,
-        outgoing: outTx1,
-        role: peer2role,
-    };
-
-    const peer1AsPeer: Peer = {
-        id: peer1id,
-        incoming: inRx2,
-        outgoing: outTx2,
-        role: peer1role,
-    };
 
-    return [peer1AsPeer, peer2AsPeer];
-}