@livestore/webmesh 0.4.0 → 0.5.0-dev.0

package/dist/worker/mod.js

@@ -0,0 +1,44 @@
+import { LS_DEV } from '@livestore/utils';
+import { Context, Deferred, Effect, Layer, Queue, Stream, WebChannel } from '@livestore/utils/effect';
+import * as WebmeshSchema from "../mesh-schema.js";
+import { makeMeshNode } from "../node.js";
+import * as WorkerSchema from "./schema.js";
+export * as Schema from "./schema.js";
+export class CacheService extends Context.Service()('@livestore/webmesh:worker:CacheService') {
+    static layer = ({ nodeName }) => Effect.gen(function* () {
+        const node = yield* makeMeshNode(nodeName);
+        globalThis.__debugWebmeshNode = node;
+        return CacheService.of({ node });
+    }).pipe(Layer.effect(CacheService));
+}
+export const CreateConnection = ({ from, port }) => Stream.callback((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, }) => Effect.gen(function* () {
+    const mc = new MessageChannel();
+    const isConnected = yield* Deferred.make();
+    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}`);
+    }
+});
+//# sourceMappingURL=mod.js.map

package/dist/worker/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../src/worker/mod.ts"],"names":[],"mappings":"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"}

package/dist/worker/schema.d.ts

@@ -0,0 +1,10 @@
+import { Schema, Transferable } from '@livestore/utils/effect';
+export declare const CreateConnection: Schema.TaggedStruct<"WebmeshWorker.CreateConnection", {
+    readonly from: Schema.String;
+    readonly port: Transferable.Transferable<Schema.declare<MessagePort, MessagePort>>;
+}>;
+export declare const Request: Schema.Union<readonly [Schema.TaggedStruct<"WebmeshWorker.CreateConnection", {
+    readonly from: Schema.String;
+    readonly port: Transferable.Transferable<Schema.declare<MessagePort, MessagePort>>;
+}>]>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/worker/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/worker/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE9D,eAAO,MAAM,gBAAgB;;;EAG3B,CAAA;AAEF,eAAO,MAAM,OAAO;;;IAAmC,CAAA"}

package/dist/worker/schema.js

@@ -0,0 +1,7 @@
+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]);
+//# sourceMappingURL=schema.js.map

package/dist/worker/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/worker/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE9D,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,YAAY,CAAC,gCAAgC,EAAE;IACpF,IAAI,EAAE,MAAM,CAAC,MAAM;IACnB,IAAI,EAAE,YAAY,CAAC,WAAW;CAC/B,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/webmesh",
-  "version": "0.4.0",
+  "version": "0.5.0-dev.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -14,57 +14,40 @@
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": "./dist/mod.js"
+    ".": "./dist/mod.js",
+    "./worker": "./dist/worker/mod.js"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@livestore/utils": "^0.4.0"
+    "@livestore/utils": "^0.5.0-dev.0"
   },
   "devDependencies": {
-    "@effect/ai": "0.35.0",
-    "@effect/cli": "0.75.1",
-    "@effect/cluster": "0.58.2",
-    "@effect/experimental": "0.60.0",
-    "@effect/opentelemetry": "0.63.0",
-    "@effect/platform": "0.96.1",
-    "@effect/platform-browser": "0.76.0",
-    "@effect/platform-bun": "0.89.0",
-    "@effect/platform-node": "0.106.0",
-    "@effect/printer": "0.49.0",
-    "@effect/printer-ansi": "0.49.0",
-    "@effect/rpc": "0.75.1",
-    "@effect/sql": "0.51.1",
-    "@effect/typeclass": "0.40.0",
-    "@effect/vitest": "0.29.0",
+    "@effect/opentelemetry": "4.0.0-rc.111",
+    "@effect/platform-browser": "4.0.0-rc.111",
+    "@effect/platform-bun": "4.0.0-rc.111",
+    "@effect/platform-node": "4.0.0-rc.111",
+    "@effect/platform-node-shared": "4.0.0-rc.111",
+    "@effect/vitest": "4.0.0-rc.111",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/resources": "2.2.0",
     "@standard-schema/spec": "1.1.0",
-    "effect": "3.21.2",
-    "vitest": "3.2.4",
-    "@livestore/utils-dev": "^0.4.0"
+    "effect": "4.0.0-rc.111",
+    "vitest": "4.1.9",
+    "@livestore/utils-dev": "^0.5.0-dev.0"
   },
   "peerDependencies": {
-    "@effect/ai": "^0.35.0",
-    "@effect/cli": "^0.75.1",
-    "@effect/cluster": "^0.58.2",
-    "@effect/experimental": "^0.60.0",
-    "@effect/opentelemetry": "^0.63.0",
-    "@effect/platform": "^0.96.1",
-    "@effect/platform-browser": "^0.76.0",
-    "@effect/platform-bun": "^0.89.0",
-    "@effect/platform-node": "^0.106.0",
-    "@effect/printer": "^0.49.0",
-    "@effect/printer-ansi": "^0.49.0",
-    "@effect/rpc": "^0.75.1",
-    "@effect/sql": "^0.51.1",
-    "@effect/typeclass": "^0.40.0",
-    "@effect/vitest": "^0.29.0",
+    "@effect/opentelemetry": "^4.0.0-rc.111",
+    "@effect/platform-browser": "^4.0.0-rc.111",
+    "@effect/platform-bun": "^4.0.0-rc.111",
+    "@effect/platform-node": "^4.0.0-rc.111",
+    "@effect/platform-node-shared": "^4.0.0-rc.111",
+    "@effect/vitest": "^4.0.0-rc.111",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/resources": "^2.2.0",
     "@standard-schema/spec": "^1.1.0",
-    "effect": "^3.21.2"
+    "effect": "^4.0.0-rc.111"
   },
   "$genie": {
     "source": "package.json.genie.ts",

package/src/channel/direct-channel-internal.ts

@@ -1,9 +1,10 @@
 import { casesHandled, shouldNeverHappen } from '@livestore/utils'
-import type { PubSub } from '@livestore/utils/effect'
 import {
+  type PubSub,
   Deferred,
   Effect,
   Exit,
+  Fiber,
   Predicate,
   Queue,
   Schema,
@@ -52,7 +53,7 @@ export const makeDirectChannelInternal = ({
 }: MakeDirectChannelArgs & {
   channelVersion: number
   /** We're passing in the closeable scope from the wrapping direct channel */
-  scope: Scope.CloseableScope
+  scope: Scope.Closeable
   sourceId: string
 }): Effect.Effect<
   WebChannel.WebChannel<any, any>,
@@ -89,8 +90,8 @@ export const makeDirectChannelInternal = ({
     const deferred = yield* makeDeferredResult()
 
     const schema = {
-      send: Schema.Union(schema_.send, MeshSchema.DirectChannelPing, MeshSchema.DirectChannelPong),
-      listen: Schema.Union(schema_.listen, MeshSchema.DirectChannelPing, MeshSchema.DirectChannelPong),
+      send: Schema.Union([schema_.send, MeshSchema.DirectChannelPing, MeshSchema.DirectChannelPong]),
+      listen: Schema.Union([schema_.listen, MeshSchema.DirectChannelPing, MeshSchema.DirectChannelPong]),
     }
 
     const channelStateRef: { current: ChannelState } = {
@@ -105,7 +106,9 @@ export const makeDirectChannelInternal = ({
           channelState: channelState._tag,
           packetId: packet.id,
           packetReqId: packet.reqId,
-          ...(Predicate.hasProperty('channelVersion')(packet) === true ? { packetChannelVersion: packet.channelVersion } : {}),
+          ...(Predicate.hasProperty('channelVersion')(packet) === true
+            ? { packetChannelVersion: packet.channelVersion }
+            : {}),
         })
 
         // const reqIdStr =
@@ -185,7 +188,9 @@ export const makeDirectChannelInternal = ({
                 remainingHops: packet.hops,
                 reqId: packet.id,
               })
-              yield* Effect.spanEvent(`Re-sending new request (${newRequestPacket.id}) for incoming request (${packet.id})`)
+              yield* Effect.spanEvent(
+                `Re-sending new request (${newRequestPacket.id}) for incoming request (${packet.id})`,
+              )
 
               yield* sendPacket(newRequestPacket)
             }
@@ -223,7 +228,7 @@ export const makeDirectChannelInternal = ({
 
               // Now we wait for the other side to respond via the channel
               yield* channel.listen.pipe(
-                Stream.flatten(),
+                Stream.mapEffect(Effect.fromResult),
                 Stream.filter(Schema.is(MeshSchema.DirectChannelPing)),
                 Stream.take(1),
                 Stream.runDrain,
@@ -258,11 +263,11 @@ export const makeDirectChannelInternal = ({
             }).pipe(Effect.andThen(WebChannel.toOpenChannel))
 
             const waitForPongFiber = yield* channel.listen.pipe(
-              Stream.flatten(),
+              Stream.mapEffect(Effect.fromResult),
               Stream.filter(Schema.is(MeshSchema.DirectChannelPong)),
               Stream.take(1),
               Stream.runDrain,
-              Effect.fork,
+              Effect.forkChild,
             )
 
             // There seems to be some scenario where the initial ping message is lost.
@@ -273,7 +278,7 @@ export const makeDirectChannelInternal = ({
               .send(MeshSchema.DirectChannelPing.make({}))
               .pipe(Effect.timeout(10), Effect.retry({ times: 2 }))
 
-            yield* waitForPongFiber
+            yield* Fiber.join(waitForPongFiber)
 
             yield* Effect.spanEvent(`loser side: established`)
             channelStateRef.current = { _tag: 'Established', otherSourceId: channelState.otherSourceId }
@@ -292,17 +297,6 @@ export const makeDirectChannelInternal = ({
         }),
       )
 
-    yield* Effect.gen(function* () {
-      while (true) {
-        const packet = yield* Queue.take(incomingPacketsQueue)
-        const res = yield* processMessagePacket(packet)
-        // We want to give requests another chance to be processed
-        if (res === 'close') {
-          return
-        }
-      }
-    }).pipe(Effect.interruptible, Effect.tapCauseLogPretty, Effect.forkScoped)
-
     const channelState = channelStateRef.current
 
     if (channelState._tag !== 'Initial') {
@@ -336,7 +330,21 @@ export const makeDirectChannelInternal = ({
 
     yield* edgeRequest
 
-    const channel = yield* deferred
+    // Start draining only after `edgeRequest` moved the channel to `RequestSent`. Under Effect v4
+    // an eagerly forked processor can otherwise handle an already-buffered packet while still
+    // `Initial`.
+    yield* Effect.gen(function* () {
+      while (true) {
+        const packet = yield* Queue.take(incomingPacketsQueue)
+        const res = yield* processMessagePacket(packet)
+        // We want to give requests another chance to be processed
+        if (res === 'close') {
+          return
+        }
+      }
+    }).pipe(Effect.interruptible, Effect.tapCauseLogPretty, Effect.forkScoped)
+
+    const channel = yield* Deferred.await(deferred)
 
     return channel
   }).pipe(Effect.withSpanScoped(`makeDirectChannel:${channelVersion}`))

package/src/channel/direct-channel.ts

@@ -2,14 +2,16 @@ import {
   Cause,
   Deferred,
   Effect,
-  Either,
+  Fiber,
+  Result,
   Exit,
   Option,
   Queue,
+  References,
   Schema,
   Scope,
   Stream,
-  TQueue,
+  TxQueue,
   WebChannel,
 } from '@livestore/utils/effect'
 import { nanoid } from '@livestore/utils/nanoid'
@@ -49,7 +51,7 @@ export const makeDirectChannel = ({
       const sourceId = nanoid()
 
       const listenQueue = yield* Queue.unbounded<any>()
-      const sendQueue = yield* TQueue.unbounded<[msg: any, deferred: Deferred.Deferred<void>]>()
+      const sendQueue = yield* TxQueue.unbounded<[msg: any, deferred: Deferred.Deferred<void>]>()
 
       const initialEdgeDeferred = yield* Deferred.make<void>()
 
@@ -66,7 +68,7 @@ export const makeDirectChannel = ({
         const resultDeferred = yield* Deferred.make<{
           channel: WebChannel.WebChannel<any, any>
           channelVersion: number
-          makeDirectChannelScope: Scope.CloseableScope
+          makeDirectChannelScope: Scope.Closeable
         }>()
 
         while (true) {
@@ -99,7 +101,7 @@ export const makeDirectChannel = ({
             Stream.take(1),
             Stream.runDrain,
             Effect.as('new-edge' as const),
-            Effect.fork,
+            Effect.forkChild,
           )
 
           const makeChannel = makeDirectChannelInternal({
@@ -115,29 +117,30 @@ export const makeDirectChannel = ({
             sendPacket,
             scope: makeDirectChannelScope,
           }).pipe(
-            Scope.extend(makeDirectChannelScope),
+            Scope.provide(makeDirectChannelScope),
             Effect.forkIn(makeDirectChannelScope),
-            // Given we only call `Effect.exit` later when joining the fiber,
+            // Given we only await the exit later when observing the fiber,
             // we don't want Effect to produce a "unhandled error" log message
-            Effect.withUnhandledErrorLogLevel(Option.none()),
+            Effect.provideService(References.UnhandledLogLevel, undefined),
           )
 
-          const raceResult = yield* Effect.raceFirst(makeChannel, waitForNewEdgeFiber.pipe(Effect.disconnect))
+          const raceResult = yield* Effect.raceFirst(makeChannel, Fiber.join(waitForNewEdgeFiber))
 
           if (raceResult === 'new-edge') {
             yield* Scope.close(makeDirectChannelScope, Exit.fail('new-edge'))
             // We'll try again
           } else {
-            const channelExit = yield* raceResult.pipe(Effect.exit)
+            const channelExit = yield* Fiber.await(raceResult)
             if (channelExit._tag === 'Failure') {
               yield* Scope.close(makeDirectChannelScope, channelExit)
 
               if (
-                Cause.isFailType(channelExit.cause) === true &&
-                Schema.is(WebmeshSchema.DirectChannelResponseNoTransferables)(channelExit.cause.error) === true
+                Option.exists(Cause.findErrorOption(channelExit.cause), (error) =>
+                  Schema.is(WebmeshSchema.DirectChannelResponseNoTransferables)(error),
+                ) === true
               ) {
                 // Only retry when there is a new edge available
-                yield* waitForNewEdgeFiber.pipe(Effect.exit)
+                yield* Effect.exit(Fiber.join(waitForNewEdgeFiber))
               }
             } else {
               const channel = channelExit.value
@@ -149,7 +152,7 @@ export const makeDirectChannel = ({
         }
 
         // Now we wait until the first channel is established
-        const { channel, makeDirectChannelScope, channelVersion } = yield* resultDeferred
+        const { channel, makeDirectChannelScope, channelVersion } = yield* Deferred.await(resultDeferred)
 
         yield* Effect.spanEvent(`Connected#${channelVersion}`)
         debugInfo.isConnected = true
@@ -159,9 +162,9 @@ export const makeDirectChannel = ({
 
         // We'll now forward all incoming messages to the listen queue
         yield* channel.listen.pipe(
-          Stream.flatten(),
+          Stream.mapEffect(Effect.fromResult),
           // Stream.tap((msg) => Effect.log(`${target}→${channelName}→${nodeName}:message:${msg.message}`)),
-          Stream.tapChunk((chunk) => Queue.offerAll(listenQueue, chunk)),
+          Stream.tapArray((array) => Queue.offerAll(listenQueue, array)),
           Stream.runDrain,
           Effect.tapCauseLogPretty,
           Effect.forkIn(makeDirectChannelScope),
@@ -169,18 +172,18 @@ export const makeDirectChannel = ({
 
         yield* Effect.gen(function* () {
           while (true) {
-            const [msg, deferred] = yield* TQueue.peek(sendQueue)
+            const [msg, deferred] = yield* TxQueue.peek(sendQueue)
             // NOTE we don't need an explicit retry flow here since in case of the channel being closed,
             // the send will never succeed. Meanwhile the send-loop fiber will be interrupted and
             // given we only peeked at the queue, the message to send is still there.
             yield* channel.send(msg)
             yield* Deferred.succeed(deferred, void 0)
-            yield* TQueue.take(sendQueue) // Remove the message from the queue
+            yield* TxQueue.take(sendQueue) // Remove the message from the queue
           }
         }).pipe(Effect.forkIn(makeDirectChannelScope))
 
         // Wait until the channel is closed and then try to reconnect
-        yield* channel.closedDeferred
+        yield* Deferred.await(channel.closedDeferred)
 
         yield* Scope.close(makeDirectChannelScope, Exit.succeed('channel-closed'))
 
@@ -204,16 +207,16 @@ export const makeDirectChannel = ({
           debugInfo.pendingSends++
           debugInfo.totalSends++
 
-          yield* TQueue.offer(sendQueue, [message, sentDeferred])
+          yield* TxQueue.offer(sendQueue, [message, sentDeferred])
 
-          yield* sentDeferred
+          yield* Deferred.await(sentDeferred)
 
           debugInfo.pendingSends--
         }).pipe(Effect.scoped, Effect.withParentSpan(parentSpan))
 
-      const listen = Stream.fromQueue(listenQueue, { maxChunkSize: 1 }).pipe(Stream.map(Either.right))
+      const listen = Stream.fromQueue(listenQueue).pipe(Stream.rechunk(1), Stream.map(Result.succeed))
 
-      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 webChannel = {
         [WebChannel.WebChannelSymbol]: WebChannel.WebChannelSymbol,

package/src/channel/proxy-channel.ts

@@ -1,9 +1,9 @@
 import { casesHandled, shouldNeverHappen } from '@livestore/utils'
-import type { PubSub } from '@livestore/utils/effect'
 import {
+  type PubSub,
   Deferred,
   Effect,
-  Either,
+  Result,
   Exit,
   Fiber,
   FiberHandle,
@@ -39,11 +39,11 @@ export const ProxyChannelSimulationParams = Schema.Struct({
    */
   onPayload: Schema.Struct({
     /** Delay before sending the ACK response (simulates slow ACK send) */
-    beforeAckSend: Schema.Int.pipe(Schema.between(0, 500)),
+    beforeAckSend: Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 500 })),
     /** Delay after forking the ACK send, before adding message to listen queue */
-    afterAckFork: Schema.Int.pipe(Schema.between(0, 500)),
+    afterAckFork: Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 500 })),
     /** Delay after adding message to listen queue */
-    afterListenQueueOffer: Schema.Int.pipe(Schema.between(0, 500)),
+    afterListenQueueOffer: Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 500 })),
   }),
 })
 
@@ -66,8 +66,8 @@ interface MakeProxyChannelArgs {
   channelName: ChannelName
   target: MeshNodeName
   schema: {
-    send: Schema.Schema<any, any>
-    listen: Schema.Schema<any, any>
+    send: Schema.Codec<any, any>
+    listen: Schema.Codec<any, any>
   }
   /** Optional simulation parameters for testing timing-sensitive behavior */
   simulation?: ProxyChannelSimulationParams
@@ -105,7 +105,7 @@ export const makeProxyChannel = ({
 
       type ProxiedChannelStateEstablished = {
         _tag: 'Established'
-        listenSchema: Schema.Schema<any, any>
+        listenSchema: Schema.Codec<any, any>
         listenQueue: Queue.Queue<any>
         ackMap: Map<string, Deferred.Deferred<void>>
         combinedChannelId: string
@@ -131,6 +131,10 @@ export const makeProxyChannel = ({
       const channelSpan = yield* Effect.currentSpan.pipe(Effect.orDie)
 
       const connectedStateRef = yield* SubscriptionRef.make<ProxiedChannelStateEstablished | false>(false)
+      // Incoming packets can be processed as soon as the queue-draining fiber starts, so state
+      // referenced by established channels must exist before that processor is forked.
+      const listenQueue = yield* Queue.unbounded<any>()
+      const ackMap = new Map<string, Deferred.Deferred<void>>()
 
       const waitForEstablished = Effect.gen(function* () {
         const state = yield* SubscriptionRef.waitUntil(connectedStateRef, (state) => state !== false)
@@ -162,8 +166,9 @@ export const makeProxyChannel = ({
       const getCombinedChannelId = (otherSideChannelIdCandidate: string) =>
         [channelIdCandidate, otherSideChannelIdCandidate].toSorted().join('_')
 
-      const earlyPayloadBuffer = yield* Queue.unbounded<typeof MeshSchema.ProxyChannelPayload.Type>().pipe(
-        Effect.acquireRelease(Queue.shutdown),
+      const earlyPayloadBuffer = yield* Effect.acquireRelease(
+        Queue.unbounded<typeof MeshSchema.ProxyChannelPayload.Type>(),
+        Queue.shutdown,
       )
 
       const processProxyPacket = ({ packet, respondToSender }: ProxyQueueItem) =>
@@ -267,7 +272,7 @@ export const makeProxyChannel = ({
               const establishedState = channelStateRef.current
               if (establishedState._tag === 'Established') {
                 //
-                const bufferedPackets = yield* Queue.takeAll(earlyPayloadBuffer)
+                const bufferedPackets = yield* Queue.clear(earlyPayloadBuffer)
                 // yield* Effect.logDebug(
                 //   `[${nodeName}] Draining early payload buffer (${bufferedPackets.length}) after ResponseSuccess`,
                 // )
@@ -278,10 +283,10 @@ export const makeProxyChannel = ({
                     )
                     continue
                   }
-                  const decodedMessage = yield* Schema.decodeUnknown(establishedState.listenSchema)(
+                  const decodedMessage = yield* Schema.decodeUnknownEffect(establishedState.listenSchema)(
                     bufferedPacket.payload,
                   )
-                  yield* establishedState.listenQueue.pipe(Queue.offer(decodedMessage))
+                  yield* Queue.offer(establishedState.listenQueue, decodedMessage)
                 }
               } else {
                 yield* Effect.logError(
@@ -327,8 +332,8 @@ export const makeProxyChannel = ({
               yield* simSleep('onPayload', 'afterAckFork')
 
               if (channelState._tag === 'Established') {
-                const decodedMessage = yield* Schema.decodeUnknown(channelState.listenSchema)(packet.payload)
-                yield* channelState.listenQueue.pipe(Queue.offer(decodedMessage))
+                const decodedMessage = yield* Schema.decodeUnknownEffect(channelState.listenSchema)(packet.payload)
+                yield* Queue.offer(channelState.listenQueue, decodedMessage)
 
                 // Simulation point: delay after adding to listen queue
                 yield* simSleep('onPayload', 'afterListenQueueOffer')
@@ -370,19 +375,8 @@ export const makeProxyChannel = ({
           }),
         )
 
-      yield* Stream.fromQueue(queue).pipe(
-        Stream.tap(processProxyPacket),
-        Stream.runDrain,
-        Effect.tapCauseLogPretty,
-        Effect.forkScoped,
-      )
-
-      const listenQueue = yield* Queue.unbounded<any>()
-
       yield* Effect.spanEvent(`Connecting`)
 
-      const ackMap = new Map<string, Deferred.Deferred<void>>()
-
       // check if already established via incoming `ProxyChannelRequest` from other side
       // which indicates we already have a edge to the target node
       // const channelState = channelStateRef.current
@@ -401,6 +395,15 @@ export const makeProxyChannel = ({
           Effect.forkScoped,
         )
 
+        // Drain queued proxy packets only after the local side entered `Pending` and sent its
+        // request. Otherwise an already-buffered response can race initialization.
+        yield* Stream.fromQueue(queue).pipe(
+          Stream.tap(processProxyPacket),
+          Stream.runDrain,
+          Effect.tapCauseLogPretty,
+          Effect.forkScoped,
+        )
+
         const { combinedChannelId: channelId } = yield* waitForEstablished
 
         yield* Fiber.interrupt(retryOnNewEdgeFiber)
@@ -410,7 +413,7 @@ export const makeProxyChannel = ({
 
       const send = (message: any) =>
         Effect.gen(function* () {
-          const payload = yield* Schema.encodeUnknown(schema.send)(message)
+          const payload = yield* Schema.encodeUnknownEffect(schema.send)(message)
           const sendFiberHandle = yield* FiberHandle.make<void, never>()
 
           const sentDeferred = yield* Deferred.make<void>()
@@ -441,7 +444,7 @@ export const makeProxyChannel = ({
 
               yield* sendPacket(packet)
 
-              yield* ack
+              yield* Deferred.await(ack)
               yield* Deferred.succeed(sentDeferred, void 0)
 
               debugInfo.pendingSends--
@@ -450,18 +453,18 @@ export const makeProxyChannel = ({
             // TODO make this configurable
             // Schedule.exponential(10): 10, 20, 40, 80, 160, 320, ...
             yield* innerSend.pipe(Effect.timeout(100), Effect.retry(Schedule.exponential(10)), Effect.orDie)
-          }).pipe(Effect.tapErrorCause(Effect.logError))
+          }).pipe(Effect.tapCause(Effect.logError))
 
-          const rerunOnNewChannelFiber = yield* connectedStateRef.changes.pipe(
+          const rerunOnNewChannelFiber = yield* SubscriptionRef.changes(connectedStateRef).pipe(
             Stream.filter((_) => _ === false),
             Stream.tap(() => FiberHandle.run(sendFiberHandle, trySend)),
             Stream.runDrain,
-            Effect.fork,
+            Effect.forkChild,
           )
 
           yield* FiberHandle.run(sendFiberHandle, trySend)
 
-          yield* sentDeferred
+          yield* Deferred.await(sentDeferred)
 
           yield* Fiber.interrupt(rerunOnNewChannelFiber)
         }).pipe(
@@ -470,11 +473,11 @@ export const makeProxyChannel = ({
           Effect.withParentSpan(channelSpan),
         )
 
-      const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Either.right))
+      const listen = Stream.fromQueue(listenQueue).pipe(Stream.map(Result.succeed))
 
-      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 runtime = yield* Effect.runtime()
+      const services = yield* Effect.context()
 
       const webChannel = {
         [WebChannel.WebChannelSymbol]: WebChannel.WebChannelSymbol,
@@ -489,7 +492,7 @@ export const makeProxyChannel = ({
           debug: {
             ping: (message = 'ping') =>
               send(WebChannel.DebugPingMessage.make({ message })).pipe(
-                Effect.provide(runtime),
+                Effect.provide(services),
                 Effect.tapCauseLogPretty,
                 Effect.runFork,
               ),