liminal 0.17.1 → 0.17.2

package/Client.ts

@@ -1,4 +1,3 @@
-import { Socket, Worker } from "@effect/platform"
 import {
   Context,
   Encoding,
@@ -9,6 +8,7 @@ import {
   PubSub,
   RcRef,
   Record,
+  pipe,
   Ref,
   Scope,
   Stream,
@@ -16,19 +16,30 @@ import {
   Schema as S,
   Array,
   Struct,
+  Fiber,
+  Exit,
+  Cause,
+  Result,
+  flow,
+  identity,
 } from "effect"
+import { Socket } from "effect/unstable/socket"
+import { Worker } from "effect/unstable/workers"
 
-import type { FieldsRecord } from "./_types.ts"
-import { type ClientError, AuditionError, ConnectionError } from "./errors.ts"
-import { type F, type FError, UnresolvedError } from "./F.ts"
 import type { MethodDefinition } from "./Method.ts"
+
+import * as Diagnostic from "./_util/Diagnostic.ts"
+import { type ClientError, AuditionError, ConnectionError, type FError, UnresolvedError } from "./errors.ts"
+import { type F } from "./F.ts"
 import * as Protocol from "./Protocol.ts"
 
+const { debug, span } = Diagnostic.module("Client")
+
 export const TypeId = "~liminal/Client" as const
 
 export interface ClientDefinition<
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
+  EventDefinitions extends Record<string, S.Struct.Fields>,
 > {
   readonly methods: MethodDefinitions
 
@@ -47,83 +58,39 @@ interface EventTake<A, E> {
   readonly take: Take.Take<A, E>
 }
 
-export interface TransportSession<
+export interface Session<
   ClientSelf,
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
+  EventDefinitions extends Record<string, S.Struct.Fields>,
 > {
-  readonly events: Stream.Stream<FieldsRecord.TaggedMember.Type<EventDefinitions>, ClientError>
+  readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<EventDefinitions>>["Type"], ClientError>
 
   readonly f: F<ClientSelf, MethodDefinitions>
 
-  readonly endEvents: Effect.Effect<void>
+  readonly end: Effect.Effect<void>
 }
 
 export type Service<
   ClientSelf,
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
-> = RcRef.RcRef<TransportSession<ClientSelf, MethodDefinitions, EventDefinitions>, ClientError>
-
-export interface Spec<
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
-> {
-  Call: {
-    Payload: Protocol.Call.Payload.Type<MethodDefinitions>
-    Success: Protocol.Call.Success.Type<MethodDefinitions>
-    Failure: Protocol.Call.Failure.Type<MethodDefinitions>
-  }
-  Event: FieldsRecord.TaggedMember.Type<EventDefinitions>
-  Actor: Protocol.Actor.Type<MethodDefinitions, EventDefinitions>
-}
-
-export interface ClientSchema<
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
-> {
-  readonly call: {
-    readonly payload: S.Schema<
-      Protocol.Call.Payload.Type<MethodDefinitions>,
-      Protocol.Call.Payload.Encoded<MethodDefinitions>
-    >
-
-    readonly success: S.Schema<
-      Protocol.Call.Success.Type<MethodDefinitions>,
-      Protocol.Call.Success.Encoded<MethodDefinitions>
-    >
-
-    readonly failure: S.Schema<
-      Protocol.Call.Failure.Type<MethodDefinitions>,
-      Protocol.Call.Failure.Encoded<MethodDefinitions>
-    >
-  }
-
-  readonly event: S.Schema<Protocol.Event.Type<EventDefinitions>, Protocol.Event.Encoded<EventDefinitions>>
-
-  readonly actor: S.Schema<
-    Protocol.Actor.Type<MethodDefinitions, EventDefinitions>,
-    Protocol.Actor.Encoded<MethodDefinitions, EventDefinitions>
-  >
-}
+  EventDefinitions extends Record<string, S.Struct.Fields>,
+> = RcRef.RcRef<Session<ClientSelf, MethodDefinitions, EventDefinitions>, ClientError>
 
 export interface Client<
   ClientSelf,
   ClientId extends string,
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
-> extends Context.Tag<ClientSelf, Service<ClientSelf, MethodDefinitions, EventDefinitions>> {
-  new (_: never): Context.TagClassShape<ClientId, Service<ClientSelf, MethodDefinitions, EventDefinitions>>
+  EventDefinitions extends Record<string, S.Struct.Fields>,
+> extends Context.Service<ClientSelf, Service<ClientSelf, MethodDefinitions, EventDefinitions>> {
+  new (_: never): Context.ServiceClass.Shape<ClientId, Service<ClientSelf, MethodDefinitions, EventDefinitions>>
 
   readonly [TypeId]: typeof TypeId
 
   readonly definition: ClientDefinition<MethodDefinitions, EventDefinitions>
 
-  readonly schema: ClientSchema<MethodDefinitions, EventDefinitions>
-
-  readonly events: Stream.Stream<FieldsRecord.TaggedMember.Type<EventDefinitions>, ClientError, ClientSelf>
+  readonly schema: Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>
 
-  readonly endEvents: Effect.Effect<void, never, ClientSelf>
+  readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<EventDefinitions>>["Type"], ClientError, ClientSelf>
 
   readonly f: F<ClientSelf, MethodDefinitions>
 
@@ -135,72 +102,28 @@ export const Service =
   <
     ClientId extends string,
     MethodDefinitions extends Record<string, MethodDefinition.Any>,
-    EventDefinitions extends FieldsRecord,
+    EventDefinitions extends Record<string, S.Struct.Fields>,
   >(
     id: ClientId,
     definition: ClientDefinition<MethodDefinitions, EventDefinitions>,
   ): Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions> => {
-    const tag = Context.Tag(id)<ClientSelf, Service<ClientSelf, MethodDefinitions, EventDefinitions>>()
-
-    const call: ClientSchema<MethodDefinitions, EventDefinitions>["call"] = {
-      payload: S.TaggedStruct("Call.Payload", {
-        id: S.Int,
-        payload: S.Union(
-          ...Record.toEntries(definition.methods).map(([_tag, { payload }]) =>
-            S.TaggedStruct(_tag, { value: S.Struct(payload) }),
-          ),
-        ),
-      }) as never,
-      success: S.TaggedStruct("Call.Success", {
-        id: S.Int,
-        value: S.Union(
-          ...Record.toEntries(definition.methods).map(([_tag, { success: value }]) => S.TaggedStruct(_tag, { value })),
-        ),
-      }) as never,
-      failure: S.TaggedStruct("Call.Failure", {
-        id: S.Int,
-        cause: S.Union(
-          ...Record.toEntries(definition.methods).map(([_tag, { failure: value }]) => S.TaggedStruct(_tag, { value })),
-        ),
-      }) as never,
-    }
-
-    const event: S.Schema<
-      Protocol.Event.Type<EventDefinitions>,
-      Protocol.Event.Encoded<EventDefinitions>
-    > = S.TaggedStruct("Event", {
-      event: S.Union(...Object.entries(definition.events).map(([_tag, fields]) => S.TaggedStruct(_tag, fields))),
-    }) as never
-
-    const actor: S.Schema<
-      Protocol.Actor.Type<MethodDefinitions, EventDefinitions>,
-      Protocol.Actor.Encoded<MethodDefinitions, EventDefinitions>
-    > = S.Union(
-      call.success,
-      call.failure,
-      event,
-      Protocol.Audition.Success,
-      Protocol.Audition.Failure,
-      Protocol.Disconnect,
-    )
+    const tag = Context.Service<ClientSelf, Service<ClientSelf, MethodDefinitions, EventDefinitions>>()(id)
 
-    const events: Stream.Stream<FieldsRecord.TaggedMember.Type<EventDefinitions>, ClientError, ClientSelf> = tag.pipe(
-      Effect.flatMap(RcRef.get),
-      Effect.map(Struct.get("events")),
-      Stream.unwrapScoped,
-    )
+    const events = tag.asEffect().pipe(Effect.flatMap(RcRef.get), Effect.map(Struct.get("events")), Stream.unwrap)
 
     const f: F<ClientSelf, MethodDefinitions> = (_tag) =>
       Effect.fnUntraced(function* (value) {
-        const { f } = yield* tag.pipe(Effect.flatMap(RcRef.get))
+        const { f } = yield* tag.asEffect().pipe(Effect.flatMap(RcRef.get))
         return yield* f(_tag)(value)
       }, Effect.scoped)
 
-    const invalidate = tag.pipe(Effect.flatMap(RcRef.invalidate))
-
-    const endEvents = tag.pipe(
-      Effect.flatMap(RcRef.get),
-      Effect.flatMap(({ endEvents }) => endEvents),
+    const invalidate = tag.asEffect().pipe(
+      Effect.flatMap((rc) =>
+        RcRef.get(rc).pipe(
+          Effect.flatMap(({ end }) => end),
+          Effect.andThen(RcRef.invalidate(rc)),
+        ),
+      ),
       Effect.scoped,
       Effect.ignore,
     )
@@ -208,9 +131,8 @@ export const Service =
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
-      schema: { call, event, actor },
+      schema: Protocol.ProtocolSchemas(definition.methods, definition.events),
       events,
-      endEvents,
       f,
       invalidate,
     })
@@ -218,22 +140,34 @@ export const Service =
 
 export interface Transport<
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
+  EventDefinitions extends Record<string, S.Struct.Fields>,
 > {
   readonly listen: (
     publish: (
-      message: Protocol.Actor.Type<MethodDefinitions, EventDefinitions> | typeof Protocol.TransportFailure.Type,
-    ) => Effect.Effect<void, never>,
-  ) => Effect.Effect<void, never, Scope.Scope>
+      message:
+        | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["actor"]["Type"]
+        | typeof Protocol.TransportFailure.Type,
+    ) => Effect.Effect<void, ClientError>,
+  ) => Effect.Effect<
+    void,
+    ClientError,
+    Scope.Scope | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["actor"]["DecodingServices"]
+  >
 
-  readonly send: (v: Protocol.Call.Payload.Type<MethodDefinitions>) => Effect.Effect<void, ConnectionError, never>
+  readonly send: (
+    message: Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["Type"],
+  ) => Effect.Effect<
+    void,
+    ConnectionError,
+    Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]
+  >
 }
 
 const make = <
   ClientSelf,
   ClientId extends string,
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
+  EventDefinitions extends Record<string, S.Struct.Fields>,
   R,
 >(
   client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>,
@@ -241,33 +175,33 @@ const make = <
   replay?: ReplayConfig | undefined,
 ) =>
   Effect.gen(function* () {
-    type _ = Spec<MethodDefinitions, EventDefinitions>
-
-    const rcr: RcRef.RcRef<
-      TransportSession<ClientSelf, MethodDefinitions, EventDefinitions>,
-      ClientError
-    > = yield* RcRef.make({
+    const rcr: RcRef.RcRef<Session<ClientSelf, MethodDefinitions, EventDefinitions>, ClientError> = yield* RcRef.make({
       acquire: Effect.gen(function* () {
+        type _ = typeof client.schema
+        type Event = ReturnType<typeof S.TaggedUnion<EventDefinitions>>["Type"]
+
+        yield* debug("AcquisitionStarted")
+
         const { listen, send } = yield* build
 
-        const audition = yield* Deferred.make<void, AuditionError>()
-        const inflights: Record<string, Deferred.Deferred<_["Call"]["Success"], FError<MethodDefinitions>>> = {}
+        const audition = yield* Deferred.make<void>()
+
+        const inflights: Record<string, Deferred.Deferred<_["f"]["success"]["Type"], FError<MethodDefinitions>>> = {}
         let callId = 0
         let takeCount = 0
-        let finalError: ClientError | UnresolvedError | undefined
-        const pubsub = yield* PubSub.unbounded<EventTake<_["Event"], ClientError>>()
+        const pubsub = yield* PubSub.unbounded<EventTake<Event, ClientError>>()
 
         const replayState = yield* Ref.make<{
           readonly startupOpen: boolean
-          readonly buffer: ReadonlyArray<EventTake<_["Event"], ClientError>>
+          readonly buffer: ReadonlyArray<EventTake<Event, ClientError>>
         }>({
           startupOpen: true,
           buffer: [],
         })
 
-        const publishTake = (take: Take.Take<_["Event"], ClientError>, replayable?: boolean | undefined) =>
+        const publishTake = (take: Take.Take<Event, ClientError>, replayable?: boolean | undefined) =>
           Effect.gen(function* () {
-            const eventTake: EventTake<_["Event"], ClientError> = {
+            const eventTake: EventTake<Event, ClientError> = {
               seq: takeCount++,
               take,
             }
@@ -287,10 +221,82 @@ const make = <
             yield* PubSub.publish(pubsub, eventTake)
           })
 
-        const events: Stream.Stream<_["Event"], ClientError> = Effect.gen(function* () {
+        const outer = yield* Scope.Scope
+        const scope = yield* Scope.fork(outer, "sequential")
+        const end = Scope.close(scope, Exit.void)
+
+        const fiber = yield* listen(
+          Effect.fnUntraced(function* (message) {
+            switch (message._tag) {
+              case "AuditionSuccess": {
+                yield* debug("AuditionSucceeded")
+                yield* Deferred.succeed(audition, void 0)
+                return
+              }
+              case "Event": {
+                const { event } = message
+                yield* debug("EventEmitted", { event })
+                yield* publishTake([event as never], true)
+                return
+              }
+              case "FSuccess":
+              case "FFailure": {
+                const { id } = message
+                const deferred = inflights[id]
+                if (deferred) {
+                  delete inflights[id]
+                  switch (message._tag) {
+                    case "FSuccess": {
+                      const { _tag, value } = message.success as never
+                      yield* debug("CallSucceeded", { id, _tag, value })
+                      yield* Deferred.succeed(deferred, value)
+                      return
+                    }
+                    case "FFailure": {
+                      const { _tag, value } = message.failure as never
+                      yield* debug("CallFailed", { id, _tag, value })
+                      yield* Deferred.fail(deferred, value)
+                      return
+                    }
+                  }
+                }
+                return
+              }
+              case "AuditionFailure": {
+                const { client, routed } = message
+                yield* debug("AuditionFailed", { client, routed })
+                return yield* new AuditionError({ value: { client, routed } })
+              }
+              case "Disconnect": {
+                yield* debug("Disconnected")
+                return
+              }
+              case "TransportFailure": {
+                const { cause } = message
+                yield* debug("TransportFailed", { cause })
+                return yield* new ConnectionError({ cause })
+              }
+            }
+          }),
+        ).pipe(
+          Effect.ensuring(
+            Effect.all(
+              [
+                debug("ClientClosed", { unresolved: Record.keys(inflights).length }),
+                Deferred.succeed(audition, void 0),
+                RcRef.invalidate(rcr),
+              ],
+              { concurrency: "unbounded" },
+            ),
+          ),
+          Effect.forkScoped,
+          Effect.provideService(Scope.Scope, scope),
+        )
+
+        const events = Effect.gen(function* () {
           const queue = yield* PubSub.subscribe(pubsub)
-          const live = (replayCount: number): Stream.Stream<_["Event"], ClientError> =>
-            Stream.fromQueue(queue).pipe(
+          const live = (replayCount: number) =>
+            Stream.fromSubscription(queue).pipe(
               Stream.filter((entry) => entry.seq > replayCount),
               Stream.map((entry) => entry.take),
               Stream.flattenTake,
@@ -325,114 +331,58 @@ const make = <
                 ),
                 live(replayCount),
               )
-        }).pipe(Stream.unwrapScoped)
-
-        yield* listen(
-          Effect.fnUntraced(function* (message) {
-            switch (message._tag) {
-              case "Audition.Success": {
-                yield* Deferred.succeed(audition, void 0)
-                break
-              }
-              case "Event": {
-                const { event } = message
-                yield* publishTake(Take.of(event), true)
-                break
-              }
-              case "Call.Success":
-              case "Call.Failure": {
-                const { id } = message
-                const deferred = inflights[id]
-                if (deferred) {
-                  delete inflights[id]
-                  switch (message._tag) {
-                    case "Call.Success": {
-                      yield* Deferred.succeed(deferred, message.value.value)
-                      break
-                    }
-                    case "Call.Failure": {
-                      yield* Deferred.fail(deferred, message.cause.value)
-                      break
-                    }
-                  }
-                }
-                break
-              }
-              case "Audition.Failure": {
-                const { actual, expected } = message
-                finalError = AuditionError.make({ value: { actual, expected } })
-                yield* Deferred.fail(audition, finalError)
-                break
-              }
-              case "Disconnect":
-              case "TransportFailure": {
-                yield* Deferred.succeed(audition, void 0)
-                switch (message._tag) {
-                  case "Disconnect": {
-                    finalError = UnresolvedError.make()
-                    yield* publishTake(Take.end)
-                    break
-                  }
-                  case "TransportFailure": {
-                    const { cause } = message
-                    yield* publishTake(Take.fail((finalError = ConnectionError.make({ cause }))))
-                    break
-                  }
-                }
-                break
-              }
-            }
-          }),
-        ).pipe(
-          Effect.ensuring(
-            Effect.all(
-              [
-                PubSub.shutdown(pubsub),
-                Effect.forEach(
-                  Record.values(inflights),
-                  (deferred) => Deferred.fail(deferred, finalError ?? UnresolvedError.make()),
-                  {
-                    concurrency: "unbounded",
-                  },
-                ),
-                RcRef.invalidate(rcr),
-              ],
-              { concurrency: "unbounded" },
-            ),
-          ),
-          Effect.forkScoped,
-        )
+        }).pipe(Stream.unwrap, Stream.interruptWhen(Fiber.join(fiber)))
 
         yield* Deferred.await(audition)
 
+        const encodingServices = yield* Effect.context<_["f"]["payload"]["EncodingServices"]>()
+
         const f: F<ClientSelf, MethodDefinitions> = (_tag) =>
-          Effect.fnUntraced(function* (value) {
-            if (finalError) return yield* finalError
-            const id = callId++
-            const inflight = yield* Deferred.make<_["Call"]["Success"], FError<MethodDefinitions>>()
-            inflights[id] = inflight
-            yield* send({
-              _tag: "Call.Payload",
-              id,
-              payload: { _tag, value },
-            })
-            return yield* Deferred.await(inflight)
-          }, Effect.scoped)
-
-        const endEvents = publishTake(Take.end)
-
-        return { events, f, endEvents }
-      }),
+          Effect.fnUntraced(
+            function* (value) {
+              const exit = fiber.pollUnsafe()
+              if (exit) {
+                return yield* Exit.match(exit, {
+                  onSuccess: () => new UnresolvedError(),
+                  onFailure: flow(
+                    Cause.findError,
+                    Result.match({
+                      onSuccess: identity,
+                      onFailure: () => new UnresolvedError(),
+                    }),
+                  ),
+                })
+              }
+              const id = callId++
+              const inflight = yield* Deferred.make<_["f"]["success"]["Type"], FError<MethodDefinitions>>()
+              inflights[id] = inflight
+              yield* send({
+                _tag: "FPayload",
+                id,
+                payload: { _tag, value } as never,
+              })
+              return yield* Effect.raceFirst(
+                Deferred.await(inflight),
+                Fiber.join(fiber).pipe(Effect.andThen(() => new UnresolvedError().asEffect())),
+              )
+            },
+            span("f"),
+            Effect.scoped,
+            Effect.provide(encodingServices),
+          )
+
+        return { events, f, end }
+      }).pipe(span("acquire", { attributes: { client: client.key } }), Effect.annotateLogs("client", client.key)),
     })
 
     return rcr
-  }).pipe(Layer.scoped(client))
+  }).pipe(Layer.effect(client))
 
 export const layerSocket = <
   ClientSelf,
   ClientId extends string,
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
+  EventDefinitions extends Record<string, S.Struct.Fields>,
 >({
   client,
   url,
@@ -443,7 +393,13 @@ export const layerSocket = <
   readonly url?: string | undefined
   readonly protocols?: string | Array<string> | undefined
   readonly replay?: ReplayConfig | undefined
-}): Layer.Layer<ClientSelf, never, Socket.WebSocketConstructor> =>
+}): Layer.Layer<
+  ClientSelf,
+  never,
+  | Socket.WebSocketConstructor
+  | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["actor"]["DecodingServices"]
+  | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]
+> =>
   make<ClientSelf, ClientId, MethodDefinitions, EventDefinitions, Socket.WebSocketConstructor>(
     client,
     Effect.gen(function* () {
@@ -453,61 +409,59 @@ export const layerSocket = <
       return {
         listen: Effect.fnUntraced(function* (publish) {
           yield* socket
-            .runRaw(
-              Effect.fnUntraced(function* (raw) {
-                const message = yield* S.decodeUnknown(S.parseJson(client.schema.actor))(
-                  raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw,
-                )
-                yield* publish(message)
-              }),
+            .runRaw((raw) =>
+              pipe(
+                raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw,
+                S.decodeUnknownEffect(S.fromJsonString(client.schema.actor)),
+                Effect.andThen(publish),
+              ),
             )
             .pipe(
-              Effect.catchTag("ParseError", (cause) => publish({ _tag: "TransportFailure", cause })),
               Effect.catchTag(
                 "SocketError",
                 Effect.fnUntraced(function* (cause) {
-                  switch (cause.reason) {
-                    case "Read":
-                    case "Write":
-                    case "Open":
-                    case "OpenTimeout": {
-                      // TODO
-                      console.log(cause)
+                  const { reason } = cause
+                  switch (reason._tag) {
+                    case "SocketReadError":
+                    case "SocketWriteError":
+                    case "SocketOpenError": {
+                      yield* debug(reason._tag, { cause })
                       return yield* publish({ _tag: "TransportFailure", cause })
                     }
-                    case "Close": {
-                      const { code, closeReason } = cause
+                    case "SocketCloseError": {
+                      const { code, closeReason } = reason
                       switch (code) {
                         case 1000: {
                           return yield* publish({ _tag: "Disconnect" })
                         }
                         case 4003: {
-                          const parsed = S.decodeUnknownOption(S.parseJson(Protocol.Audition.Failure))(closeReason)
-                          if (parsed._tag === "None") {
-                            return yield* publish({ _tag: "TransportFailure", cause })
-                          }
-                          const { actual, expected } = parsed.value
-                          return yield* publish({
-                            _tag: "Audition.Failure",
-                            actual,
-                            expected,
-                          })
+                          return yield* S.decodeUnknownEffect(S.fromJsonString(Protocol.AuditionFailure))(
+                            closeReason,
+                          ).pipe(Effect.andThen(publish))
                         }
                       }
+                      yield* debug("SocketCloseError", { cause })
                       return yield* publish({ _tag: "TransportFailure", cause })
                     }
                   }
                 }),
               ),
+              Effect.catchTag("SchemaError", Effect.die),
             )
-        }),
-        send: Effect.fnUntraced(function* (v) {
-          const write = yield* socket.writer
-          const message = yield* S.encode(S.parseJson(client.schema.call.payload))(v).pipe(
-            Effect.mapError((cause) => ConnectionError.make({ cause })),
-          )
-          yield* write(message).pipe(Effect.catchTag("SocketError", (cause) => ConnectionError.make({ cause })))
-        }, Effect.scoped),
+        }, span("listen")),
+        send: Effect.fnUntraced(
+          function* (v) {
+            const write = yield* socket.writer
+            const message = yield* S.encodeEffect(S.fromJsonString(client.schema.f.payload))(v).pipe(
+              Effect.mapError((cause) => new ConnectionError({ cause })),
+            )
+            yield* write(message).pipe(
+              Effect.catchTag("SocketError", (cause) => new ConnectionError({ cause }).asEffect()),
+            )
+          },
+          span("send"),
+          Effect.scoped,
+        ),
       }
     }),
     replay,
@@ -517,42 +471,53 @@ export const layerWorker = <
   ClientSelf,
   ClientId extends string,
   MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends FieldsRecord,
+  EventDefinitions extends Record<string, S.Struct.Fields>,
 >({
   client,
   replay,
 }: {
   readonly client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>
   readonly replay?: ReplayConfig | undefined
-}): Layer.Layer<ClientSelf, never, Worker.PlatformWorker | Worker.Spawner> =>
-  make<ClientSelf, ClientId, MethodDefinitions, EventDefinitions, Worker.PlatformWorker | Worker.Spawner>(
+}): Layer.Layer<
+  ClientSelf,
+  never,
+  | Worker.WorkerPlatform
+  | Worker.Spawner
+  | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["actor"]["DecodingServices"]
+  | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]
+> =>
+  make<ClientSelf, ClientId, MethodDefinitions, EventDefinitions, Worker.WorkerPlatform | Worker.Spawner>(
     client,
     Effect.gen(function* () {
-      const manager = yield* Worker.makeManager
-      const worker = yield* manager
-        .spawn<
-          Protocol.Call.Payload.Type<MethodDefinitions> | string,
-          Protocol.Actor.Type<MethodDefinitions, EventDefinitions>,
-          never
-        >({})
-        .pipe(Effect.catchTag("WorkerError", (cause) => ConnectionError.make({ cause })))
-
-      const send = (message: Protocol.Call.Payload.Type<MethodDefinitions>) =>
-        worker.executeEffect(message).pipe(Effect.catchTag("WorkerError", (cause) => ConnectionError.make({ cause })))
+      type T = typeof client.schema
+
+      const platform = yield* Worker.WorkerPlatform
+      const backing = yield* platform
+        .spawn<T["actor"]["Type"], T["f"]["payload"]["Type"] | string>(0)
+        .pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()))
+
+      const send = (message: T["f"]["payload"]["Type"]) =>
+        backing.send(message).pipe(
+          Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()),
+          span("send"),
+        )
 
       return {
         listen: Effect.fnUntraced(function* (publish) {
-          yield* worker.execute(client.key).pipe(
-            Stream.catchTag("WorkerError", (cause) =>
-              Effect.gen(function* () {
-                yield* publish({ _tag: "TransportFailure", cause })
-                return Stream.empty
-              }).pipe(Stream.unwrap),
+          const stop = yield* Deferred.make<void>()
+          yield* Effect.raceFirst(
+            backing.run(
+              Effect.fnUntraced(function* (message) {
+                yield* publish(message)
+                if (message._tag === "Disconnect" || message._tag === "AuditionFailure") {
+                  yield* Deferred.succeed(stop, void 0)
+                }
+              }),
+              { onSpawn: backing.send(client.key).pipe(Effect.orDie) },
             ),
-            Stream.takeUntil((message) => message._tag === "Disconnect" || message._tag === "Audition.Failure"),
-            Stream.runForEach(publish),
-          )
-        }),
+            Deferred.await(stop),
+          ).pipe(Effect.catchTag("WorkerError", (cause) => publish({ _tag: "TransportFailure", cause })))
+        }, span("listen")),
         send,
       }
     }),