cojson 0.7.23 → 0.7.26

package/src/tests/sync.test.ts

@@ -8,369 +8,480 @@ import { connectedPeers, newQueuePair } from "../streamUtils.js";
 import { AccountID } from "../coValues/account.js";
 import { stableStringify } from "../jsonStringify.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import { Effect, Queue, Sink, Stream } from "effect";
-import { newRandomSessionID } from "../coValueCore.js";
 import { expectMap } from "../coValue.js";
+import { newRandomSessionID } from "../coValueCore.js";
 
 const Crypto = await WasmCrypto.create();
 
-test("Node replies with initial tx and header to empty subscribe", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-        const node = new LocalNode(admin, session, Crypto);
+test("Node replies with initial tx and header to empty subscribe", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
 
-        const group = node.createGroup();
+    const group = node.createGroup();
 
-        const map = group.createMap();
+    const map = group.createMap();
 
-        map.set("hello", "world", "trusting");
+    map.set("hello", "world", "trusting");
 
-        const [inRx, inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
+    const [inRx, inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
 
-        node.syncManager.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "peer",
-        });
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "peer",
+    });
 
-        yield* Queue.offer(inTx, {
-            action: "load",
-            id: map.core.id,
-            header: false,
-            sessions: {},
-        });
+    await inTx.push({
+        action: "load",
+        id: map.core.id,
+        header: false,
+        sessions: {},
+    });
 
-        // expect((yield* Queue.take(outRxQ))).toMatchObject(admStateEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
 
-        const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
-        expect(mapTellKnownStateMsg).toEqual({
-            action: "known",
-            ...map.core.knownState(),
-        } satisfies SyncMessage);
+    const mapTellKnownStateMsg = (await outRxQ.next()).value;
+    expect(mapTellKnownStateMsg).toEqual({
+        action: "known",
+        ...map.core.knownState(),
+    } satisfies SyncMessage);
 
-        // expect((yield * Queue.take(outRxQ))).toMatchObject(admContEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
 
-        const newContentMsg = yield* Queue.take(outRxQ);
+    const newContentMsg = (await outRxQ.next()).value;
 
-        expect(newContentMsg).toEqual({
-            action: "content",
-            id: map.core.id,
-            header: {
-                type: "comap",
-                ruleset: { type: "ownedByGroup", group: group.id },
-                meta: null,
-                createdAt: map.core.header.createdAt,
-                uniqueness: map.core.header.uniqueness,
-            },
-            new: {
-                [node.currentSessionID]: {
-                    after: 0,
-                    newTransactions: [
-                        {
-                            privacy: "trusting" as const,
-                            madeAt: map.core.sessionLogs.get(
-                                node.currentSessionID,
-                            )!.transactions[0]!.madeAt,
-                            changes: stableStringify([
-                                {
-                                    op: "set",
-                                    key: "hello",
-                                    value: "world",
-                                } satisfies MapOpPayload<string, string>,
-                            ]),
-                        },
-                    ],
-                    lastSignature: map.core.sessionLogs.get(
-                        node.currentSessionID,
-                    )!.lastSignature!,
-                },
+    expect(newContentMsg).toEqual({
+        action: "content",
+        id: map.core.id,
+        header: {
+            type: "comap",
+            ruleset: { type: "ownedByGroup", group: group.id },
+            meta: null,
+            createdAt: map.core.header.createdAt,
+            uniqueness: map.core.header.uniqueness,
+        },
+        new: {
+            [node.currentSessionID]: {
+                after: 0,
+                newTransactions: [
+                    {
+                        privacy: "trusting" as const,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID)!
+                            .transactions[0]!.madeAt,
+                        changes: stableStringify([
+                            {
+                                op: "set",
+                                key: "hello",
+                                value: "world",
+                            } satisfies MapOpPayload<string, string>,
+                        ]),
+                    },
+                ],
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID)!
+                    .lastSignature!,
             },
-        } satisfies SyncMessage);
-    }).pipe(Effect.scoped, Effect.runPromise));
+        },
+    } satisfies SyncMessage);
+});
 
-test("Node replies with only new tx to subscribe with some known state", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-        const node = new LocalNode(admin, session, Crypto);
+test("Node replies with only new tx to subscribe with some known state", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
 
-        const group = node.createGroup();
+    const group = node.createGroup();
 
-        const map = group.createMap();
+    const map = group.createMap();
 
-        map.set("hello", "world", "trusting");
-        map.set("goodbye", "world", "trusting");
+    map.set("hello", "world", "trusting");
+    map.set("goodbye", "world", "trusting");
 
-        const [inRx, inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
+    const [inRx, inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
 
-        node.syncManager.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "peer",
-        });
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "peer",
+    });
 
-        yield* Queue.offer(inTx, {
-            action: "load",
-            id: map.core.id,
-            header: true,
-            sessions: {
-                [node.currentSessionID]: 1,
-            },
-        });
+    await inTx.push({
+        action: "load",
+        id: map.core.id,
+        header: true,
+        sessions: {
+            [node.currentSessionID]: 1,
+        },
+    });
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
 
-        const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
-        expect(mapTellKnownStateMsg).toEqual({
-            action: "known",
-            ...map.core.knownState(),
-        } satisfies SyncMessage);
+    const mapTellKnownStateMsg = (await outRxQ.next()).value;
+    expect(mapTellKnownStateMsg).toEqual({
+        action: "known",
+        ...map.core.knownState(),
+    } satisfies SyncMessage);
 
-        // expect(yield* Queue.take(outRxQ))).toMatchObject(admContEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
 
-        const mapNewContentMsg = yield* Queue.take(outRxQ);
+    const mapNewContentMsg = (await outRxQ.next()).value;
 
-        expect(mapNewContentMsg).toEqual({
-            action: "content",
-            id: map.core.id,
-            header: undefined,
-            new: {
-                [node.currentSessionID]: {
-                    after: 1,
-                    newTransactions: [
-                        {
-                            privacy: "trusting" as const,
-                            madeAt: map.core.sessionLogs.get(
-                                node.currentSessionID,
-                            )!.transactions[1]!.madeAt,
-                            changes: stableStringify([
-                                {
-                                    op: "set",
-                                    key: "goodbye",
-                                    value: "world",
-                                } satisfies MapOpPayload<string, string>,
-                            ]),
-                        },
-                    ],
-                    lastSignature: map.core.sessionLogs.get(
-                        node.currentSessionID,
-                    )!.lastSignature!,
-                },
+    expect(mapNewContentMsg).toEqual({
+        action: "content",
+        id: map.core.id,
+        header: undefined,
+        new: {
+            [node.currentSessionID]: {
+                after: 1,
+                newTransactions: [
+                    {
+                        privacy: "trusting" as const,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID)!
+                            .transactions[1]!.madeAt,
+                        changes: stableStringify([
+                            {
+                                op: "set",
+                                key: "goodbye",
+                                value: "world",
+                            } satisfies MapOpPayload<string, string>,
+                        ]),
+                    },
+                ],
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID)!
+                    .lastSignature!,
             },
-        } satisfies SyncMessage);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
+        },
+    } satisfies SyncMessage);
+});
 test.todo(
     "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", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-        const node = new LocalNode(admin, session, Crypto);
+test("After subscribing, node sends own known state and new txs to peer", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
 
-        const group = node.createGroup();
+    const group = node.createGroup();
 
-        const map = group.createMap();
+    const map = group.createMap();
 
-        const [inRx, inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
+    const [inRx, inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
 
-        node.syncManager.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "peer",
-        });
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "peer",
+    });
 
-        yield* Queue.offer(inTx, {
-            action: "load",
-            id: map.core.id,
-            header: false,
-            sessions: {
-                [node.currentSessionID]: 0,
-            },
-        });
+    await inTx.push({
+        action: "load",
+        id: map.core.id,
+        header: false,
+        sessions: {
+            [node.currentSessionID]: 0,
+        },
+    });
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
 
-        const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
-        expect(mapTellKnownStateMsg).toEqual({
-            action: "known",
-            ...map.core.knownState(),
-        } satisfies SyncMessage);
+    const mapTellKnownStateMsg = (await outRxQ.next()).value;
+    expect(mapTellKnownStateMsg).toEqual({
+        action: "known",
+        ...map.core.knownState(),
+    } satisfies SyncMessage);
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
 
-        const mapNewContentHeaderOnlyMsg = yield* Queue.take(outRxQ);
+    const mapNewContentHeaderOnlyMsg = (await outRxQ.next()).value;
 
-        expect(mapNewContentHeaderOnlyMsg).toEqual({
-            action: "content",
-            id: map.core.id,
-            header: map.core.header,
-            new: {},
-        } satisfies SyncMessage);
+    expect(mapNewContentHeaderOnlyMsg).toEqual({
+        action: "content",
+        id: map.core.id,
+        header: map.core.header,
+        new: {},
+    } satisfies SyncMessage);
 
-        map.set("hello", "world", "trusting");
+    map.set("hello", "world", "trusting");
 
-        const mapEditMsg1 = yield* Queue.take(outRxQ);
+    const mapEditMsg1 = (await outRxQ.next()).value;
 
-        expect(mapEditMsg1).toEqual({
-            action: "content",
-            id: map.core.id,
-            new: {
-                [node.currentSessionID]: {
-                    after: 0,
-                    newTransactions: [
-                        {
-                            privacy: "trusting" as const,
-                            madeAt: map.core.sessionLogs.get(
-                                node.currentSessionID,
-                            )!.transactions[0]!.madeAt,
-                            changes: stableStringify([
-                                {
-                                    op: "set",
-                                    key: "hello",
-                                    value: "world",
-                                } satisfies MapOpPayload<string, string>,
-                            ]),
-                        },
-                    ],
-                    lastSignature: map.core.sessionLogs.get(
-                        node.currentSessionID,
-                    )!.lastSignature!,
-                },
+    expect(mapEditMsg1).toEqual({
+        action: "content",
+        id: map.core.id,
+        new: {
+            [node.currentSessionID]: {
+                after: 0,
+                newTransactions: [
+                    {
+                        privacy: "trusting" as const,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID)!
+                            .transactions[0]!.madeAt,
+                        changes: stableStringify([
+                            {
+                                op: "set",
+                                key: "hello",
+                                value: "world",
+                            } satisfies MapOpPayload<string, string>,
+                        ]),
+                    },
+                ],
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID)!
+                    .lastSignature!,
             },
-        } satisfies SyncMessage);
+        },
+    } satisfies SyncMessage);
 
-        map.set("goodbye", "world", "trusting");
+    map.set("goodbye", "world", "trusting");
 
-        const mapEditMsg2 = yield* Queue.take(outRxQ);
+    const mapEditMsg2 = (await outRxQ.next()).value;
 
-        expect(mapEditMsg2).toEqual({
-            action: "content",
-            id: map.core.id,
-            new: {
-                [node.currentSessionID]: {
-                    after: 1,
-                    newTransactions: [
-                        {
-                            privacy: "trusting" as const,
-                            madeAt: map.core.sessionLogs.get(
-                                node.currentSessionID,
-                            )!.transactions[1]!.madeAt,
-                            changes: stableStringify([
-                                {
-                                    op: "set",
-                                    key: "goodbye",
-                                    value: "world",
-                                } satisfies MapOpPayload<string, string>,
-                            ]),
-                        },
-                    ],
-                    lastSignature: map.core.sessionLogs.get(
-                        node.currentSessionID,
-                    )!.lastSignature!,
-                },
+    expect(mapEditMsg2).toEqual({
+        action: "content",
+        id: map.core.id,
+        new: {
+            [node.currentSessionID]: {
+                after: 1,
+                newTransactions: [
+                    {
+                        privacy: "trusting" as const,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID)!
+                            .transactions[1]!.madeAt,
+                        changes: stableStringify([
+                            {
+                                op: "set",
+                                key: "goodbye",
+                                value: "world",
+                            } satisfies MapOpPayload<string, string>,
+                        ]),
+                    },
+                ],
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID)!
+                    .lastSignature!,
             },
-        } satisfies SyncMessage);
-    }).pipe(Effect.scoped, Effect.runPromise));
+        },
+    } satisfies SyncMessage);
+});
 
-test("Client replies with known new content to tellKnownState from server", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-        const node = new LocalNode(admin, session, Crypto);
+test("Client replies with known new content to tellKnownState from server", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
 
-        const group = node.createGroup();
+    const group = node.createGroup();
 
-        const map = group.createMap();
+    const map = group.createMap();
 
-        map.set("hello", "world", "trusting");
+    map.set("hello", "world", "trusting");
 
-        const [inRx, inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
+    const [inRx, inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
 
-        node.syncManager.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "peer",
-        });
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "peer",
+    });
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    // expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
 
-        yield* Queue.offer(inTx, {
-            action: "known",
-            id: map.core.id,
-            header: false,
-            sessions: {
-                [node.currentSessionID]: 0,
+    await inTx.push({
+        action: "known",
+        id: map.core.id,
+        header: false,
+        sessions: {
+            [node.currentSessionID]: 0,
+        },
+    });
+
+    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
+
+    const mapTellKnownStateMsg = (await outRxQ.next()).value;
+    expect(mapTellKnownStateMsg).toEqual({
+        action: "known",
+        ...map.core.knownState(),
+    } satisfies SyncMessage);
+
+    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
+
+    const mapNewContentMsg = (await outRxQ.next()).value;
+
+    expect(mapNewContentMsg).toEqual({
+        action: "content",
+        id: map.core.id,
+        header: map.core.header,
+        new: {
+            [node.currentSessionID]: {
+                after: 0,
+                newTransactions: [
+                    {
+                        privacy: "trusting" as const,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID)!
+                            .transactions[0]!.madeAt,
+                        changes: stableStringify([
+                            {
+                                op: "set",
+                                key: "hello",
+                                value: "world",
+                            } satisfies MapOpPayload<string, string>,
+                        ]),
+                    },
+                ],
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID)!
+                    .lastSignature!,
             },
-        });
+        },
+    } satisfies SyncMessage);
+});
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+test("No matter the optimistic known state, node respects invalid known state messages and resyncs", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
 
-        const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
-        expect(mapTellKnownStateMsg).toEqual({
-            action: "known",
-            ...map.core.knownState(),
-        } satisfies SyncMessage);
+    const group = node.createGroup();
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    const map = group.createMap();
 
-        const mapNewContentMsg = yield* Queue.take(outRxQ);
+    const [inRx, inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
 
-        expect(mapNewContentMsg).toEqual({
-            action: "content",
-            id: map.core.id,
-            header: map.core.header,
-            new: {
-                [node.currentSessionID]: {
-                    after: 0,
-                    newTransactions: [
-                        {
-                            privacy: "trusting" as const,
-                            madeAt: map.core.sessionLogs.get(
-                                node.currentSessionID,
-                            )!.transactions[0]!.madeAt,
-                            changes: stableStringify([
-                                {
-                                    op: "set",
-                                    key: "hello",
-                                    value: "world",
-                                } satisfies MapOpPayload<string, string>,
-                            ]),
-                        },
-                    ],
-                    lastSignature: map.core.sessionLogs.get(
-                        node.currentSessionID,
-                    )!.lastSignature!,
-                },
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "peer",
+    });
+
+    await inTx.push({
+        action: "load",
+        id: map.core.id,
+        header: false,
+        sessions: {
+            [node.currentSessionID]: 0,
+        },
+    });
+
+    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
+
+    const mapTellKnownStateMsg = (await outRxQ.next()).value;
+    expect(mapTellKnownStateMsg).toEqual({
+        action: "known",
+        ...map.core.knownState(),
+    } satisfies SyncMessage);
+
+    // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
+
+    const mapNewContentHeaderOnlyMsg = (await outRxQ.next()).value;
+
+    expect(mapNewContentHeaderOnlyMsg).toEqual({
+        action: "content",
+        id: map.core.id,
+        header: map.core.header,
+        new: {},
+    } satisfies SyncMessage);
+
+    map.set("hello", "world", "trusting");
+
+    map.set("goodbye", "world", "trusting");
+
+    const _mapEditMsgs = (await outRxQ.next()).value;
+
+    console.log("Sending correction");
+
+    await inTx.push({
+        action: "known",
+        isCorrection: true,
+        id: map.core.id,
+        header: true,
+        sessions: {
+            [node.currentSessionID]: 1,
+        },
+    } satisfies SyncMessage);
+
+    const newContentAfterWrongAssumedState = (await outRxQ.next()).value;
+
+    expect(newContentAfterWrongAssumedState).toEqual({
+        action: "content",
+        id: map.core.id,
+        header: undefined,
+        new: {
+            [node.currentSessionID]: {
+                after: 1,
+                newTransactions: [
+                    {
+                        privacy: "trusting" as const,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID)!
+                            .transactions[1]!.madeAt,
+                        changes: stableStringify([
+                            {
+                                op: "set",
+                                key: "goodbye",
+                                value: "world",
+                            } satisfies MapOpPayload<string, string>,
+                        ]),
+                    },
+                ],
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID)!
+                    .lastSignature!,
             },
-        } satisfies SyncMessage);
-    }).pipe(Effect.scoped, Effect.runPromise));
+        },
+    } satisfies SyncMessage);
+});
+
+test("If we add a peer, but it never subscribes to a coValue, it won't get any messages", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
+
+    const group = node.createGroup();
+
+    const map = group.createMap();
+
+    const [inRx, _inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
+
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "peer",
+    });
+
+    map.set("hello", "world", "trusting");
 
-test("No matter the optimistic known state, node respects invalid known state messages and resyncs", () =>
-    Effect.gen(function* () {
+    const timeoutPromise = new Promise((resolve) =>
+        setTimeout(() => resolve("neverHappened"), 100),
+    );
+
+    const result = await Promise.race([
+        outRxQ.next().then((value) => value.value),
+        timeoutPromise,
+    ]);
+
+    expect(result).toEqual("neverHappened");
+});
+
+test.todo(
+    "If we add a server peer, all updates to all coValues are sent to it, even if it doesn't subscribe",
+    async () => {
         const [admin, session] = randomAnonymousAccountAndSessionID();
         const node = new LocalNode(admin, session, Crypto);
 
@@ -378,85 +489,61 @@ test("No matter the optimistic known state, node respects invalid known state me
 
         const map = group.createMap();
 
-        const [inRx, inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
+        const [inRx, _inTx] = newQueuePair();
+        const [outRx, outTx] = newQueuePair();
+        const outRxQ = outRx[Symbol.asyncIterator]();
 
         node.syncManager.addPeer({
             id: "test",
             incoming: inRx,
             outgoing: outTx,
-            role: "peer",
+            role: "server",
         });
 
-        yield* Queue.offer(inTx, {
+        // expect((await outRxQ.next()).value).toMatchObject({
+        //     action: "load",
+        //     id: adminID,
+        // });
+        expect((await outRxQ.next()).value).toMatchObject({
             action: "load",
-            id: map.core.id,
-            header: false,
-            sessions: {
-                [node.currentSessionID]: 0,
-            },
+            id: group.core.id,
         });
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+        const mapSubscribeMsg = (await outRxQ.next()).value;
 
-        const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
-        expect(mapTellKnownStateMsg).toEqual({
-            action: "known",
-            ...map.core.knownState(),
-        } satisfies SyncMessage);
-
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
-
-        const mapNewContentHeaderOnlyMsg = yield* Queue.take(outRxQ);
-
-        expect(mapNewContentHeaderOnlyMsg).toEqual({
-            action: "content",
-            id: map.core.id,
-            header: map.core.header,
-            new: {},
-        } satisfies SyncMessage);
-
-        map.set("hello", "world", "trusting");
-
-        map.set("goodbye", "world", "trusting");
-
-        const _mapEditMsgs = yield* Queue.take(outRxQ);
-
-        console.log("Sending correction");
-
-        yield* Queue.offer(inTx, {
-            action: "known",
-            isCorrection: true,
+        expect(mapSubscribeMsg).toEqual({
+            action: "load",
             id: map.core.id,
             header: true,
-            sessions: {
-                [node.currentSessionID]: 1,
-            },
+            sessions: {},
         } satisfies SyncMessage);
 
-        const newContentAfterWrongAssumedState = yield* Queue.take(outRxQ);
+        map.set("hello", "world", "trusting");
+
+        // expect((await outRxQ.next()).value).toMatchObject(admContEx(admin.id));
+        expect((await outRxQ.next()).value).toMatchObject(
+            groupContentEx(group),
+        );
+
+        const mapNewContentMsg = (await outRxQ.next()).value;
 
-        expect(newContentAfterWrongAssumedState).toEqual({
+        expect(mapNewContentMsg).toEqual({
             action: "content",
             id: map.core.id,
-            header: undefined,
+            header: map.core.header,
             new: {
                 [node.currentSessionID]: {
-                    after: 1,
+                    after: 0,
                     newTransactions: [
                         {
                             privacy: "trusting" as const,
                             madeAt: map.core.sessionLogs.get(
                                 node.currentSessionID,
-                            )!.transactions[1]!.madeAt,
+                            )!.transactions[0]!.madeAt,
                             changes: stableStringify([
                                 {
                                     op: "set",
-                                    key: "goodbye",
+                                    key: "hello",
                                     value: "world",
                                 } satisfies MapOpPayload<string, string>,
                             ]),
@@ -468,375 +555,246 @@ test("No matter the optimistic known state, node respects invalid known state me
                 },
             },
         } satisfies SyncMessage);
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-test("If we add a peer, but it never subscribes to a coValue, it won't get any messages", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-        const node = new LocalNode(admin, session, Crypto);
-
-        const group = node.createGroup();
-
-        const map = group.createMap();
-
-        const [inRx, _inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
-
-        node.syncManager.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "peer",
-        });
-
-        map.set("hello", "world", "trusting");
-
-        expect(
-            yield* Queue.take(outRxQ).pipe(
-                Effect.timeout(100),
-                Effect.catch("_tag", {
-                    failure: "TimeoutException",
-                    onFailure: () => Effect.succeed("neverHappened"),
-                }),
-            ),
-        ).toEqual("neverHappened");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-test.todo(
-    "If we add a server peer, all updates to all coValues are sent to it, even if it doesn't subscribe",
-    () =>
-        Effect.gen(function* () {
-            const [admin, session] = randomAnonymousAccountAndSessionID();
-            const node = new LocalNode(admin, session, Crypto);
-
-            const group = node.createGroup();
-
-            const map = group.createMap();
-
-            const [inRx, _inTx] = yield* newQueuePair();
-            const [outRx, outTx] = yield* newQueuePair();
-            const outRxQ = yield* Queue.unbounded<SyncMessage>();
-            yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
-
-            node.syncManager.addPeer({
-                id: "test",
-                incoming: inRx,
-                outgoing: outTx,
-                role: "server",
-            });
-
-            // expect(yield* Queue.take(outRxQ)).toMatchObject({
-            //     action: "load",
-            //     id: adminID,
-            // });
-            expect(yield* Queue.take(outRxQ)).toMatchObject({
-                action: "load",
-                id: group.core.id,
-            });
-
-            const mapSubscribeMsg = Queue.take(outRxQ);
-
-            expect(mapSubscribeMsg).toEqual({
-                action: "load",
-                id: map.core.id,
-                header: true,
-                sessions: {},
-            } satisfies SyncMessage);
-
-            map.set("hello", "world", "trusting");
-
-            // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(admin.id));
-            expect(yield* Queue.take(outRxQ)).toMatchObject(
-                groupContentEx(group),
-            );
-
-            const mapNewContentMsg = Queue.take(outRxQ);
-
-            expect(mapNewContentMsg).toEqual({
-                action: "content",
-                id: map.core.id,
-                header: map.core.header,
-                new: {
-                    [node.currentSessionID]: {
-                        after: 0,
-                        newTransactions: [
-                            {
-                                privacy: "trusting" as const,
-                                madeAt: map.core.sessionLogs.get(
-                                    node.currentSessionID,
-                                )!.transactions[0]!.madeAt,
-                                changes: stableStringify([
-                                    {
-                                        op: "set",
-                                        key: "hello",
-                                        value: "world",
-                                    } satisfies MapOpPayload<string, string>,
-                                ]),
-                            },
-                        ],
-                        lastSignature: map.core.sessionLogs.get(
-                            node.currentSessionID,
-                        )!.lastSignature!,
-                    },
-                },
-            } satisfies SyncMessage);
-        }).pipe(Effect.scoped, Effect.runPromise),
+    },
 );
 
-test.skip("If we add a server peer, newly created coValues are auto-subscribed to", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-        const node = new LocalNode(admin, session, Crypto);
+test.skip("If we add a server peer, newly created coValues are auto-subscribed to", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
 
-        const group = node.createGroup();
+    const group = node.createGroup();
 
-        const [inRx, _inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
+    const [inRx, _inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
 
-        node.syncManager.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "server",
-        });
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "server",
+    });
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject({
-        //     action: "load",
-        //     id: admin.id,
-        // });
-        expect(yield* Queue.take(outRxQ)).toMatchObject({
-            action: "load",
-            id: group.core.id,
-        });
+    // expect((await outRxQ.next()).value).toMatchObject({
+    //     action: "load",
+    //     id: admin.id,
+    // });
+    expect((await outRxQ.next()).value).toMatchObject({
+        action: "load",
+        id: group.core.id,
+    });
 
-        const map = group.createMap();
+    const map = group.createMap();
 
-        const mapSubscribeMsg = Queue.take(outRxQ);
+    const mapSubscribeMsg = (await outRxQ.next()).value;
 
-        expect(mapSubscribeMsg).toEqual({
-            action: "load",
-            ...map.core.knownState(),
-        } satisfies SyncMessage);
+    expect(mapSubscribeMsg).toEqual({
+        action: "load",
+        ...map.core.knownState(),
+    } satisfies SyncMessage);
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(adminID));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    // expect((await outRxQ.next()).value).toMatchObject(admContEx(adminID));
+    expect((await outRxQ.next()).value).toMatchObject(groupContentEx(group));
 
-        const mapContentMsg = Queue.take(outRxQ);
+    const mapContentMsg = (await outRxQ.next()).value;
 
-        expect(mapContentMsg).toEqual({
-            action: "content",
-            id: map.core.id,
-            header: map.core.header,
-            new: {},
-        } satisfies SyncMessage);
-    }).pipe(Effect.scoped, Effect.runPromise));
+    expect(mapContentMsg).toEqual({
+        action: "content",
+        id: map.core.id,
+        header: map.core.header,
+        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",
 );
 
-test("When we connect a new server peer, we try to sync all existing coValues to it", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-        const node = new LocalNode(admin, session, Crypto);
+test("When we connect a new server peer, we try to sync all existing coValues to it", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
 
-        const group = node.createGroup();
+    const group = node.createGroup();
 
-        const map = group.createMap();
+    const map = group.createMap();
 
-        const [inRx, _inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
+    const [inRx, _inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
 
-        node.syncManager.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "server",
-        });
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "server",
+    });
 
-        // const _adminSubscribeMessage = yield* Queue.take(outRxQ);
-        const groupSubscribeMessage = yield* Queue.take(outRxQ);
+    // const _adminSubscribeMessage = await outRxQ.next();
+    const groupSubscribeMessage = (await outRxQ.next()).value;
 
-        expect(groupSubscribeMessage).toEqual({
-            action: "load",
-            ...group.core.knownState(),
-        } satisfies SyncMessage);
+    expect(groupSubscribeMessage).toEqual({
+        action: "load",
+        ...group.core.knownState(),
+    } satisfies SyncMessage);
 
-        const secondMessage = yield* Queue.take(outRxQ);
+    const secondMessage = (await outRxQ.next()).value;
 
-        expect(secondMessage).toEqual({
-            action: "load",
-            ...map.core.knownState(),
-        } satisfies SyncMessage);
-    }).pipe(Effect.scoped, Effect.runPromise));
+    expect(secondMessage).toEqual({
+        action: "load",
+        ...map.core.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", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-        const node = new LocalNode(admin, session, Crypto);
+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, session] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(admin, session, Crypto);
 
-        const group = node.createGroup();
+    const group = node.createGroup();
 
-        const map = group.createMap();
+    const map = group.createMap();
 
-        const [inRx, inTx] = yield* newQueuePair();
-        const [outRx, outTx] = yield* newQueuePair();
-        const outRxQ = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
+    const [inRx, inTx] = newQueuePair();
+    const [outRx, outTx] = newQueuePair();
+    const outRxQ = outRx[Symbol.asyncIterator]();
 
-        node.syncManager.addPeer({
-            id: "test",
-            incoming: inRx,
-            outgoing: outTx,
-            role: "peer",
-        });
+    node.syncManager.addPeer({
+        id: "test",
+        incoming: inRx,
+        outgoing: outTx,
+        role: "peer",
+    });
 
-        yield* Queue.offer(inTx, {
-            action: "load",
-            id: map.core.id,
-            header: true,
-            sessions: {
-                [node.currentSessionID]: 1,
-            },
-        });
+    await inTx.push({
+        action: "load",
+        id: map.core.id,
+        header: true,
+        sessions: {
+            [node.currentSessionID]: 1,
+        },
+    });
 
-        // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
-        expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
-        const mapTellKnownState = yield* Queue.take(outRxQ);
+    // expect((await outRxQ.next()).value).toMatchObject(admStateEx(admin.id));
+    expect((await outRxQ.next()).value).toMatchObject(groupStateEx(group));
+    const mapTellKnownState = (await outRxQ.next()).value;
 
-        expect(mapTellKnownState).toEqual({
-            action: "known",
-            ...map.core.knownState(),
-        } satisfies SyncMessage);
-    }).pipe(Effect.scoped, Effect.runPromise));
+    expect(mapTellKnownState).toEqual({
+        action: "known",
+        ...map.core.knownState(),
+    } satisfies SyncMessage);
+});
 
-test.skip("When replaying creation and transactions of a coValue as new content, the receiving peer integrates this information", () =>
-    Effect.gen(function* () {
-        // 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, session] = randomAnonymousAccountAndSessionID();
+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, session] = randomAnonymousAccountAndSessionID();
 
-        const node1 = new LocalNode(admin, session, Crypto);
+    const node1 = new LocalNode(admin, session, Crypto);
 
-        const group = node1.createGroup();
+    const group = node1.createGroup();
 
-        const [inRx1, inTx1] = yield* newQueuePair();
-        const [outRx1, outTx1] = yield* newQueuePair();
-        const outRxQ1 = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx1, Sink.fromQueue(outRxQ1)));
+    const [inRx1, inTx1] = newQueuePair();
+    const [outRx1, outTx1] = newQueuePair();
+    const outRxQ1 = outRx1[Symbol.asyncIterator]();
 
-        node1.syncManager.addPeer({
-            id: "test2",
-            incoming: inRx1,
-            outgoing: outTx1,
-            role: "server",
-        });
+    node1.syncManager.addPeer({
+        id: "test2",
+        incoming: inRx1,
+        outgoing: outTx1,
+        role: "server",
+    });
 
-        const node2 = new LocalNode(
-            admin,
-            newRandomSessionID(admin.id),
-            Crypto,
-        );
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
 
-        const [inRx2, inTx2] = yield* newQueuePair();
-        const [outRx2, outTx2] = yield* newQueuePair();
-        const outRxQ2 = yield* Queue.unbounded<SyncMessage>();
-        yield* Effect.fork(Stream.run(outRx2, Sink.fromQueue(outRxQ1)));
+    const [inRx2, inTx2] = newQueuePair();
+    const [outRx2, outTx2] = newQueuePair();
+    const outRxQ2 = outRx2[Symbol.asyncIterator]();
 
-        node2.syncManager.addPeer({
-            id: "test1",
-            incoming: inRx2,
-            outgoing: outTx2,
-            role: "client",
-        });
+    node2.syncManager.addPeer({
+        id: "test1",
+        incoming: inRx2,
+        outgoing: outTx2,
+        role: "client",
+    });
 
-        const adminSubscribeMessage: SyncMessage = yield* Queue.take(outRxQ1);
-        expect(adminSubscribeMessage).toMatchObject({
-            action: "load",
-            id: admin.id,
-        });
-        const groupSubscribeMsg = yield* Queue.take(outRxQ1);
-        expect(groupSubscribeMsg).toMatchObject({
-            action: "load",
-            id: group.core.id,
-        });
+    const adminSubscribeMessage = (await outRxQ1.next()).value;
+    expect(adminSubscribeMessage).toMatchObject({
+        action: "load",
+        id: admin.id,
+    });
+    const groupSubscribeMsg = (await outRxQ1.next()).value;
+    expect(groupSubscribeMsg).toMatchObject({
+        action: "load",
+        id: group.core.id,
+    });
 
-        yield* Queue.offer(inTx2, adminSubscribeMessage);
-        yield* Queue.offer(inTx2, groupSubscribeMsg);
+    await inTx2.push(adminSubscribeMessage);
+    await inTx2.push(groupSubscribeMsg);
 
-        // const adminTellKnownStateMsg = yield* Queue.take(outRxQ2);
-        // expect(adminTellKnownStateMsg).toMatchObject(admStateEx(admin.id));
+    // const adminTellKnownStateMsg = (await outRxQ2.next()).value;
+    // expect(adminTellKnownStateMsg).toMatchObject(admStateEx(admin.id));
 
-        const groupTellKnownStateMsg = yield* Queue.take(outRxQ2);
-        expect(groupTellKnownStateMsg).toMatchObject(groupStateEx(group));
+    const groupTellKnownStateMsg = (await outRxQ2.next()).value;
+    expect(groupTellKnownStateMsg).toMatchObject(groupStateEx(group));
 
-        expect(
-            node2.syncManager.peers["test1"]!.optimisticKnownStates[
-                group.core.id
-            ],
-        ).toBeDefined();
+    expect(
+        node2.syncManager.peers["test1"]!.optimisticKnownStates[group.core.id],
+    ).toBeDefined();
 
-        // yield* Queue.offer(inTx1, adminTellKnownStateMsg);
-        yield* Queue.offer(inTx1, groupTellKnownStateMsg);
+    // await inTx1.push(adminTellKnownStateMsg);
+    await inTx1.push(groupTellKnownStateMsg);
 
-        // const adminContentMsg = yield* Queue.take(outRxQ1);
-        // expect(adminContentMsg).toMatchObject(admContEx(admin.id));
+    // const adminContentMsg = (await outRxQ1.next()).value;
+    // expect(adminContentMsg).toMatchObject(admContEx(admin.id));
 
-        const groupContentMsg = yield* Queue.take(outRxQ1);
-        expect(groupContentMsg).toMatchObject(groupContentEx(group));
+    const groupContentMsg = (await outRxQ1.next()).value;
+    expect(groupContentMsg).toMatchObject(groupContentEx(group));
 
-        // yield* Queue.offer(inTx2, adminContentMsg);
-        yield* Queue.offer(inTx2, groupContentMsg);
+    // await inTx2.push(adminContentMsg);
+    await inTx2.push(groupContentMsg);
 
-        const map = group.createMap();
+    const map = group.createMap();
 
-        const mapSubscriptionMsg = yield* Queue.take(outRxQ1);
-        expect(mapSubscriptionMsg).toMatchObject({
-            action: "load",
-            id: map.core.id,
-        });
+    const mapSubscriptionMsg = (await outRxQ1.next()).value;
+    expect(mapSubscriptionMsg).toMatchObject({
+        action: "load",
+        id: map.core.id,
+    });
 
-        const mapNewContentMsg = yield* Queue.take(outRxQ1);
-        expect(mapNewContentMsg).toEqual({
-            action: "content",
-            id: map.core.id,
-            header: map.core.header,
-            new: {},
-        } satisfies SyncMessage);
+    const mapNewContentMsg = (await outRxQ1.next()).value;
+    expect(mapNewContentMsg).toEqual({
+        action: "content",
+        id: map.core.id,
+        header: map.core.header,
+        new: {},
+    } satisfies SyncMessage);
 
-        yield* Queue.offer(inTx2, mapSubscriptionMsg);
+    await inTx2.push(mapSubscriptionMsg);
 
-        const mapTellKnownStateMsg = yield* Queue.take(outRxQ2);
-        expect(mapTellKnownStateMsg).toEqual({
-            action: "known",
-            id: map.core.id,
-            header: false,
-            sessions: {},
-        } satisfies SyncMessage);
+    const mapTellKnownStateMsg = (await outRxQ2.next()).value;
+    expect(mapTellKnownStateMsg).toEqual({
+        action: "known",
+        id: map.core.id,
+        header: false,
+        sessions: {},
+    } satisfies SyncMessage);
 
-        expect(node2.coValues[map.core.id]?.state).toEqual("loading");
+    expect(node2.coValues[map.core.id]?.state).toEqual("loading");
 
-        yield* Queue.offer(inTx2, mapNewContentMsg);
+    await inTx2.push(mapNewContentMsg);
 
-        map.set("hello", "world", "trusting");
+    map.set("hello", "world", "trusting");
 
-        const mapEditMsg = yield* Queue.take(outRxQ1);
+    const mapEditMsg = (await outRxQ1.next()).value;
 
-        yield* Queue.offer(inTx2, mapEditMsg);
+    await inTx2.push(mapEditMsg);
 
-        yield* Effect.sleep(100);
+    await new Promise((resolve) => setTimeout(resolve, 100));
 
-        expect(
-            expectMap(
-                node2.expectCoValueLoaded(map.core.id).getCurrentContent(),
-            ).get("hello"),
-        ).toEqual("world");
-    }).pipe(Effect.scoped, Effect.runPromise));
+    expect(
+        expectMap(
+            node2.expectCoValueLoaded(map.core.id).getCurrentContent(),
+        ).get("hello"),
+    ).toEqual("world");
+});
 
 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 () => {
     /*
@@ -867,125 +825,109 @@ 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", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-
-        const client1 = new LocalNode(admin, session, Crypto);
-
-        const group = client1.createGroup();
-
-        const map = group.createMap();
-        map.set("hello", "world", "trusting");
-
-        const [serverUser, serverSession] =
-            randomAnonymousAccountAndSessionID();
-
-        const server = new LocalNode(serverUser, serverSession, Crypto);
-
-        const [serverAsPeerForClient1, client1AsPeer] = yield* connectedPeers(
-            "serverFor1",
-            "client1",
-            {
-                peer1role: "server",
-                peer2role: "client",
-                trace: true,
-            },
-        );
-
-        client1.syncManager.addPeer(serverAsPeerForClient1);
-        server.syncManager.addPeer(client1AsPeer);
-
-        const client2 = new LocalNode(
-            admin,
-            newRandomSessionID(admin.id),
-            Crypto,
-        );
-
-        const [serverAsPeerForClient2, client2AsPeer] = yield* connectedPeers(
-            "serverFor2",
-            "client2",
-            {
-                peer1role: "server",
-                peer2role: "client",
-                trace: true,
-            },
-        );
-
-        client2.syncManager.addPeer(serverAsPeerForClient2);
-        server.syncManager.addPeer(client2AsPeer);
-
-        const mapOnClient2 = yield* Effect.promise(() =>
-            client2.loadCoValueCore(map.core.id),
-        );
-        if (mapOnClient2 === "unavailable") {
-            throw new Error("Map is unavailable");
-        }
-
-        expect(
-            expectMap(mapOnClient2.getCurrentContent()).get("hello"),
-        ).toEqual("world");
-    }).pipe(Effect.scoped, Effect.runPromise));
-
-test("Can sync a coValue with private transactions through a server to another client", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
-
-        const client1 = new LocalNode(admin, session, Crypto);
-
-        const group = client1.createGroup();
-
-        const map = group.createMap();
-        map.set("hello", "world", "private");
-
-        const [serverUser, serverSession] =
-            randomAnonymousAccountAndSessionID();
+test("Can sync a coValue through a server to another client", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
 
-        const server = new LocalNode(serverUser, serverSession, Crypto);
+    const client1 = new LocalNode(admin, session, Crypto);
 
-        const [serverAsPeer, client1AsPeer] = yield* connectedPeers(
-            "server",
-            "client1",
-            {
-                trace: true,
-                peer1role: "server",
-                peer2role: "client",
-            },
-        );
+    const group = client1.createGroup();
 
-        client1.syncManager.addPeer(serverAsPeer);
-        server.syncManager.addPeer(client1AsPeer);
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
 
-        const client2 = new LocalNode(
-            admin,
-            newRandomSessionID(admin.id),
-            Crypto,
-        );
+    const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
+
+    const server = new LocalNode(serverUser, serverSession, Crypto);
+
+    const [serverAsPeerForClient1, client1AsPeer] = await connectedPeers(
+        "serverFor1",
+        "client1",
+        {
+            peer1role: "server",
+            peer2role: "client",
+            trace: true,
+        },
+    );
+
+    client1.syncManager.addPeer(serverAsPeerForClient1);
+    server.syncManager.addPeer(client1AsPeer);
+
+    const client2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
+
+    const [serverAsPeerForClient2, client2AsPeer] = connectedPeers(
+        "serverFor2",
+        "client2",
+        {
+            peer1role: "server",
+            peer2role: "client",
+            trace: true,
+        },
+    );
+
+    client2.syncManager.addPeer(serverAsPeerForClient2);
+    server.syncManager.addPeer(client2AsPeer);
+
+    const mapOnClient2 = await client2.loadCoValueCore(map.core.id);
+    if (mapOnClient2 === "unavailable") {
+        throw new Error("Map is unavailable");
+    }
+
+    expect(expectMap(mapOnClient2.getCurrentContent()).get("hello")).toEqual(
+        "world",
+    );
+});
 
-        const [serverAsOtherPeer, client2AsPeer] = yield* connectedPeers(
-            "server",
-            "client2",
-            {
-                trace: true,
-                peer1role: "server",
-                peer2role: "client",
-            },
-        );
+test("Can sync a coValue with private transactions through a server to another client", async () => {
+    const [admin, session] = randomAnonymousAccountAndSessionID();
 
-        client2.syncManager.addPeer(serverAsOtherPeer);
-        server.syncManager.addPeer(client2AsPeer);
+    const client1 = new LocalNode(admin, session, Crypto);
 
-        const mapOnClient2 = yield* Effect.promise(() =>
-            client2.loadCoValueCore(map.core.id),
-        );
-        if (mapOnClient2 === "unavailable") {
-            throw new Error("Map is unavailable");
-        }
+    const group = client1.createGroup();
 
-        expect(
-            expectMap(mapOnClient2.getCurrentContent()).get("hello"),
-        ).toEqual("world");
-    }).pipe(Effect.scoped, Effect.runPromise));
+    const map = group.createMap();
+    map.set("hello", "world", "private");
+
+    const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
+
+    const server = new LocalNode(serverUser, serverSession, Crypto);
+
+    const [serverAsPeer, client1AsPeer] = await connectedPeers(
+        "server",
+        "client1",
+        {
+            trace: true,
+            peer1role: "server",
+            peer2role: "client",
+        },
+    );
+
+    client1.syncManager.addPeer(serverAsPeer);
+    server.syncManager.addPeer(client1AsPeer);
+
+    const client2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
+
+    const [serverAsOtherPeer, client2AsPeer] = await connectedPeers(
+        "server",
+        "client2",
+        {
+            trace: true,
+            peer1role: "server",
+            peer2role: "client",
+        },
+    );
+
+    client2.syncManager.addPeer(serverAsOtherPeer);
+    server.syncManager.addPeer(client2AsPeer);
+
+    const mapOnClient2 = await client2.loadCoValueCore(map.core.id);
+    if (mapOnClient2 === "unavailable") {
+        throw new Error("Map is unavailable");
+    }
+
+    expect(expectMap(mapOnClient2.getCurrentContent()).get("hello")).toEqual(
+        "world",
+    );
+});
 
 test.skip("When a peer's incoming/readable stream closes, we remove the peer", async () => {
     /*
@@ -1100,50 +1042,41 @@ test.skip("When a peer's outgoing/writable stream closes, we remove the peer", a
     */
 });
 
-test("If we start loading a coValue before connecting to a peer that has it, it will load it once we connect", () =>
-    Effect.gen(function* () {
-        const [admin, session] = randomAnonymousAccountAndSessionID();
+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, Crypto);
+    const node1 = new LocalNode(admin, session, Crypto);
 
-        const group = node1.createGroup();
+    const group = node1.createGroup();
 
-        const map = group.createMap();
-        map.set("hello", "world", "trusting");
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
 
-        const node2 = new LocalNode(
-            admin,
-            newRandomSessionID(admin.id),
-            Crypto,
-        );
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
 
-        const [node1asPeer, node2asPeer] = yield* connectedPeers(
-            "peer1",
-            "peer2",
-            {
-                peer1role: "server",
-                peer2role: "client",
-                trace: true,
-            },
-        );
+    const [node1asPeer, node2asPeer] = await connectedPeers("peer1", "peer2", {
+        peer1role: "server",
+        peer2role: "client",
+        trace: true,
+    });
 
-        node1.syncManager.addPeer(node2asPeer);
+    node1.syncManager.addPeer(node2asPeer);
 
-        const mapOnNode2Promise = node2.loadCoValueCore(map.core.id);
+    const mapOnNode2Promise = node2.loadCoValueCore(map.core.id);
 
-        expect(node2.coValues[map.core.id]?.state).toEqual("loading");
+    expect(node2.coValues[map.core.id]?.state).toEqual("loading");
 
-        node2.syncManager.addPeer(node1asPeer);
+    node2.syncManager.addPeer(node1asPeer);
 
-        const mapOnNode2 = yield* Effect.promise(() => mapOnNode2Promise);
-        if (mapOnNode2 === "unavailable") {
-            throw new Error("Map is unavailable");
-        }
+    const mapOnNode2 = await mapOnNode2Promise;
+    if (mapOnNode2 === "unavailable") {
+        throw new Error("Map is unavailable");
+    }
 
-        expect(expectMap(mapOnNode2.getCurrentContent()).get("hello")).toEqual(
-            "world",
-        );
-    }).pipe(Effect.scoped, Effect.runPromise));
+    expect(expectMap(mapOnNode2.getCurrentContent()).get("hello")).toEqual(
+        "world",
+    );
+});
 
 function groupContentEx(group: RawGroup) {
     return {