@livestore/webmesh 0.4.0 → 0.5.0-dev.0

package/dist/node.test.js

@@ -1,7 +1,7 @@
+import { expect } from 'vitest';
 import { IS_CI, omitUndefineds } from '@livestore/utils';
-import { Chunk, Deferred, Effect, Exit, Schema, Scope, Stream, WebChannel } from '@livestore/utils/effect';
 import { Vitest } from '@livestore/utils-dev/node-vitest';
-import { expect } from 'vitest';
+import { Deferred, Effect, Exit, Fiber, Schema, Scope, Stream, WebChannel } from '@livestore/utils/effect';
 import { Packet } from "./mesh-schema.js";
 import { makeMeshNode } from "./node.js";
 // TODO test cases where in-between node only comes online later
@@ -55,20 +55,23 @@ const createChannel = (source, target, options) => source.makeChannel({
     mode: options?.mode ?? 'direct',
     timeout: options?.timeout ?? 200,
 });
-const getFirstMessage = (channel) => channel.listen.pipe(Stream.flatten(), Stream.take(1), Stream.runCollect, Effect.map(([message]) => message));
+const getFirstMessage = (channel) => channel.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.take(1), Stream.runCollect, Effect.map(([message]) => message));
 // NOTE we distinguish between undefined and 0 delays as it changes the fiber execution
 const maybeDelay = (delay, label) => (effect) => delay === undefined
     ? effect
     : Effect.sleep(delay).pipe(Effect.withSpan(`${label}:delay(${delay})`), Effect.andThen(effect));
 const testTimeout = IS_CI === true ? 30_000 : 1000;
 const propTestTimeout = IS_CI === true ? 60_000 : 20_000;
-// TODO also make work without `Vitest.scopedLive` (i.e. with `Vitest.scoped`)
+// TODO also make work without `Vitest.live` (i.e. with `Vitest.effect`)
 // probably requires controlling the clocks
 Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
-    const Delay = Schema.UndefinedOr(Schema.Literal(0, 1, 10, 50));
+    const Delay = Schema.UndefinedOr(Schema.Literals([0, 1, 10, 50]));
     // NOTE for message channels, we test both with and without transferables (i.e. proxying)
-    const ChannelType = Schema.Literal('direct', 'proxy(via-messagechannel-edge)', 'proxy');
-    const NodeNames = Schema.Union(Schema.Tuple(Schema.Literal('A'), Schema.Literal('B')), Schema.Tuple(Schema.Literal('B'), Schema.Literal('A')));
+    const ChannelType = Schema.Literals(['direct', 'proxy(via-messagechannel-edge)', 'proxy']);
+    const NodeNames = Schema.Union([
+        Schema.Tuple([Schema.Literal('A'), Schema.Literal('B')]),
+        Schema.Tuple([Schema.Literal('B'), Schema.Literal('A')]),
+    ]);
     const fromChannelType = (channelType) => {
         switch (channelType) {
             case 'proxy': {
@@ -114,10 +117,10 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             // const connectDelay = undefined
             // const channelType = 'direct'
             // const nodeNames = ['B', 'A'] as const
-            // Vitest.scopedLive(
+            // Vitest.live(
             //   'a / b connect at different times with different channel types',
             //   (test) =>
-            Vitest.scopedLive.prop('a / b connect at different times with different channel types', [Delay, Delay, Delay, ChannelType, NodeNames], ([delayX, delayY, connectDelay, channelType, nodeNames], test) => Effect.gen(function* () {
+            Vitest.live.prop('a / b connect at different times with different channel types', [Delay, Delay, Delay, ChannelType, NodeNames], ([delayX, delayY, connectDelay, channelType, nodeNames], test) => Effect.gen(function* () {
                 // console.log({ delayX, delayY, connectDelay, channelType, nodeNames })
                 const [nodeNameX, nodeNameY] = nodeNames;
                 const nodeX = yield* makeMeshNode(nodeNameX);
@@ -141,10 +144,10 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             // const waitForOfflineDelay = undefined
             // const sleepDelay = 0
             // const channelType = 'direct'
-            // Vitest.scopedLive(
+            // Vitest.live(
             //   'b reconnects',
             //   (test) =>
-            Vitest.scopedLive.prop('b reconnects', [Delay, Delay, ChannelType], ([waitForOfflineDelay, sleepDelay, channelType], test) => Effect.gen(function* () {
+            Vitest.live.prop('b reconnects', [Delay, Delay, ChannelType], ([waitForOfflineDelay, sleepDelay, channelType], test) => Effect.gen(function* () {
                 // console.log({ waitForOfflineDelay, sleepDelay, channelType })
                 if (waitForOfflineDelay === undefined) {
                     // TODO we still need to fix this scenario but it shouldn't really be common in practice
@@ -162,7 +165,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                     expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' });
                     console.log('nodeACode:waiting for B to be offline');
                     if (waitForBToBeOffline !== undefined) {
-                        yield* waitForBToBeOffline;
+                        yield* Deferred.await(waitForBToBeOffline);
                     }
                     yield* channelAToB.send({ message: 'A2' });
                     expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B2' });
@@ -194,11 +197,11 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             }).pipe(Vitest.withTestCtx(test, {
                 suffix: `waitForOfflineDelay=${waitForOfflineDelay} sleepDelay=${sleepDelay} channelType=${channelType}`,
             })), { fastCheck: { numRuns: 20 } });
-            Vitest.scopedLive('reconnect with re-created node', (test) => Effect.gen(function* () {
+            Vitest.live('reconnect with re-created node', (test) => Effect.gen(function* () {
                 const nodeBgen1Scope = yield* Scope.make();
                 const nodeA = yield* makeMeshNode('A');
-                const nodeBgen1 = yield* makeMeshNode('B').pipe(Scope.extend(nodeBgen1Scope));
-                yield* connectNodesViaMessageChannel(nodeA, nodeBgen1).pipe(Scope.extend(nodeBgen1Scope));
+                const nodeBgen1 = yield* makeMeshNode('B').pipe(Scope.provide(nodeBgen1Scope));
+                yield* connectNodesViaMessageChannel(nodeA, nodeBgen1).pipe(Scope.provide(nodeBgen1Scope));
                 // yield* Effect.sleep(100)
                 const channelAToBOnce = yield* Effect.cached(createChannel(nodeA, 'B'));
                 const nodeACode = Effect.gen(function* () {
@@ -213,7 +216,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                     expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' });
                     // expect(channelBToA.debugInfo.connectCounter).toBe(1)
                 });
-                yield* Effect.all([nodeACode, nodeBCode(nodeBgen1).pipe(Scope.extend(nodeBgen1Scope))], {
+                yield* Effect.all([nodeACode, nodeBCode(nodeBgen1).pipe(Scope.provide(nodeBgen1Scope))], {
                     concurrency: 'unbounded',
                 }).pipe(Effect.withSpan('test1'));
                 yield* Scope.close(nodeBgen1Scope, Exit.void);
@@ -221,7 +224,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                 yield* connectNodesViaMessageChannel(nodeA, nodeBgen2, { replaceIfExists: true });
                 yield* Effect.all([nodeACode, nodeBCode(nodeBgen2)], { concurrency: 'unbounded' }).pipe(Effect.withSpan('test2'));
             }).pipe(Vitest.withTestCtx(test)));
-            const ChannelTypeWithoutMessageChannelProxy = Schema.Literal('proxy', 'direct');
+            const ChannelTypeWithoutMessageChannelProxy = Schema.Literals(['proxy', 'direct']);
             // TODO there seems to be a flaky case here which gets hit sometimes (e.g. 2025-02-28-17:11)
             // Log output:
             // test: { seed: -964670352, path: "1", endOnFailure: true }
@@ -237,7 +240,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             // test: Error: Property failed after 2 tests
             // test: { seed: -964670352, path: "1", endOnFailure: true }
             // test: Counterexample: ["direct",["A","B"]]
-            Vitest.scopedLive.prop('replace edge while keeping the channel', [ChannelTypeWithoutMessageChannelProxy, NodeNames], ([channelType, nodeNames], test) => Effect.gen(function* () {
+            Vitest.live.prop('replace edge while keeping the channel', [ChannelTypeWithoutMessageChannelProxy, NodeNames], ([channelType, nodeNames], test) => Effect.gen(function* () {
                 const [nodeNameX, nodeNameY] = nodeNames;
                 const nodeX = yield* makeMeshNode(nodeNameX);
                 const nodeY = yield* makeMeshNode(nodeNameY);
@@ -249,7 +252,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                     const channelXToY = yield* createChannel(nodeX, nodeLabel.y, { mode });
                     yield* channelXToY.send({ message: `${nodeLabel.x}1` });
                     expect(yield* getFirstMessage(channelXToY)).toEqual({ message: `${nodeLabel.y}1` });
-                    yield* waitForEdgeReplacement;
+                    yield* Deferred.await(waitForEdgeReplacement);
                     yield* channelXToY.send({ message: `${nodeLabel.x}2` });
                     expect(yield* getFirstMessage(channelXToY)).toEqual({ message: `${nodeLabel.y}2` });
                 });
@@ -271,7 +274,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             })), { fastCheck: { numRuns: 10 } });
             Vitest.describe('TODO improve latency', () => {
                 // TODO we need to improve latency when sending messages concurrently
-                Vitest.scopedLive.prop('concurrent messages', [ChannelType, Schema.Int.pipe(Schema.between(1, 50))], ([channelType, count], test) => Effect.gen(function* () {
+                Vitest.live.prop('concurrent messages', [ChannelType, Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 50 }))], ([channelType, count], test) => Effect.gen(function* () {
                     const nodeA = yield* makeMeshNode('A');
                     const nodeB = yield* makeMeshNode('B');
                     const { mode, connectNodes } = fromChannelType(channelType);
@@ -279,15 +282,15 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                     const nodeACode = Effect.gen(function* () {
                         const channelAToB = yield* createChannel(nodeA, 'B', { mode });
                         // send 10 times A1
-                        yield* Effect.forEach(Chunk.makeBy(count, (i) => ({ message: `A${i}` })), channelAToB.send, { concurrency: 'unbounded' });
-                        expect(yield* channelAToB.listen.pipe(Stream.flatten(), Stream.take(count), Stream.runCollect)).toEqual(Chunk.makeBy(count, (i) => ({ message: `B${i}` })));
+                        yield* Effect.forEach(Array.from({ length: count }, (_, i) => ({ message: `A${i}` })), channelAToB.send, { concurrency: 'unbounded' });
+                        expect(yield* channelAToB.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.take(count), Stream.runCollect)).toEqual(Array.from({ length: count }, (_, i) => ({ message: `B${i}` })));
                         // expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'A2' })
                     });
                     const nodeBCode = Effect.gen(function* () {
                         const channelBToA = yield* createChannel(nodeB, 'A', { mode });
                         // send 10 times B1
-                        yield* Effect.forEach(Chunk.makeBy(count, (i) => ({ message: `B${i}` })), channelBToA.send, { concurrency: 'unbounded' });
-                        expect(yield* channelBToA.listen.pipe(Stream.flatten(), Stream.take(count), Stream.runCollect)).toEqual(Chunk.makeBy(count, (i) => ({ message: `A${i}` })));
+                        yield* Effect.forEach(Array.from({ length: count }, (_, i) => ({ message: `B${i}` })), channelBToA.send, { concurrency: 'unbounded' });
+                        expect(yield* channelBToA.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.take(count), Stream.runCollect)).toEqual(Array.from({ length: count }, (_, i) => ({ message: `A${i}` })));
                     });
                     yield* Effect.all([nodeACode, nodeBCode, connectNodes(nodeA, nodeB).pipe(Effect.delay(100))], {
                         concurrency: 'unbounded',
@@ -299,27 +302,27 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             });
         });
         Vitest.describe('message channel specific tests', () => {
-            Vitest.scopedLive('differing initial edge counter', (test) => Effect.gen(function* () {
+            Vitest.live('differing initial edge counter', (test) => Effect.gen(function* () {
                 const nodeA = yield* makeMeshNode('A');
                 const nodeB = yield* makeMeshNode('B');
                 yield* connectNodesViaMessageChannel(nodeA, nodeB);
                 const messageCount = 3;
                 const bFiber = yield* Effect.gen(function* () {
                     const channelBToA = yield* createChannel(nodeB, 'A');
-                    yield* channelBToA.listen.pipe(Stream.flatten(), Stream.tap((msg) => channelBToA.send({ message: `resp:${msg.message}` })), Stream.take(messageCount), Stream.runDrain);
-                }).pipe(Effect.scoped, Effect.fork);
+                    yield* channelBToA.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.tap((msg) => channelBToA.send({ message: `resp:${msg.message}` })), Stream.take(messageCount), Stream.runDrain);
+                }).pipe(Effect.scoped, Effect.forkChild);
                 // yield* createChannel(nodeA, 'B').pipe(Effect.andThen(WebChannel.shutdown))
                 // // yield* createChannel(nodeA, 'B').pipe(Effect.andThen(WebChannel.shutdown))
                 // // yield* createChannel(nodeA, 'B').pipe(Effect.andThen(WebChannel.shutdown))
-                yield* Effect.gen(function* () {
+                yield* Effect.replicateEffect(Effect.gen(function* () {
                     const channelAToB = yield* createChannel(nodeA, 'B');
                     yield* channelAToB.send({ message: 'A' });
                     expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'resp:A' });
-                }).pipe(Effect.scoped, Effect.repeatN(messageCount));
-                yield* bFiber;
+                }).pipe(Effect.scoped), messageCount, { discard: true });
+                yield* Fiber.join(bFiber);
             }).pipe(Vitest.withTestCtx(test)));
         });
-        Vitest.scopedLive('manual debug test', (test) => Effect.gen(function* () {
+        Vitest.live('manual debug test', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             // const connectNodes = connectNodesViaBroadcastChannel
@@ -338,16 +341,16 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                 concurrency: 'unbounded',
             });
         }).pipe(Vitest.withTestCtx(test)));
-        Vitest.scopedLive('broadcast edge with message channel', (test) => Effect.gen(function* () {
+        Vitest.live('broadcast edge with message channel', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             yield* connectNodesViaBroadcastChannel(nodeA, nodeB);
             const err = yield* createChannel(nodeA, 'B', { mode: 'direct' }).pipe(Effect.timeout(200), Effect.flip);
-            expect(err._tag).toBe('TimeoutException');
+            expect(err._tag).toBe('TimeoutError');
         }).pipe(Vitest.withTestCtx(test)));
     });
     Vitest.describe('A <> B <> C', () => {
-        Vitest.scopedLive('should work', (test) => Effect.gen(function* () {
+        Vitest.live('should work', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -369,7 +372,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             });
             yield* Effect.all([nodeACode, nodeCCode], { concurrency: 'unbounded' });
         }).pipe(Vitest.withTestCtx(test)));
-        Vitest.scopedLive('should work - delayed edge', (test) => Effect.gen(function* () {
+        Vitest.live('should work - delayed edge', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -393,7 +396,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                 connectNodes(nodeB, nodeC).pipe(Effect.delay(100), Effect.withSpan('connect-nodeB-nodeC-delay(100)')),
             ], { concurrency: 'unbounded' });
         }).pipe(Vitest.withTestCtx(test)));
-        Vitest.scopedLive('proxy channel', (test) => Effect.gen(function* () {
+        Vitest.live('proxy channel', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -429,7 +432,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
          * 2. Verify the pattern works correctly with forked ACKs
          * 3. Serve as a reference for the fix in proxy-channel.ts
          */
-        Vitest.scopedLive('ACK sending should not block message processing', (test) => Effect.gen(function* () {
+        Vitest.live('ACK sending should not block message processing', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -440,18 +443,18 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             const nodeACode = Effect.gen(function* () {
                 const channelAToC = yield* createChannel(nodeA, 'C', { mode: 'proxy' });
                 // Send multiple messages concurrently
-                yield* Effect.forEach(Chunk.makeBy(messageCount, (i) => ({ message: `A${i}` })), channelAToC.send, { concurrency: 'unbounded' });
+                yield* Effect.forEach(Array.from({ length: messageCount }, (_, i) => ({ message: `A${i}` })), channelAToC.send, { concurrency: 'unbounded' });
                 // Receive responses
-                const responses = yield* channelAToC.listen.pipe(Stream.flatten(), Stream.take(messageCount), Stream.runCollect);
-                expect(Chunk.size(responses)).toBe(messageCount);
+                const responses = yield* channelAToC.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.take(messageCount), Stream.runCollect);
+                expect(responses.length).toBe(messageCount);
             });
             const nodeCCode = Effect.gen(function* () {
                 const channelCToA = yield* createChannel(nodeC, 'A', { mode: 'proxy' });
                 // Send multiple messages concurrently
-                yield* Effect.forEach(Chunk.makeBy(messageCount, (i) => ({ message: `C${i}` })), channelCToA.send, { concurrency: 'unbounded' });
+                yield* Effect.forEach(Array.from({ length: messageCount }, (_, i) => ({ message: `C${i}` })), channelCToA.send, { concurrency: 'unbounded' });
                 // Receive responses
-                const responses = yield* channelCToA.listen.pipe(Stream.flatten(), Stream.take(messageCount), Stream.runCollect);
-                expect(Chunk.size(responses)).toBe(messageCount);
+                const responses = yield* channelCToA.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.take(messageCount), Stream.runCollect);
+                expect(responses.length).toBe(messageCount);
             });
             yield* Effect.all([nodeACode, nodeCCode], { concurrency: 'unbounded' });
         }).pipe(Vitest.withTestCtx(test)));
@@ -482,7 +485,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
              * without being blocked by slow ACK sends. We measure how long it takes to receive
              * all messages - with forked ACKs it should be fast, with blocking ACKs it would be slow.
              */
-            Vitest.scopedLive('messages arrive in listen queue without waiting for ACK send', (test) => Effect.gen(function* () {
+            Vitest.live('messages arrive in listen queue without waiting for ACK send', (test) => Effect.gen(function* () {
                 const ACK_DELAY_MS = 50;
                 const MESSAGE_COUNT = 5;
                 const nodeA = yield* makeMeshNode('A');
@@ -500,7 +503,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                     // Send all messages concurrently - this is key!
                     // With forked ACKs, all messages get processed immediately at receiver
                     // With blocking ACKs, messages would be processed one at a time with delays
-                    yield* Effect.forEach(Chunk.makeBy(MESSAGE_COUNT, (i) => ({ message: `msg${i}` })), channelAToB.send, { concurrency: 'unbounded' });
+                    yield* Effect.forEach(Array.from({ length: MESSAGE_COUNT }, (_, i) => ({ message: `msg${i}` })), channelAToB.send, { concurrency: 'unbounded' });
                 });
                 const receiverCode = Effect.gen(function* () {
                     const channelBToA = yield* nodeB.makeChannel({
@@ -520,7 +523,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                             },
                         },
                     });
-                    yield* channelBToA.listen.pipe(Stream.flatten(), Stream.tap((msg) => Effect.sync(() => {
+                    yield* channelBToA.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.tap((msg) => Effect.sync(() => {
                         receivedMessages.push(msg.message);
                     })), Stream.take(MESSAGE_COUNT), Stream.runDrain);
                 });
@@ -548,7 +551,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
              * This test sends multiple messages concurrently and verifies they're all
              * processed even when ACK sends are slow.
              */
-            Vitest.scopedLive('concurrent messages processed despite slow ACK sends', (test) => Effect.gen(function* () {
+            Vitest.live('concurrent messages processed despite slow ACK sends', (test) => Effect.gen(function* () {
                 const ACK_DELAY_MS = 50;
                 const MESSAGE_COUNT = 5;
                 const nodeA = yield* makeMeshNode('A');
@@ -564,7 +567,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                         timeout: 3000,
                     });
                     // Send all messages concurrently
-                    yield* Effect.forEach(Chunk.makeBy(MESSAGE_COUNT, (i) => ({ message: `msg${i}` })), channelAToB.send, { concurrency: 'unbounded' });
+                    yield* Effect.forEach(Array.from({ length: MESSAGE_COUNT }, (_, i) => ({ message: `msg${i}` })), channelAToB.send, { concurrency: 'unbounded' });
                 });
                 const receiverCode = Effect.gen(function* () {
                     const channelBToA = yield* nodeB.makeChannel({
@@ -581,7 +584,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                             },
                         },
                     });
-                    yield* channelBToA.listen.pipe(Stream.flatten(), Stream.tap((msg) => Effect.sync(() => {
+                    yield* channelBToA.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.tap((msg) => Effect.sync(() => {
                         receivedMessages.push(msg.message);
                     })), Stream.take(MESSAGE_COUNT), Stream.runDrain);
                 });
@@ -598,7 +601,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                 console.log(`[regression-test] Elapsed: ${elapsed}ms, Blocking estimate: ${blockingTime}ms`);
             }).pipe(Vitest.withTestCtx(test)));
         });
-        Vitest.scopedLive('should fail with timeout due to missing edge', (test) => Effect.gen(function* () {
+        Vitest.live('should fail with timeout due to missing edge', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -606,35 +609,35 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             // We're not connecting nodeB and nodeC, so this should fail
             const nodeACode = Effect.gen(function* () {
                 const err = yield* createChannel(nodeA, 'C').pipe(Effect.timeout(200), Effect.flip);
-                expect(err._tag).toBe('TimeoutException');
+                expect(err._tag).toBe('TimeoutError');
             });
             const nodeCCode = Effect.gen(function* () {
                 const err = yield* createChannel(nodeC, 'A').pipe(Effect.timeout(200), Effect.flip);
-                expect(err._tag).toBe('TimeoutException');
+                expect(err._tag).toBe('TimeoutError');
             });
             yield* Effect.all([nodeACode, nodeCCode], { concurrency: 'unbounded' });
         }).pipe(Vitest.withTestCtx(test)));
-        Vitest.scopedLive('should fail with timeout due no transferable', (test) => Effect.gen(function* () {
+        Vitest.live('should fail with timeout due no transferable', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             yield* connectNodesViaBroadcastChannel(nodeA, nodeB);
             const nodeACode = Effect.gen(function* () {
                 const err = yield* createChannel(nodeA, 'B').pipe(Effect.timeout(200), Effect.flip);
-                expect(err._tag).toBe('TimeoutException');
+                expect(err._tag).toBe('TimeoutError');
             });
             const nodeBCode = Effect.gen(function* () {
                 const err = yield* createChannel(nodeB, 'A').pipe(Effect.timeout(200), Effect.flip);
-                expect(err._tag).toBe('TimeoutException');
+                expect(err._tag).toBe('TimeoutError');
             });
             yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' });
         }).pipe(Vitest.withTestCtx(test)));
-        Vitest.scopedLive('reconnect with re-created node', (test) => Effect.gen(function* () {
+        Vitest.live('reconnect with re-created node', (test) => Effect.gen(function* () {
             const nodeCgen1Scope = yield* Scope.make();
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
-            const nodeCgen1 = yield* makeMeshNode('C').pipe(Scope.extend(nodeCgen1Scope));
+            const nodeCgen1 = yield* makeMeshNode('C').pipe(Scope.provide(nodeCgen1Scope));
             yield* connectNodesViaMessageChannel(nodeA, nodeB);
-            yield* connectNodesViaMessageChannel(nodeB, nodeCgen1).pipe(Scope.extend(nodeCgen1Scope));
+            yield* connectNodesViaMessageChannel(nodeB, nodeCgen1).pipe(Scope.provide(nodeCgen1Scope));
             const nodeACode = Effect.gen(function* () {
                 const channelAToB = yield* createChannel(nodeA, 'C');
                 yield* channelAToB.send({ message: 'A1' });
@@ -645,7 +648,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                 yield* channelBToA.send({ message: 'C1' });
                 expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' });
             });
-            yield* Effect.all([nodeACode, nodeCCode(nodeCgen1)], { concurrency: 'unbounded' }).pipe(Effect.withSpan('test1'), Scope.extend(nodeCgen1Scope));
+            yield* Effect.all([nodeACode, nodeCCode(nodeCgen1)], { concurrency: 'unbounded' }).pipe(Effect.withSpan('test1'), Scope.provide(nodeCgen1Scope));
             yield* Scope.close(nodeCgen1Scope, Exit.void);
             const nodeCgen2 = yield* makeMeshNode('C');
             yield* connectNodesViaMessageChannel(nodeB, nodeCgen2, { replaceIfExists: true });
@@ -660,7 +663,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
      *    D
      */
     Vitest.describe('diamond topology', () => {
-        Vitest.scopedLive('should work', (test) => Effect.gen(function* () {
+        Vitest.live('should work', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -692,7 +695,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
      * Topology: Butterfly topology with two connected hubs (C-D) each serving multiple nodes
      */
     Vitest.describe('butterfly topology', () => {
-        Vitest.scopedLive('should work', (test) => Effect.gen(function* () {
+        Vitest.live('should work', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -721,14 +724,14 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
     Vitest.describe('mixture of direct and proxy edge connections', () => {
         // TODO test case to better guard against case where side A tries to create a proxy channel to B
         // and side B tries to create a direct to A
-        Vitest.scopedLive('should work for proxy channels', (test) => Effect.gen(function* () {
+        Vitest.live('should work for proxy channels', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             yield* connectNodesViaMessageChannel(nodeB, nodeA);
             const err = yield* connectNodesViaBroadcastChannel(nodeA, nodeB).pipe(Effect.flip);
             expect(err._tag).toBe('EdgeAlreadyExistsError');
         }).pipe(Vitest.withTestCtx(test)));
-        Vitest.scopedLive('should work for directs', (test) => Effect.gen(function* () {
+        Vitest.live('should work for directs', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -748,7 +751,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
         }).pipe(Vitest.withTestCtx(test)));
     });
     Vitest.describe('listenForChannel', () => {
-        Vitest.scopedLive('connect later', (test) => Effect.gen(function* () {
+        Vitest.live('connect later', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const mode = 'direct';
             const connect = mode === 'direct' ? connectNodesViaMessageChannel : connectNodesViaBroadcastChannel;
@@ -772,7 +775,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             yield* Effect.all([nodeACode, nodeBCode.pipe(Effect.delay(500))], { concurrency: 'unbounded' });
         }).pipe(Vitest.withTestCtx(test)));
         // TODO provide a way to allow for reconnecting in the `listenForChannel` case
-        Vitest.scopedLive.skip('reconnect', (test) => Effect.gen(function* () {
+        Vitest.live.skip('reconnect', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const mode = 'direct';
             const connect = mode === 'direct' ? connectNodesViaMessageChannel : connectNodesViaBroadcastChannel;
@@ -808,7 +811,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' });
         }).pipe(Vitest.withTestCtx(test)));
         Vitest.describe('prop tests', { timeout: propTestTimeout }, () => {
-            Vitest.scopedLive.prop('listenForChannel A <> B <> C', [Delay, Delay, Delay, Delay, ChannelType], ([delayNodeA, delayNodeC, delayConnectAB, delayConnectBC, channelType], test) => Effect.gen(function* () {
+            Vitest.live.prop('listenForChannel A <> B <> C', [Delay, Delay, Delay, Delay, ChannelType], ([delayNodeA, delayNodeC, delayConnectAB, delayConnectBC, channelType], test) => Effect.gen(function* () {
                 const nodeA = yield* makeMeshNode('A');
                 const nodeB = yield* makeMeshNode('B');
                 const nodeC = yield* makeMeshNode('C');
@@ -844,7 +847,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
         });
     });
     Vitest.describe('broadcast channel', () => {
-        Vitest.scopedLive('should work', (test) => Effect.gen(function* () {
+        Vitest.live('should work', (test) => Effect.gen(function* () {
             const nodeA = yield* makeMeshNode('A');
             const nodeB = yield* makeMeshNode('B');
             const nodeC = yield* makeMeshNode('C');
@@ -852,12 +855,12 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             yield* connectNodesViaMessageChannel(nodeB, nodeC);
             const channelOnA = yield* nodeA.makeBroadcastChannel({ channelName: 'test', schema: Schema.String });
             const channelOnC = yield* nodeC.makeBroadcastChannel({ channelName: 'test', schema: Schema.String });
-            const listenOnAFiber = yield* channelOnA.listen.pipe(Stream.flatten(), Stream.runHead, Effect.flatten, Effect.fork);
-            const listenOnCFiber = yield* channelOnC.listen.pipe(Stream.flatten(), Stream.runHead, Effect.flatten, Effect.fork);
+            const listenOnAFiber = yield* channelOnA.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.runHead, Effect.flatMap(Effect.fromOption), Effect.forkChild);
+            const listenOnCFiber = yield* channelOnC.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.runHead, Effect.flatMap(Effect.fromOption), Effect.forkChild);
             yield* channelOnA.send('A1');
             yield* channelOnC.send('C1');
-            expect(yield* listenOnAFiber).toEqual('C1');
-            expect(yield* listenOnCFiber).toEqual('A1');
+            expect(yield* Fiber.join(listenOnAFiber)).toEqual('C1');
+            expect(yield* Fiber.join(listenOnCFiber)).toEqual('A1');
         }).pipe(Vitest.withTestCtx(test)));
     });
 });