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

package/src/effect/WebChannel/WebChannel.ts

@@ -1,5 +1,5 @@
-import { Deferred, Either, Exit, GlobalValue, identity, Option, PubSub, Queue, Scope } from 'effect'
-import type { DurationInput } from 'effect/Duration'
+import type { Duration } from 'effect'
+import { Cause, Deferred, Result, Exit, Filter, identity, Option, PubSub, Queue, Scope } from 'effect'
 
 import { shouldNeverHappen } from '../../misc.ts'
 import * as Effect from '../Effect.ts'
@@ -27,7 +27,7 @@ export const noopChannel = <MsgListen, MsgSend>(): Effect.Effect<WebChannel<MsgL
         [WebChannelSymbol]: WebChannelSymbol,
         send: () => Effect.void,
         listen: Stream.never,
-        closedDeferred: yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void))),
+        closedDeferred: yield* Effect.acquireRelease(Deferred.make<void>(), Deferred.done(Exit.void)),
         shutdown: Scope.close(scope, Exit.succeed('shutdown')),
         schema: {
           listen: Schema.Any,
@@ -38,131 +38,10 @@ export const noopChannel = <MsgListen, MsgSend>(): Effect.Effect<WebChannel<MsgL
     }).pipe(Effect.withSpan(`WebChannel:noopChannel`)),
   )
 
-/** Only works in browser environments */
-export const broadcastChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
-  channelName,
-  schema: inputSchema,
-}: {
-  channelName: string
-  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-}): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
-  Effect.scopeWithCloseable((scope) =>
-    Effect.gen(function* () {
-      const schema = mapSchema(inputSchema)
-
-      const channel = new BroadcastChannel(channelName)
-
-      yield* Effect.addFinalizer(() => Effect.try(() => channel.close()).pipe(Effect.ignoreLogged))
-
-      const send = (message: MsgSend) =>
-        Effect.gen(function* () {
-          const messageEncoded = yield* Schema.encode(schema.send)(message)
-          channel.postMessage(messageEncoded)
-        })
-
-      // TODO also listen to `messageerror` in parallel
-      const listen = Stream.fromEventListener<MessageEvent>(channel, 'message').pipe(
-        Stream.map((_) => Schema.decodeEither(schema.listen)(_.data)),
-        listenToDebugPing(channelName),
-      )
-
-      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
-      const supportsTransferables = false
-
-      return {
-        [WebChannelSymbol]: WebChannelSymbol,
-        send,
-        listen,
-        closedDeferred,
-        shutdown: Scope.close(scope, Exit.succeed('shutdown')),
-        schema,
-        supportsTransferables,
-      }
-    }).pipe(Effect.withSpan(`WebChannel:broadcastChannel(${channelName})`)),
-  )
-
-/**
- * NOTE the `listenName` and `sendName` is needed for cases where both sides are using the same window
- * e.g. for a browser extension, so we need a way to know for which side a message is intended for.
- */
-export const windowChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
-  listenWindow,
-  sendWindow,
-  targetOrigin = '*',
-  ids,
-  schema: inputSchema,
-}: {
-  listenWindow: Window
-  sendWindow: Window
-  targetOrigin?: string
-  ids: { own: string; other: string }
-  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-}): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
-  Effect.scopeWithCloseable((scope) =>
-    Effect.gen(function* () {
-      const schema = mapSchema(inputSchema)
-
-      const debugInfo = {
-        sendTotal: 0,
-        listenTotal: 0,
-        targetOrigin,
-        ids,
-      }
-
-      const WindowMessageListen = Schema.Struct({
-        message: schema.listen,
-        from: Schema.Literal(ids.other),
-        to: Schema.Literal(ids.own),
-      }).annotations({ title: 'webmesh.WindowMessageListen' })
-
-      const WindowMessageSend = Schema.Struct({
-        message: schema.send,
-        from: Schema.Literal(ids.own),
-        to: Schema.Literal(ids.other),
-      }).annotations({ title: 'webmesh.WindowMessageSend' })
-
-      const send = (message: MsgSend) =>
-        Effect.gen(function* () {
-          debugInfo.sendTotal++
-
-          const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(WindowMessageSend)({
-            message,
-            from: ids.own,
-            to: ids.other,
-          })
-          sendWindow.postMessage(messageEncoded, targetOrigin, transferables)
-        })
-
-      const listen = Stream.fromEventListener<MessageEvent>(listenWindow, 'message').pipe(
-        // Stream.tap((_) => Effect.log(`${ids.other}→${ids.own}:message`, _.data)),
-        Stream.filter((_) => Schema.is(Schema.encodedSchema(WindowMessageListen))(_.data)),
-        Stream.map((_) => {
-          debugInfo.listenTotal++
-          return Schema.decodeEither(schema.listen)(_.data.message)
-        }),
-        listenToDebugPing('window'),
-      )
-
-      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
-      const supportsTransferables = true
-
-      return {
-        [WebChannelSymbol]: WebChannelSymbol,
-        send,
-        listen,
-        closedDeferred,
-        shutdown: Scope.close(scope, Exit.succeed('shutdown')),
-        schema,
-        supportsTransferables,
-        debugInfo,
-      }
-    }).pipe(Effect.withSpan(`WebChannel:windowChannel`)),
-  )
-
 export const messagePortChannel: <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
   port: MessagePort
   schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-  debugId?: string | number
+  debugId?: string | number | undefined
 }) => Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> = ({ port, schema: inputSchema, debugId }) =>
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
@@ -170,15 +49,25 @@ export const messagePortChannel: <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
 
       const label = debugId === undefined ? 'messagePort' : `messagePort:${debugId}`
 
+      // In Effect v4, forking a consumer is not a readiness handshake. Install the MessagePort
+      // listener while constructing the channel and buffer into a scoped queue so early messages
+      // are not lost before `listen` is pulled.
+      const messageQueue = yield* Effect.acquireRelease(Queue.unbounded<MessageDataEvent>(), Queue.shutdown)
+      const handler = (event: MessageDataEvent) => {
+        Queue.offerUnsafe(messageQueue, event)
+      }
+      port.addEventListener('message', handler)
+      yield* Effect.addFinalizer(() => Effect.sync(() => port.removeEventListener('message', handler)))
+
       const send = (message: any) =>
         Effect.gen(function* () {
           const [messageEncoded, transferables] = yield* Schema.encodeWithTransferables(schema.send)(message)
           port.postMessage(messageEncoded, transferables)
         })
 
-      const listen = Stream.fromEventListener<MessageEvent>(port, 'message').pipe(
+      const listen = Stream.fromQueue(messageQueue).pipe(
         // Stream.tap((_) => Effect.log(`${label}:message`, _.data)),
-        Stream.map((_) => Schema.decodeEither(schema.listen)(_.data)),
+        Stream.map((_) => Schema.decodeResult(schema.listen)(_.data)),
         listenToDebugPing(label),
       )
 
@@ -186,10 +75,15 @@ export const messagePortChannel: <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
 
       port.start()
 
-      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))
       const supportsTransferables = true
 
-      yield* Effect.addFinalizer(() => Effect.try(() => port.close()).pipe(Effect.ignoreLogged))
+      yield* Effect.addFinalizer(() =>
+        Effect.try({
+          try: () => port.close(),
+          catch: (cause) => new Cause.UnknownError(cause),
+        }).pipe(Effect.ignore),
+      )
 
       return {
         [WebChannelSymbol]: WebChannelSymbol,
@@ -203,10 +97,7 @@ export const messagePortChannel: <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
     }).pipe(Effect.withSpan(`WebChannel:messagePortChannel`)),
   )
 
-const sameThreadChannels = GlobalValue.globalValue(
-  'livestore:sameThreadChannels',
-  () => new Map<string, PubSub.PubSub<any>>(),
-)
+const sameThreadChannels = new Map<string, PubSub.PubSub<any>>()
 
 export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>({
   schema: inputSchema,
@@ -219,20 +110,17 @@ export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
     Effect.gen(function* () {
       let pubSub = sameThreadChannels.get(channelName)
       if (pubSub === undefined) {
-        pubSub = yield* PubSub.unbounded<any>().pipe(Effect.acquireRelease(PubSub.shutdown))
+        pubSub = yield* Effect.acquireRelease(PubSub.unbounded<any>(), PubSub.shutdown)
         sameThreadChannels.set(channelName, pubSub)
       }
 
       const schema = mapSchema(inputSchema)
 
-      const send = (message: MsgSend) =>
-        Effect.gen(function* () {
-          yield* PubSub.publish(pubSub, message)
-        })
+      const send = (message: MsgSend) => PubSub.publish(pubSub, message)
 
-      const listen = Stream.fromPubSub(pubSub).pipe(Stream.map(Either.right), listenToDebugPing(channelName))
+      const listen = Stream.fromPubSub(pubSub).pipe(Stream.map(Result.succeed), listenToDebugPing(channelName))
 
-      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 {
         [WebChannelSymbol]: WebChannelSymbol,
@@ -249,7 +137,7 @@ export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
 export const messagePortChannelWithAck: <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(args: {
   port: MessagePort
   schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
-  debugId?: string | number
+  debugId?: string | number | undefined
 }) => Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> = ({ port, schema: inputSchema, debugId }) =>
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
@@ -262,12 +150,12 @@ export const messagePortChannelWithAck: <MsgListen, MsgSend, MsgListenEncoded, M
 
       const ChannelRequest = Schema.TaggedStruct('ChannelRequest', {
         id: Schema.String,
-        payload: Schema.Union(schema.listen, schema.send),
-      }).annotations({ title: 'webmesh.ChannelRequest' })
+        payload: Schema.Union([schema.listen, schema.send]),
+      }).annotate({ title: 'webmesh.ChannelRequest' })
       const ChannelRequestAck = Schema.TaggedStruct('ChannelRequestAck', {
         reqId: Schema.String,
-      }).annotations({ title: 'webmesh.ChannelRequestAck' })
-      const ChannelMessage = Schema.Union(ChannelRequest, ChannelRequestAck).annotations({
+      }).annotate({ title: 'webmesh.ChannelRequestAck' })
+      const ChannelMessage = Schema.Union([ChannelRequest, ChannelRequestAck]).annotate({
         title: 'webmesh.ChannelMessage',
       })
 
@@ -278,6 +166,15 @@ export const messagePortChannelWithAck: <MsgListen, MsgSend, MsgListenEncoded, M
         id: debugId,
       }
 
+      // The ack channel sends protocol messages during setup. Buffer MessagePort events eagerly so
+      // the initial ping/pong cannot race a lazily-started `listen` stream under Effect v4.
+      const messageQueue = yield* Effect.acquireRelease(Queue.unbounded<MessageDataEvent>(), Queue.shutdown)
+      const handler = (event: MessageDataEvent) => {
+        Queue.offerUnsafe(messageQueue, event)
+      }
+      port.addEventListener('message', handler)
+      yield* Effect.addFinalizer(() => Effect.sync(() => port.removeEventListener('message', handler)))
+
       const send = (message: any) =>
         Effect.gen(function* () {
           debugInfo.sendTotal++
@@ -295,48 +192,56 @@ export const messagePortChannelWithAck: <MsgListen, MsgSend, MsgListenEncoded, M
 
           port.postMessage(messageEncoded, transferables)
 
-          yield* ack
+          yield* Deferred.await(ack)
 
           requestAckMap.delete(id)
 
           debugInfo.sendPending--
         })
 
-      // TODO re-implement this via `port.onmessage`
-      // https://github.com/livestorejs/livestore/issues/262
-      const listen = Stream.fromEventListener<MessageEvent>(port, 'message').pipe(
+      const listen = Stream.fromQueue(messageQueue).pipe(
         // Stream.onStart(Effect.log(`${label}:listen:start`)),
         // Stream.tap((_) => Effect.log(`${label}:message`, _.data)),
-        Stream.map((_) => Schema.decodeEither(ChannelMessage)(_.data)),
+        Stream.map((_) => Schema.decodeResult(ChannelMessage)(_.data)),
         Stream.tap((msg) =>
           Effect.gen(function* () {
-            if (msg._tag === 'Right') {
-              if (msg.right._tag === 'ChannelRequestAck') {
-                yield* Deferred.succeed(requestAckMap.get(msg.right.reqId)!, void 0)
-              } else if (msg.right._tag === 'ChannelRequest') {
+            if (Result.isSuccess(msg) === true) {
+              if (msg.success._tag === 'ChannelRequestAck') {
+                yield* Deferred.succeed(requestAckMap.get(msg.success.reqId)!, void 0)
+              } else if (msg.success._tag === 'ChannelRequest') {
                 debugInfo.listenTotal++
-                port.postMessage(Schema.encodeSync(ChannelMessage)({ _tag: 'ChannelRequestAck', reqId: msg.right.id }))
+                port.postMessage(
+                  yield* Schema.encodeEffect(ChannelMessage)({ _tag: 'ChannelRequestAck', reqId: msg.success.id }).pipe(
+                    Effect.orDie,
+                  ),
+                )
               }
             }
           }),
         ),
-        Stream.filterMap((msg) =>
-          msg._tag === 'Left'
-            ? Option.some(msg as any)
-            : msg.right._tag === 'ChannelRequest'
-              ? Option.some(Either.right(msg.right.payload))
-              : Option.none(),
+        Stream.filterMap(
+          Filter.fromPredicateOption((msg) =>
+            Result.isFailure(msg) === true
+              ? Option.some(msg as Result.Result<any, any>)
+              : msg.success._tag === 'ChannelRequest'
+                ? Option.some(Result.succeed(msg.success.payload) as Result.Result<any, any>)
+                : Option.none(),
+          ),
         ),
-        (_) => _ as Stream.Stream<Either.Either<any, any>>,
         listenToDebugPing(label),
       )
 
       port.start()
 
-      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))
       const supportsTransferables = true
 
-      yield* Effect.addFinalizer(() => Effect.try(() => port.close()).pipe(Effect.ignoreLogged))
+      yield* Effect.addFinalizer(() =>
+        Effect.try({
+          try: () => port.close(),
+          catch: (cause) => new Cause.UnknownError(cause),
+        }).pipe(Effect.ignore),
+      )
 
       return {
         [WebChannelSymbol]: WebChannelSymbol,
@@ -351,6 +256,9 @@ export const messagePortChannelWithAck: <MsgListen, MsgSend, MsgListenEncoded, M
     }).pipe(Effect.withSpan(`WebChannel:messagePortChannelWithAck`)),
   )
 
+/** DOM and Node worker_threads expose incompatible MessageEvent globals; the channel only needs payload data. */
+type MessageDataEvent = Event & { readonly data: any }
+
 export type QueueChannelProxy<MsgListen, MsgSend> = {
   /** Only meant to be used externally */
   webChannel: WebChannel<MsgListen, MsgSend>
@@ -374,19 +282,19 @@ export const queueChannelProxy = <MsgListen, MsgSend>({
   schema: inputSchema,
 }: {
   schema:
-    | Schema.Schema<MsgListen | MsgSend, any>
-    | { listen: Schema.Schema<MsgListen, any>; send: Schema.Schema<MsgSend, any> }
+    | Schema.Codec<MsgListen | MsgSend, any>
+    | { listen: Schema.Codec<MsgListen, any>; send: Schema.Codec<MsgSend, any> }
 }): Effect.Effect<QueueChannelProxy<MsgListen, MsgSend>, never, Scope.Scope> =>
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
-      const sendQueue = yield* Queue.unbounded<MsgSend>().pipe(Effect.acquireRelease(Queue.shutdown))
-      const listenQueue = yield* Queue.unbounded<MsgListen>().pipe(Effect.acquireRelease(Queue.shutdown))
+      const sendQueue = yield* Effect.acquireRelease(Queue.unbounded<MsgSend>(), Queue.shutdown)
+      const listenQueue = yield* Effect.acquireRelease(Queue.unbounded<MsgListen>(), Queue.shutdown)
 
       const send = (message: MsgSend) => Queue.offer(sendQueue, message)
 
-      const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Either.right), listenToDebugPing('queueChannel'))
+      const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Result.succeed), listenToDebugPing('queueChannel'))
 
-      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))
       const supportsTransferables = true
 
       const schema = mapSchema(inputSchema)
@@ -408,21 +316,26 @@ export const queueChannelProxy = <MsgListen, MsgSend>({
 /**
  * Eagerly starts listening to a channel by buffering incoming messages in a queue.
  */
-export const toOpenChannel = (
-  channel: WebChannel<any, any>,
+export const toOpenChannel = <MsgListen, MsgSend>(
+  channel: WebChannel<MsgListen, MsgSend>,
   options?: {
     /**
      * Sends a heartbeat message to the other end of the channel every `interval`.
      * If the other end doesn't respond within `timeout` milliseconds, the channel is shutdown.
      */
     heartbeat?: {
-      interval: DurationInput
-      timeout: DurationInput
+      interval: Duration.Input
+      timeout: Duration.Input
     }
   },
-): Effect.Effect<WebChannel<any, any>, never, Scope.Scope> =>
+): Effect.Effect<WebChannel<MsgListen, MsgSend>, never, Scope.Scope> =>
   Effect.gen(function* () {
-    const queue = yield* Queue.unbounded<Either.Either<any, any>>().pipe(Effect.acquireRelease(Queue.shutdown))
+    const queue = yield* Effect.acquireRelease(Queue.unbounded<Result.Result<MsgListen, any>>(), Queue.shutdown)
+
+    const heartbeatChannel = channel as WebChannel<
+      MsgListen | typeof WebChannelHeartbeat.Type,
+      MsgSend | typeof WebChannelHeartbeat.Type
+    >
 
     const pendingPingDeferredRef = {
       current: undefined as { deferred: Deferred.Deferred<void>; requestId: string } | undefined,
@@ -430,16 +343,16 @@ export const toOpenChannel = (
 
     yield* channel.listen.pipe(
       // TODO implement this on the "chunk" level for better performance
-      options?.heartbeat
+      options?.heartbeat !== undefined
         ? Stream.filterEffect(
             Effect.fn(function* (msg) {
-              if (msg._tag === 'Right' && Schema.is(WebChannelHeartbeat)(msg.right)) {
-                if (msg.right._tag === 'WebChannel.Ping') {
-                  yield* channel.send(WebChannelPong.make({ requestId: msg.right.requestId }))
+              if (Result.isSuccess(msg) === true && Schema.is(WebChannelHeartbeat)(msg.success) === true) {
+                if (msg.success._tag === 'WebChannel.Ping') {
+                  yield* heartbeatChannel.send(WebChannelPong.make({ requestId: msg.success.requestId }))
                 } else {
                   const { deferred, requestId } = pendingPingDeferredRef.current ?? shouldNeverHappen('No pending ping')
-                  if (requestId !== msg.right.requestId) {
-                    shouldNeverHappen('Received pong for unexpected requestId', requestId, msg.right.requestId)
+                  if (requestId !== msg.success.requestId) {
+                    shouldNeverHappen('Received pong for unexpected requestId', requestId, msg.success.requestId)
                   }
                   yield* Deferred.succeed(deferred, void 0)
                 }
@@ -450,23 +363,23 @@ export const toOpenChannel = (
             }),
           )
         : identity,
-      Stream.tapChunk((chunk) => Queue.offerAll(queue, chunk)),
+      Stream.tapArray((array) => Queue.offerAll(queue, array)),
       Stream.runDrain,
       Effect.forkScoped,
     )
 
-    if (options?.heartbeat) {
+    if (options?.heartbeat !== undefined) {
       const { interval, timeout } = options.heartbeat
       yield* Effect.gen(function* () {
         while (true) {
           yield* Effect.sleep(interval)
           const requestId = crypto.randomUUID()
-          yield* channel.send(WebChannelPing.make({ requestId }))
+          yield* heartbeatChannel.send(WebChannelPing.make({ requestId }))
           const deferred = yield* Deferred.make<void>()
           pendingPingDeferredRef.current = { deferred, requestId }
-          yield* deferred.pipe(
+          yield* Deferred.await(deferred).pipe(
             Effect.timeout(timeout),
-            Effect.catchTag('TimeoutException', () => channel.shutdown),
+            Effect.catchTag('TimeoutError', () => channel.shutdown),
           )
         }
       }).pipe(Effect.withSpan(`WebChannel:heartbeat`), Effect.forkScoped)
@@ -475,7 +388,7 @@ export const toOpenChannel = (
     // We're currently limiting the chunk size to 1 to not drop messages in scearnios where
     // the listen stream get subscribed to, only take N messages and then unsubscribe.
     // Without this limit, messages would be dropped.
-    const listen = Stream.fromQueue(queue, { maxChunkSize: 1 })
+    const listen = Stream.fromQueue(queue).pipe(Stream.rechunk(1))
 
     return {
       [WebChannelSymbol]: WebChannelSymbol,
@@ -492,7 +405,4 @@ export const toOpenChannel = (
     }
   })
 
-export const sendDebugPing = (channel: WebChannel<any, any>) =>
-  Effect.gen(function* () {
-    yield* channel.send(DebugPingMessage.make({ message: 'ping' }))
-  })
+export const sendDebugPing = (channel: WebChannel<any, any>) => channel.send(DebugPingMessage.make({ message: 'ping' }))

package/src/effect/WebChannel/broadcastChannelWithAck.ts

@@ -1,6 +1,7 @@
-import { Deferred, Exit, Predicate, Queue, Schema, Scope, Stream } from 'effect'
+import { Deferred, Exit, Filter, Latch, Predicate, Queue, Scope, Stream } from 'effect'
 
 import * as Effect from '../Effect.ts'
+import * as Schema from '../Schema/index.ts'
 import type { InputSchema, WebChannel } from './common.ts'
 import { listenToDebugPing, mapSchema, WebChannelSymbol } from './common.ts'
 
@@ -23,7 +24,7 @@ const PayloadMessage = Schema.TaggedStruct('PayloadMessage', {
   payload: Schema.Any,
 })
 
-const Message = Schema.Union(ConnectMessage, ConnectAckMessage, DisconnectMessage, PayloadMessage)
+const Message = Schema.Union([ConnectMessage, ConnectAckMessage, DisconnectMessage, PayloadMessage])
 
 /**
  * Same as `broadcastChannel`, but with a queue in between to guarantee message delivery and meant
@@ -39,28 +40,35 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
   Effect.scopeWithCloseable((scope) =>
     Effect.gen(function* () {
       const channel = new BroadcastChannel(channelName)
-      const messageQueue = yield* Queue.unbounded<MsgSend>()
+      // BroadcastChannel messages are dropped unless a listener is already registered. Effect v4
+      // makes stream startup ordering explicit, so buffer events from channel construction time.
+      const messageQueue = yield* Effect.acquireRelease(Queue.unbounded<MessageDataEvent>(), Queue.shutdown)
       const connectionId = crypto.randomUUID()
       const schema = mapSchema(inputSchema)
 
       const peerIdRef = { current: undefined as undefined | string }
-      const connectedLatch = yield* Effect.makeLatch(false)
+      const connectedLatch = yield* Latch.make(false)
       const supportsTransferables = false
 
       const postMessage = (msg: typeof Message.Type) => channel.postMessage(Schema.encodeSync(Message)(msg))
 
+      const handler = (event: MessageDataEvent) => {
+        Queue.offerUnsafe(messageQueue, event)
+      }
+      channel.addEventListener('message', handler)
+      yield* Effect.addFinalizer(() => Effect.sync(() => channel.removeEventListener('message', handler)))
+
       const send = (message: MsgSend) =>
         Effect.gen(function* () {
           yield* connectedLatch.await
 
-          const payload = yield* Schema.encode(schema.send)(message)
+          const payload = yield* Schema.encodeEffect(schema.send)(message)
           postMessage(PayloadMessage.make({ from: connectionId, to: peerIdRef.current!, payload }))
         })
 
-      const listen = Stream.fromEventListener<MessageEvent>(channel, 'message').pipe(
+      const listen = Stream.fromQueue(messageQueue).pipe(
         Stream.map(({ data }) => data),
-        Stream.map(Schema.decodeOption(Message)),
-        Stream.filterMap((_) => _),
+        Stream.filterMap(Filter.fromPredicateOption(Schema.decodeUnknownOption(Message))),
         Stream.mapEffect((data) =>
           Effect.gen(function* () {
             switch (data._tag) {
@@ -69,7 +77,7 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
                 peerIdRef.current = data.from
                 postMessage(ConnectAckMessage.make({ from: connectionId, to: data.from }))
                 yield* connectedLatch.open
-                break
+                return undefined
               }
               // Case: other side sends connect-ack message (because otherside was already online when this side connected)
               case 'ConnectAckMessage': {
@@ -77,7 +85,7 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
                   peerIdRef.current = data.from
                   yield* connectedLatch.open
                 }
-                break
+                return undefined
               }
               case 'DisconnectMessage': {
                 if (data.from === peerIdRef.current) {
@@ -85,13 +93,13 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
                   yield* connectedLatch.close
                   yield* establishConnection
                 }
-                break
+                return undefined
               }
               case 'PayloadMessage': {
                 if (data.to === connectionId) {
-                  return Schema.decodeEither(schema.listen)(data.payload)
+                  return Schema.decodeResult(schema.listen)(data.payload)
                 }
-                break
+                return undefined
               }
             }
           }),
@@ -110,11 +118,10 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
         Effect.gen(function* () {
           postMessage(DisconnectMessage.make({ from: connectionId }))
           channel.close()
-          yield* Queue.shutdown(messageQueue)
         }),
       )
 
-      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 {
         [WebChannelSymbol]: WebChannelSymbol,
@@ -127,3 +134,6 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
       }
     }).pipe(Effect.withSpan(`WebChannel:broadcastChannelWithAck(${channelName})`)),
   )
+
+/** DOM and Node worker_threads expose incompatible MessageEvent globals; the channel only needs payload data. */
+type MessageDataEvent = Event & { readonly data: any }