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

package/src/node.ts

@@ -6,7 +6,6 @@ import {
   Effect,
   Exit,
   Fiber,
-  Option,
   PubSub,
   Queue,
   Schema,
@@ -16,7 +15,7 @@ import {
 } from '@livestore/utils/effect'
 
 import { makeDirectChannel } from './channel/direct-channel.ts'
-import { makeProxyChannel } from './channel/proxy-channel.ts'
+import { makeProxyChannel, type ProxyChannelSimulationParams } from './channel/proxy-channel.ts'
 import type { ChannelKey, ListenForChannelResult, MeshNodeName, MessageQueueItem, ProxyQueueItem } from './common.ts'
 import { EdgeAlreadyExistsError, packetAsOtelAttributes } from './common.ts'
 import * as WebmeshSchema from './mesh-schema.ts'
@@ -61,7 +60,7 @@ export interface MeshNode<TName extends MeshNodeName = MeshNodeName> {
     }): Effect.Effect<void, EdgeAlreadyExistsError, Scope.Scope>
   }
 
-  removeEdge: (targetNodeName: MeshNodeName) => Effect.Effect<void, Cause.NoSuchElementException>
+  removeEdge: (targetNodeName: MeshNodeName) => Effect.Effect<void, Cause.NoSuchElementError>
 
   hasChannel: ({
     target,
@@ -93,10 +92,10 @@ export interface MeshNode<TName extends MeshNodeName = MeshNodeName> {
      */
     channelName: string
     schema:
-      | Schema.Schema<MsgListen | MsgSend, any>
+      | Schema.Codec<MsgListen | MsgSend, any>
       | {
-          listen: Schema.Schema<MsgListen, any>
-          send: Schema.Schema<MsgSend, any>
+          listen: Schema.Codec<MsgListen, any>
+          send: Schema.Codec<MsgSend, any>
         }
     /**
      * If possible, prefer using a DirectChannel with transferables (i.e. transferring memory instead of copying it).
@@ -107,13 +106,18 @@ export interface MeshNode<TName extends MeshNodeName = MeshNodeName> {
      *
      * @default 1 second
      */
-    timeout?: Duration.DurationInput
+    timeout?: Duration.Input
     /**
      * If true, will close an existing channel if it exists.
      *
      * @default false
      */
     closeExisting?: boolean
+    /**
+     * Optional simulation parameters for testing timing-sensitive behavior.
+     * Only used when mode is 'proxy'.
+     */
+    simulation?: ProxyChannelSimulationParams
   }) => Effect.Effect<WebChannel.WebChannel<MsgListen, MsgSend>, never, Scope.Scope>
 
   listenForChannel: Stream.Stream<ListenForChannelResult>
@@ -124,7 +128,7 @@ export interface MeshNode<TName extends MeshNodeName = MeshNodeName> {
    */
   makeBroadcastChannel: <Msg>(args: {
     channelName: string
-    schema: Schema.Schema<Msg, any>
+    schema: Schema.Codec<Msg, any>
   }) => Effect.Effect<WebChannel.WebChannel<Msg, Msg>, never, Scope.Scope>
 }
 
@@ -132,16 +136,17 @@ export const makeMeshNode = <TName extends MeshNodeName>(
   nodeName: TName,
 ): Effect.Effect<MeshNode<TName>, never, Scope.Scope> =>
   Effect.gen(function* () {
-    const edgeChannels = new Map<MeshNodeName, { channel: EdgeChannel; listenFiber: Fiber.RuntimeFiber<void> }>()
+    const edgeChannels = new Map<MeshNodeName, { channel: EdgeChannel; listenFiber: Fiber.Fiber<void> }>()
 
     // To avoid unbounded memory growth, we automatically forget about packet ids after a while
     const handledPacketIds = yield* TimeoutSet.make(Duration.minutes(1))
 
-    const newEdgeAvailablePubSub = yield* PubSub.unbounded<MeshNodeName>().pipe(Effect.acquireRelease(PubSub.shutdown))
+    const newEdgeAvailablePubSub = yield* Effect.acquireRelease(PubSub.unbounded<MeshNodeName>(), PubSub.shutdown)
 
-    // const proxyPacketsToProcess = yield* Queue.unbounded<ProxyQueueItem>().pipe(Effect.acquireRelease(Queue.shutdown))
-    // const messagePacketsToProcess = yield* Queue.unbounded<MessageQueueItem>().pipe(
-    //   Effect.acquireRelease(Queue.shutdown),
+    // const proxyPacketsToProcess = yield* Effect.acquireRelease(Queue.unbounded<ProxyQueueItem>(), Queue.shutdown)
+    // const messagePacketsToProcess = yield* Effect.acquireRelease(
+    //   Queue.unbounded<MessageQueueItem>(),
+    //   Queue.shutdown,
     // )
 
     const channelMap = new Map<
@@ -158,9 +163,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
       }
     >()
 
-    const channelRequestsQueue = yield* Queue.unbounded<ListenForChannelResult>().pipe(
-      Effect.acquireRelease(Queue.shutdown),
-    )
+    const channelRequestsQueue = yield* Effect.acquireRelease(Queue.unbounded<ListenForChannelResult>(), Queue.shutdown)
 
     type RequestId = string
     const topologyRequestsMap = new Map<RequestId, Map<MeshNodeName, Set<MeshNodeName>>>()
@@ -173,7 +176,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
         (packet._tag === 'DirectChannelRequest' &&
           (edgeChannels.size === 0 || // Either if direct edge does not support transferables ...
             edgeChannels.get(packet.target)?.channel.supportsTransferables === false)) || // ... or if no forward-edges support transferables
-        ![...edgeChannels.values()].some((c) => c.channel.supportsTransferables === true)
+        [...edgeChannels.values()].some((c) => c.channel.supportsTransferables) === false
       ) {
         return WebmeshSchema.DirectChannelResponseNoTransferables.make({
           reqId: packet.id,
@@ -187,13 +190,14 @@ export const makeMeshNode = <TName extends MeshNodeName>(
           hops: [],
         })
       }
+      return undefined
     }
 
     const sendPacket = (packet: typeof WebmeshSchema.Packet.Type) =>
       Effect.gen(function* () {
         // yield* Effect.log(`${nodeName}: sendPacket:${packet._tag} [${packet.id}]`)
 
-        if (Schema.is(WebmeshSchema.NetworkEdgeAdded)(packet)) {
+        if (Schema.is(WebmeshSchema.NetworkEdgeAdded)(packet) === true) {
           yield* Effect.spanEvent('NetworkEdgeAdded', { packet, nodeName })
           yield* PubSub.publish(newEdgeAvailablePubSub, packet.target)
 
@@ -205,7 +209,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
           return
         }
 
-        if (Schema.is(WebmeshSchema.BroadcastChannelPacket)(packet)) {
+        if (Schema.is(WebmeshSchema.BroadcastChannelPacket)(packet) === true) {
           const edgesToForwardTo = Array.from(edgeChannels)
             .filter(([name]) => !packet.hops.includes(name))
             .map(([_, con]) => con.channel)
@@ -231,7 +235,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
           return
         }
 
-        if (Schema.is(WebmeshSchema.NetworkTopologyRequest)(packet)) {
+        if (Schema.is(WebmeshSchema.NetworkTopologyRequest)(packet) === true) {
           if (packet.source !== nodeName) {
             const backEdgeName =
               packet.hops.at(-1) ?? shouldNeverHappen(`${nodeName}: Expected hops for packet`, packet)
@@ -265,7 +269,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
           return
         }
 
-        if (Schema.is(WebmeshSchema.NetworkTopologyResponse)(packet)) {
+        if (Schema.is(WebmeshSchema.NetworkTopologyResponse)(packet) === true) {
           if (packet.source === nodeName) {
             const topologyRequestItem = topologyRequestsMap.get(packet.reqId)!
             topologyRequestItem.set(packet.nodeName, new Set(packet.edges))
@@ -289,7 +293,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
         }
 
         // We have a direct edge to the target node
-        if (edgeChannels.has(packet.target)) {
+        if (edgeChannels.has(packet.target) === true) {
           const edgeChannel = edgeChannels.get(packet.target)!.channel
           const hops = packet.source === nodeName ? [] : [...packet.hops, nodeName]
           yield* Effect.annotateCurrentSpan({ hasDirectEdge: true })
@@ -325,7 +329,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
             .map(([name, con]) => ({ name, channel: con.channel }))
 
           // TODO if hops-depth=0, we should fail right away with no route found
-          if (hops.length === 0 && edgesToForwardTo.length === 0 && LS_DEV) {
+          if (hops.length === 0 && edgesToForwardTo.length === 0 && LS_DEV === true) {
             yield* Effect.logWarning(nodeName, 'no route found to', packet.target, packet._tag, 'TODO handle better')
             // TODO return a expected failure
           }
@@ -348,8 +352,8 @@ export const makeMeshNode = <TName extends MeshNodeName>(
 
     const addEdge: MeshNode['addEdge'] = ({ target: targetNodeName, edgeChannel, replaceIfExists = false }) =>
       Effect.gen(function* () {
-        if (edgeChannels.has(targetNodeName)) {
-          if (replaceIfExists) {
+        if (edgeChannels.has(targetNodeName) === true) {
+          if (replaceIfExists === true) {
             yield* removeEdge(targetNodeName).pipe(Effect.orDie)
           } else {
             return yield* new EdgeAlreadyExistsError({ target: targetNodeName })
@@ -358,14 +362,14 @@ export const makeMeshNode = <TName extends MeshNodeName>(
 
         // TODO use a priority queue instead to prioritize network-changes/edge-requests over payloads
         const listenFiber = yield* edgeChannel.listen.pipe(
-          Stream.flatten(),
+          Stream.mapEffect(Effect.fromResult),
           Stream.tap((message) =>
             Effect.gen(function* () {
-              const packet = yield* Schema.decodeUnknown(WebmeshSchema.Packet)(message)
+              const packet = yield* Schema.decodeUnknownEffect(WebmeshSchema.Packet)(message)
 
               // console.debug(nodeName, 'recv', packet._tag, packet.source, packet.target)
 
-              if (handledPacketIds.has(packet.id)) return
+              if (handledPacketIds.has(packet.id) === true) return
               handledPacketIds.add(packet.id)
 
               switch (packet._tag) {
@@ -380,9 +384,10 @@ export const makeMeshNode = <TName extends MeshNodeName>(
                   if (packet.target === nodeName) {
                     const channelKey = `target:${packet.source}, channelName:${packet.channelName}` satisfies ChannelKey
 
-                    if (!channelMap.has(channelKey)) {
-                      const channelQueue = yield* Queue.unbounded<MessageQueueItem | ProxyQueueItem>().pipe(
-                        Effect.acquireRelease(Queue.shutdown),
+                    if (channelMap.has(channelKey) === false) {
+                      const channelQueue = yield* Effect.acquireRelease(
+                        Queue.unbounded<MessageQueueItem | ProxyQueueItem>(),
+                        Queue.shutdown,
                       )
                       channelMap.set(channelKey, { queue: channelQueue, debugInfo: undefined })
                     }
@@ -400,9 +405,9 @@ export const makeMeshNode = <TName extends MeshNodeName>(
                           Effect.orDie,
                         )
 
-                    if (Schema.is(WebmeshSchema.ProxyChannelPacket)(packet)) {
+                    if (Schema.is(WebmeshSchema.ProxyChannelPacket)(packet) === true) {
                       yield* Queue.offer(channelQueue, { packet, respondToSender })
-                    } else if (Schema.is(WebmeshSchema.DirectChannelPacket)(packet)) {
+                    } else if (Schema.is(WebmeshSchema.DirectChannelPacket)(packet) === true) {
                       yield* Queue.offer(channelQueue, { packet, respondToSender })
                     }
 
@@ -414,7 +419,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
                       })
                     }
                   } else {
-                    if (Schema.is(WebmeshSchema.DirectChannelPacket)(packet)) {
+                    if (Schema.is(WebmeshSchema.DirectChannelPacket)(packet) === true) {
                       const noTransferableResponse = checkTransferableEdges(packet)
                       if (noTransferableResponse !== undefined) {
                         yield* Effect.spanEvent(`No transferable edges found for ${packet.source}→${packet.target}`)
@@ -455,8 +460,8 @@ export const makeMeshNode = <TName extends MeshNodeName>(
 
     const removeEdge: MeshNode['removeEdge'] = (targetNodeName) =>
       Effect.gen(function* () {
-        if (!edgeChannels.has(targetNodeName)) {
-          yield* new Cause.NoSuchElementException(`No edge found for ${targetNodeName}`)
+        if (edgeChannels.has(targetNodeName) === false) {
+          return yield* new Cause.NoSuchElementError(`No edge found for ${targetNodeName}`)
         }
 
         yield* Fiber.interrupt(edgeChannels.get(targetNodeName)!.listenFiber)
@@ -477,15 +482,16 @@ export const makeMeshNode = <TName extends MeshNodeName>(
       mode,
       timeout = Duration.seconds(1),
       closeExisting = false,
+      simulation,
     }) =>
       Effect.gen(function* () {
         const schema = WebChannel.mapSchema(inputSchema)
         const channelKey = `target:${target}, channelName:${channelName}` satisfies ChannelKey
 
-        if (channelMap.has(channelKey)) {
+        if (channelMap.has(channelKey) === true) {
           const existingChannel = channelMap.get(channelKey)!.debugInfo?.channel
-          if (existingChannel) {
-            if (closeExisting) {
+          if (existingChannel !== undefined) {
+            if (closeExisting === true) {
               yield* existingChannel.shutdown
               channelMap.delete(channelKey)
             } else {
@@ -495,8 +501,9 @@ export const makeMeshNode = <TName extends MeshNodeName>(
         }
 
         if (channelMap.has(channelKey) === false) {
-          const channelQueue = yield* Queue.unbounded<MessageQueueItem | ProxyQueueItem>().pipe(
-            Effect.acquireRelease(Queue.shutdown),
+          const channelQueue = yield* Effect.acquireRelease(
+            Queue.unbounded<MessageQueueItem | ProxyQueueItem>(),
+            Queue.shutdown,
           )
           channelMap.set(channelKey, { queue: channelQueue, debugInfo: undefined })
         }
@@ -506,7 +513,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
         yield* Effect.addFinalizer(() => Effect.sync(() => channelMap.delete(channelKey)))
 
         if (mode === 'direct') {
-          const incomingPacketsQueue = yield* Queue.unbounded<any>().pipe(Effect.acquireRelease(Queue.shutdown))
+          const incomingPacketsQueue = yield* Effect.acquireRelease(Queue.unbounded<any>(), Queue.shutdown)
 
           // We're we're draining the queue into another new queue.
           // It's a bit of a mystery why this is needed, since the unit tests also work without it.
@@ -534,7 +541,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
 
           channelMap.set(channelKey, { queue: channelQueue, debugInfo: { channel: webChannel, target } })
 
-          yield* initialEdgeDeferred
+          yield* Deferred.await(initialEdgeDeferred)
 
           return webChannel
         } else {
@@ -546,6 +553,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
             schema,
             queue: channelQueue,
             sendPacket,
+            ...(simulation !== undefined ? { simulation } : {}),
           })
 
           channelMap.set(channelKey, { queue: channelQueue, debugInfo: { channel, target } })
@@ -564,7 +572,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
     // TODO also provide a way to allow for reconnects
     let listenAlreadyStarted = false
     const listenForChannel: MeshNode['listenForChannel'] = Stream.suspend(() => {
-      if (listenAlreadyStarted) {
+      if (listenAlreadyStarted === true) {
         return shouldNeverHappen('listenForChannel already started')
       }
       listenAlreadyStarted = true
@@ -576,7 +584,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
       return Stream.fromQueue(channelRequestsQueue).pipe(
         Stream.filter((res) => {
           const hashed = hash(res)
-          if (seen.has(hashed)) {
+          if (seen.has(hashed) === true) {
             return false
           }
           seen.add(hashed)
@@ -588,7 +596,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
     const makeBroadcastChannel: MeshNode['makeBroadcastChannel'] = ({ channelName, schema }) =>
       Effect.scopeWithCloseable((scope) =>
         Effect.gen(function* () {
-          if (broadcastChannelListenQueueMap.has(channelName)) {
+          if (broadcastChannelListenQueueMap.has(channelName) === true) {
             return shouldNeverHappen(
               `Broadcast channel ${channelName} already exists`,
               broadcastChannelListenQueueMap.get(channelName),
@@ -597,12 +605,12 @@ export const makeMeshNode = <TName extends MeshNodeName>(
 
           const debugInfo = {}
 
-          const queue = yield* Queue.unbounded<any>().pipe(Effect.acquireRelease(Queue.shutdown))
+          const queue = yield* Effect.acquireRelease(Queue.unbounded<any>(), Queue.shutdown)
           broadcastChannelListenQueueMap.set(channelName, queue)
 
           const send = (message: any) =>
             Effect.gen(function* () {
-              const payload = yield* Schema.encode(schema)(message)
+              const payload = yield* Schema.encodeEffect(schema)(message)
               const packet = WebmeshSchema.BroadcastChannelPacket.make({
                 channelName,
                 payload,
@@ -616,10 +624,10 @@ export const makeMeshNode = <TName extends MeshNodeName>(
 
           const listen = Stream.fromQueue(queue).pipe(
             Stream.filter(Schema.is(WebmeshSchema.BroadcastChannelPacket)),
-            Stream.map((_) => Schema.decodeEither(schema)(_.payload)),
+            Stream.map((_) => Schema.decodeResult(schema)(_.payload)),
           )
 
-          const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
+          const closedDeferred = yield* Effect.acquireRelease(Deferred.make<void>(), Deferred.done(Exit.void))
 
           return {
             [WebChannel.WebChannelSymbol]: WebChannel.WebChannelSymbol,
@@ -636,7 +644,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
 
     const edgeKeys: MeshNode['edgeKeys'] = Effect.sync(() => new Set(edgeChannels.keys()))
 
-    const runtime = yield* Effect.runtime()
+    const services = yield* Effect.context()
 
     const debug: MeshNode['debug'] = {
       print: () => {
@@ -657,12 +665,12 @@ export const makeMeshNode = <TName extends MeshNodeName>(
               supportsTransferables: value.debugInfo?.channel.supportsTransferables,
               ...value.debugInfo?.channel.debugInfo,
             })
-              .map(([key, value]) => indent(`${key}=${value}`, 4))
+              .map(([key, value]) => indent(`${key}=${String(value)}`, 4))
               .join('\n'),
             '    ',
             value.debugInfo?.channel,
             '\n',
-            indent(`Queue: ${value.queue.unsafeSize().pipe(Option.getOrUndefined)}`, 4),
+            indent(`Queue: ${Queue.sizeUnsafe(value.queue)}`, 4),
             value.queue,
           )
         }
@@ -691,7 +699,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
             yield* Effect.logDebug(`sending ping via channel ${channelKey}`)
             yield* channel.debugInfo.channel.send(msg(`channel ${channelKey}`) as any)
           }
-        }).pipe(Effect.provide(runtime), Effect.tapCauseLogPretty, Effect.runFork)
+        }).pipe(Effect.provide(services), Effect.tapCauseLogPretty, Effect.runFork)
       },
       requestTopology: (timeoutMs = 1000) =>
         Effect.gen(function* () {
@@ -714,7 +722,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
           for (const [key, value] of item) {
             yield* Effect.logDebug(`  node '${key}' has edge to: ${Array.from(value.values()).join(', ')}`)
           }
-        }).pipe(Effect.provide(runtime), Effect.tapCauseLogPretty, Effect.runPromise),
+        }).pipe(Effect.provide(services), Effect.tapCauseLogPretty, Effect.runPromise),
     }
 
     return {

package/src/utils.ts

@@ -6,14 +6,14 @@ import { Duration, Effect } from '@livestore/utils/effect'
  */
 export class TimeoutSet<V> {
   private values = new Map<V, number>()
-  private timeoutHandle: NodeJS.Timeout | undefined
+  private timeoutHandle: ReturnType<typeof setTimeout> | undefined
   private readonly timeoutMs: number
 
-  private constructor({ timeout }: { timeout: Duration.DurationInput }) {
+  private constructor({ timeout }: { timeout: Duration.Input }) {
     this.timeoutMs = Duration.toMillis(timeout)
   }
 
-  static make = (timeout: Duration.DurationInput) =>
+  static make = (timeout: Duration.Input) =>
     Effect.gen(function* () {
       const timeoutSet = new TimeoutSet({ timeout })
 

package/src/websocket-edge.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Tests for websocket-edge.ts
+ *
+ * These tests verify basic WebSocket edge functionality.
+ */
+
+import { expect } from 'vitest'
+
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { Effect, Result, Schema, WebChannel } from '@livestore/utils/effect'
+
+import * as MeshSchema from './mesh-schema.ts'
+import { MessageMsgpack, WSEdgeInit, WSEdgePayload } from './websocket-edge.ts'
+
+Vitest.describe('websocket-edge', () => {
+  /**
+   * Test that WSEdgeInit messages can be encoded/decoded via MessageMsgpack.
+   */
+  Vitest.live('should encode/decode WSEdgeInit', (test) =>
+    Effect.gen(function* () {
+      const initMessage = WSEdgeInit.make({ from: 'test-node' })
+
+      // Encode to msgpack
+      const encoded = yield* Schema.encodeEffect(MessageMsgpack)(initMessage)
+
+      // Decode back
+      const decoded = yield* Schema.decodeEffect(MessageMsgpack)(encoded)
+
+      expect(decoded._tag).toBe('WSEdgeInit')
+      if (decoded._tag === 'WSEdgeInit') {
+        expect(decoded.from).toBe('test-node')
+      }
+    }).pipe(Vitest.withTestCtx(test)),
+  )
+
+  /**
+   * Test that WSEdgePayload messages with valid Packet payloads work correctly.
+   */
+  Vitest.live('should encode/decode WSEdgePayload with Packet', (test) =>
+    Effect.gen(function* () {
+      const packet = {
+        _tag: 'NetworkEdgeAdded' as const,
+        id: 'test-id',
+        source: 'node-a',
+        target: 'node-b',
+      }
+      const wsMessage = WSEdgePayload.make({ from: 'test-node', payload: packet })
+
+      // Encode to msgpack
+      const encoded = yield* Schema.encodeEffect(MessageMsgpack)(wsMessage)
+
+      // Decode back
+      const decoded = yield* Schema.decodeEffect(MessageMsgpack)(encoded)
+
+      expect(decoded._tag).toBe('WSEdgePayload')
+      if (decoded._tag === 'WSEdgePayload') {
+        expect(decoded.from).toBe('test-node')
+        expect(decoded.payload).toEqual(packet)
+      }
+    }).pipe(Vitest.withTestCtx(test)),
+  )
+
+  /**
+   * Test that mapSchema(Packet) includes WebChannel internal messages.
+   * This is important because channels can send/receive WebChannel.Ping/Pong/DebugPing.
+   */
+  Vitest.live('mapSchema should include WebChannel messages in schema', (test) =>
+    Effect.gen(function* () {
+      const schema = WebChannel.mapSchema(MeshSchema.Packet)
+
+      // WebChannel.Ping should be decodable via the wrapped listen schema
+      const pingPayload = { _tag: 'WebChannel.Ping' as const, requestId: 'test-123' }
+      const result = Schema.decodeUnknownResult(schema.listen)(pingPayload)
+
+      // mapSchema adds WebChannel messages to the schema
+      expect(Result.isSuccess(result)).toBe(true)
+    }).pipe(Vitest.withTestCtx(test)),
+  )
+
+  /**
+   * Test that valid webmesh packets can be decoded.
+   */
+  Vitest.live('should decode valid webmesh packets', (test) =>
+    Effect.gen(function* () {
+      const schema = WebChannel.mapSchema(MeshSchema.Packet)
+
+      const packet = {
+        _tag: 'NetworkEdgeAdded' as const,
+        id: 'test-id',
+        source: 'node-a',
+        target: 'node-b',
+      }
+
+      const result = yield* Schema.decodeUnknownEffect(schema.listen)(packet)
+      expect(result._tag).toBe('NetworkEdgeAdded')
+    }).pipe(Vitest.withTestCtx(test)),
+  )
+})