@livestore/webmesh 0.4.0-dev.9 → 0.5.0-dev.0

package/src/node.test.ts

@@ -1,7 +1,8 @@
+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.ts'
 import type { MeshNode } from './node.ts'
@@ -71,7 +72,7 @@ const createChannel = (source: MeshNode, target: string, options?: Partial<Param
 
 const getFirstMessage = <T1, T2>(channel: WebChannel.WebChannel<T1, T2>) =>
   channel.listen.pipe(
-    Stream.flatten(),
+    Stream.mapEffect(Effect.fromResult),
     Stream.take(1),
     Stream.runCollect,
     Effect.map(([message]) => message),
@@ -85,19 +86,19 @@ const maybeDelay =
       ? 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
+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: typeof ChannelType.Type,
@@ -170,10 +171,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(
+      Vitest.live.prop(
         'a / b connect at different times with different channel types',
         [Delay, Delay, Delay, ChannelType, NodeNames],
         ([delayX, delayY, connectDelay, channelType, nodeNames], test) =>
@@ -200,7 +201,7 @@ 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(',')}`,
             }),
           ),
         // { fastCheck: { numRuns: 20 } },
@@ -208,10 +209,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(
+      Vitest.live.prop(
         'b reconnects',
         [Delay, Delay, ChannelType],
         ([waitForOfflineDelay, sleepDelay, channelType], test) =>
@@ -231,8 +232,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             // TODO also optionally delay the edge
             yield* connectNodes(nodeA, nodeB)
 
-            const waitForBToBeOffline =
-              waitForOfflineDelay === undefined ? undefined : yield* Deferred.make<void, never>()
+            const waitForBToBeOffline = waitForOfflineDelay === undefined ? undefined : yield* Deferred.make<void>()
 
             const nodeACode = Effect.gen(function* () {
               const channelAToB = yield* createChannel(nodeA, 'B', { mode })
@@ -241,7 +241,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
 
               console.log('nodeACode:waiting for B to be offline')
               if (waitForBToBeOffline !== undefined) {
-                yield* waitForBToBeOffline
+                yield* Deferred.await(waitForBToBeOffline)
               }
 
               yield* channelAToB.send({ message: 'A2' })
@@ -286,14 +286,14 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
         { fastCheck: { numRuns: 20 } },
       )
 
-      Vitest.scopedLive('reconnect with re-created node', (test) =>
+      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))
+          const nodeBgen1 = yield* makeMeshNode('B').pipe(Scope.provide(nodeBgen1Scope))
 
-          yield* connectNodesViaMessageChannel(nodeA, nodeBgen1).pipe(Scope.extend(nodeBgen1Scope))
+          yield* connectNodesViaMessageChannel(nodeA, nodeBgen1).pipe(Scope.provide(nodeBgen1Scope))
 
           // yield* Effect.sleep(100)
 
@@ -314,7 +314,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
               // 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'))
 
@@ -329,7 +329,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
         }).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 }
@@ -345,7 +345,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(
+      Vitest.live.prop(
         'replace edge while keeping the channel',
         [ChannelTypeWithoutMessageChannelProxy, NodeNames],
         ([channelType, nodeNames], test) =>
@@ -367,7 +367,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
               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` })
@@ -392,7 +392,7 @@ 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 } },
@@ -400,9 +400,9 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
 
       Vitest.describe('TODO improve latency', () => {
         // TODO we need to improve latency when sending messages concurrently
-        Vitest.scopedLive.prop(
+        Vitest.live.prop(
           'concurrent messages',
-          [ChannelType, Schema.Int.pipe(Schema.between(1, 50))],
+          [ChannelType, Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 50 }))],
           ([channelType, count], test) =>
             Effect.gen(function* () {
               const nodeA = yield* makeMeshNode('A')
@@ -416,14 +416,18 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
 
                 // send 10 times A1
                 yield* Effect.forEach(
-                  Chunk.makeBy(count, (i) => ({ message: `A${i}` })),
+                  Array.from({ length: 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}` })),
-                )
+                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' })
               })
 
@@ -432,14 +436,18 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
 
                 // send 10 times B1
                 yield* Effect.forEach(
-                  Chunk.makeBy(count, (i) => ({ message: `B${i}` })),
+                  Array.from({ length: 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}` })),
-                )
+                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))], {
@@ -457,7 +465,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
     })
 
     Vitest.describe('message channel specific tests', () => {
-      Vitest.scopedLive('differing initial edge counter', (test) =>
+      Vitest.live('differing initial edge counter', (test) =>
         Effect.gen(function* () {
           const nodeA = yield* makeMeshNode('A')
           const nodeB = yield* makeMeshNode('B')
@@ -469,28 +477,32 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
           const bFiber = yield* Effect.gen(function* () {
             const channelBToA = yield* createChannel(nodeB, 'A')
             yield* channelBToA.listen.pipe(
-              Stream.flatten(),
+              Stream.mapEffect(Effect.fromResult),
               Stream.tap((msg) => channelBToA.send({ message: `resp:${msg.message}` })),
               Stream.take(messageCount),
               Stream.runDrain,
             )
-          }).pipe(Effect.scoped, Effect.fork)
+          }).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* () {
-            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* 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),
+            messageCount,
+            { discard: true },
+          )
 
-          yield* bFiber
+          yield* Fiber.join(bFiber)
         }).pipe(Vitest.withTestCtx(test)),
       )
     })
 
-    Vitest.scopedLive('manual debug test', (test) =>
+    Vitest.live('manual debug test', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -518,7 +530,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('broadcast edge with message channel', (test) =>
+    Vitest.live('broadcast edge with message channel', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -526,13 +538,13 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
         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) =>
+    Vitest.live('should work', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -562,7 +574,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('should work - delayed edge', (test) =>
+    Vitest.live('should work - delayed edge', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -597,7 +609,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('proxy channel', (test) =>
+    Vitest.live('proxy channel', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -622,7 +634,271 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('should fail with timeout due to missing edge', (test) =>
+    /**
+     * 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: string[] = []
+
+          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: string[] = []
+
+          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')
@@ -633,19 +909,19 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
 
         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) =>
+    Vitest.live('should fail with timeout due no transferable', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -654,28 +930,28 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
 
         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) =>
+    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')
@@ -694,7 +970,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
 
         yield* Effect.all([nodeACode, nodeCCode(nodeCgen1)], { concurrency: 'unbounded' }).pipe(
           Effect.withSpan('test1'),
-          Scope.extend(nodeCgen1Scope),
+          Scope.provide(nodeCgen1Scope),
         )
 
         yield* Scope.close(nodeCgen1Scope, Exit.void)
@@ -717,7 +993,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
    *    D
    */
   Vitest.describe('diamond topology', () => {
-    Vitest.scopedLive('should work', (test) =>
+    Vitest.live('should work', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -756,7 +1032,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) =>
+    Vitest.live('should work', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -793,7 +1069,7 @@ 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) =>
+    Vitest.live('should work for proxy channels', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -805,7 +1081,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('should work for directs', (test) =>
+    Vitest.live('should work for directs', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -832,7 +1108,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
   })
 
   Vitest.describe('listenForChannel', () => {
-    Vitest.scopedLive('connect later', (test) =>
+    Vitest.live('connect later', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
 
@@ -871,7 +1147,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
     )
 
     // TODO provide a way to allow for reconnecting in the `listenForChannel` case
-    Vitest.scopedLive.skip('reconnect', (test) =>
+    Vitest.live.skip('reconnect', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
 
@@ -935,7 +1211,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
     )
 
     Vitest.describe('prop tests', { timeout: propTestTimeout }, () => {
-      Vitest.scopedLive.prop(
+      Vitest.live.prop(
         'listenForChannel A <> B <> C',
         [Delay, Delay, Delay, Delay, ChannelType],
         ([delayNodeA, delayNodeC, delayConnectAB, delayConnectBC, channelType], test) =>
@@ -944,7 +1220,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
             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'))
@@ -996,7 +1272,7 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
   })
 
   Vitest.describe('broadcast channel', () => {
-    Vitest.scopedLive('should work', (test) =>
+    Vitest.live('should work', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -1009,23 +1285,23 @@ Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
         const channelOnC = yield* nodeC.makeBroadcastChannel({ channelName: 'test', schema: Schema.String })
 
         const listenOnAFiber = yield* channelOnA.listen.pipe(
-          Stream.flatten(),
+          Stream.mapEffect(Effect.fromResult),
           Stream.runHead,
-          Effect.flatten,
-          Effect.fork,
+          Effect.flatMap(Effect.fromOption),
+          Effect.forkChild,
         )
         const listenOnCFiber = yield* channelOnC.listen.pipe(
-          Stream.flatten(),
+          Stream.mapEffect(Effect.fromResult),
           Stream.runHead,
-          Effect.flatten,
-          Effect.fork,
+          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)),
     )
   })