cojson 0.7.11 → 0.7.14

package/dist/tests/sync.test.js

@@ -1,45 +1,46 @@
 import { expect, test } from "vitest";
-import { newRandomSessionID } from "../coValueCore.js";
 import { LocalNode } from "../localNode.js";
-import { expectMap } from "../coValue.js";
-import { randomAnonymousAccountAndSessionID, shouldNotResolve, } from "./testUtils.js";
-import { connectedPeers, newStreamPair } from "../streamUtils.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { connectedPeers, newQueuePair } from "../streamUtils.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";
 const Crypto = await WasmCrypto.create();
-test("Node replies with initial tx and header to empty subscribe", async () => {
+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);
     const group = node.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
-    const [inRx, inTx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "peer",
     });
-    const writer = inTx.getWriter();
-    await writer.write({
+    yield* Queue.offer(inTx, {
         action: "load",
         id: map.core.id,
         header: false,
         sessions: {},
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = await reader.read();
-    expect(mapTellKnownStateMsg.value).toEqual({
+    // expect((yield* Queue.take(outRxQ))).toMatchObject(admStateEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
+    expect(mapTellKnownStateMsg).toEqual({
         action: "known",
         ...map.core.knownState(),
     });
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
-    const newContentMsg = await reader.read();
-    expect(newContentMsg.value).toEqual({
+    // expect((yield * Queue.take(outRxQ))).toMatchObject(admContEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    const newContentMsg = yield* Queue.take(outRxQ);
+    expect(newContentMsg).toEqual({
         action: "content",
         id: map.core.id,
         header: {
@@ -55,8 +56,7 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
                 newTransactions: [
                     {
                         privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[0].madeAt,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID).transactions[0].madeAt,
                         changes: stableStringify([
                             {
                                 op: "set",
@@ -66,29 +66,29 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
                         ]),
                     },
                 ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID).lastSignature,
             },
         },
     });
-});
-test("Node replies with only new tx to subscribe with some known state", async () => {
+}).pipe(Effect.scoped, Effect.runPromise));
+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);
     const group = node.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
     map.set("goodbye", "world", "trusting");
-    const [inRx, inTx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "peer",
     });
-    const writer = inTx.getWriter();
-    await writer.write({
+    yield* Queue.offer(inTx, {
         action: "load",
         id: map.core.id,
         header: true,
@@ -96,18 +96,17 @@ test("Node replies with only new tx to subscribe with some known state", async (
             [node.currentSessionID]: 1,
         },
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = await reader.read();
-    expect(mapTellKnownStateMsg.value).toEqual({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
+    expect(mapTellKnownStateMsg).toEqual({
         action: "known",
         ...map.core.knownState(),
     });
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentMsg = await reader.read();
-    expect(mapNewContentMsg.value).toEqual({
+    // expect(yield* Queue.take(outRxQ))).toMatchObject(admContEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    const mapNewContentMsg = yield* Queue.take(outRxQ);
+    expect(mapNewContentMsg).toEqual({
         action: "content",
         id: map.core.id,
         header: undefined,
@@ -117,8 +116,7 @@ test("Node replies with only new tx to subscribe with some known state", async (
                 newTransactions: [
                     {
                         privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[1].madeAt,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID).transactions[1].madeAt,
                         changes: stableStringify([
                             {
                                 op: "set",
@@ -128,28 +126,28 @@ test("Node replies with only new tx to subscribe with some known state", async (
                         ]),
                     },
                 ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID).lastSignature,
             },
         },
     });
-});
+}).pipe(Effect.scoped, Effect.runPromise));
 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", async () => {
+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);
     const group = node.createGroup();
     const map = group.createMap();
-    const [inRx, inTx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "peer",
     });
-    const writer = inTx.getWriter();
-    await writer.write({
+    yield* Queue.offer(inTx, {
         action: "load",
         id: map.core.id,
         header: false,
@@ -157,26 +155,25 @@ test("After subscribing, node sends own known state and new txs to peer", async
             [node.currentSessionID]: 0,
         },
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = await reader.read();
-    expect(mapTellKnownStateMsg.value).toEqual({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
+    expect(mapTellKnownStateMsg).toEqual({
         action: "known",
         ...map.core.knownState(),
     });
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentHeaderOnlyMsg = await reader.read();
-    expect(mapNewContentHeaderOnlyMsg.value).toEqual({
+    // 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: {},
     });
     map.set("hello", "world", "trusting");
-    const mapEditMsg1 = await reader.read();
-    expect(mapEditMsg1.value).toEqual({
+    const mapEditMsg1 = yield* Queue.take(outRxQ);
+    expect(mapEditMsg1).toEqual({
         action: "content",
         id: map.core.id,
         new: {
@@ -185,8 +182,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
                 newTransactions: [
                     {
                         privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[0].madeAt,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID).transactions[0].madeAt,
                         changes: stableStringify([
                             {
                                 op: "set",
@@ -196,14 +192,13 @@ test("After subscribing, node sends own known state and new txs to peer", async
                         ]),
                     },
                 ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID).lastSignature,
             },
         },
     });
     map.set("goodbye", "world", "trusting");
-    const mapEditMsg2 = await reader.read();
-    expect(mapEditMsg2.value).toEqual({
+    const mapEditMsg2 = yield* Queue.take(outRxQ);
+    expect(mapEditMsg2).toEqual({
         action: "content",
         id: map.core.id,
         new: {
@@ -212,8 +207,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
                 newTransactions: [
                     {
                         privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[1].madeAt,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID).transactions[1].madeAt,
                         changes: stableStringify([
                             {
                                 op: "set",
@@ -223,30 +217,29 @@ test("After subscribing, node sends own known state and new txs to peer", async
                         ]),
                     },
                 ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID).lastSignature,
             },
         },
     });
-});
-test("Client replies with known new content to tellKnownState from server", async () => {
+}).pipe(Effect.scoped, Effect.runPromise));
+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);
     const group = node.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
-    const [inRx, inTx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "peer",
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject(groupStateEx(group));
-    const writer = inTx.getWriter();
-    await writer.write({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    yield* Queue.offer(inTx, {
         action: "known",
         id: map.core.id,
         header: false,
@@ -254,17 +247,17 @@ test("Client replies with known new content to tellKnownState from server", asyn
             [node.currentSessionID]: 0,
         },
     });
-    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = await reader.read();
-    expect(mapTellKnownStateMsg.value).toEqual({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
+    expect(mapTellKnownStateMsg).toEqual({
         action: "known",
         ...map.core.knownState(),
     });
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentMsg = await reader.read();
-    expect(mapNewContentMsg.value).toEqual({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    const mapNewContentMsg = yield* Queue.take(outRxQ);
+    expect(mapNewContentMsg).toEqual({
         action: "content",
         id: map.core.id,
         header: map.core.header,
@@ -274,8 +267,7 @@ test("Client replies with known new content to tellKnownState from server", asyn
                 newTransactions: [
                     {
                         privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[0].madeAt,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID).transactions[0].madeAt,
                         changes: stableStringify([
                             {
                                 op: "set",
@@ -285,27 +277,27 @@ test("Client replies with known new content to tellKnownState from server", asyn
                         ]),
                     },
                 ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID).lastSignature,
             },
         },
     });
-});
-test("No matter the optimistic known state, node respects invalid known state messages and resyncs", async () => {
+}).pipe(Effect.scoped, Effect.runPromise));
+test("No matter the optimistic known state, node respects invalid known state messages and resyncs", () => 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] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "peer",
     });
-    const writer = inTx.getWriter();
-    await writer.write({
+    yield* Queue.offer(inTx, {
         action: "load",
         id: map.core.id,
         header: false,
@@ -313,18 +305,17 @@ test("No matter the optimistic known state, node respects invalid known state me
             [node.currentSessionID]: 0,
         },
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownStateMsg = await reader.read();
-    expect(mapTellKnownStateMsg.value).toEqual({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    const mapTellKnownStateMsg = yield* Queue.take(outRxQ);
+    expect(mapTellKnownStateMsg).toEqual({
         action: "known",
         ...map.core.knownState(),
     });
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentHeaderOnlyMsg = await reader.read();
-    expect(mapNewContentHeaderOnlyMsg.value).toEqual({
+    // 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,
@@ -332,9 +323,9 @@ test("No matter the optimistic known state, node respects invalid known state me
     });
     map.set("hello", "world", "trusting");
     map.set("goodbye", "world", "trusting");
-    const _mapEditMsgs = await reader.read();
+    const _mapEditMsgs = yield* Queue.take(outRxQ);
     console.log("Sending correction");
-    await writer.write({
+    yield* Queue.offer(inTx, {
         action: "known",
         isCorrection: true,
         id: map.core.id,
@@ -343,8 +334,8 @@ test("No matter the optimistic known state, node respects invalid known state me
             [node.currentSessionID]: 1,
         },
     });
-    const newContentAfterWrongAssumedState = await reader.read();
-    expect(newContentAfterWrongAssumedState.value).toEqual({
+    const newContentAfterWrongAssumedState = yield* Queue.take(outRxQ);
+    expect(newContentAfterWrongAssumedState).toEqual({
         action: "content",
         id: map.core.id,
         header: undefined,
@@ -354,8 +345,7 @@ test("No matter the optimistic known state, node respects invalid known state me
                 newTransactions: [
                     {
                         privacy: "trusting",
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)
-                            .transactions[1].madeAt,
+                        madeAt: map.core.sessionLogs.get(node.currentSessionID).transactions[1].madeAt,
                         changes: stableStringify([
                             {
                                 op: "set",
@@ -365,19 +355,20 @@ test("No matter the optimistic known state, node respects invalid known state me
                         ]),
                     },
                 ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)
-                    .lastSignature,
+                lastSignature: map.core.sessionLogs.get(node.currentSessionID).lastSignature,
             },
         },
     });
-});
-test("If we add a peer, but it never subscribes to a coValue, it won't get any messages", async () => {
+}).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] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, _inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
@@ -385,43 +376,46 @@ test("If we add a peer, but it never subscribes to a coValue, it won't get any m
         role: "peer",
     });
     map.set("hello", "world", "trusting");
-    const reader = outRx.getReader();
-    await expect(shouldNotResolve(reader.read(), { timeout: 100 })).resolves.toBeUndefined();
-});
-test.todo("If we add a server peer, all updates to all coValues are sent to it, even if it doesn't subscribe", async () => {
+    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] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, _inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "server",
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject({
     //     action: "load",
     //     id: adminID,
     // });
-    expect((await reader.read()).value).toMatchObject({
+    expect(yield* Queue.take(outRxQ)).toMatchObject({
         action: "load",
         id: group.core.id,
     });
-    const mapSubscribeMsg = await reader.read();
-    expect(mapSubscribeMsg.value).toEqual({
+    const mapSubscribeMsg = Queue.take(outRxQ);
+    expect(mapSubscribeMsg).toEqual({
         action: "load",
         id: map.core.id,
         header: true,
         sessions: {},
     });
     map.set("hello", "world", "trusting");
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
-    const mapNewContentMsg = await reader.read();
-    expect(mapNewContentMsg.value).toEqual({
+    // 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,
@@ -445,86 +439,89 @@ test.todo("If we add a server peer, all updates to all coValues are sent to it,
             },
         },
     });
-});
-test.skip("If we add a server peer, newly created coValues are auto-subscribed to", async () => {
+}).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);
     const group = node.createGroup();
-    const [inRx, _inTx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, _inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "server",
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject({
     //     action: "load",
     //     id: admin.id,
     // });
-    expect((await reader.read()).value).toMatchObject({
+    expect(yield* Queue.take(outRxQ)).toMatchObject({
         action: "load",
         id: group.core.id,
     });
     const map = group.createMap();
-    const mapSubscribeMsg = await reader.read();
-    expect(mapSubscribeMsg.value).toEqual({
+    const mapSubscribeMsg = Queue.take(outRxQ);
+    expect(mapSubscribeMsg).toEqual({
         action: "load",
         ...map.core.knownState(),
     });
-    // expect((await reader.read()).value).toMatchObject(admContEx(adminID));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
-    const mapContentMsg = await reader.read();
-    expect(mapContentMsg.value).toEqual({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(adminID));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+    const mapContentMsg = Queue.take(outRxQ);
+    expect(mapContentMsg).toEqual({
         action: "content",
         id: map.core.id,
         header: map.core.header,
         new: {},
     });
-});
+}).pipe(Effect.scoped, Effect.runPromise));
 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", async () => {
+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);
     const group = node.createGroup();
     const map = group.createMap();
-    const [inRx, _inTx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, _inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "server",
     });
-    const reader = outRx.getReader();
-    // const _adminSubscribeMessage = await reader.read();
-    const groupSubscribeMessage = await reader.read();
-    expect(groupSubscribeMessage.value).toEqual({
+    // const _adminSubscribeMessage = yield* Queue.take(outRxQ);
+    const groupSubscribeMessage = yield* Queue.take(outRxQ);
+    expect(groupSubscribeMessage).toEqual({
         action: "load",
         ...group.core.knownState(),
     });
-    const secondMessage = await reader.read();
-    expect(secondMessage.value).toEqual({
+    const secondMessage = yield* Queue.take(outRxQ);
+    expect(secondMessage).toEqual({
         action: "load",
         ...map.core.knownState(),
     });
-});
-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 () => {
+}).pipe(Effect.scoped, Effect.runPromise));
+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);
     const group = node.createGroup();
     const map = group.createMap();
-    const [inRx, inTx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+    const [inRx, inTx] = yield* newQueuePair();
+    const [outRx, outTx] = yield* newQueuePair();
+    const outRxQ = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx, Sink.fromQueue(outRxQ)));
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "peer",
     });
-    const writer = inTx.getWriter();
-    await writer.write({
+    yield* Queue.offer(inTx, {
         action: "load",
         id: map.core.id,
         header: true,
@@ -532,110 +529,123 @@ test("When receiving a subscribe with a known state that is ahead of our own, pe
             [node.currentSessionID]: 1,
         },
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
-    const mapTellKnownState = await reader.read();
-    expect(mapTellKnownState.value).toEqual({
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admStateEx(admin.id));
+    expect(yield* Queue.take(outRxQ)).toMatchObject(groupStateEx(group));
+    const mapTellKnownState = yield* Queue.take(outRxQ);
+    expect(mapTellKnownState).toEqual({
         action: "known",
         ...map.core.knownState(),
     });
-});
-test.skip("When replaying creation and transactions of a coValue as new content, the receiving peer integrates this information", async () => {
+}).pipe(Effect.scoped, Effect.runPromise));
+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();
     const node1 = new LocalNode(admin, session, Crypto);
     const group = node1.createGroup();
-    const [inRx1, inTx1] = newStreamPair();
-    const [outRx1, outTx1] = newStreamPair();
+    const [inRx1, inTx1] = yield* newQueuePair();
+    const [outRx1, outTx1] = yield* newQueuePair();
+    const outRxQ1 = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx1, Sink.fromQueue(outRxQ1)));
     node1.syncManager.addPeer({
         id: "test2",
         incoming: inRx1,
         outgoing: outTx1,
         role: "server",
     });
-    const to1 = inTx1.getWriter();
-    const from1 = outRx1.getReader();
     const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
-    const [inRx2, inTx2] = newStreamPair();
-    const [outRx2, outTx2] = newStreamPair();
+    const [inRx2, inTx2] = yield* newQueuePair();
+    const [outRx2, outTx2] = yield* newQueuePair();
+    const outRxQ2 = yield* Queue.unbounded();
+    yield* Effect.fork(Stream.run(outRx2, Sink.fromQueue(outRxQ1)));
     node2.syncManager.addPeer({
         id: "test1",
         incoming: inRx2,
         outgoing: outTx2,
         role: "client",
     });
-    const to2 = inTx2.getWriter();
-    const from2 = outRx2.getReader();
-    const adminSubscribeMessage = await from1.read();
-    expect(adminSubscribeMessage.value).toMatchObject({
+    const adminSubscribeMessage = yield* Queue.take(outRxQ1);
+    expect(adminSubscribeMessage).toMatchObject({
         action: "load",
         id: admin.id,
     });
-    const groupSubscribeMsg = await from1.read();
-    expect(groupSubscribeMsg.value).toMatchObject({
+    const groupSubscribeMsg = yield* Queue.take(outRxQ1);
+    expect(groupSubscribeMsg).toMatchObject({
         action: "load",
         id: group.core.id,
     });
-    await to2.write(adminSubscribeMessage.value);
-    await to2.write(groupSubscribeMsg.value);
-    // const adminTellKnownStateMsg = await from2.read();
-    // expect(adminTellKnownStateMsg.value).toMatchObject(admStateEx(admin.id));
-    const groupTellKnownStateMsg = await from2.read();
-    expect(groupTellKnownStateMsg.value).toMatchObject(groupStateEx(group));
+    yield* Queue.offer(inTx2, adminSubscribeMessage);
+    yield* Queue.offer(inTx2, groupSubscribeMsg);
+    // const adminTellKnownStateMsg = yield* Queue.take(outRxQ2);
+    // expect(adminTellKnownStateMsg).toMatchObject(admStateEx(admin.id));
+    const groupTellKnownStateMsg = yield* Queue.take(outRxQ2);
+    expect(groupTellKnownStateMsg).toMatchObject(groupStateEx(group));
     expect(node2.syncManager.peers["test1"].optimisticKnownStates[group.core.id]).toBeDefined();
-    // await to1.write(adminTellKnownStateMsg.value!);
-    await to1.write(groupTellKnownStateMsg.value);
-    // const adminContentMsg = await from1.read();
-    // expect(adminContentMsg.value).toMatchObject(admContEx(admin.id));
-    const groupContentMsg = await from1.read();
-    expect(groupContentMsg.value).toMatchObject(groupContentEx(group));
-    // await to2.write(adminContentMsg.value!);
-    await to2.write(groupContentMsg.value);
+    // yield* Queue.offer(inTx1, adminTellKnownStateMsg);
+    yield* Queue.offer(inTx1, groupTellKnownStateMsg);
+    // const adminContentMsg = yield* Queue.take(outRxQ1);
+    // expect(adminContentMsg).toMatchObject(admContEx(admin.id));
+    const groupContentMsg = yield* Queue.take(outRxQ1);
+    expect(groupContentMsg).toMatchObject(groupContentEx(group));
+    // yield* Queue.offer(inTx2, adminContentMsg);
+    yield* Queue.offer(inTx2, groupContentMsg);
     const map = group.createMap();
-    const mapSubscriptionMsg = await from1.read();
-    expect(mapSubscriptionMsg.value).toMatchObject({
+    const mapSubscriptionMsg = yield* Queue.take(outRxQ1);
+    expect(mapSubscriptionMsg).toMatchObject({
         action: "load",
         id: map.core.id,
     });
-    const mapNewContentMsg = await from1.read();
-    expect(mapNewContentMsg.value).toEqual({
+    const mapNewContentMsg = yield* Queue.take(outRxQ1);
+    expect(mapNewContentMsg).toEqual({
         action: "content",
         id: map.core.id,
         header: map.core.header,
         new: {},
     });
-    await to2.write(mapSubscriptionMsg.value);
-    const mapTellKnownStateMsg = await from2.read();
-    expect(mapTellKnownStateMsg.value).toEqual({
+    yield* Queue.offer(inTx2, mapSubscriptionMsg);
+    const mapTellKnownStateMsg = yield* Queue.take(outRxQ2);
+    expect(mapTellKnownStateMsg).toEqual({
         action: "known",
         id: map.core.id,
         header: false,
         sessions: {},
     });
     expect(node2.coValues[map.core.id]?.state).toEqual("loading");
-    await to2.write(mapNewContentMsg.value);
+    yield* Queue.offer(inTx2, mapNewContentMsg);
     map.set("hello", "world", "trusting");
-    const mapEditMsg = await from1.read();
-    await to2.write(mapEditMsg.value);
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    const mapEditMsg = yield* Queue.take(outRxQ1);
+    yield* Queue.offer(inTx2, mapEditMsg);
+    yield* Effect.sleep(100);
     expect(expectMap(node2.expectCoValueLoaded(map.core.id).getCurrentContent()).get("hello")).toEqual("world");
-});
+}).pipe(Effect.scoped, Effect.runPromise));
 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, session] = randomAnonymousAccountAndSessionID();
+
     const node1 = new LocalNode(admin, session, Crypto);
+
     const group = node1.createGroup();
+
     const map = group.createMap();
     map.set("hello", "world", "trusting");
+
     const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
+
     const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2");
+
     node1.syncManager.addPeer(node2asPeer);
     node2.syncManager.addPeer(node1asPeer);
+
     await node2.loadCoValueCore(map.core.id);
-    expect(expectMap(node2.expectCoValueLoaded(map.core.id).getCurrentContent()).get("hello")).toEqual("world");
+
+    expect(
+        expectMap(
+            node2.expectCoValueLoaded(map.core.id).getCurrentContent(),
+        ).get("hello"),
+    ).toEqual("world");
+    */
 });
-test("Can sync a coValue through a server to another client", async () => {
+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();
@@ -643,24 +653,28 @@ test("Can sync a coValue through a server to another client", async () => {
     map.set("hello", "world", "trusting");
     const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
     const server = new LocalNode(serverUser, serverSession, Crypto);
-    const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
+    const [serverAsPeerForClient1, client1AsPeer] = yield* connectedPeers("serverFor1", "client1", {
         peer1role: "server",
         peer2role: "client",
         trace: true,
     });
-    client1.syncManager.addPeer(serverAsPeer);
+    client1.syncManager.addPeer(serverAsPeerForClient1);
     server.syncManager.addPeer(client1AsPeer);
     const client2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
-    const [serverAsOtherPeer, client2AsPeer] = connectedPeers("server", "client2", { peer1role: "server", peer2role: "client", trace: true });
-    client2.syncManager.addPeer(serverAsOtherPeer);
+    const [serverAsPeerForClient2, client2AsPeer] = yield* 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);
+    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");
-});
-test("Can sync a coValue with private transactions through a server to another client", async () => {
+}).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();
@@ -668,7 +682,7 @@ test("Can sync a coValue with private transactions through a server to another c
     map.set("hello", "world", "private");
     const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
     const server = new LocalNode(serverUser, serverSession, Crypto);
-    const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
+    const [serverAsPeer, client1AsPeer] = yield* connectedPeers("server", "client1", {
         trace: true,
         peer1role: "server",
         peer2role: "client",
@@ -676,105 +690,138 @@ test("Can sync a coValue with private transactions through a server to another c
     client1.syncManager.addPeer(serverAsPeer);
     server.syncManager.addPeer(client1AsPeer);
     const client2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
-    const [serverAsOtherPeer, client2AsPeer] = connectedPeers("server", "client2", { trace: true, peer1role: "server", peer2role: "client" });
+    const [serverAsOtherPeer, client2AsPeer] = yield* 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);
+    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.skip("When a peer's incoming/readable stream closes, we remove the peer", async () => {
+    /*
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session, Crypto);
+
     const group = node.createGroup();
-    const [inRx, inTx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+
+    const [inRx, inTx] = await Effect.runPromise(newStreamPair());
+    const [outRx, outTx] = await Effect.runPromise(newStreamPair());
+
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "server",
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject({
+
+    // expect(yield* Queue.take(outRxQ)).toMatchObject({
     //     action: "load",
     //     id: admin.id,
     // });
-    expect((await reader.read()).value).toMatchObject({
+    expect(yield * Queue.take(outRxQ)).toMatchObject({
         action: "load",
         id: group.core.id,
     });
+
     const map = group.createMap();
+
     const mapSubscribeMsg = await reader.read();
+
     expect(mapSubscribeMsg.value).toEqual({
         action: "load",
         ...map.core.knownState(),
-    });
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
+    } satisfies SyncMessage);
+
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(admin.id));
+    expect(yield * Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+
     const mapContentMsg = await reader.read();
+
     expect(mapContentMsg.value).toEqual({
         action: "content",
         id: map.core.id,
         header: map.core.header,
         new: {},
-    });
+    } satisfies SyncMessage);
+
     await inTx.abort();
+
     await new Promise((resolve) => setTimeout(resolve, 100));
+
     expect(node.syncManager.peers["test"]).toBeUndefined();
+    */
 });
 test.skip("When a peer's outgoing/writable stream closes, we remove the peer", async () => {
+    /*
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session, Crypto);
+
     const group = node.createGroup();
-    const [inRx] = newStreamPair();
-    const [outRx, outTx] = newStreamPair();
+
+    const [inRx] = await Effect.runPromise(newStreamPair());
+    const [outRx, outTx] = await Effect.runPromise(newStreamPair());
+
     node.syncManager.addPeer({
         id: "test",
         incoming: inRx,
         outgoing: outTx,
         role: "server",
     });
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject({
+
+    // expect(yield* Queue.take(outRxQ)).toMatchObject({
     //     action: "load",
     //     id: admin.id,
     // });
-    expect((await reader.read()).value).toMatchObject({
+    expect(yield * Queue.take(outRxQ)).toMatchObject({
         action: "load",
         id: group.core.id,
     });
+
     const map = group.createMap();
+
     const mapSubscribeMsg = await reader.read();
+
     expect(mapSubscribeMsg.value).toEqual({
         action: "load",
         ...map.core.knownState(),
-    });
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
+    } satisfies SyncMessage);
+
+    // expect(yield* Queue.take(outRxQ)).toMatchObject(admContEx(admin.id));
+    expect(yield * Queue.take(outRxQ)).toMatchObject(groupContentEx(group));
+
     const mapContentMsg = await reader.read();
+
     expect(mapContentMsg.value).toEqual({
         action: "content",
         id: map.core.id,
         header: map.core.header,
         new: {},
-    });
+    } satisfies SyncMessage);
+
     reader.releaseLock();
     await outRx.cancel();
+
     map.set("hello", "world", "trusting");
+
     await new Promise((resolve) => setTimeout(resolve, 100));
+
     expect(node.syncManager.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 () => {
+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();
     const node1 = new LocalNode(admin, session, Crypto);
     const group = node1.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
     const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
-    const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2", {
+    const [node1asPeer, node2asPeer] = yield* connectedPeers("peer1", "peer2", {
         peer1role: "server",
         peer2role: "client",
         trace: true,
@@ -783,12 +830,12 @@ test("If we start loading a coValue before connecting to a peer that has it, it
     const mapOnNode2Promise = node2.loadCoValueCore(map.core.id);
     expect(node2.coValues[map.core.id]?.state).toEqual("loading");
     node2.syncManager.addPeer(node1asPeer);
-    const mapOnNode2 = await mapOnNode2Promise;
+    const mapOnNode2 = yield* Effect.promise(() => mapOnNode2Promise);
     if (mapOnNode2 === "unavailable") {
         throw new Error("Map is unavailable");
     }
     expect(expectMap(mapOnNode2.getCurrentContent()).get("hello")).toEqual("world");
-});
+}).pipe(Effect.scoped, Effect.runPromise));
 function groupContentEx(group) {
     return {
         action: "content",