@livestore/webmesh 0.3.0-dev.37 → 0.3.0-dev.39

package/src/channel/{message-channel-internal.ts → direct-channel-internal.ts}

@@ -16,30 +16,30 @@ import {
 import { type ChannelName, type MeshNodeName, type MessageQueueItem, packetAsOtelAttributes } from '../common.js'
 import * as MeshSchema from '../mesh-schema.js'
 
-export interface MakeMessageChannelArgs {
+export interface MakeDirectChannelArgs {
   nodeName: MeshNodeName
   /** Queue of incoming messages for this channel */
   incomingPacketsQueue: Queue.Queue<MessageQueueItem>
   newEdgeAvailablePubSub: PubSub.PubSub<MeshNodeName>
   channelName: ChannelName
   target: MeshNodeName
-  sendPacket: (packet: typeof MeshSchema.MessageChannelPacket.Type) => Effect.Effect<void>
+  sendPacket: (packet: typeof MeshSchema.DirectChannelPacket.Type) => Effect.Effect<void>
   checkTransferableEdges: (
-    packet: typeof MeshSchema.MessageChannelPacket.Type,
-  ) => typeof MeshSchema.MessageChannelResponseNoTransferables.Type | undefined
+    packet: typeof MeshSchema.DirectChannelPacket.Type,
+  ) => typeof MeshSchema.DirectChannelResponseNoTransferables.Type | undefined
   schema: WebChannel.OutputSchema<any, any, any, any>
 }
 
 const makeDeferredResult = Deferred.make<
   WebChannel.WebChannel<any, any>,
-  typeof MeshSchema.MessageChannelResponseNoTransferables.Type
+  typeof MeshSchema.DirectChannelResponseNoTransferables.Type
 >
 
 /**
  * The channel version is important here, as a channel will only be established once both sides have the same version.
  * The version is used to avoid concurrency issues where both sides have different incompatible message ports.
  */
-export const makeMessageChannelInternal = ({
+export const makeDirectChannelInternal = ({
   nodeName,
   incomingPacketsQueue,
   target,
@@ -50,14 +50,14 @@ export const makeMessageChannelInternal = ({
   channelVersion,
   scope,
   sourceId,
-}: MakeMessageChannelArgs & {
+}: MakeDirectChannelArgs & {
   channelVersion: number
-  /** We're passing in the closeable scope from the wrapping message channel */
+  /** We're passing in the closeable scope from the wrapping direct channel */
   scope: Scope.CloseableScope
   sourceId: string
 }): Effect.Effect<
   WebChannel.WebChannel<any, any>,
-  typeof MeshSchema.MessageChannelResponseNoTransferables.Type,
+  typeof MeshSchema.DirectChannelResponseNoTransferables.Type,
   Scope.Scope
 > =>
   Effect.gen(function* () {
@@ -95,8 +95,8 @@ export const makeMessageChannelInternal = ({
     // }
 
     const schema = {
-      send: Schema.Union(schema_.send, MeshSchema.MessageChannelPing, MeshSchema.MessageChannelPong),
-      listen: Schema.Union(schema_.listen, MeshSchema.MessageChannelPing, MeshSchema.MessageChannelPong),
+      send: Schema.Union(schema_.send, MeshSchema.DirectChannelPing, MeshSchema.DirectChannelPong),
+      listen: Schema.Union(schema_.listen, MeshSchema.DirectChannelPing, MeshSchema.DirectChannelPong),
     }
 
     const channelStateRef: { current: ChannelState } = {
@@ -122,7 +122,7 @@ export const makeMessageChannelInternal = ({
 
         if (channelState._tag === 'Initial') return shouldNeverHappen()
 
-        if (packet._tag === 'MessageChannelResponseNoTransferables') {
+        if (packet._tag === 'DirectChannelResponseNoTransferables') {
           yield* Deferred.fail(deferred, packet)
           return 'close'
         }
@@ -139,7 +139,7 @@ export const makeMessageChannelInternal = ({
         // If this channel has a higher version, we need to signal the other side to close
         // and recreate the channel with the new version
         if (packet.channelVersion < channelVersion) {
-          const newPacket = MeshSchema.MessageChannelRequest.make({
+          const newPacket = MeshSchema.DirectChannelRequest.make({
             source: nodeName,
             sourceId,
             target,
@@ -158,7 +158,7 @@ export const makeMessageChannelInternal = ({
           return
         }
 
-        if (channelState._tag === 'Established' && packet._tag === 'MessageChannelRequest') {
+        if (channelState._tag === 'Established' && packet._tag === 'DirectChannelRequest') {
           if (packet.sourceId === channelState.otherSourceId) {
             return
           } else {
@@ -172,7 +172,7 @@ export const makeMessageChannelInternal = ({
 
         switch (packet._tag) {
           // Assumption: Each side has sent an initial request and another request as a response for an incoming request
-          case 'MessageChannelRequest': {
+          case 'DirectChannelRequest': {
             if (channelState._tag !== 'RequestSent') {
               // We can safely ignore further incoming requests as we're already creating a channel
               return
@@ -181,7 +181,7 @@ export const makeMessageChannelInternal = ({
             if (packet.reqId === channelState.reqPacketId) {
               // Circuit-breaker: We've already sent a request so we don't need to send another one
             } else {
-              const newRequestPacket = MeshSchema.MessageChannelRequest.make({
+              const newRequestPacket = MeshSchema.DirectChannelRequest.make({
                 source: nodeName,
                 sourceId,
                 target,
@@ -199,10 +199,10 @@ export const makeMessageChannelInternal = ({
             const isWinner = nodeName > target
 
             if (isWinner) {
-              span?.addEvent(`winner side: creating message channel and sending response`)
+              span?.addEvent(`winner side: creating direct channel and sending response`)
               const mc = new MessageChannel()
 
-              // We're using a message channel with acks here to make sure messages are not lost
+              // We're using a direct channel with acks here to make sure messages are not lost
               // which might happen during re-edge scenarios.
               // Also we need to eagerly start listening since we're using the channel "ourselves"
               // for the initial ping-pong sequence.
@@ -213,7 +213,7 @@ export const makeMessageChannelInternal = ({
               }).pipe(Effect.andThen(WebChannel.toOpenChannel))
 
               yield* respondToSender(
-                MeshSchema.MessageChannelResponseSuccess.make({
+                MeshSchema.DirectChannelResponseSuccess.make({
                   reqId: packet.id,
                   target,
                   source: nodeName,
@@ -232,14 +232,14 @@ export const makeMessageChannelInternal = ({
               // Now we wait for the other side to respond via the channel
               yield* channel.listen.pipe(
                 Stream.flatten(),
-                Stream.filter(Schema.is(MeshSchema.MessageChannelPing)),
+                Stream.filter(Schema.is(MeshSchema.DirectChannelPing)),
                 Stream.take(1),
                 Stream.runDrain,
               )
 
               // span?.addEvent(`winner side: sending pong`)
 
-              yield* channel.send(MeshSchema.MessageChannelPong.make({}))
+              yield* channel.send(MeshSchema.DirectChannelPong.make({}))
 
               span?.addEvent(`winner side: established`)
               channelStateRef.current = { _tag: 'Established', otherSourceId: packet.sourceId }
@@ -247,20 +247,20 @@ export const makeMessageChannelInternal = ({
               yield* Deferred.succeed(deferred, channel)
             } else {
               span?.addEvent(`loser side: waiting for response`)
-              // Wait for `MessageChannelResponseSuccess` packet
+              // Wait for `DirectChannelResponseSuccess` packet
               channelStateRef.current = { _tag: 'loser:WaitingForResponse', otherSourceId: packet.sourceId }
             }
 
             break
           }
-          case 'MessageChannelResponseSuccess': {
+          case 'DirectChannelResponseSuccess': {
             if (channelState._tag !== 'loser:WaitingForResponse') {
               return shouldNeverHappen(
-                `Expected to find message channel response from ${target}, but was in ${channelState._tag} state`,
+                `Expected to find direct channel response from ${target}, but was in ${channelState._tag} state`,
               )
             }
 
-            // See message-channel notes above
+            // See direct-channel notes above
             const channel = yield* WebChannel.messagePortChannelWithAck({
               port: packet.port,
               schema,
@@ -269,7 +269,7 @@ export const makeMessageChannelInternal = ({
 
             const waitForPongFiber = yield* channel.listen.pipe(
               Stream.flatten(),
-              Stream.filter(Schema.is(MeshSchema.MessageChannelPong)),
+              Stream.filter(Schema.is(MeshSchema.DirectChannelPong)),
               Stream.take(1),
               Stream.runDrain,
               Effect.fork,
@@ -282,7 +282,7 @@ export const makeMessageChannelInternal = ({
             // TODO write a test that reproduces this issue and fix the root cause ()
             // https://github.com/livestorejs/livestore/issues/262
             yield* channel
-              .send(MeshSchema.MessageChannelPing.make({}))
+              .send(MeshSchema.DirectChannelPing.make({}))
               .pipe(Effect.timeout(10), Effect.retry({ times: 2 }))
 
             // span?.addEvent(`loser side: waiting for pong`)
@@ -324,7 +324,7 @@ export const makeMessageChannelInternal = ({
     }
 
     const edgeRequest = Effect.gen(function* () {
-      const packet = MeshSchema.MessageChannelRequest.make({
+      const packet = MeshSchema.DirectChannelRequest.make({
         source: nodeName,
         sourceId,
         target,
@@ -353,4 +353,4 @@ export const makeMessageChannelInternal = ({
     const channel = yield* deferred
 
     return channel
-  }).pipe(Effect.withSpanScoped(`makeMessageChannel:${channelVersion}`))
+  }).pipe(Effect.withSpanScoped(`makeDirectChannel:${channelVersion}`))

package/src/channel/{message-channel.ts → direct-channel.ts}

@@ -15,8 +15,8 @@ import {
 import { nanoid } from '@livestore/utils/nanoid'
 
 import * as WebmeshSchema from '../mesh-schema.js'
-import type { MakeMessageChannelArgs } from './message-channel-internal.js'
-import { makeMessageChannelInternal } from './message-channel-internal.js'
+import type { MakeDirectChannelArgs } from './direct-channel-internal.js'
+import { makeDirectChannelInternal } from './direct-channel-internal.js'
 
 /**
  * Behaviour:
@@ -33,7 +33,7 @@ import { makeMessageChannelInternal } from './message-channel-internal.js'
  *
  * If needed we can also implement further functionality (like heartbeat) in this wrapper channel.
  */
-export const makeMessageChannel = ({
+export const makeDirectChannel = ({
   schema,
   newEdgeAvailablePubSub,
   channelName,
@@ -42,7 +42,7 @@ export const makeMessageChannel = ({
   incomingPacketsQueue,
   target,
   sendPacket,
-}: MakeMessageChannelArgs) =>
+}: MakeDirectChannelArgs) =>
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
       /** Only used to identify whether a source is the same instance to know when to reconnect */
@@ -66,7 +66,7 @@ export const makeMessageChannel = ({
         const resultDeferred = yield* Deferred.make<{
           channel: WebChannel.WebChannel<any, any>
           channelVersion: number
-          makeMessageChannelScope: Scope.CloseableScope
+          makeDirectChannelScope: Scope.CloseableScope
         }>()
 
         while (true) {
@@ -75,9 +75,9 @@ export const makeMessageChannel = ({
 
           yield* Effect.spanEvent(`Connecting#${channelVersion}`)
 
-          const makeMessageChannelScope = yield* Scope.make()
+          const makeDirectChannelScope = yield* Scope.make()
           // Attach the new scope to the parent scope
-          yield* Effect.addFinalizer((ex) => Scope.close(makeMessageChannelScope, ex))
+          yield* Effect.addFinalizer((ex) => Scope.close(makeDirectChannelScope, ex))
 
           /**
            * Expected concurrency behaviour:
@@ -86,7 +86,7 @@ export const makeMessageChannel = ({
            *   - The edge setup succeeds and we can interrupt the waitForNewEdgeFiber
            * - Tricky paths:
            *   - While a edge is still being setup, we want to re-try when there is a new edge
-           *   - If the edge setup returns a `MessageChannelResponseNoTransferables` error,
+           *   - If the edge setup returns a `DirectChannelResponseNoTransferables` error,
            *     we want to wait for a new edge and then re-try
            * - Further notes:
            *   - If the parent scope closes, we want to also interrupt both the edge setup and the waitForNewEdgeFiber
@@ -102,7 +102,7 @@ export const makeMessageChannel = ({
             Effect.fork,
           )
 
-          const makeChannel = makeMessageChannelInternal({
+          const makeChannel = makeDirectChannelInternal({
             nodeName,
             sourceId,
             incomingPacketsQueue,
@@ -113,10 +113,10 @@ export const makeMessageChannel = ({
             channelVersion,
             newEdgeAvailablePubSub,
             sendPacket,
-            scope: makeMessageChannelScope,
+            scope: makeDirectChannelScope,
           }).pipe(
-            Scope.extend(makeMessageChannelScope),
-            Effect.forkIn(makeMessageChannelScope),
+            Scope.extend(makeDirectChannelScope),
+            Effect.forkIn(makeDirectChannelScope),
             // Given we only call `Effect.exit` later when joining the fiber,
             // we don't want Effect to produce a "unhandled error" log message
             Effect.withUnhandledErrorLogLevel(Option.none()),
@@ -125,16 +125,16 @@ export const makeMessageChannel = ({
           const raceResult = yield* Effect.raceFirst(makeChannel, waitForNewEdgeFiber.pipe(Effect.disconnect))
 
           if (raceResult === 'new-edge') {
-            yield* Scope.close(makeMessageChannelScope, Exit.fail('new-edge'))
+            yield* Scope.close(makeDirectChannelScope, Exit.fail('new-edge'))
             // We'll try again
           } else {
             const channelExit = yield* raceResult.pipe(Effect.exit)
             if (channelExit._tag === 'Failure') {
-              yield* Scope.close(makeMessageChannelScope, channelExit)
+              yield* Scope.close(makeDirectChannelScope, channelExit)
 
               if (
                 Cause.isFailType(channelExit.cause) &&
-                Schema.is(WebmeshSchema.MessageChannelResponseNoTransferables)(channelExit.cause.error)
+                Schema.is(WebmeshSchema.DirectChannelResponseNoTransferables)(channelExit.cause.error)
               ) {
                 // Only retry when there is a new edge available
                 yield* waitForNewEdgeFiber.pipe(Effect.exit)
@@ -142,14 +142,14 @@ export const makeMessageChannel = ({
             } else {
               const channel = channelExit.value
 
-              yield* Deferred.succeed(resultDeferred, { channel, makeMessageChannelScope, channelVersion })
+              yield* Deferred.succeed(resultDeferred, { channel, makeDirectChannelScope, channelVersion })
               break
             }
           }
         }
 
         // Now we wait until the first channel is established
-        const { channel, makeMessageChannelScope, channelVersion } = yield* resultDeferred
+        const { channel, makeDirectChannelScope, channelVersion } = yield* resultDeferred
 
         yield* Effect.spanEvent(`Connected#${channelVersion}`)
         debugInfo.isConnected = true
@@ -164,7 +164,7 @@ export const makeMessageChannel = ({
           Stream.tapChunk((chunk) => Queue.offerAll(listenQueue, chunk)),
           Stream.runDrain,
           Effect.tapCauseLogPretty,
-          Effect.forkIn(makeMessageChannelScope),
+          Effect.forkIn(makeDirectChannelScope),
         )
 
         yield* Effect.gen(function* () {
@@ -177,12 +177,12 @@ export const makeMessageChannel = ({
             yield* Deferred.succeed(deferred, void 0)
             yield* TQueue.take(sendQueue) // Remove the message from the queue
           }
-        }).pipe(Effect.forkIn(makeMessageChannelScope))
+        }).pipe(Effect.forkIn(makeDirectChannelScope))
 
         // Wait until the channel is closed and then try to reconnect
         yield* channel.closedDeferred
 
-        yield* Scope.close(makeMessageChannelScope, Exit.succeed('channel-closed'))
+        yield* Scope.close(makeDirectChannelScope, Exit.succeed('channel-closed'))
 
         yield* Effect.spanEvent(`Disconnected#${channelVersion}`)
         debugInfo.isConnected = false

package/src/channel/proxy-channel.ts

@@ -71,6 +71,7 @@ export const makeProxyChannel = ({
       const channelStateRef = { current: { _tag: 'Initial' } as ProxiedChannelState }
 
       const debugInfo = {
+        kind: 'proxy-channel',
         pendingSends: 0,
         totalSends: 0,
         connectCounter: 0,
@@ -118,9 +119,15 @@ export const makeProxyChannel = ({
       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.log(`${nodeName}:processing packet ${packet._tag} from ${packet.source}`)
+          // 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
@@ -130,19 +137,46 @@ export const makeProxyChannel = ({
             case 'ProxyChannelRequest': {
               const combinedChannelId = getCombinedChannelId(packet.channelIdCandidate)
 
-              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))
-                debugInfo.isConnected = false
-                debugInfo.connectCounter++
-
-                // If we're already connected, we need to re-establish the edge
-                if (channelState._tag === 'Established' && channelState.combinedChannelId !== combinedChannelId) {
+              // 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),
+                )
+                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
               }
+              // 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,
@@ -160,7 +194,6 @@ export const makeProxyChannel = ({
             }
             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
@@ -168,8 +201,14 @@ export const makeProxyChannel = ({
                   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 {
-                  // for now just ignore it but should be looked into (there seems to be some kind of race condition/inefficiency)
+                  yield* Effect.logWarning(
+                    `[${nodeName}] Ignoring ResponseSuccess ${packet.id} received in unexpected state ${channelState._tag}`,
+                  )
+                  return
                 }
               }
 
@@ -182,21 +221,41 @@ export const makeProxyChannel = ({
 
               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
-              }
-
-              if (channelState.combinedChannelId !== packet.combinedChannelId) {
+              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)`,
                 )
               }
 
+              // yield* Effect.logDebug(`[${nodeName}] Received payload reqId: ${packet.id}. Sending Ack.`)
               yield* respondToSender(
                 MeshSchema.ProxyChannelPayloadAck.make({
                   reqId: packet.id,
@@ -205,25 +264,36 @@ export const makeProxyChannel = ({
                   target,
                   source: nodeName,
                   channelName,
-                  combinedChannelId: channelState.combinedChannelId,
+                  combinedChannelId:
+                    channelState._tag === 'Established' ? channelState.combinedChannelId : packet.combinedChannelId,
                 }),
               )
 
-              const decodedMessage = yield* Schema.decodeUnknown(channelState.listenSchema)(packet.payload)
-              yield* channelState.listenQueue.pipe(Queue.offer(decodedMessage))
-
+              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}`)
+
               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
               }
 
               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)
@@ -344,15 +414,27 @@ export const makeProxyChannel = ({
 
       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: true,
+        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>

package/src/common.ts

@@ -1,6 +1,6 @@
 import { type Effect, Predicate, Schema } from '@livestore/utils/effect'
 
-import type { MessageChannelPacket, Packet, ProxyChannelPacket } from './mesh-schema.js'
+import type { DirectChannelPacket, Packet, ProxyChannelPacket } from './mesh-schema.js'
 
 export type ProxyQueueItem = {
   packet: typeof ProxyChannelPacket.Type
@@ -8,8 +8,8 @@ export type ProxyQueueItem = {
 }
 
 export type MessageQueueItem = {
-  packet: typeof MessageChannelPacket.Type
-  respondToSender: (msg: typeof MessageChannelPacket.Type) => Effect.Effect<void>
+  packet: typeof DirectChannelPacket.Type
+  respondToSender: (msg: typeof DirectChannelPacket.Type) => Effect.Effect<void>
 }
 
 export type MeshNodeName = string
@@ -31,5 +31,13 @@ export const packetAsOtelAttributes = (packet: typeof Packet.Type) => ({
   packetId: packet.id,
   'span.label':
     packet.id + (Predicate.hasProperty(packet, 'reqId') && packet.reqId !== undefined ? ` for ${packet.reqId}` : ''),
-  ...(packet._tag !== 'MessageChannelResponseSuccess' && packet._tag !== 'ProxyChannelPayload' ? { packet } : {}),
+  ...(packet._tag !== 'DirectChannelResponseSuccess' && packet._tag !== 'ProxyChannelPayload' ? { packet } : {}),
 })
+
+export const ListenForChannelResult = Schema.Struct({
+  channelName: Schema.String,
+  source: Schema.String,
+  mode: Schema.Union(Schema.Literal('proxy'), Schema.Literal('direct')),
+})
+
+export type ListenForChannelResult = typeof ListenForChannelResult.Type