@livestore/utils 0.4.0 → 0.5.0-dev.0

package/src/effect/WebChannel/WebChannel.test.ts

@@ -1,12 +1,12 @@
 import * as Vitest from '@effect/vitest'
-import { Effect, Schema, Stream } from 'effect'
+import { Effect, Fiber, Schema, Stream } from 'effect'
 import { JSDOM } from 'jsdom'
 
 import * as WebChannel from '../../browser/WebChannelBrowser.ts'
 
 Vitest.describe('WebChannel', () => {
   Vitest.describe('windowChannel', () => {
-    Vitest.scopedLive('should work with 2 windows', () =>
+    Vitest.live('should work with 2 windows', () =>
       Effect.gen(function* () {
         const windowA = new JSDOM().window as unknown as globalThis.Window
         const windowB = new JSDOM().window as unknown as globalThis.Window
@@ -16,19 +16,19 @@ Vitest.describe('WebChannel', () => {
             listenWindow: windowA,
             sendWindow: windowB,
             ids: { own: 'a', other: 'b' },
-            schema: Schema.Number,
+            schema: Schema.Finite,
           })
 
           const msgFromBFiber = yield* channelToB.listen.pipe(
-            Stream.flatten(),
             Stream.runHead,
-            Effect.flatten,
-            Effect.fork,
+            Effect.flatMap(Effect.fromOption),
+            Effect.flatMap(Effect.fromResult),
+            Effect.forkChild,
           )
 
           yield* channelToB.send(1)
 
-          Vitest.expect(yield* msgFromBFiber).toEqual(2)
+          Vitest.expect(yield* Fiber.join(msgFromBFiber)).toEqual(2)
         })
 
         const codeSideB = Effect.gen(function* () {
@@ -36,26 +36,26 @@ Vitest.describe('WebChannel', () => {
             listenWindow: windowB,
             sendWindow: windowA,
             ids: { own: 'b', other: 'a' },
-            schema: Schema.Number,
+            schema: Schema.Finite,
           })
 
           const msgFromAFiber = yield* channelToA.listen.pipe(
-            Stream.flatten(),
             Stream.runHead,
-            Effect.flatten,
-            Effect.fork,
+            Effect.flatMap(Effect.fromOption),
+            Effect.flatMap(Effect.fromResult),
+            Effect.forkChild,
           )
 
           yield* channelToA.send(2)
 
-          Vitest.expect(yield* msgFromAFiber).toEqual(1)
+          Vitest.expect(yield* Fiber.join(msgFromAFiber)).toEqual(1)
         })
 
         yield* Effect.all([codeSideA, codeSideB], { concurrency: 'unbounded' })
       }),
     )
 
-    Vitest.scopedLive('should work with the same window', () =>
+    Vitest.live('should work with the same window', () =>
       Effect.gen(function* () {
         const window = new JSDOM().window as unknown as globalThis.Window
 
@@ -64,19 +64,19 @@ Vitest.describe('WebChannel', () => {
             listenWindow: window,
             sendWindow: window,
             ids: { own: 'a', other: 'b' },
-            schema: Schema.Number,
+            schema: Schema.Finite,
           })
 
           const msgFromBFiber = yield* channelToB.listen.pipe(
-            Stream.flatten(),
             Stream.runHead,
-            Effect.flatten,
-            Effect.fork,
+            Effect.flatMap(Effect.fromOption),
+            Effect.flatMap(Effect.fromResult),
+            Effect.forkChild,
           )
 
           yield* channelToB.send(1)
 
-          Vitest.expect(yield* msgFromBFiber).toEqual(2)
+          Vitest.expect(yield* Fiber.join(msgFromBFiber)).toEqual(2)
         })
 
         const codeSideB = Effect.gen(function* () {
@@ -84,19 +84,19 @@ Vitest.describe('WebChannel', () => {
             listenWindow: window,
             sendWindow: window,
             ids: { own: 'b', other: 'a' },
-            schema: Schema.Number,
+            schema: Schema.Finite,
           })
 
           const msgFromAFiber = yield* channelToA.listen.pipe(
-            Stream.flatten(),
             Stream.runHead,
-            Effect.flatten,
-            Effect.fork,
+            Effect.flatMap(Effect.fromOption),
+            Effect.flatMap(Effect.fromResult),
+            Effect.forkChild,
           )
 
           yield* channelToA.send(2)
 
-          Vitest.expect(yield* msgFromAFiber).toEqual(1)
+          Vitest.expect(yield* Fiber.join(msgFromAFiber)).toEqual(1)
         })
 
         yield* Effect.all([codeSideA, codeSideB], { concurrency: 'unbounded' })

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,
@@ -49,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),
       )
 
@@ -65,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,
@@ -82,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,
@@ -98,7 +110,7 @@ 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)
       }
 
@@ -106,9 +118,9 @@ export const sameThreadChannel = <MsgListen, MsgSend, MsgListenEncoded, MsgSendE
 
       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,
@@ -138,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',
       })
 
@@ -154,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++
@@ -171,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(yield* Schema.encode(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,
@@ -227,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>
@@ -250,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)
@@ -292,13 +324,13 @@ export const toOpenChannel = <MsgListen, MsgSend>(
      * 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<MsgListen, MsgSend>, never, Scope.Scope> =>
   Effect.gen(function* () {
-    const queue = yield* Queue.unbounded<Either.Either<MsgListen, 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,
@@ -314,13 +346,13 @@ export const toOpenChannel = <MsgListen, MsgSend>(
       options?.heartbeat !== undefined
         ? Stream.filterEffect(
             Effect.fn(function* (msg) {
-              if (msg._tag === 'Right' && Schema.is(WebChannelHeartbeat)(msg.right) === true) {
-                if (msg.right._tag === 'WebChannel.Ping') {
-                  yield* heartbeatChannel.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)
                 }
@@ -331,7 +363,7 @@ export const toOpenChannel = <MsgListen, MsgSend>(
             }),
           )
         : identity,
-      Stream.tapChunk((chunk) => Queue.offerAll(queue, chunk)),
+      Stream.tapArray((array) => Queue.offerAll(queue, array)),
       Stream.runDrain,
       Effect.forkScoped,
     )
@@ -345,9 +377,9 @@ export const toOpenChannel = <MsgListen, MsgSend>(
           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)
@@ -356,7 +388,7 @@ export const toOpenChannel = <MsgListen, MsgSend>(
     // 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,

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) {
@@ -89,7 +97,7 @@ export const broadcastChannelWithAck = <MsgListen, MsgSend, MsgListenEncoded, Ms
               }
               case 'PayloadMessage': {
                 if (data.to === connectionId) {
-                  return Schema.decodeEither(schema.listen)(data.payload)
+                  return Schema.decodeResult(schema.listen)(data.payload)
                 }
                 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 }

package/src/effect/WebChannel/common.ts

@@ -1,5 +1,4 @@
-import type { Deferred, Either, ParseResult } from 'effect'
-import { Effect, Predicate, Schema, Stream } from 'effect'
+import { type Deferred, Effect, Predicate, Result, Schema, Stream } from 'effect'
 
 export const WebChannelSymbol = Symbol('WebChannel')
 export type WebChannelSymbol = typeof WebChannelSymbol
@@ -9,12 +8,12 @@ export const isWebChannel = <MsgListen, MsgSend>(value: unknown): value is WebCh
 
 export interface WebChannel<MsgListen, MsgSend, E = never> {
   readonly [WebChannelSymbol]: unknown
-  send: (a: MsgSend) => Effect.Effect<void, ParseResult.ParseError | E>
-  listen: Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>, E>
+  send: (a: MsgSend) => Effect.Effect<void, Schema.SchemaError | E>
+  listen: Stream.Stream<Result.Result<MsgListen, Schema.SchemaError>, E>
   supportsTransferables: boolean
   closedDeferred: Deferred.Deferred<void>
   shutdown: Effect.Effect<void>
-  schema: { listen: Schema.Schema<MsgListen, any>; send: Schema.Schema<MsgSend, any> }
+  schema: { listen: Schema.Codec<MsgListen, any>; send: Schema.Codec<MsgSend, any> }
   debugInfo?: Record<string, any> | undefined
 }
 
@@ -31,24 +30,24 @@ export const WebChannelPong = Schema.TaggedStruct('WebChannel.Pong', {
   requestId: Schema.String,
 })
 
-export const WebChannelHeartbeat = Schema.Union(WebChannelPing, WebChannelPong)
+export const WebChannelHeartbeat = Schema.Union([WebChannelPing, WebChannelPong])
 
 type WebChannelMessages = typeof DebugPingMessage.Type | typeof WebChannelPing.Type | typeof WebChannelPong.Type
 
 export const schemaWithWebChannelMessages = <MsgListen, MsgSend>(
   schema: OutputSchema<MsgListen, MsgSend, any, any>,
 ): OutputSchema<MsgListen | WebChannelMessages, MsgSend | WebChannelMessages, any, any> => ({
-  send: Schema.Union(schema.send, DebugPingMessage, WebChannelPing, WebChannelPong),
-  listen: Schema.Union(schema.listen, DebugPingMessage, WebChannelPing, WebChannelPong),
+  send: Schema.Union([schema.send, DebugPingMessage, WebChannelPing, WebChannelPong]),
+  listen: Schema.Union([schema.listen, DebugPingMessage, WebChannelPing, WebChannelPong]),
 })
 
 export type InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> =
-  | Schema.Schema<MsgListen | MsgSend, MsgListenEncoded | MsgSendEncoded>
+  | Schema.Codec<MsgListen | MsgSend, MsgListenEncoded | MsgSendEncoded>
   | OutputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
 
 export type OutputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> = {
-  listen: Schema.Schema<MsgListen, MsgListenEncoded>
-  send: Schema.Schema<MsgSend, MsgSendEncoded>
+  listen: Schema.Codec<MsgListen, MsgListenEncoded>
+  send: Schema.Codec<MsgSend, MsgSendEncoded>
 }
 
 export const mapSchema = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(
@@ -61,13 +60,13 @@ export const mapSchema = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(
 export const listenToDebugPing =
   (channelName: string) =>
   <MsgListen>(
-    stream: Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>>,
-  ): Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>> =>
+    stream: Stream.Stream<Result.Result<MsgListen, Schema.SchemaError>>,
+  ): Stream.Stream<Result.Result<MsgListen, Schema.SchemaError>> =>
     stream.pipe(
       Stream.filterEffect(
         Effect.fn(function* (msg) {
-          if (msg._tag === 'Right' && Schema.is(DebugPingMessage)(msg.right) === true) {
-            yield* Effect.logDebug(`WebChannel:ping [${channelName}] ${msg.right.message}`, msg.right.payload)
+          if (Result.isSuccess(msg) === true && Schema.is(DebugPingMessage)(msg.success) === true) {
+            yield* Effect.logDebug(`WebChannel:ping [${channelName}] ${msg.success.message}`, msg.success.payload)
             return false
           }
           return true

package/src/effect/WebSocket.test.ts

@@ -1,11 +1,11 @@
-import { FetchHttpClient } from '@effect/platform'
 import * as Vitest from '@effect/vitest'
 import { Effect, Exit } from 'effect'
+import { FetchHttpClient } from 'effect/unstable/http'
 
 import { makeWebSocket } from './WebSocket.ts'
 
 Vitest.describe('WebSocket', () => {
-  Vitest.scopedLive(
+  Vitest.live(
     'should create a WebSocket connection',
     Effect.fn(function* () {
       const exit = yield* makeWebSocket({ url: 'ws://localhost:1000' }).pipe(Effect.timeout(500), Effect.exit)

package/src/effect/WebSocket.ts

@@ -1,10 +1,13 @@
-import { HttpClient } from '@effect/platform'
 import type { Schedule, Scope } from 'effect'
 import { Effect, Exit, identity, Schema } from 'effect'
+import { HttpClient } from 'effect/unstable/http'
 
-export class WebSocketError extends Schema.TaggedError<WebSocketError>('~@livestore/utils/WebSocketError')('WebSocketError', {
-  cause: Schema.Defect,
-}) {}
+export class WebSocketError extends Schema.TaggedError<WebSocketError>('~@livestore/utils/WebSocketError')(
+  'WebSocketError',
+  {
+    cause: Schema.Defect(),
+  },
+) {}
 
 // TODO refactor using Effect socket implementation
 // https://github.com/Effect-TS/effect/blob/main/packages%2Fexperimental%2Fsrc%2FDevTools%2FClient.ts#L113
@@ -25,7 +28,7 @@ export const makeWebSocket = ({
   Effect.gen(function* () {
     yield* validateUrl(url)
 
-    const socket = yield* Effect.async<globalThis.WebSocket, WebSocketError>((cb, signal) => {
+    const socket = yield* Effect.callback<globalThis.WebSocket, WebSocketError>((cb, signal) => {
       try {
         const socket = new globalThis.WebSocket(url)
 
@@ -63,7 +66,7 @@ export const makeWebSocket = ({
       }
     }).pipe(
       Effect.tapErrorTag('WebSocketError', () => tryLogWebsocketConnectError(url)),
-      reconnect !== undefined ? Effect.retry(reconnect) : identity,
+      reconnect !== undefined && reconnect !== false ? Effect.retry(reconnect) : identity,
     )
 
     /**

package/src/effect/mod.browser-build.test.ts

@@ -0,0 +1,19 @@
+import { build } from 'esbuild'
+import { expect, it } from 'vitest'
+
+it('bundles the Effect facade for browsers without Node builtins', async () => {
+  const result = await build({
+    bundle: true,
+    format: 'esm',
+    platform: 'browser',
+    stdin: {
+      contents: `import { Schema } from './mod.ts'; export const BrowserSchema = Schema.Struct({ value: Schema.String })`,
+      loader: 'ts',
+      resolveDir: import.meta.dirname,
+      sourcefile: 'browser-build-fixture.ts',
+    },
+    write: false,
+  })
+
+  expect(result.outputFiles).toHaveLength(1)
+})