@livestore/webmesh 0.4.0 → 0.5.0-dev.0

package/src/node.ts

@@ -6,7 +6,6 @@ import {
   Effect,
   Exit,
   Fiber,
-  Option,
   PubSub,
   Queue,
   Schema,
@@ -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,7 +106,7 @@ 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.
      *
@@ -129,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>
 }
 
@@ -137,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<
@@ -163,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>>>()
@@ -364,10 +362,10 @@ 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)
 
@@ -387,8 +385,9 @@ export const makeMeshNode = <TName extends MeshNodeName>(
                     const channelKey = `target:${packet.source}, channelName:${packet.channelName}` satisfies ChannelKey
 
                     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 })
                     }
@@ -462,7 +461,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
     const removeEdge: MeshNode['removeEdge'] = (targetNodeName) =>
       Effect.gen(function* () {
         if (edgeChannels.has(targetNodeName) === false) {
-          return yield* new Cause.NoSuchElementException(`No edge found for ${targetNodeName}`)
+          return yield* new Cause.NoSuchElementError(`No edge found for ${targetNodeName}`)
         }
 
         yield* Fiber.interrupt(edgeChannels.get(targetNodeName)!.listenFiber)
@@ -502,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 })
         }
@@ -513,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.
@@ -541,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 {
@@ -605,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,
@@ -624,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,
@@ -644,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: () => {
@@ -670,7 +670,7 @@ export const makeMeshNode = <TName extends MeshNodeName>(
             '    ',
             value.debugInfo?.channel,
             '\n',
-            indent(`Queue: ${value.queue.unsafeSize().pipe(Option.getOrUndefined)}`, 4),
+            indent(`Queue: ${Queue.sizeUnsafe(value.queue)}`, 4),
             value.queue,
           )
         }
@@ -699,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* () {
@@ -722,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

@@ -7,24 +7,24 @@
 import { expect } from 'vitest'
 
 import { Vitest } from '@livestore/utils-dev/node-vitest'
-import { Effect, Either, Schema, WebChannel } from '@livestore/utils/effect'
+import { Effect, Result, Schema, WebChannel } from '@livestore/utils/effect'
 
 import * as MeshSchema from './mesh-schema.ts'
-import { MessageMsgPack, WSEdgeInit, WSEdgePayload } from './websocket-edge.ts'
+import { MessageMsgpack, WSEdgeInit, WSEdgePayload } from './websocket-edge.ts'
 
 Vitest.describe('websocket-edge', () => {
   /**
-   * Test that WSEdgeInit messages can be encoded/decoded via MessageMsgPack.
+   * Test that WSEdgeInit messages can be encoded/decoded via MessageMsgpack.
    */
-  Vitest.scopedLive('should encode/decode WSEdgeInit', (test) =>
+  Vitest.live('should encode/decode WSEdgeInit', (test) =>
     Effect.gen(function* () {
       const initMessage = WSEdgeInit.make({ from: 'test-node' })
 
       // Encode to msgpack
-      const encoded = yield* Schema.encode(MessageMsgPack)(initMessage)
+      const encoded = yield* Schema.encodeEffect(MessageMsgpack)(initMessage)
 
       // Decode back
-      const decoded = yield* Schema.decode(MessageMsgPack)(encoded)
+      const decoded = yield* Schema.decodeEffect(MessageMsgpack)(encoded)
 
       expect(decoded._tag).toBe('WSEdgeInit')
       if (decoded._tag === 'WSEdgeInit') {
@@ -36,7 +36,7 @@ Vitest.describe('websocket-edge', () => {
   /**
    * Test that WSEdgePayload messages with valid Packet payloads work correctly.
    */
-  Vitest.scopedLive('should encode/decode WSEdgePayload with Packet', (test) =>
+  Vitest.live('should encode/decode WSEdgePayload with Packet', (test) =>
     Effect.gen(function* () {
       const packet = {
         _tag: 'NetworkEdgeAdded' as const,
@@ -47,10 +47,10 @@ Vitest.describe('websocket-edge', () => {
       const wsMessage = WSEdgePayload.make({ from: 'test-node', payload: packet })
 
       // Encode to msgpack
-      const encoded = yield* Schema.encode(MessageMsgPack)(wsMessage)
+      const encoded = yield* Schema.encodeEffect(MessageMsgpack)(wsMessage)
 
       // Decode back
-      const decoded = yield* Schema.decode(MessageMsgPack)(encoded)
+      const decoded = yield* Schema.decodeEffect(MessageMsgpack)(encoded)
 
       expect(decoded._tag).toBe('WSEdgePayload')
       if (decoded._tag === 'WSEdgePayload') {
@@ -64,23 +64,23 @@ Vitest.describe('websocket-edge', () => {
    * Test that mapSchema(Packet) includes WebChannel internal messages.
    * This is important because channels can send/receive WebChannel.Ping/Pong/DebugPing.
    */
-  Vitest.scopedLive('mapSchema should include WebChannel messages in schema', (test) =>
+  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.decodeUnknownEither(schema.listen)(pingPayload)
+      const result = Schema.decodeUnknownResult(schema.listen)(pingPayload)
 
       // mapSchema adds WebChannel messages to the schema
-      expect(Either.isRight(result)).toBe(true)
+      expect(Result.isSuccess(result)).toBe(true)
     }).pipe(Vitest.withTestCtx(test)),
   )
 
   /**
    * Test that valid webmesh packets can be decoded.
    */
-  Vitest.scopedLive('should decode valid webmesh packets', (test) =>
+  Vitest.live('should decode valid webmesh packets', (test) =>
     Effect.gen(function* () {
       const schema = WebChannel.mapSchema(MeshSchema.Packet)
 
@@ -91,7 +91,7 @@ Vitest.describe('websocket-edge', () => {
         target: 'node-b',
       }
 
-      const result = yield* Schema.decodeUnknown(schema.listen)(packet)
+      const result = yield* Schema.decodeUnknownEffect(schema.listen)(packet)
       expect(result._tag).toBe('NetworkEdgeAdded')
     }).pipe(Vitest.withTestCtx(test)),
   )

package/src/websocket-edge.ts

@@ -1,11 +1,13 @@
-import type { HttpClient } from '@livestore/utils/effect'
 import {
+  type HttpClient,
   Deferred,
+  Duration,
   Effect,
-  Either,
+  Result,
   Exit,
+  Latch,
   Layer,
-  MsgPack,
+  Msgpack,
   Queue,
   Schedule,
   Schema,
@@ -18,18 +20,18 @@ import {
 import * as WebmeshSchema from './mesh-schema.ts'
 import type { MeshNode } from './node.ts'
 
-export class WSEdgeInit extends Schema.TaggedStruct('WSEdgeInit', {
+export const WSEdgeInit = Schema.TaggedStruct('WSEdgeInit', {
   from: Schema.String,
-}) {}
+})
 
-export class WSEdgePayload extends Schema.TaggedStruct('WSEdgePayload', {
+export const WSEdgePayload = Schema.TaggedStruct('WSEdgePayload', {
   from: Schema.String,
   payload: Schema.Any,
-}) {}
+})
 
-export class WSEdgeMessage extends Schema.Union(WSEdgeInit, WSEdgePayload) {}
+export const WSEdgeMessage = Schema.Union([WSEdgeInit, WSEdgePayload])
 
-export const MessageMsgPack = MsgPack.schema(WSEdgeMessage)
+export const MessageMsgpack = Msgpack.schema(WSEdgeMessage)
 
 export type SocketType =
   | {
@@ -58,11 +60,12 @@ export const connectViaWebSocket = ({
       debug: { id: `node:${node.nodeName}` },
     })
 
-    yield* node
-      .addEdge({ target: 'ws', edgeChannel: edgeChannel.webChannel, replaceIfExists: true })
-      .pipe(Effect.acquireRelease(() => node.removeEdge('ws').pipe(Effect.orDie)))
+    yield* Effect.acquireRelease(
+      node.addEdge({ target: 'ws', edgeChannel: edgeChannel.webChannel, replaceIfExists: true }),
+      () => node.removeEdge('ws').pipe(Effect.orDie),
+    )
 
-    yield* edgeChannel.webChannel.closedDeferred
+    yield* Deferred.await(edgeChannel.webChannel.closedDeferred)
   }).pipe(Effect.scoped, Effect.forever, Effect.interruptible, Effect.provide(binaryWebSocketConstructorLayer))
 
 const binaryWebSocketConstructorLayer = Layer.succeed(Socket.WebSocketConstructor, (url, protocols) => {
@@ -91,46 +94,49 @@ export const makeWebSocketEdge = ({
     Effect.gen(function* () {
       const fromDeferred = yield* Deferred.make<string>()
 
-      const listenQueue = yield* Queue.unbounded<typeof WebmeshSchema.Packet.Type>().pipe(
-        Effect.acquireRelease(Queue.shutdown),
+      const listenQueue = yield* Effect.acquireRelease(
+        Queue.unbounded<typeof WebmeshSchema.Packet.Type>(),
+        Queue.shutdown,
       )
 
       const schema = WebChannel.mapSchema(WebmeshSchema.Packet)
 
-      const isConnectedLatch = yield* Effect.makeLatch(true)
+      const isConnectedLatch = yield* Latch.make(true)
 
-      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 retryOpenTimeoutSchedule = Schedule.union(Schedule.exponential(100), Schedule.spaced(5000)).pipe(
-        Schedule.whileInput((_: Socket.SocketError) => _.reason === 'OpenTimeout' || _.reason === 'Open'),
+      const retryOpenErrorSchedule = Schedule.exponential(100).pipe(
+        Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.min(duration, Duration.millis(5000)))),
+        Schedule.setInputType<Socket.SocketError>(),
+        Schedule.while(({ input }) => input.reason._tag === 'SocketOpenError'),
       )
 
       const sendToSocket = yield* socket.writer
 
       yield* Stream.never.pipe(
         Stream.pipeThroughChannel(Socket.toChannel(socket)),
-        Stream.catchTag(
-          'SocketError',
-          Effect.fnUntraced(function* (error) {
-            // In the case of the socket being closed, we're interrupting the stream
-            // and close the WebChannel (which can be observed from the outside)
-            if (error.reason === 'Close') {
-              yield* Deferred.succeed(closedDeferred, undefined)
-              yield* isConnectedLatch.close
-              return yield* Effect.interrupt
-            } else {
-              return yield* error
-            }
-          }),
-        ),
-        Stream.retry(retryOpenTimeoutSchedule),
+        Stream.catchTag('SocketError', (error) => {
+          // In the case of the socket being closed, close the WebChannel
+          // which can be observed from the outside.
+          if (error.reason._tag === 'SocketCloseError') {
+            return Stream.fromEffectDrain(
+              Effect.gen(function* () {
+                yield* Deferred.succeed(closedDeferred, undefined)
+                yield* isConnectedLatch.close
+              }),
+            )
+          }
+
+          return Stream.fail(error)
+        }),
+        Stream.retry(retryOpenErrorSchedule),
         Stream.tap(
           Effect.fn(function* (bytes) {
-            const msg = yield* Schema.decode(MessageMsgPack)(new Uint8Array(bytes))
+            const msg = yield* Schema.decodeEffect(MessageMsgpack)(new Uint8Array(bytes))
             if (msg._tag === 'WSEdgeInit') {
               yield* Deferred.succeed(fromDeferred, msg.from)
             } else {
-              const decodedPayload = yield* Schema.decode(schema.listen)(msg.payload)
+              const decodedPayload = yield* Schema.decodeEffect(schema.listen)(msg.payload)
               yield* Queue.offer(listenQueue, decodedPayload)
             }
           }),
@@ -149,13 +155,13 @@ export const makeWebSocketEdge = ({
       )
 
       const initHandshake = (from: string) =>
-        sendToSocket(Schema.encodeSync(MessageMsgPack)({ _tag: 'WSEdgeInit', from }))
+        sendToSocket(Schema.encodeSync(MessageMsgpack)({ _tag: 'WSEdgeInit', from }))
 
       if (socketType._tag === 'leaf') {
         yield* initHandshake(socketType.from)
       }
 
-      const deferredResult = yield* fromDeferred
+      const deferredResult = yield* Deferred.await(fromDeferred)
       const from = socketType._tag === 'leaf' ? socketType.from : deferredResult
 
       if (socketType._tag === 'relay') {
@@ -165,12 +171,12 @@ export const makeWebSocketEdge = ({
       const send = (message: typeof WebmeshSchema.Packet.Type) =>
         Effect.gen(function* () {
           yield* isConnectedLatch.await
-          const payload = yield* Schema.encode(schema.send)(message)
-          yield* sendToSocket(yield* Schema.encode(MessageMsgPack)({ _tag: 'WSEdgePayload', payload, from }))
+          const payload = yield* Schema.encodeEffect(schema.send)(message)
+          yield* sendToSocket(yield* Schema.encodeEffect(MessageMsgpack)({ _tag: 'WSEdgePayload', payload, from }))
         }).pipe(Effect.orDie)
 
       const listen = Stream.fromQueue(listenQueue).pipe(
-        Stream.map(Either.right),
+        Stream.map(Result.succeed),
         WebChannel.listenToDebugPing('websocket-edge'),
       )
 

package/src/worker/mod.ts

@@ -0,0 +1,89 @@
+import { LS_DEV } from '@livestore/utils'
+import { Context, Deferred, Effect, Layer, Queue, Stream, WebChannel } from '@livestore/utils/effect'
+
+import * as WebmeshSchema from '../mesh-schema.ts'
+import type { MeshNode } from '../node.ts'
+import { makeMeshNode } from '../node.ts'
+import * as WorkerSchema from './schema.ts'
+
+export * as Schema from './schema.ts'
+
+declare global {
+  var __debugWebmeshNode: any
+}
+
+export class CacheService extends Context.Service<CacheService, { node: MeshNode }>()(
+  '@livestore/webmesh:worker:CacheService',
+) {
+  static layer = ({ nodeName }: { nodeName: string }) =>
+    Effect.gen(function* () {
+      const node = yield* makeMeshNode(nodeName)
+
+      globalThis.__debugWebmeshNode = node
+
+      return CacheService.of({ node })
+    }).pipe(Layer.effect(CacheService))
+}
+
+export const CreateConnection = ({ from, port }: typeof WorkerSchema.CreateConnection.Type) =>
+  Stream.callback<{}, never, CacheService>((emit) =>
+    Effect.gen(function* () {
+      const { node } = yield* CacheService
+
+      const messagePortChannel = yield* WebChannel.messagePortChannel({ port, schema: WebmeshSchema.Packet })
+
+      yield* node.addEdge({ target: from, edgeChannel: messagePortChannel, replaceIfExists: true })
+
+      if (LS_DEV === true) {
+        yield* Effect.logDebug(`@livestore/webmesh:worker: accepted edge: ${node.nodeName} <- ${from}`)
+      }
+
+      // `Stream.callback` exposes a queue-like emitter in Effect v4. Emit the single success value
+      // and then end the stream to preserve the old one-response worker command behavior.
+      yield* Queue.offer(emit, {})
+      yield* Queue.end(emit)
+
+      yield* Effect.spanEvent({ connectedTo: [...node.edgeKeys] })
+    }).pipe(Effect.orDie),
+  ).pipe(Stream.withSpan(`@livestore/webmesh:worker:create-connection:${from}`))
+
+export const connectViaWorker = ({
+  node,
+  target,
+  worker,
+}: {
+  node: MeshNode
+  target: string
+  // Effect v4 removed the serialized worker pool type this package used to reference. Webmesh only
+  // needs this structural `execute` contract; adapter code can provide any compatible pool.
+  worker: { execute: (request: typeof WorkerSchema.Request.Type) => Stream.Stream<{}> }
+}) =>
+  Effect.gen(function* () {
+    const mc = new MessageChannel()
+
+    const isConnected = yield* Deferred.make<boolean>()
+
+    if (LS_DEV === true) {
+      yield* Effect.addFinalizerLog(`@livestore/webmesh:worker: closing message channel ${node.nodeName} -> ${target}`)
+    }
+
+    yield* worker.execute(WorkerSchema.CreateConnection.make({ from: node.nodeName, port: mc.port1 })).pipe(
+      Stream.tap(() => Deferred.succeed(isConnected, true)),
+      Stream.runDrain,
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
+    )
+
+    yield* Deferred.await(isConnected)
+
+    const workerConnection = yield* WebChannel.messagePortChannel({
+      port: mc.port2,
+      schema: WebmeshSchema.Packet,
+    })
+
+    yield* node.addEdge({ target, edgeChannel: workerConnection, replaceIfExists: true })
+
+    if (LS_DEV === true) {
+      yield* Effect.logDebug(`@livestore/webmesh:worker: initiated connection: ${node.nodeName} -> ${target}`)
+    }
+  })

package/src/worker/schema.ts

@@ -0,0 +1,8 @@
+import { Schema, Transferable } from '@livestore/utils/effect'
+
+export const CreateConnection = Schema.TaggedStruct('WebmeshWorker.CreateConnection', {
+  from: Schema.String,
+  port: Transferable.MessagePort,
+})
+
+export const Request = Schema.Union([CreateConnection])