@livestore/webmesh 0.4.0-dev.9 → 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 ? 30_000 : 1000;
-const propTestTimeout = IS_CI ? 60_000 : 20_000;
-// TODO also make work without `Vitest.scopedLive` (i.e. with `Vitest.scoped`)
+const testTimeout = IS_CI === true ? 30_000 : 1000;
+const propTestTimeout = IS_CI === true ? 60_000 : 20_000;
+// 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);
@@ -136,15 +139,15 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                 });
                 yield* Effect.promise(() => nodeX.debug.requestTopology(100));
             }).pipe(Vitest.withTestCtx(test, {
-                suffix: `delayX=${delayX} delayY=${delayY} connectDelay=${connectDelay} channelType=${channelType} nodeNames=${nodeNames}`,
+                suffix: `delayX=${delayX} delayY=${delayY} connectDelay=${connectDelay} channelType=${channelType} nodeNames=${nodeNames.join(',')}`,
             })));
             // 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` });
                 });
@@ -267,11 +270,11 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
                 });
                 yield* Effect.all([nodeXCode, nodeYCode], { concurrency: 'unbounded' });
             }).pipe(Vitest.withTestCtx(test, {
-                suffix: `channelType=${channelType} nodeNames=${nodeNames}`,
+                suffix: `channelType=${channelType} nodeNames=${nodeNames.join(',')}`,
             })), { 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');
@@ -411,7 +414,194 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             });
             yield* Effect.all([nodeACode, nodeCCode], { concurrency: 'unbounded' });
         }).pipe(Vitest.withTestCtx(test)));
-        Vitest.scopedLive('should fail with timeout due to missing edge', (test) => Effect.gen(function* () {
+        /**
+         * Pattern test: ACK sending must not block message processing.
+         *
+         * This test documents the pattern where ACKs are sent fire-and-forget using `Effect.forkScoped`
+         * to avoid blocking the message processing loop.
+         *
+         * Background: Before the fix, ACKs were sent with `await` which blocked message processing.
+         * This caused heartbeat timeouts in devtools after ~30 seconds ("Connection to app lost").
+         *
+         * Note: This unit test passes both with and without the fix because in-memory channels
+         * complete ACK sends instantly. The actual regression test is the Playwright test
+         * `node-adapter-timeout.play.ts` which uses real network conditions.
+         *
+         * This test exists to:
+         * 1. Document the expected pattern (high message throughput via proxy channels)
+         * 2. Verify the pattern works correctly with forked ACKs
+         * 3. Serve as a reference for the fix in proxy-channel.ts
+         */
+        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');
+            yield* connectNodesViaBroadcastChannel(nodeA, nodeB);
+            yield* connectNodesViaBroadcastChannel(nodeB, nodeC);
+            // Send many messages to stress the ACK handling
+            const messageCount = 10;
+            const nodeACode = Effect.gen(function* () {
+                const channelAToC = yield* createChannel(nodeA, 'C', { mode: 'proxy' });
+                // Send multiple messages concurrently
+                yield* Effect.forEach(Array.from({ length: messageCount }, (_, i) => ({ message: `A${i}` })), channelAToC.send, { concurrency: 'unbounded' });
+                // Receive responses
+                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(Array.from({ length: messageCount }, (_, i) => ({ message: `C${i}` })), channelCToA.send, { concurrency: 'unbounded' });
+                // Receive responses
+                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)));
+        Vitest.describe('ACK forkScoped regression tests', { timeout: 10_000 }, () => {
+            /**
+             * REGRESSION TEST: ACK sends must be forked (non-blocking) to allow message processing to continue.
+             *
+             * This test uses simulation parameters to inject a delay BEFORE the ACK send.
+             * It then measures when messages arrive at the receiver's listen queue.
+             *
+             * With the fix (Effect.forkScoped):
+             * - ACK send is forked in the background
+             * - Message is added to listen queue IMMEDIATELY (before ACK send completes)
+             * - Multiple messages arrive close together regardless of ACK delay
+             *
+             * Without the fix (blocking yield*):
+             * - ACK send blocks the processing loop
+             * - Message is added to listen queue AFTER ACK send completes
+             * - Messages arrive spread out by the ACK delay
+             *
+             * To verify this test catches the regression:
+             * 1. Temporarily change `Effect.forkScoped` to `yield*` in proxy-channel.ts:319
+             * 2. Run this test - it should FAIL because messages arrive too slowly
+             * 3. Revert the change - test should PASS
+             */
+            /**
+             * This test verifies the fix works: messages should arrive at the listen queue
+             * 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.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');
+                const nodeB = yield* makeMeshNode('B');
+                yield* connectNodesViaMessageChannel(nodeA, nodeB);
+                const receivedMessages = [];
+                const senderCode = Effect.gen(function* () {
+                    const channelAToB = yield* nodeA.makeChannel({
+                        target: 'B',
+                        channelName: 'test-ack-timing',
+                        schema: ExampleSchema,
+                        mode: 'proxy',
+                        timeout: 3000,
+                    });
+                    // 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(Array.from({ length: MESSAGE_COUNT }, (_, i) => ({ message: `msg${i}` })), channelAToB.send, { concurrency: 'unbounded' });
+                });
+                const receiverCode = Effect.gen(function* () {
+                    const channelBToA = yield* nodeB.makeChannel({
+                        target: 'A',
+                        channelName: 'test-ack-timing',
+                        schema: ExampleSchema,
+                        mode: 'proxy',
+                        timeout: 3000,
+                        // KEY: Inject delay BEFORE ACK send
+                        // With forkScoped: message arrives in queue immediately, then ACK is sent in background
+                        // Without forkScoped: message waits for ACK delay before being added to queue
+                        simulation: {
+                            onPayload: {
+                                beforeAckSend: ACK_DELAY_MS,
+                                afterAckFork: 0,
+                                afterListenQueueOffer: 0,
+                            },
+                        },
+                    });
+                    yield* channelBToA.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.tap((msg) => Effect.sync(() => {
+                        receivedMessages.push(msg.message);
+                    })), Stream.take(MESSAGE_COUNT), Stream.runDrain);
+                });
+                const startTime = Date.now();
+                yield* Effect.all([senderCode, receiverCode], { concurrency: 'unbounded' });
+                const elapsed = Date.now() - startTime;
+                console.log(`[regression-test-1] Received ${receivedMessages.length} messages in ${elapsed}ms`);
+                console.log(`[regression-test-1] Messages: ${receivedMessages.join(', ')}`);
+                expect(receivedMessages.length).toBe(MESSAGE_COUNT);
+                // With forked ACKs, elapsed time should be much less than MESSAGE_COUNT * ACK_DELAY_MS
+                // because ACKs don't block message processing
+                const blockingTime = MESSAGE_COUNT * ACK_DELAY_MS;
+                console.log(`[regression-test-1] Elapsed: ${elapsed}ms, Blocking estimate: ${blockingTime}ms`);
+                // The test passes if messages arrive faster than they would with blocking ACKs
+                // Allow some margin for test overhead (2x faster than blocking)
+                if (elapsed > blockingTime / 2) {
+                    throw new Error(`REGRESSION DETECTED: Processing took ${elapsed}ms, blocking estimate: ${blockingTime}ms. ` +
+                        `With forked ACKs, processing should be much faster. ` +
+                        `Check that proxy-channel.ts uses Effect.forkScoped for ACK sends.`);
+                }
+            }).pipe(Vitest.withTestCtx(test)));
+            /**
+             * Additional test: Verify message processing continues during slow ACK sends.
+             *
+             * This test sends multiple messages concurrently and verifies they're all
+             * processed even when ACK sends are slow.
+             */
+            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');
+                const nodeB = yield* makeMeshNode('B');
+                yield* connectNodesViaMessageChannel(nodeA, nodeB);
+                const receivedMessages = [];
+                const senderCode = Effect.gen(function* () {
+                    const channelAToB = yield* nodeA.makeChannel({
+                        target: 'B',
+                        channelName: 'test-concurrent',
+                        schema: ExampleSchema,
+                        mode: 'proxy',
+                        timeout: 3000,
+                    });
+                    // Send all messages concurrently
+                    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({
+                        target: 'A',
+                        channelName: 'test-concurrent',
+                        schema: ExampleSchema,
+                        mode: 'proxy',
+                        timeout: 3000,
+                        simulation: {
+                            onPayload: {
+                                beforeAckSend: ACK_DELAY_MS,
+                                afterAckFork: 0,
+                                afterListenQueueOffer: 0,
+                            },
+                        },
+                    });
+                    yield* channelBToA.listen.pipe(Stream.mapEffect(Effect.fromResult), Stream.tap((msg) => Effect.sync(() => {
+                        receivedMessages.push(msg.message);
+                    })), Stream.take(MESSAGE_COUNT), Stream.runDrain);
+                });
+                const startTime = Date.now();
+                yield* Effect.all([senderCode, receiverCode], { concurrency: 'unbounded' });
+                const elapsed = Date.now() - startTime;
+                console.log(`[regression-test] Received ${receivedMessages.length} messages in ${elapsed}ms`);
+                console.log(`[regression-test] Messages: ${receivedMessages.join(', ')}`);
+                // All messages should be received
+                expect(receivedMessages.length).toBe(MESSAGE_COUNT);
+                // With forked ACKs, elapsed time should be much less than MESSAGE_COUNT * ACK_DELAY_MS
+                // because ACKs don't block message processing
+                const blockingTime = MESSAGE_COUNT * ACK_DELAY_MS;
+                console.log(`[regression-test] Elapsed: ${elapsed}ms, Blocking estimate: ${blockingTime}ms`);
+            }).pipe(Vitest.withTestCtx(test)));
+        });
+        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');
@@ -419,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' });
@@ -458,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 });
@@ -473,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');
@@ -505,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');
@@ -534,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');
@@ -561,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;
@@ -585,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;
@@ -621,11 +811,11 @@ 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');
-                const mode = channelType.includes('proxy') ? 'proxy' : 'direct';
+                const mode = channelType.includes('proxy') === true ? 'proxy' : 'direct';
                 const connect = channelType === 'direct' ? connectNodesViaMessageChannel : connectNodesViaBroadcastChannel;
                 yield* connect(nodeA, nodeB).pipe(maybeDelay(delayConnectAB, 'delayConnectAB'));
                 yield* connect(nodeB, nodeC).pipe(maybeDelay(delayConnectBC, 'delayConnectBC'));
@@ -657,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');
@@ -665,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)));
     });
 });