@livestore/webmesh 0.3.0-dev.5 → 0.3.0-dev.50

package/src/node.test.ts

@@ -1,6 +1,22 @@
-import { Chunk, Deferred, Effect, identity, Layer, Logger, Schema, Stream, WebChannel } from '@livestore/utils/effect'
-import { OtelLiveHttp } from '@livestore/utils/node'
-import { Vitest } from '@livestore/utils/node-vitest'
+import '@livestore/utils-dev/node-vitest-polyfill'
+
+import { IS_CI } from '@livestore/utils'
+import {
+  Chunk,
+  Deferred,
+  Effect,
+  Exit,
+  identity,
+  Layer,
+  Logger,
+  LogLevel,
+  Schema,
+  Scope,
+  Stream,
+  WebChannel,
+} from '@livestore/utils/effect'
+import { OtelLiveHttp } from '@livestore/utils-dev/node'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
 import { expect } from 'vitest'
 
 import { Packet } from './mesh-schema.js'
@@ -9,42 +25,54 @@ import { makeMeshNode } from './node.js'
 
 // TODO test cases where in-between node only comes online later
 // TODO test cases where other side tries to reconnect
-// TODO test combination of connection types (message, proxy)
+// TODO test combination of channel types (message, proxy)
 // TODO test "diamond shape" topology (A <> B1, A <> B2, B1 <> C, B2 <> C)
 // TODO test cases where multiple entities try to claim to be the same channel end (e.g. A,B,B)
 // TODO write tests with worker threads
 
 const ExampleSchema = Schema.Struct({ message: Schema.String })
 
-const connectNodesViaMessageChannel = (nodeA: MeshNode, nodeB: MeshNode) =>
+const connectNodesViaMessageChannel = (nodeA: MeshNode, nodeB: MeshNode, options?: { replaceIfExists?: boolean }) =>
   Effect.gen(function* () {
     const mc = new MessageChannel()
     const meshChannelAToB = yield* WebChannel.messagePortChannel({ port: mc.port1, schema: Packet })
     const meshChannelBToA = yield* WebChannel.messagePortChannel({ port: mc.port2, schema: Packet })
 
-    yield* nodeA.addConnection({ target: nodeB.nodeName, connectionChannel: meshChannelAToB })
-    yield* nodeB.addConnection({ target: nodeA.nodeName, connectionChannel: meshChannelBToA })
-
-    return mc
+    yield* nodeA.addEdge({
+      target: nodeB.nodeName,
+      edgeChannel: meshChannelAToB,
+      replaceIfExists: options?.replaceIfExists,
+    })
+    yield* nodeB.addEdge({
+      target: nodeA.nodeName,
+      edgeChannel: meshChannelBToA,
+      replaceIfExists: options?.replaceIfExists,
+    })
   }).pipe(Effect.withSpan(`connectNodesViaMessageChannel:${nodeA.nodeName}↔${nodeB.nodeName}`))
 
-const connectNodesViaBroadcastChannel = (nodeA: MeshNode, nodeB: MeshNode) =>
+const connectNodesViaBroadcastChannel = (nodeA: MeshNode, nodeB: MeshNode, options?: { replaceIfExists?: boolean }) =>
   Effect.gen(function* () {
     // Need to instantiate two different channels because they filter out messages they sent themselves
     const broadcastWebChannelA = yield* WebChannel.broadcastChannelWithAck({
       channelName: `${nodeA.nodeName}↔${nodeB.nodeName}`,
-      listenSchema: Packet,
-      sendSchema: Packet,
+      schema: Packet,
     })
 
     const broadcastWebChannelB = yield* WebChannel.broadcastChannelWithAck({
       channelName: `${nodeA.nodeName}↔${nodeB.nodeName}`,
-      listenSchema: Packet,
-      sendSchema: Packet,
+      schema: Packet,
     })
 
-    yield* nodeA.addConnection({ target: nodeB.nodeName, connectionChannel: broadcastWebChannelA })
-    yield* nodeB.addConnection({ target: nodeA.nodeName, connectionChannel: broadcastWebChannelB })
+    yield* nodeA.addEdge({
+      target: nodeB.nodeName,
+      edgeChannel: broadcastWebChannelA,
+      replaceIfExists: options?.replaceIfExists,
+    })
+    yield* nodeB.addEdge({
+      target: nodeA.nodeName,
+      edgeChannel: broadcastWebChannelB,
+      replaceIfExists: options?.replaceIfExists,
+    })
   }).pipe(Effect.withSpan(`connectNodesViaBroadcastChannel:${nodeA.nodeName}↔${nodeB.nodeName}`))
 
 const createChannel = (source: MeshNode, target: string, options?: Partial<Parameters<MeshNode['makeChannel']>[0]>) =>
@@ -53,7 +81,7 @@ const createChannel = (source: MeshNode, target: string, options?: Partial<Param
     channelName: options?.channelName ?? 'test',
     schema: ExampleSchema,
     // transferables: options?.transferables ?? 'prefer',
-    mode: options?.mode ?? 'messagechannel',
+    mode: options?.mode ?? 'direct',
     timeout: options?.timeout ?? 200,
   })
 
@@ -73,206 +101,320 @@ 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
+
 // TODO also make work without `Vitest.scopedLive` (i.e. with `Vitest.scoped`)
 // probably requires controlling the clocks
-Vitest.describe('webmesh node', { timeout: 1000 }, () => {
-  Vitest.describe('A <> B', () => {
-    Vitest.describe('prop tests', { timeout: 10_000 }, () => {
-      const Delay = Schema.UndefinedOr(Schema.Literal(0, 1, 10, 50))
-      // NOTE for message channels, we test both with and without transferables (i.e. proxying)
-      const ChannelType = Schema.Literal('messagechannel', 'messagechannel.proxy', 'proxy')
-
-      const fromChannelType = (
-        channelType: typeof ChannelType.Type,
-      ): {
-        mode: 'messagechannel' | 'proxy'
-        connectNodes: typeof connectNodesViaMessageChannel | typeof connectNodesViaBroadcastChannel
-      } => {
-        switch (channelType) {
-          case 'proxy': {
-            return { mode: 'proxy', connectNodes: connectNodesViaBroadcastChannel }
-          }
-          case 'messagechannel': {
-            return { mode: 'messagechannel', connectNodes: connectNodesViaMessageChannel }
-          }
-          case 'messagechannel.proxy': {
-            return { mode: 'proxy', connectNodes: connectNodesViaMessageChannel }
-          }
-        }
-      }
+Vitest.describe('webmesh node', { timeout: testTimeout }, () => {
+  const Delay = Schema.UndefinedOr(Schema.Literal(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')),
+  )
 
-      Vitest.scopedLive.prop(
-        // Vitest.scopedLive.only(
-        'a / b connect at different times with different channel types',
-        [Delay, Delay, Delay, ChannelType],
-        ([delayA, delayB, connectDelay, channelType], test) =>
-          // (test) =>
-          Effect.gen(function* () {
-            // const delayA = 1
-            // const delayB = 10
-            // const connectDelay = 10
-            // const channelType = 'message.prefer'
-            // console.log('delayA', delayA, 'delayB', delayB, 'connectDelay', connectDelay, 'channelType', channelType)
+  const fromChannelType = (
+    channelType: typeof ChannelType.Type,
+  ): {
+    mode: 'direct' | 'proxy'
+    connectNodes: typeof connectNodesViaMessageChannel | typeof connectNodesViaBroadcastChannel
+  } => {
+    switch (channelType) {
+      case 'proxy': {
+        return { mode: 'proxy', connectNodes: connectNodesViaBroadcastChannel }
+      }
+      case 'direct': {
+        return { mode: 'direct', connectNodes: connectNodesViaMessageChannel }
+      }
+      case 'proxy(via-messagechannel-edge)': {
+        return { mode: 'proxy', connectNodes: connectNodesViaMessageChannel }
+      }
+    }
+  }
+
+  const exchangeMessages = ({
+    nodeX,
+    nodeY,
+    channelType,
+    // numberOfMessages = 1,
+    delays,
+  }: {
+    nodeX: MeshNode
+    nodeY: MeshNode
+    channelType: 'direct' | 'proxy' | 'proxy(via-messagechannel-edge)'
+    numberOfMessages?: number
+    delays?: { x?: number; y?: number; connect?: number }
+  }) =>
+    Effect.gen(function* () {
+      const nodeLabel = { x: nodeX.nodeName, y: nodeY.nodeName }
+      const { mode, connectNodes } = fromChannelType(channelType)
+
+      const nodeXCode = Effect.gen(function* () {
+        const channelXToY = yield* createChannel(nodeX, nodeY.nodeName, { mode })
+
+        yield* channelXToY.send({ message: `${nodeLabel.x}1` })
+        // console.log('channelXToY', channelXToY.debugInfo)
+        expect(yield* getFirstMessage(channelXToY)).toEqual({ message: `${nodeLabel.y}1` })
+        // expect(channelXToY.debugInfo.connectCounter).toBe(1)
+      })
 
-            const nodeA = yield* makeMeshNode('A')
-            const nodeB = yield* makeMeshNode('B')
+      const nodeYCode = Effect.gen(function* () {
+        const channelYToX = yield* createChannel(nodeY, nodeX.nodeName, { mode })
 
-            const { mode, connectNodes } = fromChannelType(channelType)
+        yield* channelYToX.send({ message: `${nodeLabel.y}1` })
+        // console.log('channelYToX', channelYToX.debugInfo)
+        expect(yield* getFirstMessage(channelYToX)).toEqual({ message: `${nodeLabel.x}1` })
+        // expect(channelYToX.debugInfo.connectCounter).toBe(1)
+      })
 
-            const nodeACode = Effect.gen(function* () {
-              const channelAToB = yield* createChannel(nodeA, 'B', { mode })
+      yield* Effect.all(
+        [
+          connectNodes(nodeX, nodeY).pipe(maybeDelay(delays?.connect, 'connectNodes')),
+          nodeXCode.pipe(maybeDelay(delays?.x, `node${nodeLabel.x}Code`)),
+          nodeYCode.pipe(maybeDelay(delays?.y, `node${nodeLabel.y}Code`)),
+        ],
+        { concurrency: 'unbounded' },
+      ).pipe(Effect.withSpan(`exchangeMessages(${nodeLabel.x}↔${nodeLabel.y})`))
+    })
 
-              yield* channelAToB.send({ message: 'A1' })
-              expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'A2' })
-            })
+  Vitest.describe('A <> B', () => {
+    Vitest.describe('prop tests', { timeout: propTestTimeout }, () => {
+      // const delayX = 40
+      // const delayY = undefined
+      // const connectDelay = undefined
+      // const channelType = 'direct'
+      // const nodeNames = ['B', 'A'] as const
+      // Vitest.scopedLive(
+      //   '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* () {
+            // console.log({ delayX, delayY, connectDelay, channelType, nodeNames })
 
-            const nodeBCode = Effect.gen(function* () {
-              const channelBToA = yield* createChannel(nodeB, 'A', { mode })
+            const [nodeNameX, nodeNameY] = nodeNames
+            const nodeX = yield* makeMeshNode(nodeNameX)
+            const nodeY = yield* makeMeshNode(nodeNameY)
 
-              yield* channelBToA.send({ message: 'A2' })
-              expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
+            yield* exchangeMessages({
+              nodeX,
+              nodeY,
+              channelType,
+              delays: { x: delayX, y: delayY, connect: connectDelay },
             })
 
-            yield* Effect.all(
-              [
-                connectNodes(nodeA, nodeB).pipe(maybeDelay(connectDelay, 'connectNodes')),
-                nodeACode.pipe(maybeDelay(delayA, 'nodeACode')),
-                nodeBCode.pipe(maybeDelay(delayB, 'nodeBCode')),
-              ],
-              { concurrency: 'unbounded' },
-            )
+            yield* Effect.promise(() => nodeX.debug.requestTopology(100))
           }).pipe(
-            withCtx(test, { skipOtel: true, suffix: `delayA=${delayA} delayB=${delayB} channelType=${channelType}` }),
+            withCtx(test, {
+              skipOtel: true,
+              suffix: `delayX=${delayX} delayY=${delayY} connectDelay=${connectDelay} channelType=${channelType} nodeNames=${nodeNames}`,
+            }),
           ),
+        // { fastCheck: { numRuns: 20 } },
       )
 
-      // Vitest.scopedLive.only(
-      //   'reconnects',
-      //   (test) =>
-      Vitest.scopedLive.prop(
-        'b reconnects',
-        [Delay, Delay, ChannelType],
-        ([waitForOfflineDelay, sleepDelay, channelType], test) =>
-          Effect.gen(function* () {
-            // const waitForOfflineDelay = 0
-            // const sleepDelay = 10
-            // const channelType = 'proxy'
-            // console.log(
-            //   'waitForOfflineDelay',
-            //   waitForOfflineDelay,
-            //   'sleepDelay',
-            //   sleepDelay,
-            //   'channelType',
-            //   channelType,
-            // )
+      {
+        // const waitForOfflineDelay = undefined
+        // const sleepDelay = 0
+        // const channelType = 'direct'
+        // Vitest.scopedLive(
+        //   'b reconnects',
+        //   (test) =>
+        Vitest.scopedLive.prop(
+          'b reconnects',
+          [Delay, Delay, ChannelType],
+          ([waitForOfflineDelay, sleepDelay, channelType], test) =>
+            Effect.gen(function* () {
+              // console.log({ waitForOfflineDelay, sleepDelay, channelType })
 
-            const nodeA = yield* makeMeshNode('A')
-            const nodeB = yield* makeMeshNode('B')
+              if (waitForOfflineDelay === undefined) {
+                // TODO we still need to fix this scenario but it shouldn't really be common in practice
+                return
+              }
 
-            const { mode, connectNodes } = fromChannelType(channelType)
+              const nodeA = yield* makeMeshNode('A')
+              const nodeB = yield* makeMeshNode('B')
 
-            // TODO also optionally delay the connection
-            yield* connectNodes(nodeA, nodeB)
+              const { mode, connectNodes } = fromChannelType(channelType)
 
-            const waitForBToBeOffline =
-              waitForOfflineDelay === undefined ? undefined : yield* Deferred.make<void, never>()
+              // TODO also optionally delay the edge
+              yield* connectNodes(nodeA, nodeB)
 
-            const nodeACode = Effect.gen(function* () {
-              const channelAToB = yield* createChannel(nodeA, 'B', { mode })
+              const waitForBToBeOffline =
+                waitForOfflineDelay === undefined ? undefined : yield* Deferred.make<void, never>()
 
-              yield* channelAToB.send({ message: 'A1' })
-              expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
+              const nodeACode = Effect.gen(function* () {
+                const channelAToB = yield* createChannel(nodeA, 'B', { mode })
+                yield* channelAToB.send({ message: 'A1' })
+                expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
 
-              if (waitForBToBeOffline !== undefined) {
-                yield* waitForBToBeOffline
-              }
+                console.log('nodeACode:waiting for B to be offline')
+                if (waitForBToBeOffline !== undefined) {
+                  yield* waitForBToBeOffline
+                }
 
-              yield* channelAToB.send({ message: 'A2' })
-              expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B2' })
-            })
+                yield* channelAToB.send({ message: 'A2' })
+                expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B2' })
+              })
 
-            // Simulating node b going offline and then coming back online
-            const nodeBCode = Effect.gen(function* () {
-              yield* Effect.gen(function* () {
-                const channelBToA = yield* createChannel(nodeB, 'A', { mode })
+              // Simulating node b going offline and then coming back online
+              // This test also illustrates why we need a ack-message channel since otherwise
+              // sent messages might get lost
+              const nodeBCode = Effect.gen(function* () {
+                yield* Effect.gen(function* () {
+                  const channelBToA = yield* createChannel(nodeB, 'A', { mode })
 
-                yield* channelBToA.send({ message: 'B1' })
-                expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
-              }).pipe(Effect.scoped)
+                  yield* channelBToA.send({ message: 'B1' })
+                  expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
+                }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part1'))
 
-              if (waitForBToBeOffline !== undefined) {
-                yield* Deferred.succeed(waitForBToBeOffline, void 0)
-              }
+                console.log('nodeBCode:B node going offline')
+                if (waitForBToBeOffline !== undefined) {
+                  yield* Deferred.succeed(waitForBToBeOffline, void 0)
+                }
 
-              if (sleepDelay !== undefined) {
-                yield* Effect.sleep(sleepDelay).pipe(Effect.withSpan(`B:sleep(${sleepDelay})`))
-              }
+                if (sleepDelay !== undefined) {
+                  yield* Effect.sleep(sleepDelay).pipe(Effect.withSpan(`B:sleep(${sleepDelay})`))
+                }
 
-              yield* Effect.gen(function* () {
-                const channelBToA = yield* createChannel(nodeB, 'A', { mode })
+                // Recreating the channel
+                yield* Effect.gen(function* () {
+                  const channelBToA = yield* createChannel(nodeB, 'A', { mode })
+
+                  yield* channelBToA.send({ message: 'B2' })
+                  expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A2' })
+                }).pipe(Effect.scoped, Effect.withSpan('nodeBCode:part2'))
+              })
+
+              yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' }).pipe(Effect.withSpan('test'))
+            }).pipe(
+              withCtx(test, {
+                skipOtel: true,
+                suffix: `waitForOfflineDelay=${waitForOfflineDelay} sleepDelay=${sleepDelay} channelType=${channelType}`,
+              }),
+            ),
+          { fastCheck: { numRuns: 20 } },
+        )
+      }
+
+      Vitest.scopedLive('reconnect with re-created node', (test) =>
+        Effect.gen(function* () {
+          const nodeBgen1Scope = yield* Scope.make()
 
-                yield* channelBToA.send({ message: 'B2' })
-                expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A2' })
-              }).pipe(Effect.scoped)
+          const nodeA = yield* makeMeshNode('A')
+          const nodeBgen1 = yield* makeMeshNode('B').pipe(Scope.extend(nodeBgen1Scope))
+
+          yield* connectNodesViaMessageChannel(nodeA, nodeBgen1).pipe(Scope.extend(nodeBgen1Scope))
+
+          // yield* Effect.sleep(100)
+
+          const channelAToBOnce = yield* Effect.cached(createChannel(nodeA, 'B'))
+          const nodeACode = Effect.gen(function* () {
+            const channelAToB = yield* channelAToBOnce
+            yield* channelAToB.send({ message: 'A1' })
+            expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
+            // expect(channelAToB.debugInfo.connectCounter).toBe(1)
+          })
+
+          const nodeBCode = (nodeB: MeshNode) =>
+            Effect.gen(function* () {
+              const channelBToA = yield* createChannel(nodeB, 'A')
+
+              yield* channelBToA.send({ message: 'B1' })
+              expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
+              // expect(channelBToA.debugInfo.connectCounter).toBe(1)
             })
 
-            yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' })
-          }).pipe(
-            withCtx(test, {
-              skipOtel: true,
-              suffix: `waitForOfflineDelay=${waitForOfflineDelay} sleepDelay=${sleepDelay} channelType=${channelType}`,
-            }),
-          ),
+          yield* Effect.all([nodeACode, nodeBCode(nodeBgen1).pipe(Scope.extend(nodeBgen1Scope))], {
+            concurrency: 'unbounded',
+          }).pipe(Effect.withSpan('test1'))
+
+          yield* Scope.close(nodeBgen1Scope, Exit.void)
+
+          const nodeBgen2 = yield* makeMeshNode('B')
+          yield* connectNodesViaMessageChannel(nodeA, nodeBgen2, { replaceIfExists: true })
+
+          yield* Effect.all([nodeACode, nodeBCode(nodeBgen2)], { concurrency: 'unbounded' }).pipe(
+            Effect.withSpan('test2'),
+          )
+        }).pipe(withCtx(test)),
       )
 
-      const ChannelTypeWithoutMessageChannelProxy = Schema.Literal('proxy', 'messagechannel')
+      const ChannelTypeWithoutMessageChannelProxy = Schema.Literal('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 }
+      // test: Counterexample: ["direct",["A","B"]]
+      // test: Shrunk 0 time(s)
+      // test: Got AssertionError: expected { _tag: 'MessageChannelPing' } to deeply equal { message: 'A1' }
+      // test:     at next (/Users/schickling/Code/overtone/submodules/livestore/packages/@livestore/webmesh/src/node.test.ts:376:59)
+      // test:     at prop tests:replace edge while keeping the channel:channelType=direct nodeNames=A,B (/Users/schickling/Code/overtone/submodules/livestore/packages/@livestore/webmesh/src/node.test.ts:801:14)
+      // test: Hint: Enable verbose mode in order to have the list of all failing values encountered during the run
+      // test:    ✓ webmesh node > A <> B > prop tests > TODO improve latency > concurrent messages 2110ms
+      // test: ⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯
+      // test:  FAIL  src/node.test.ts > webmesh node > A <> B > prop tests > replace edge while keeping the channel
+      // test: Error: Property failed after 2 tests
+      // test: { seed: -964670352, path: "1", endOnFailure: true }
+      // test: Counterexample: ["direct",["A","B"]]
       Vitest.scopedLive.prop(
-        'replace connection while keeping the channel',
-        [ChannelTypeWithoutMessageChannelProxy],
-        ([channelType], test) =>
+        'replace edge while keeping the channel',
+        [ChannelTypeWithoutMessageChannelProxy, NodeNames],
+        ([channelType, nodeNames], test) =>
           Effect.gen(function* () {
-            const nodeA = yield* makeMeshNode('A')
-            const nodeB = yield* makeMeshNode('B')
+            const [nodeNameX, nodeNameY] = nodeNames
+            const nodeX = yield* makeMeshNode(nodeNameX)
+            const nodeY = yield* makeMeshNode(nodeNameY)
+            const nodeLabel = { x: nodeX.nodeName, y: nodeY.nodeName }
 
             const { mode, connectNodes } = fromChannelType(channelType)
 
-            yield* connectNodes(nodeA, nodeB)
+            yield* connectNodes(nodeX, nodeY)
 
-            const waitForConnectionReplacement = yield* Deferred.make<void>()
+            const waitForEdgeReplacement = yield* Deferred.make<void>()
 
-            const nodeACode = Effect.gen(function* () {
-              const channelAToB = yield* createChannel(nodeA, 'B', { mode })
+            const nodeXCode = Effect.gen(function* () {
+              const channelXToY = yield* createChannel(nodeX, nodeLabel.y, { mode })
 
-              yield* channelAToB.send({ message: 'A1' })
-              expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
+              yield* channelXToY.send({ message: `${nodeLabel.x}1` })
+              expect(yield* getFirstMessage(channelXToY)).toEqual({ message: `${nodeLabel.y}1` })
 
-              yield* waitForConnectionReplacement
+              yield* waitForEdgeReplacement
 
-              yield* channelAToB.send({ message: 'A2' })
-              expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B2' })
+              yield* channelXToY.send({ message: `${nodeLabel.x}2` })
+              expect(yield* getFirstMessage(channelXToY)).toEqual({ message: `${nodeLabel.y}2` })
             })
 
-            const nodeBCode = Effect.gen(function* () {
-              const channelBToA = yield* createChannel(nodeB, 'A', { mode })
+            const nodeYCode = Effect.gen(function* () {
+              const channelYToX = yield* createChannel(nodeY, nodeLabel.x, { mode })
 
-              yield* channelBToA.send({ message: 'B1' })
-              expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
+              yield* channelYToX.send({ message: `${nodeLabel.y}1` })
+              expect(yield* getFirstMessage(channelYToX)).toEqual({ message: `${nodeLabel.x}1` })
 
-              // Switch out connection while keeping the channel
-              yield* nodeA.removeConnection('B')
-              yield* nodeB.removeConnection('A')
-              yield* connectNodes(nodeA, nodeB)
-              yield* Deferred.succeed(waitForConnectionReplacement, void 0)
+              // Switch out edge while keeping the channel
+              yield* nodeX.removeEdge(nodeLabel.y)
+              yield* nodeY.removeEdge(nodeLabel.x)
+              yield* connectNodes(nodeX, nodeY)
+              yield* Deferred.succeed(waitForEdgeReplacement, void 0)
 
-              yield* channelBToA.send({ message: 'B2' })
-              expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A2' })
+              yield* channelYToX.send({ message: `${nodeLabel.y}2` })
+              expect(yield* getFirstMessage(channelYToX)).toEqual({ message: `${nodeLabel.x}2` })
             })
 
-            yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' })
-          }).pipe(withCtx(test, { skipOtel: true, suffix: `channelType=${channelType}` })),
+            yield* Effect.all([nodeXCode, nodeYCode], { concurrency: 'unbounded' })
+          }).pipe(
+            withCtx(test, {
+              skipOtel: true,
+              suffix: `channelType=${channelType} nodeNames=${nodeNames}`,
+            }),
+          ),
+        { fastCheck: { numRuns: 10 } },
       )
 
-      Vitest.describe.todo('TODO improve latency', () => {
+      Vitest.describe('TODO improve latency', () => {
         // TODO we need to improve latency when sending messages concurrently
         Vitest.scopedLive.prop(
           'concurrent messages',
@@ -319,12 +461,52 @@ Vitest.describe('webmesh node', { timeout: 1000 }, () => {
               yield* Effect.all([nodeACode, nodeBCode, connectNodes(nodeA, nodeB).pipe(Effect.delay(100))], {
                 concurrency: 'unbounded',
               })
-            }).pipe(withCtx(test, { skipOtel: false, suffix: `channelType=${channelType} count=${count}` })),
-          { timeout: 30_000 },
+            }).pipe(
+              withCtx(test, {
+                skipOtel: true,
+                suffix: `channelType=${channelType} count=${count}`,
+                timeout: testTimeout * 2,
+              }),
+            ),
+          { fastCheck: { numRuns: 10 } },
         )
       })
     })
 
+    Vitest.describe('message channel specific tests', () => {
+      Vitest.scopedLive('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* 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* bFiber
+        }).pipe(withCtx(test)),
+      )
+    })
+
     Vitest.scopedLive('manual debug test', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
@@ -353,14 +535,14 @@ Vitest.describe('webmesh node', { timeout: 1000 }, () => {
       }).pipe(withCtx(test)),
     )
 
-    Vitest.scopedLive('broadcast connection with message channel', (test) =>
+    Vitest.scopedLive('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: 'messagechannel' }).pipe(Effect.timeout(200), Effect.flip)
+        const err = yield* createChannel(nodeA, 'B', { mode: 'direct' }).pipe(Effect.timeout(200), Effect.flip)
         expect(err._tag).toBe('TimeoutException')
       }).pipe(withCtx(test)),
     )
@@ -382,6 +564,7 @@ Vitest.describe('webmesh node', { timeout: 1000 }, () => {
           yield* channelAToC.send({ message: 'A1' })
           expect(yield* getFirstMessage(channelAToC)).toEqual({ message: 'C1' })
           expect(yield* getFirstMessage(channelAToC)).toEqual({ message: 'C2' })
+          expect(yield* getFirstMessage(channelAToC)).toEqual({ message: 'C3' })
         })
 
         const nodeCCode = Effect.gen(function* () {
@@ -396,7 +579,7 @@ Vitest.describe('webmesh node', { timeout: 1000 }, () => {
       }).pipe(withCtx(test)),
     )
 
-    Vitest.scopedLive('should work - delayed connection', (test) =>
+    Vitest.scopedLive('should work - delayed edge', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -420,9 +603,14 @@ Vitest.describe('webmesh node', { timeout: 1000 }, () => {
           expect(yield* getFirstMessage(channelCToA)).toEqual({ message: 'A1' })
         })
 
-        yield* Effect.all([nodeACode, nodeCCode, connectNodes(nodeB, nodeC).pipe(Effect.delay(100))], {
-          concurrency: 'unbounded',
-        })
+        yield* Effect.all(
+          [
+            nodeACode,
+            nodeCCode,
+            connectNodes(nodeB, nodeC).pipe(Effect.delay(100), Effect.withSpan('connect-nodeB-nodeC-delay(100)')),
+          ],
+          { concurrency: 'unbounded' },
+        )
       }).pipe(withCtx(test)),
     )
 
@@ -451,7 +639,7 @@ Vitest.describe('webmesh node', { timeout: 1000 }, () => {
       }).pipe(withCtx(test)),
     )
 
-    Vitest.scopedLive('should fail', (test) =>
+    Vitest.scopedLive('should fail with timeout due to missing edge', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
@@ -473,11 +661,155 @@ Vitest.describe('webmesh node', { timeout: 1000 }, () => {
         yield* Effect.all([nodeACode, nodeCCode], { concurrency: 'unbounded' })
       }).pipe(withCtx(test)),
     )
+
+    Vitest.scopedLive('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')
+        })
+
+        const nodeBCode = Effect.gen(function* () {
+          const err = yield* createChannel(nodeB, 'A').pipe(Effect.timeout(200), Effect.flip)
+          expect(err._tag).toBe('TimeoutException')
+        })
+
+        yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' })
+      }).pipe(withCtx(test)),
+    )
+
+    Vitest.scopedLive('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))
+
+        yield* connectNodesViaMessageChannel(nodeA, nodeB)
+        yield* connectNodesViaMessageChannel(nodeB, nodeCgen1).pipe(Scope.extend(nodeCgen1Scope))
+
+        const nodeACode = Effect.gen(function* () {
+          const channelAToB = yield* createChannel(nodeA, 'C')
+
+          yield* channelAToB.send({ message: 'A1' })
+          expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'C1' })
+        })
+
+        const nodeCCode = (nodeB: MeshNode) =>
+          Effect.gen(function* () {
+            const channelBToA = yield* createChannel(nodeB, 'A')
+
+            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* Scope.close(nodeCgen1Scope, Exit.void)
+
+        const nodeCgen2 = yield* makeMeshNode('C')
+        yield* connectNodesViaMessageChannel(nodeB, nodeCgen2, { replaceIfExists: true })
+
+        yield* Effect.all([nodeACode, nodeCCode(nodeCgen2)], { concurrency: 'unbounded' }).pipe(
+          Effect.withSpan('test2'),
+        )
+      }).pipe(withCtx(test)),
+    )
+  })
+
+  /**
+   *    A
+   *   / \
+   *  B   C
+   *   \ /
+   *    D
+   */
+  Vitest.describe('diamond topology', () => {
+    Vitest.scopedLive('should work', (test) =>
+      Effect.gen(function* () {
+        const nodeA = yield* makeMeshNode('A')
+        const nodeB = yield* makeMeshNode('B')
+        const nodeC = yield* makeMeshNode('C')
+        const nodeD = yield* makeMeshNode('D')
+
+        yield* connectNodesViaMessageChannel(nodeA, nodeB)
+        yield* connectNodesViaMessageChannel(nodeA, nodeC)
+        yield* connectNodesViaMessageChannel(nodeB, nodeD)
+        yield* connectNodesViaMessageChannel(nodeC, nodeD)
+
+        const nodeACode = Effect.gen(function* () {
+          const channelAToD = yield* createChannel(nodeA, 'D')
+          yield* channelAToD.send({ message: 'A1' })
+          expect(yield* getFirstMessage(channelAToD)).toEqual({ message: 'D1' })
+        })
+
+        const nodeDCode = Effect.gen(function* () {
+          const channelDToA = yield* createChannel(nodeD, 'A')
+          yield* channelDToA.send({ message: 'D1' })
+          expect(yield* getFirstMessage(channelDToA)).toEqual({ message: 'A1' })
+        })
+
+        yield* Effect.all([nodeACode, nodeDCode], { concurrency: 'unbounded' })
+      }).pipe(withCtx(test)),
+    )
   })
 
-  Vitest.describe('mixture of messagechannel and proxy connections', () => {
+  /**
+   *    A       E
+   *     \     /
+   *      C---D
+   *     /     \
+   *    B       F
+   *
+   * 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* () {
+        const nodeA = yield* makeMeshNode('A')
+        const nodeB = yield* makeMeshNode('B')
+        const nodeC = yield* makeMeshNode('C')
+        const nodeD = yield* makeMeshNode('D')
+        const nodeE = yield* makeMeshNode('E')
+        const nodeF = yield* makeMeshNode('F')
+
+        yield* connectNodesViaMessageChannel(nodeA, nodeC)
+        yield* connectNodesViaMessageChannel(nodeB, nodeC)
+        yield* connectNodesViaMessageChannel(nodeC, nodeD)
+        yield* connectNodesViaMessageChannel(nodeD, nodeE)
+        yield* connectNodesViaMessageChannel(nodeD, nodeF)
+
+        yield* Effect.promise(() => nodeA.debug.requestTopology(100))
+
+        const nodeACode = Effect.gen(function* () {
+          const channelAToE = yield* createChannel(nodeA, 'E')
+          yield* channelAToE.send({ message: 'A1' })
+          expect(yield* getFirstMessage(channelAToE)).toEqual({ message: 'E1' })
+        })
+
+        const nodeECode = Effect.gen(function* () {
+          const channelEToA = yield* createChannel(nodeE, 'A')
+          yield* channelEToA.send({ message: 'E1' })
+          expect(yield* getFirstMessage(channelEToA)).toEqual({ message: 'A1' })
+        })
+
+        yield* Effect.all([nodeACode, nodeECode], { concurrency: 'unbounded' })
+      }).pipe(withCtx(test)),
+    )
+  })
+
+  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 messagechannel to A
+    // and side B tries to create a direct to A
     Vitest.scopedLive('should work for proxy channels', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
@@ -486,48 +818,249 @@ Vitest.describe('webmesh node', { timeout: 1000 }, () => {
         yield* connectNodesViaMessageChannel(nodeB, nodeA)
         const err = yield* connectNodesViaBroadcastChannel(nodeA, nodeB).pipe(Effect.flip)
 
-        expect(err._tag).toBe('ConnectionAlreadyExistsError')
+        expect(err._tag).toBe('EdgeAlreadyExistsError')
       }).pipe(withCtx(test)),
     )
 
-    // TODO this currently fails but should work. probably needs some more guarding internally.
-    Vitest.scopedLive.skip('should work for messagechannels', (test) =>
+    Vitest.scopedLive('should work for directs', (test) =>
       Effect.gen(function* () {
         const nodeA = yield* makeMeshNode('A')
         const nodeB = yield* makeMeshNode('B')
+        const nodeC = yield* makeMeshNode('C')
 
         yield* connectNodesViaMessageChannel(nodeB, nodeA)
-        yield* connectNodesViaBroadcastChannel(nodeA, nodeB)
+        yield* connectNodesViaBroadcastChannel(nodeB, nodeC)
 
         const nodeACode = Effect.gen(function* () {
-          const channelAToB = yield* createChannel(nodeA, 'B', { mode: 'messagechannel' })
+          const channelAToC = yield* createChannel(nodeA, 'C', { mode: 'proxy' })
+          yield* channelAToC.send({ message: 'A1' })
+          expect(yield* getFirstMessage(channelAToC)).toEqual({ message: 'C1' })
+        })
+
+        const nodeCCode = Effect.gen(function* () {
+          const channelCToA = yield* createChannel(nodeC, 'A', { mode: 'proxy' })
+          yield* channelCToA.send({ message: 'C1' })
+          expect(yield* getFirstMessage(channelCToA)).toEqual({ message: 'A1' })
+        })
+
+        yield* Effect.all([nodeACode, nodeCCode], { concurrency: 'unbounded' })
+      }).pipe(withCtx(test)),
+    )
+  })
+
+  Vitest.describe('listenForChannel', () => {
+    Vitest.scopedLive('connect later', (test) =>
+      Effect.gen(function* () {
+        const nodeA = yield* makeMeshNode('A')
+
+        const mode = 'direct' as 'proxy' | 'direct'
+        const connect = mode === 'direct' ? connectNodesViaMessageChannel : connectNodesViaBroadcastChannel
+
+        const nodeACode = Effect.gen(function* () {
+          const channelAToB = yield* createChannel(nodeA, 'B', { channelName: 'test', mode })
           yield* channelAToB.send({ message: 'A1' })
           expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
         })
 
         const nodeBCode = Effect.gen(function* () {
-          const channelBToA = yield* createChannel(nodeB, 'A', { mode: 'messagechannel' })
-          yield* channelBToA.send({ message: 'B1' })
-          expect(yield* getFirstMessage(channelBToA)).toEqual({ message: 'A1' })
+          const nodeB = yield* makeMeshNode('B')
+          yield* connect(nodeA, nodeB)
+
+          yield* nodeB.listenForChannel.pipe(
+            Stream.filter((_) => _.channelName === 'test' && _.source === 'A' && _.mode === mode),
+            Stream.tap(
+              Effect.fn(function* (channelInfo) {
+                const channel = yield* createChannel(nodeB, channelInfo.source, {
+                  channelName: channelInfo.channelName,
+                  mode,
+                })
+                yield* channel.send({ message: 'B1' })
+                expect(yield* getFirstMessage(channel)).toEqual({ message: 'A1' })
+              }),
+            ),
+            Stream.take(1),
+            Stream.runDrain,
+          )
         })
 
+        yield* Effect.all([nodeACode, nodeBCode.pipe(Effect.delay(500))], { concurrency: 'unbounded' })
+      }).pipe(withCtx(test)),
+    )
+
+    // TODO provide a way to allow for reconnecting in the `listenForChannel` case
+    Vitest.scopedLive.skip('reconnect', (test) =>
+      Effect.gen(function* () {
+        const nodeA = yield* makeMeshNode('A')
+
+        const mode = 'direct' as 'proxy' | 'direct'
+        const connect = mode === 'direct' ? connectNodesViaMessageChannel : connectNodesViaBroadcastChannel
+
+        const nodeACode = Effect.gen(function* () {
+          const channelAToB = yield* createChannel(nodeA, 'B', { channelName: 'test', mode })
+          yield* channelAToB.send({ message: 'A1' })
+          expect(yield* getFirstMessage(channelAToB)).toEqual({ message: 'B1' })
+        })
+
+        const nodeBCode = Effect.gen(function* () {
+          const nodeB = yield* makeMeshNode('B')
+          yield* connect(nodeA, nodeB)
+
+          yield* nodeB.listenForChannel.pipe(
+            Stream.filter((_) => _.channelName === 'test' && _.source === 'A' && _.mode === mode),
+            Stream.tap(
+              Effect.fn(function* (channelInfo) {
+                const channel = yield* createChannel(nodeB, channelInfo.source, {
+                  channelName: channelInfo.channelName,
+                  mode,
+                })
+                yield* channel.send({ message: 'B1' })
+                expect(yield* getFirstMessage(channel)).toEqual({ message: 'A1' })
+              }),
+            ),
+            Stream.take(1),
+            Stream.runDrain,
+          )
+        }).pipe(
+          Effect.withSpan('nodeBCode:gen1'),
+          Effect.andThen(
+            Effect.gen(function* () {
+              const nodeB = yield* makeMeshNode('B')
+              yield* connect(nodeA, nodeB, { replaceIfExists: true })
+
+              yield* nodeB.listenForChannel.pipe(
+                Stream.filter((_) => _.channelName === 'test' && _.source === 'A' && _.mode === mode),
+                Stream.tap(
+                  Effect.fn(function* (channelInfo) {
+                    const channel = yield* createChannel(nodeB, channelInfo.source, {
+                      channelName: channelInfo.channelName,
+                      mode,
+                    })
+                    console.log('recreated channel', channel)
+                    // yield* channel.send({ message: 'B1' })
+                    // expect(yield* getFirstMessage(channel)).toEqual({ message: 'A1' })
+                  }),
+                ),
+                Stream.take(1),
+                Stream.runDrain,
+              )
+            }).pipe(Effect.withSpan('nodeBCode:gen2')),
+          ),
+        )
+
         yield* Effect.all([nodeACode, nodeBCode], { concurrency: 'unbounded' })
       }).pipe(withCtx(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* () {
+            const nodeA = yield* makeMeshNode('A')
+            const nodeB = yield* makeMeshNode('B')
+            const nodeC = yield* makeMeshNode('C')
+
+            const mode = channelType.includes('proxy') ? 'proxy' : 'direct'
+            const connect = channelType === 'direct' ? connectNodesViaMessageChannel : connectNodesViaBroadcastChannel
+            yield* connect(nodeA, nodeB).pipe(maybeDelay(delayConnectAB, 'delayConnectAB'))
+            yield* connect(nodeB, nodeC).pipe(maybeDelay(delayConnectBC, 'delayConnectBC'))
+
+            const nodeACode = Effect.gen(function* () {
+              const _channel2AToC = yield* createChannel(nodeA, 'C', { channelName: 'test-2', mode })
+
+              const channelAToC = yield* createChannel(nodeA, 'C', { channelName: 'test-1', mode })
+              yield* channelAToC.send({ message: 'A1' })
+              expect(yield* getFirstMessage(channelAToC)).toEqual({ message: 'C1' })
+            })
+
+            const nodeCCode = Effect.gen(function* () {
+              const _channel2CToA = yield* createChannel(nodeC, 'A', { channelName: 'test-2', mode })
+
+              yield* nodeC.listenForChannel.pipe(
+                Stream.filter((_) => _.channelName === 'test-1' && _.source === 'A' && _.mode === mode),
+                Stream.tap(
+                  Effect.fn(function* (channelInfo) {
+                    const channel = yield* createChannel(nodeC, channelInfo.source, {
+                      channelName: channelInfo.channelName,
+                      mode,
+                    })
+                    yield* channel.send({ message: 'C1' })
+                    expect(yield* getFirstMessage(channel)).toEqual({ message: 'A1' })
+                  }),
+                ),
+                Stream.take(1),
+                Stream.runDrain,
+              )
+            })
+
+            yield* Effect.all(
+              [
+                nodeACode.pipe(maybeDelay(delayNodeA, 'nodeACode')),
+                nodeCCode.pipe(maybeDelay(delayNodeC, 'nodeCCode')),
+              ],
+              { concurrency: 'unbounded' },
+            )
+          }).pipe(
+            withCtx(test, {
+              skipOtel: true,
+              suffix: `delayNodeA=${delayNodeA} delayNodeC=${delayNodeC} delayConnectAB=${delayConnectAB} delayConnectBC=${delayConnectBC} channelType=${channelType}`,
+              timeout: testTimeout * 2,
+            }),
+          ),
+        { fastCheck: { numRuns: 10 } },
+      )
+    })
+  })
+
+  Vitest.describe('broadcast channel', () => {
+    Vitest.scopedLive('should work', (test) =>
+      Effect.gen(function* () {
+        const nodeA = yield* makeMeshNode('A')
+        const nodeB = yield* makeMeshNode('B')
+        const nodeC = yield* makeMeshNode('C')
+
+        yield* connectNodesViaMessageChannel(nodeA, nodeB)
+        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,
+        )
+
+        yield* channelOnA.send('A1')
+        yield* channelOnC.send('C1')
+
+        expect(yield* listenOnAFiber).toEqual('C1')
+        expect(yield* listenOnCFiber).toEqual('A1')
+      }).pipe(withCtx(test)),
+    )
   })
 })
 
-const envTruish = (env: string | undefined) => env !== undefined && env !== 'false' && env !== '0'
-const isCi = envTruish(process.env.CI)
-
-const otelLayer = isCi ? Layer.empty : OtelLiveHttp({ serviceName: 'webmesh-node-test', skipLogUrl: false })
+const otelLayer = IS_CI ? Layer.empty : OtelLiveHttp({ serviceName: 'webmesh-node-test', skipLogUrl: false })
 
 const withCtx =
-  (testContext: Vitest.TaskContext, { suffix, skipOtel = false }: { suffix?: string; skipOtel?: boolean } = {}) =>
+  (
+    testContext: Vitest.TaskContext,
+    { suffix, skipOtel = false, timeout = testTimeout }: { suffix?: string; skipOtel?: boolean; timeout?: number } = {},
+  ) =>
   <A, E, R>(self: Effect.Effect<A, E, R>) =>
     self.pipe(
-      Effect.timeout(isCi ? 10_000 : 500),
+      Effect.timeout(timeout),
       Effect.provide(Logger.pretty),
+      Logger.withMinimumLogLevel(LogLevel.Debug),
       Effect.scoped, // We need to scope the effect manually here because otherwise the span is not closed
       Effect.withSpan(`${testContext.task.suite?.name}:${testContext.task.name}${suffix ? `:${suffix}` : ''}`),
       skipOtel ? identity : Effect.provide(otelLayer),