@livestore/webmesh 0.3.0-dev.4 → 0.3.0-dev.41

package/src/channel/proxy-channel.ts

@@ -4,11 +4,13 @@ import {
   Deferred,
   Effect,
   Either,
+  Exit,
   Fiber,
   FiberHandle,
   Queue,
   Schedule,
   Schema,
+  Scope,
   Stream,
   SubscriptionRef,
   WebChannel,
@@ -27,7 +29,7 @@ import * as MeshSchema from '../mesh-schema.js'
 interface MakeProxyChannelArgs {
   queue: Queue.Queue<ProxyQueueItem>
   nodeName: MeshNodeName
-  newConnectionAvailablePubSub: PubSub.PubSub<MeshNodeName>
+  newEdgeAvailablePubSub: PubSub.PubSub<MeshNodeName>
   sendPacket: (packet: typeof MeshSchema.ProxyChannelPacket.Type) => Effect.Effect<void>
   channelName: ChannelName
   target: MeshNodeName
@@ -40,293 +42,401 @@ interface MakeProxyChannelArgs {
 export const makeProxyChannel = ({
   queue,
   nodeName,
-  newConnectionAvailablePubSub,
+  newEdgeAvailablePubSub,
   sendPacket,
   target,
   channelName,
   schema,
 }: MakeProxyChannelArgs) =>
-  Effect.gen(function* () {
-    type ProxiedChannelState =
-      | {
-          _tag: 'Initial'
-        }
-      | {
-          _tag: 'Pending'
-          initiatedVia: 'outgoing-request' | 'incoming-request'
-        }
-      | ProxiedChannelStateEstablished
-
-    type ProxiedChannelStateEstablished = {
-      _tag: 'Established'
-      listenSchema: Schema.Schema<any, any>
-      listenQueue: Queue.Queue<any>
-      ackMap: Map<string, Deferred.Deferred<void, never>>
-      combinedChannelId: string
-    }
-
-    const channelStateRef = { current: { _tag: 'Initial' } as ProxiedChannelState }
-
-    /**
-     * We need to unique identify a channel as multiple channels might exist between the same two nodes.
-     * We do this by letting each channel end generate a unique id and then combining them in a deterministic way.
-     */
-    const channelIdCandidate = nanoid(5)
-    yield* Effect.annotateCurrentSpan({ channelIdCandidate })
-
-    const channelSpan = yield* Effect.currentSpan.pipe(Effect.orDie)
-
-    const connectedStateRef = yield* SubscriptionRef.make<ProxiedChannelStateEstablished | false>(false)
-
-    const waitForEstablished = Effect.gen(function* () {
-      const state = yield* SubscriptionRef.waitUntil(connectedStateRef, (state) => state !== false)
-
-      return state as ProxiedChannelStateEstablished
-    })
-
-    const setStateToEstablished = (channelId: string) =>
-      Effect.gen(function* () {
-        // TODO avoid "double" `Connected` events (we might call `setStateToEstablished` twice during initial connection)
-        yield* Effect.spanEvent(`Connected (${channelId})`).pipe(Effect.withParentSpan(channelSpan))
-        channelStateRef.current = {
-          _tag: 'Established',
-          listenSchema: schema.listen,
-          listenQueue,
-          ackMap,
-          combinedChannelId: channelId,
-        }
-        yield* SubscriptionRef.set(connectedStateRef, channelStateRef.current)
-      })
-
-    const connectionRequest = Effect.suspend(() =>
-      sendPacket(
-        MeshSchema.ProxyChannelRequest.make({ channelName, hops: [], source: nodeName, target, channelIdCandidate }),
-      ),
-    )
+  Effect.scopeWithCloseable((scope) =>
+    Effect.gen(function* () {
+      type ProxiedChannelState =
+        | {
+            _tag: 'Initial'
+          }
+        | {
+            _tag: 'Pending'
+            initiatedVia: 'outgoing-request' | 'incoming-request'
+          }
+        | ProxiedChannelStateEstablished
+
+      type ProxiedChannelStateEstablished = {
+        _tag: 'Established'
+        listenSchema: Schema.Schema<any, any>
+        listenQueue: Queue.Queue<any>
+        ackMap: Map<string, Deferred.Deferred<void, never>>
+        combinedChannelId: string
+      }
 
-    const getCombinedChannelId = (otherSideChannelIdCandidate: string) =>
-      [channelIdCandidate, otherSideChannelIdCandidate].sort().join('_')
+      const channelStateRef = { current: { _tag: 'Initial' } as ProxiedChannelState }
 
-    const processProxyPacket = ({ packet, respondToSender }: ProxyQueueItem) =>
-      Effect.gen(function* () {
-        // yield* Effect.log(`${nodeName}:processing packet ${packet._tag} from ${packet.source}`)
+      const debugInfo = {
+        kind: 'proxy-channel',
+        pendingSends: 0,
+        totalSends: 0,
+        connectCounter: 0,
+        isConnected: false,
+      }
 
-        const otherSideName = packet.source
-        const channelKey = `${otherSideName}-${packet.channelName}` satisfies ChannelKey
-        const channelState = channelStateRef.current
+      /**
+       * We need to unique identify a channel as multiple channels might exist between the same two nodes.
+       * We do this by letting each channel end generate a unique id and then combining them in a deterministic way.
+       */
+      const channelIdCandidate = nanoid(5)
+      yield* Effect.annotateCurrentSpan({ channelIdCandidate })
 
-        switch (packet._tag) {
-          case 'ProxyChannelRequest': {
-            const combinedChannelId = getCombinedChannelId(packet.channelIdCandidate)
+      const channelSpan = yield* Effect.currentSpan.pipe(Effect.orDie)
 
-            if (channelState._tag === 'Initial' || channelState._tag === 'Established') {
-              yield* SubscriptionRef.set(connectedStateRef, false)
-              channelStateRef.current = { _tag: 'Pending', initiatedVia: 'incoming-request' }
-              yield* Effect.spanEvent(`Reconnecting`).pipe(Effect.withParentSpan(channelSpan))
+      const connectedStateRef = yield* SubscriptionRef.make<ProxiedChannelStateEstablished | false>(false)
 
-              // If we're already connected, we need to re-establish the connection
-              if (channelState._tag === 'Established' && channelState.combinedChannelId !== combinedChannelId) {
-                yield* connectionRequest
-              }
-            }
+      const waitForEstablished = Effect.gen(function* () {
+        const state = yield* SubscriptionRef.waitUntil(connectedStateRef, (state) => state !== false)
 
-            yield* respondToSender(
-              MeshSchema.ProxyChannelResponseSuccess.make({
-                reqId: packet.id,
-                remainingHops: packet.hops,
-                hops: [],
-                target,
-                source: nodeName,
-                channelName,
-                combinedChannelId,
-                channelIdCandidate,
-              }),
-            )
+        return state as ProxiedChannelStateEstablished
+      })
 
-            return
+      const setStateToEstablished = (channelId: string) =>
+        Effect.gen(function* () {
+          // TODO avoid "double" `Connected` events (we might call `setStateToEstablished` twice during initial edge)
+          yield* Effect.spanEvent(`Connected (${channelId})`).pipe(Effect.withParentSpan(channelSpan))
+          channelStateRef.current = {
+            _tag: 'Established',
+            listenSchema: schema.listen,
+            listenQueue,
+            ackMap,
+            combinedChannelId: channelId,
           }
-          case 'ProxyChannelResponseSuccess': {
-            if (channelState._tag !== 'Pending') {
-              // return shouldNeverHappen(`Expected proxy channel to be pending but got ${channelState._tag}`)
-              if (channelState._tag === 'Established' && channelState.combinedChannelId !== packet.combinedChannelId) {
-                return shouldNeverHappen(
-                  `Expected proxy channel to have the same combinedChannelId as the packet:\n${channelState.combinedChannelId} (channel) === ${packet.combinedChannelId} (packet)`,
+          yield* SubscriptionRef.set(connectedStateRef, channelStateRef.current)
+          debugInfo.isConnected = true
+        })
+
+      const edgeRequest = Effect.suspend(() =>
+        sendPacket(
+          MeshSchema.ProxyChannelRequest.make({ channelName, hops: [], source: nodeName, target, channelIdCandidate }),
+        ),
+      )
+
+      const getCombinedChannelId = (otherSideChannelIdCandidate: string) =>
+        [channelIdCandidate, otherSideChannelIdCandidate].sort().join('_')
+
+      const earlyPayloadBuffer = yield* Queue.unbounded<typeof MeshSchema.ProxyChannelPayload.Type>().pipe(
+        Effect.acquireRelease(Queue.shutdown),
+      )
+
+      const processProxyPacket = ({ packet, respondToSender }: ProxyQueueItem) =>
+        Effect.gen(function* () {
+          // yield* Effect.logDebug(
+          //   `[${nodeName}] processProxyPacket received: ${packet._tag} from ${packet.source} (reqId: ${packet.id})`,
+          // )
+
+          const otherSideName = packet.source
+          const channelKey = `target:${otherSideName}, channelName:${packet.channelName}` satisfies ChannelKey
+          const channelState = channelStateRef.current
+
+          switch (packet._tag) {
+            case 'ProxyChannelRequest': {
+              const combinedChannelId = getCombinedChannelId(packet.channelIdCandidate)
+
+              // Handle Established state explicitly
+              if (channelState._tag === 'Established') {
+                // Check if the incoming request is for the *same* channel instance
+                if (channelState.combinedChannelId === combinedChannelId) {
+                  // Already established with the same ID, likely a redundant request.
+                  // Just respond and stay established.
+                  // yield* Effect.logDebug(
+                  //   `[${nodeName}] Received redundant ProxyChannelRequest for already established channel instance ${combinedChannelId}. Responding.`,
+                  // )
+                } else {
+                  // Established, but the incoming request has a different ID.
+                  // This implies a reconnect scenario where IDs don't match. Reset to Pending and re-initiate.
+                  yield* Effect.logWarning(
+                    `[${nodeName}] Received ProxyChannelRequest with different channel ID (${combinedChannelId}) while established with ${channelState.combinedChannelId}. Re-establishing.`,
+                  )
+                  yield* SubscriptionRef.set(connectedStateRef, false)
+                  channelStateRef.current = { _tag: 'Pending', initiatedVia: 'incoming-request' }
+                  yield* Effect.spanEvent(`Reconnecting (received conflicting ProxyChannelRequest)`).pipe(
+                    Effect.withParentSpan(channelSpan),
+                  )
+                  debugInfo.isConnected = false
+                  debugInfo.connectCounter++
+                  // We need to send our own request as well to complete the handshake for the new ID
+                  yield* edgeRequest
+                }
+              } else if (channelState._tag === 'Initial') {
+                // Standard initial connection: set to Pending
+                yield* SubscriptionRef.set(connectedStateRef, false) // Ensure connectedStateRef is false if we were somehow Initial but it wasn't false
+                channelStateRef.current = { _tag: 'Pending', initiatedVia: 'incoming-request' }
+                yield* Effect.spanEvent(`Connecting (received ProxyChannelRequest)`).pipe(
+                  Effect.withParentSpan(channelSpan),
                 )
-              } else {
-                // for now just ignore it but should be looked into (there seems to be some kind of race condition/inefficiency)
+                debugInfo.isConnected = false // Should be false already, but ensure consistency
+                debugInfo.connectCounter++
+                // No need to send edgeRequest here, the response acts as our part of the handshake for the incoming request's ID
               }
-            }
-
-            const combinedChannelId = getCombinedChannelId(packet.channelIdCandidate)
-            if (combinedChannelId !== packet.combinedChannelId) {
-              return yield* Effect.die(
-                `Expected proxy channel to have the same combinedChannelId as the packet:\n${combinedChannelId} (channel) === ${packet.combinedChannelId} (packet)`,
+              // If state is 'Pending', we are already trying to connect.
+              // Just let the response go out, don't change state.
+
+              // Send the response regardless of the initial state (unless an error occurred)
+              yield* respondToSender(
+                MeshSchema.ProxyChannelResponseSuccess.make({
+                  reqId: packet.id,
+                  remainingHops: packet.hops,
+                  hops: [],
+                  target,
+                  source: nodeName,
+                  channelName,
+                  combinedChannelId,
+                  channelIdCandidate,
+                }),
               )
+
+              return
             }
+            case 'ProxyChannelResponseSuccess': {
+              if (channelState._tag !== 'Pending') {
+                if (
+                  channelState._tag === 'Established' &&
+                  channelState.combinedChannelId !== packet.combinedChannelId
+                ) {
+                  return shouldNeverHappen(
+                    `ProxyChannel[${channelKey}]: Expected proxy channel to have the same combinedChannelId as the packet:\n${channelState.combinedChannelId} (channel) === ${packet.combinedChannelId} (packet)`,
+                  )
+                } else if (channelState._tag === 'Established') {
+                  // yield* Effect.logDebug(`[${nodeName}] Ignoring redundant ResponseSuccess with same ID ${packet.id}`)
+                  return
+                } else {
+                  yield* Effect.logWarning(
+                    `[${nodeName}] Ignoring ResponseSuccess ${packet.id} received in unexpected state ${channelState._tag}`,
+                  )
+                  return
+                }
+              }
+
+              const combinedChannelId = getCombinedChannelId(packet.channelIdCandidate)
+              if (combinedChannelId !== packet.combinedChannelId) {
+                return yield* Effect.die(
+                  `ProxyChannel[${channelKey}]: Expected proxy channel to have the same combinedChannelId as the packet:\n${combinedChannelId} (channel) === ${packet.combinedChannelId} (packet)`,
+                )
+              }
 
-            yield* setStateToEstablished(packet.combinedChannelId)
+              yield* setStateToEstablished(packet.combinedChannelId)
+
+              const establishedState = channelStateRef.current
+              if (establishedState._tag === 'Established') {
+                //
+                const bufferedPackets = yield* Queue.takeAll(earlyPayloadBuffer)
+                // yield* Effect.logDebug(
+                //   `[${nodeName}] Draining early payload buffer (${bufferedPackets.length}) after ResponseSuccess`,
+                // )
+                for (const bufferedPacket of bufferedPackets) {
+                  if (establishedState.combinedChannelId !== bufferedPacket.combinedChannelId) {
+                    yield* Effect.logWarning(
+                      `[${nodeName}] Discarding buffered payload ${bufferedPacket.id}: Combined channel ID mismatch during drain. Expected ${establishedState.combinedChannelId}, got ${bufferedPacket.combinedChannelId}`,
+                    )
+                    continue
+                  }
+                  const decodedMessage = yield* Schema.decodeUnknown(establishedState.listenSchema)(
+                    bufferedPacket.payload,
+                  )
+                  yield* establishedState.listenQueue.pipe(Queue.offer(decodedMessage))
+                }
+              } else {
+                yield* Effect.logError(
+                  `[${nodeName}] State is not Established immediately after setStateToEstablished was called. Cannot drain buffer. State: ${establishedState._tag}`,
+                )
+              }
 
-            return
-          }
-          case 'ProxyChannelPayload': {
-            if (channelState._tag !== 'Established') {
-              // return yield* Effect.die(`Not yet connected to ${target}. dropping message`)
-              yield* Effect.spanEvent(`Not yet connected to ${target}. dropping message`, { packet })
               return
             }
+            case 'ProxyChannelPayload': {
+              if (channelState._tag === 'Established' && channelState.combinedChannelId !== packet.combinedChannelId) {
+                return yield* Effect.die(
+                  `ProxyChannel[${channelKey}]: Expected proxy channel to have the same combinedChannelId as the packet:\n${channelState.combinedChannelId} (channel) === ${packet.combinedChannelId} (packet)`,
+                )
+              }
 
-            if (channelState.combinedChannelId !== packet.combinedChannelId) {
-              return yield* Effect.die(
-                `Expected proxy channel to have the same combinedChannelId as the packet:\n${channelState.combinedChannelId} (channel) === ${packet.combinedChannelId} (packet)`,
+              // yield* Effect.logDebug(`[${nodeName}] Received payload reqId: ${packet.id}. Sending Ack.`)
+              yield* respondToSender(
+                MeshSchema.ProxyChannelPayloadAck.make({
+                  reqId: packet.id,
+                  remainingHops: packet.hops,
+                  hops: [],
+                  target,
+                  source: nodeName,
+                  channelName,
+                  combinedChannelId:
+                    channelState._tag === 'Established' ? channelState.combinedChannelId : packet.combinedChannelId,
+                }),
               )
-            }
 
-            yield* respondToSender(
-              MeshSchema.ProxyChannelPayloadAck.make({
-                reqId: packet.id,
-                remainingHops: packet.hops,
-                hops: [],
-                target,
-                source: nodeName,
-                channelName,
-                combinedChannelId: channelState.combinedChannelId,
-              }),
-            )
-
-            const decodedMessage = yield* Schema.decodeUnknown(channelState.listenSchema)(packet.payload)
-            yield* channelState.listenQueue.pipe(Queue.offer(decodedMessage))
-
-            return
-          }
-          case 'ProxyChannelPayloadAck': {
-            if (channelState._tag !== 'Established') {
-              yield* Effect.spanEvent(`Not yet connected to ${target}. dropping message`)
+              if (channelState._tag === 'Established') {
+                const decodedMessage = yield* Schema.decodeUnknown(channelState.listenSchema)(packet.payload)
+                yield* channelState.listenQueue.pipe(Queue.offer(decodedMessage))
+              } else {
+                // yield* Effect.logDebug(
+                //   `[${nodeName}] Buffering early payload reqId: ${packet.id} (state: ${channelState._tag})`,
+                // )
+                yield* Queue.offer(earlyPayloadBuffer, packet)
+              }
               return
             }
+            case 'ProxyChannelPayloadAck': {
+              // yield* Effect.logDebug(`[${nodeName}] Received Ack for reqId: ${packet.reqId}`)
 
-            const ack =
-              channelState.ackMap.get(packet.reqId) ??
-              shouldNeverHappen(`Expected ack for ${packet.reqId} in proxy channel ${channelKey}`)
+              if (channelState._tag !== 'Established') {
+                yield* Effect.spanEvent(`Not yet connected to ${target}. dropping message`)
+                yield* Effect.logWarning(
+                  `[${nodeName}] Received Ack but not established (State: ${channelState._tag}). Dropping Ack for ${packet.reqId}`,
+                )
+                return
+              }
 
-            yield* Deferred.succeed(ack, void 0)
+              const ack =
+                channelState.ackMap.get(packet.reqId) ??
+                shouldNeverHappen(`[ProxyChannel[${channelKey}]] Expected ack for ${packet.reqId}`)
+              yield* Deferred.succeed(ack, void 0)
 
-            channelState.ackMap.delete(packet.reqId)
+              channelState.ackMap.delete(packet.reqId)
 
-            return
-          }
-          default: {
-            return casesHandled(packet)
+              return
+            }
+            default: {
+              return casesHandled(packet)
+            }
           }
-        }
-      }).pipe(
-        Effect.withSpan(`handleProxyPacket:${packet._tag}:${packet.source}->${packet.target}`, {
-          attributes: packetAsOtelAttributes(packet),
-        }),
-      )
-
-    yield* Stream.fromQueue(queue).pipe(
-      Stream.tap(processProxyPacket),
-      Stream.runDrain,
-      Effect.tapCauseLogPretty,
-      Effect.forkScoped,
-    )
+        }).pipe(
+          Effect.withSpan(`handleProxyPacket:${packet._tag}:${packet.source}->${packet.target}`, {
+            attributes: packetAsOtelAttributes(packet),
+          }),
+        )
 
-    const listenQueue = yield* Queue.unbounded<any>()
+      yield* Stream.fromQueue(queue).pipe(
+        Stream.tap(processProxyPacket),
+        Stream.runDrain,
+        Effect.tapCauseLogPretty,
+        Effect.forkScoped,
+      )
 
-    yield* Effect.spanEvent(`Connecting`)
+      const listenQueue = yield* Queue.unbounded<any>()
 
-    const ackMap = new Map<string, Deferred.Deferred<void, never>>()
+      yield* Effect.spanEvent(`Connecting`)
 
-    // check if already established via incoming `ProxyChannelRequest` from other side
-    // which indicates we already have a connection to the target node
-    // const channelState = channelStateRef.current
-    {
-      if (channelStateRef.current._tag !== 'Initial') {
-        return shouldNeverHappen('Expected proxy channel to be Initial')
-      }
+      const ackMap = new Map<string, Deferred.Deferred<void, never>>()
 
-      channelStateRef.current = { _tag: 'Pending', initiatedVia: 'outgoing-request' }
+      // check if already established via incoming `ProxyChannelRequest` from other side
+      // which indicates we already have a edge to the target node
+      // const channelState = channelStateRef.current
+      {
+        if (channelStateRef.current._tag !== 'Initial') {
+          return shouldNeverHappen('Expected proxy channel to be Initial')
+        }
 
-      yield* connectionRequest
+        channelStateRef.current = { _tag: 'Pending', initiatedVia: 'outgoing-request' }
 
-      const retryOnNewConnectionFiber = yield* Stream.fromPubSub(newConnectionAvailablePubSub).pipe(
-        Stream.tap(() => connectionRequest),
-        Stream.runDrain,
-        Effect.forkScoped,
-      )
+        yield* edgeRequest
 
-      const { combinedChannelId: channelId } = yield* waitForEstablished
+        const retryOnNewEdgeFiber = yield* Stream.fromPubSub(newEdgeAvailablePubSub).pipe(
+          Stream.tap(() => edgeRequest),
+          Stream.runDrain,
+          Effect.forkScoped,
+        )
 
-      yield* Fiber.interrupt(retryOnNewConnectionFiber)
+        const { combinedChannelId: channelId } = yield* waitForEstablished
 
-      yield* setStateToEstablished(channelId)
-    }
+        yield* Fiber.interrupt(retryOnNewEdgeFiber)
 
-    const send = (message: any) =>
-      Effect.gen(function* () {
-        const payload = yield* Schema.encodeUnknown(schema.send)(message)
-        const sendFiberHandle = yield* FiberHandle.make<void, never>()
+        yield* setStateToEstablished(channelId)
+      }
 
-        const sentDeferred = yield* Deferred.make<void>()
+      const send = (message: any) =>
+        Effect.gen(function* () {
+          const payload = yield* Schema.encodeUnknown(schema.send)(message)
+          const sendFiberHandle = yield* FiberHandle.make<void, never>()
 
-        const trySend = Effect.gen(function* () {
-          const { combinedChannelId } = (yield* SubscriptionRef.waitUntil(
-            connectedStateRef,
-            (channel) => channel !== false,
-          )) as ProxiedChannelStateEstablished
+          const sentDeferred = yield* Deferred.make<void>()
 
-          const innerSend = Effect.gen(function* () {
-            // Note we're re-creating new packets every time otherwise they will be skipped because of `handledIds`
-            const ack = yield* Deferred.make<void, never>()
-            const packet = MeshSchema.ProxyChannelPayload.make({
-              channelName,
-              payload,
-              hops: [],
-              source: nodeName,
-              target,
-              combinedChannelId,
-            })
-            ackMap.set(packet.id, ack)
+          debugInfo.pendingSends++
+          debugInfo.totalSends++
 
-            yield* sendPacket(packet)
+          const trySend = Effect.gen(function* () {
+            const { combinedChannelId } = (yield* SubscriptionRef.waitUntil(
+              connectedStateRef,
+              (channel) => channel !== false,
+            )) as ProxiedChannelStateEstablished
 
-            yield* ack
-            yield* Deferred.succeed(sentDeferred, void 0)
-          })
+            const innerSend = Effect.gen(function* () {
+              // Note we're re-creating new packets every time otherwise they will be skipped because of `handledIds`
+              const ack = yield* Deferred.make<void, never>()
+              const packet = MeshSchema.ProxyChannelPayload.make({
+                channelName,
+                payload,
+                hops: [],
+                source: nodeName,
+                target,
+                combinedChannelId,
+              })
+              // TODO consider handling previous ackMap entries which might leak/fill-up memory
+              // as only successful acks are removed from the map
+              ackMap.set(packet.id, ack)
 
-          yield* innerSend.pipe(Effect.timeout(100), Effect.retry(Schedule.exponential(100)), Effect.orDie)
-        }).pipe(Effect.tapErrorCause(Effect.logError))
+              yield* sendPacket(packet)
 
-        const rerunOnNewChannelFiber = yield* connectedStateRef.changes.pipe(
-          Stream.filter((_) => _ === false),
-          Stream.tap(() => FiberHandle.run(sendFiberHandle, trySend)),
-          Stream.runDrain,
-          Effect.fork,
-        )
+              yield* ack
+              yield* Deferred.succeed(sentDeferred, void 0)
 
-        yield* FiberHandle.run(sendFiberHandle, trySend)
+              debugInfo.pendingSends--
+            })
 
-        yield* sentDeferred
+            // TODO make this configurable
+            // Schedule.exponential(10): 10, 20, 40, 80, 160, 320, ...
+            yield* innerSend.pipe(Effect.timeout(100), Effect.retry(Schedule.exponential(10)), Effect.orDie)
+          }).pipe(Effect.tapErrorCause(Effect.logError))
 
-        yield* Fiber.interrupt(rerunOnNewChannelFiber)
-      }).pipe(
-        Effect.scoped,
-        Effect.withSpan(`sendAckWithRetry:ProxyChannelPayload`),
-        Effect.withParentSpan(channelSpan),
-      )
+          const rerunOnNewChannelFiber = yield* connectedStateRef.changes.pipe(
+            Stream.filter((_) => _ === false),
+            Stream.tap(() => FiberHandle.run(sendFiberHandle, trySend)),
+            Stream.runDrain,
+            Effect.fork,
+          )
 
-    const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Either.right))
+          yield* FiberHandle.run(sendFiberHandle, trySend)
 
-    const closedDeferred = yield* Deferred.make<void>()
+          yield* sentDeferred
 
-    const webChannel = {
-      [WebChannel.WebChannelSymbol]: WebChannel.WebChannelSymbol,
-      send,
-      listen,
-      closedDeferred,
-      supportsTransferables: true,
-      schema,
-    } satisfies WebChannel.WebChannel<any, any>
+          yield* Fiber.interrupt(rerunOnNewChannelFiber)
+        }).pipe(
+          Effect.scoped,
+          Effect.withSpan(`sendAckWithRetry:ProxyChannelPayload`),
+          Effect.withParentSpan(channelSpan),
+        )
 
-    return webChannel as WebChannel.WebChannel<any, any>
-  }).pipe(Effect.withSpanScoped('makeProxyChannel'))
+      const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Either.right))
+
+      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
+
+      const runtime = yield* Effect.runtime()
+
+      const webChannel = {
+        [WebChannel.WebChannelSymbol]: WebChannel.WebChannelSymbol,
+        send,
+        listen,
+        closedDeferred,
+        supportsTransferables: false,
+        schema,
+        shutdown: Scope.close(scope, Exit.void),
+        debugInfo,
+        ...({
+          debug: {
+            ping: (message: string = 'ping') =>
+              send(WebChannel.DebugPingMessage.make({ message })).pipe(
+                Effect.provide(runtime),
+                Effect.tapCauseLogPretty,
+                Effect.runFork,
+              ),
+          },
+        } as {}),
+      } satisfies WebChannel.WebChannel<any, any>
+
+      return webChannel as WebChannel.WebChannel<any, any>
+    }).pipe(Effect.withSpanScoped('makeProxyChannel')),
+  )