liminal 0.17.14 → 0.17.16

package/Client.ts

@@ -15,23 +15,25 @@ import {
   Take,
   Schema as S,
   Array,
-  Struct,
   Fiber,
   Exit,
   Cause,
   Result,
   flow,
+  Tracer,
+  identity,
+  Semaphore,
 } from "effect"
 import { Socket } from "effect/unstable/socket"
 import { Worker } from "effect/unstable/workers"
+import * as Boundary from "liminal-util/Boundary"
+import { decodeJsonString, encodeJsonString } from "liminal-util/schema"
 
-import { diagnostic } from "./_diagnostic.ts"
-import { decodeJsonString, encodeJsonString } from "./_util/schema.ts"
-import { type ClientError, AuditionError, ConnectionError, type FError, UnresolvedError } from "./errors.ts"
-import { type F } from "./F.ts"
+import { type ClientError, AuditionError, ConnectionError, UnresolvedError } from "./errors.ts"
+import type { Fn, FnError, FnNoSelf } from "./Fn.ts"
 import { Protocol, type ProtocolDefinition } from "./Protocol.ts"
-
-const { debug, span } = diagnostic("Client")
+import * as Reducer from "./Reducer.ts"
+import * as Tracing from "./Tracing.ts"
 
 export const TypeId = "~liminal/Client" as const
 
@@ -47,21 +49,29 @@ interface EventTake<A, E> {
   readonly take: Take.Take<A, E>
 }
 
-export interface Session<Self, D extends ProtocolDefinition> {
-  readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError>
+export type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<
+  {
+    readonly state: Stream.Stream<S.Struct<D["state"]>["Type"], ClientError | S.SchemaError>
 
-  readonly f: F<Self, D>
+    readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError>
 
-  readonly end: Effect.Effect<void>
-}
+    readonly fnRaw: <K extends keyof D["external"], M extends D["external"][K]>(
+      tag: K,
+      payload: M["payload"]["Type"],
+    ) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], ClientSelf>
 
-export type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<Session<ClientSelf, D>, ClientError>
+    readonly end: Effect.Effect<void>
+  },
+  ClientError
+>
 
-export interface Client<Self, ClientId extends string, D extends ProtocolDefinition> extends Context.Service<
+export interface Client<Self, Id extends string, D extends ProtocolDefinition> extends Context.Service<
   Self,
   Service<Self, D>
 > {
-  new (_: never): Context.ServiceClass.Shape<ClientId, Service<Self, D>>
+  new (_: never): Context.ServiceClass.Shape<Id, Service<Self, D>> & {
+    readonly State: S.Struct<D["state"]>["Type"]
+  }
 
   readonly [TypeId]: typeof TypeId
 
@@ -69,17 +79,36 @@ export interface Client<Self, ClientId extends string, D extends ProtocolDefinit
 
   readonly protocol: Protocol<D>
 
+  readonly state: Stream.Stream<
+    S.Struct<D["state"]>["Type"],
+    ClientError | S.SchemaError,
+    Self | S.Struct<D["state"]>["DecodingServices"]
+  >
+
   readonly events: Stream.Stream<
     ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"],
     ClientError | S.SchemaError,
     Self
   >
 
-  readonly f: F<Self, D>
+  readonly fn: Fn<Self, D["external"]>
 
   readonly invalidate: Effect.Effect<void, never, Self>
+
+  readonly reducer: <K extends keyof D["events"], R extends Reducer.Reducer<D, K>>(_tag: K, f: R) => R
 }
 
+export const fn = <ClientSelf, D extends ProtocolDefinition>(service: Service<ClientSelf, D>) =>
+  ((_tag: keyof D["external"], ...f: Array<any>) =>
+    Effect.fnUntraced(
+      function* (payload: any) {
+        const { fnRaw: fn } = yield* RcRef.get(service)
+        return yield* fn(_tag, payload)
+      },
+      Effect.scoped,
+      ...(f as [any]),
+    )) as FnNoSelf<D["external"]>
+
 export const Service =
   <Self>() =>
   <Id extends string, D extends ProtocolDefinition>(id: Id, definition: D): Client<Self, Id, D> => {
@@ -87,15 +116,29 @@ export const Service =
 
     const protocol = Protocol(definition)
 
-    const events = tag.asEffect().pipe(Effect.flatMap(RcRef.get), Effect.map(Struct.get("events")), Stream.unwrap)
+    const state = tag.pipe(
+      Effect.flatMap(RcRef.get),
+      Effect.map(({ state }) => state),
+      Stream.unwrap,
+    )
 
-    const f: F<Self, D> = (_tag) =>
-      Effect.fnUntraced(function* (value) {
-        const { f } = yield* tag.asEffect().pipe(Effect.flatMap(RcRef.get))
-        return yield* f(_tag)(value)
-      }, Effect.scoped)
+    const events = tag.pipe(
+      Effect.flatMap(RcRef.get),
+      Effect.map(({ events }) => events),
+      Stream.unwrap,
+    )
 
-    const invalidate = tag.asEffect().pipe(
+    const fn = ((_tag: keyof D["external"], ...f: Array<any>) =>
+      Effect.fnUntraced(
+        function* (payload: any) {
+          const { fnRaw: fn } = yield* tag.pipe(Effect.flatMap(RcRef.get))
+          return yield* fn(_tag, payload)
+        },
+        Effect.scoped,
+        ...(f as [any]),
+      )) as Fn<Self, D["external"]>
+
+    const invalidate = tag.pipe(
       Effect.flatMap((rc) =>
         RcRef.get(rc).pipe(
           Effect.flatMap(({ end }) => end),
@@ -106,47 +149,69 @@ export const Service =
       Effect.ignore,
     )
 
-    return Object.assign(tag, {
+    const reducer = <K extends keyof D["events"], R extends Reducer.Reducer<D, K>>(_event: K, f: R) => f
+
+    return Object.assign(tag satisfies Context.ServiceClass.Shape<Id, Service<Self, D>> as never, {
       [TypeId]: TypeId,
       definition,
       protocol,
+      state,
       events,
-      f,
+      fn,
       invalidate,
+      reducer,
     })
   }
 
-export interface ClientTransport<D extends ProtocolDefinition> {
+export interface ClientTransport<D extends ProtocolDefinition, R> {
   readonly listen: (
-    publish: (message: Protocol<D>["Actor"]["Type"]) => Effect.Effect<void, ClientError>,
-  ) => Effect.Effect<void, ClientError | S.SchemaError, Scope.Scope | Protocol<D>["Actor"]["DecodingServices"]>
+    publish: (message: Protocol<D>["Actor"]["Type"]) => Effect.Effect<void, ClientError, R>,
+  ) => Effect.Effect<void, ClientError | S.SchemaError, Scope.Scope | Protocol<D>["Actor"]["DecodingServices"] | R>
 
   readonly send: (
     message: Protocol<D>["F"]["Payload"]["Type"],
   ) => Effect.Effect<void, ClientError | S.SchemaError, Protocol<D>["F"]["Payload"]["EncodingServices"]>
 }
 
-const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
-  client: Client<Self, Id, D>,
-  build: Effect.Effect<ClientTransport<D>, ClientError, R | Scope.Scope>,
-  replay?: ReplayConfig | undefined,
-) =>
+const make = <Self, Id extends string, D extends ProtocolDefinition, Reducers extends Reducer.Reducers<D>, R, CR>({
+  build,
+  client,
+  reducers,
+  onConnect,
+  replay,
+}: {
+  readonly client: Client<Self, Id, D>
+  readonly onConnect?: undefined | ((state: S.Struct<D["state"]>["Type"]) => Effect.Effect<void, never, CR>)
+  readonly reducers: Reducers
+  readonly build: Effect.Effect<
+    ClientTransport<D, Reducer.Reducers.Services<Self, Reducers> | CR>,
+    ClientError,
+    R | Scope.Scope
+  >
+  readonly replay?: ReplayConfig | undefined
+}) =>
   Effect.gen(function* () {
-    const rcr: RcRef.RcRef<Session<Self, D>, ClientError> = yield* RcRef.make({
+    const rcr: Service<Self, D> = yield* RcRef.make({
       acquire: Effect.gen(function* () {
         type _ = typeof client.protocol
         type Event = ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"]
 
-        yield* debug("AcquisitionStarted")
-
         const { listen, send } = yield* build
 
         const audition = yield* Deferred.make<void>()
+        const stateDeferred = yield* Deferred.make<Ref.Ref<S.Struct<D["state"]>["Type"]>>()
 
-        const inflights: Record<string, Deferred.Deferred<_["F"]["Success"]["Type"], FError<D>>> = {}
+        const inflights: Record<
+          string,
+          {
+            readonly deferred: Deferred.Deferred<_["F"]["Success"]["Type"], FnError<D["external"], keyof D["external"]>>
+            readonly span?: Tracer.AnySpan | undefined
+          }
+        > = {}
         let callId = 0
         let takeCount = 0
-        const pubsub = yield* PubSub.unbounded<EventTake<Event, ClientError>>()
+        const eventsPubsub = yield* PubSub.unbounded<EventTake<Event, ClientError>>()
+        const statePubsub = yield* PubSub.unbounded<S.Struct<D["state"]>["Type"]>({ replay: 1 })
 
         const replayState = yield* Ref.make<{
           readonly startupOpen: boolean
@@ -175,57 +240,87 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
                 return { startupOpen, buffer }
               })
             }
-            yield* PubSub.publish(pubsub, eventTake)
+            yield* PubSub.publish(eventsPubsub, eventTake)
           })
 
         const outer = yield* Scope.Scope
         const scope = yield* Scope.fork(outer, "sequential")
         const end = Scope.close(scope, Exit.void)
+        const reduceMutex = yield* Semaphore.make(1)
+        const reduceTask = Semaphore.withPermits(reduceMutex, 1)
 
         const fiber = yield* listen(
           Effect.fnUntraced(function* (message) {
             switch (message._tag) {
               case "Audition.Success": {
-                yield* debug("Audition.Succeeded")
+                const { initial } = message
+                yield* PubSub.publish(statePubsub, initial)
+                const state = yield* Ref.make(initial)
+                yield* Deferred.succeed(stateDeferred, state)
                 yield* Deferred.succeed(audition, void 0)
+                yield* onConnect?.(initial) ?? Effect.void
                 return
               }
               case "Audition.Failure": {
                 const { expected, actual } = message
-                yield* debug("Audition.Failed", { expected, actual })
                 return yield* new AuditionError({ value: { expected, actual } })
               }
               case "Event": {
                 const { event } = message
-                yield* debug("Event.Emitted", { event })
-                yield* publishTake([event as never], true)
+                const { _tag } = event as never
+                const reducer = reducers[_tag]!
+                const state = yield* Deferred.await(stateDeferred)
+                yield* Effect.gen(function* () {
+                  const current = yield* Ref.get(state)
+                  const reduced = yield* reducer(event as never)(current).pipe(
+                    Effect.provideService(client, rcr),
+                    // TODO: rework error-handling
+                    Effect.catchDefect(() => Effect.succeed(undefined)),
+                  ) as Effect.Effect<
+                    S.Struct<D["state"]>["Type"] | undefined,
+                    never,
+                    Reducer.Reducers.Services<Self, Reducers>
+                  >
+                  if (reduced) {
+                    yield* PubSub.publish(statePubsub, reduced)
+                    yield* Ref.set(state, reduced)
+                  }
+                }).pipe(reduceTask)
+                const parent = message.trace ? Tracer.externalSpan(message.trace) : undefined
+                yield* publishTake([event], true).pipe(
+                  Boundary.span("enqueue-event", import.meta.url, {
+                    attributes: { _tag },
+                    kind: "consumer",
+                    parent,
+                  }),
+                )
                 return
               }
               case "F.Success":
               case "F.Failure": {
                 const { id } = message
-                const deferred = inflights[id]
-                if (deferred) {
+                const inflight = inflights[id]
+                if (inflight) {
                   delete inflights[id]
-                  switch (message._tag) {
-                    case "F.Success": {
-                      const { _tag, value } = message.success as never
-                      yield* debug("Call.Succeeded", { id, _tag, value })
-                      yield* Deferred.succeed(deferred, value)
-                      return
+                  return yield* Effect.gen(function* () {
+                    switch (message._tag) {
+                      case "F.Success": {
+                        const { value } = message.success as never
+                        yield* Deferred.succeed(inflight.deferred, value)
+                        return
+                      }
+                      case "F.Failure": {
+                        const { _tag, value } = message.failure as never
+                        yield* Effect.annotateLogs(Effect.logDebug("Call.Failed"), { id, _tag })
+                        yield* Deferred.fail(inflight.deferred, value)
+                        return
+                      }
                     }
-                    case "F.Failure": {
-                      const { _tag, value } = message.failure as never
-                      yield* debug("Call.Failed", { id, _tag, value })
-                      yield* Deferred.fail(deferred, value)
-                      return
-                    }
-                  }
+                  }).pipe(inflight.span ? Effect.withParentSpan(inflight.span, { captureStackTrace: false }) : identity)
                 }
                 return
               }
               case "Disconnect": {
-                yield* debug("Disconnected")
                 return
               }
             }
@@ -234,7 +329,13 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
           Effect.ensuring(
             Effect.all(
               [
-                debug("Client.Closed", { unresolved: Record.keys(inflights).length }),
+                Effect.sync(() => Record.keys(inflights).length).pipe(
+                  Effect.flatMap((unresolved) =>
+                    unresolved === 0
+                      ? Effect.void
+                      : Effect.annotateLogs(Effect.logDebug("Client.Closed"), { unresolved }),
+                  ),
+                ),
                 Deferred.succeed(audition, void 0),
                 RcRef.invalidate(rcr),
               ],
@@ -245,8 +346,25 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
           Effect.provideService(Scope.Scope, scope),
         )
 
+        const interrupt = Stream.interruptWhen(
+          Fiber.await(fiber).pipe(
+            Effect.flatMap(
+              Exit.match({
+                onSuccess: () => Effect.void,
+                onFailure: flow(
+                  Cause.findError,
+                  Result.match({
+                    onSuccess: Effect.fail,
+                    onFailure: () => Effect.void,
+                  }),
+                ),
+              }),
+            ),
+          ),
+        )
+
         const events = Effect.gen(function* () {
-          const queue = yield* PubSub.subscribe(pubsub)
+          const queue = yield* PubSub.subscribe(eventsPubsub)
           const live = (replayCount: number) =>
             Stream.fromSubscription(queue).pipe(
               Stream.filter((entry) => entry.seq > replayCount),
@@ -283,206 +401,265 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
                 ),
                 live(replayCount),
               )
-        }).pipe(
-          Stream.unwrap,
-          Stream.interruptWhen(
-            Fiber.await(fiber).pipe(
-              Effect.flatMap(
-                Exit.match({
-                  onSuccess: () => Effect.void,
-                  onFailure: flow(
-                    Cause.findError,
-                    Result.match({
-                      onSuccess: Effect.fail,
-                      onFailure: () => Effect.void,
-                    }),
-                  ),
-                }),
-              ),
-            ),
-          ),
-        )
+        }).pipe(Stream.unwrap, interrupt)
 
-        yield* Deferred.await(audition)
+        const state = Stream.fromPubSub(statePubsub).pipe(interrupt)
 
         const encodingServices = yield* Effect.context<_["F"]["Payload"]["EncodingServices"]>()
 
-        const f: F<Self, D> = (_tag) =>
-          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: Effect.fail,
-                      onFailure: () => new UnresolvedError(),
-                    }),
-                  ),
-                })
-              }
-              const id = callId++
-              const inflight = yield* Deferred.make<_["F"]["Success"]["Type"], FError<D>>()
-              inflights[id] = inflight
-              yield* send({
-                _tag: "F.Payload",
-                id,
-                payload: { _tag, value } as never,
+        yield* Deferred.await(audition)
+
+        const fnRaw = <K extends keyof D["external"]>(_tag: K, value: D["external"][K]["payload"]["Type"]) =>
+          Effect.gen(function* () {
+            const exit = fiber.pollUnsafe()
+            if (exit) {
+              return yield* Exit.match(exit, {
+                onSuccess: () => new UnresolvedError(),
+                onFailure: flow(
+                  Cause.findError,
+                  Result.match({
+                    onSuccess: Effect.fail,
+                    onFailure: () => new UnresolvedError(),
+                  }),
+                ),
               })
-              return yield* Effect.raceFirst(
-                Deferred.await(inflight),
-                Fiber.await(fiber).pipe(
-                  Effect.flatMap(
-                    (exit): Effect.Effect<never, ClientError | UnresolvedError | S.SchemaError> =>
-                      Exit.match(exit, {
-                        onSuccess: () => new UnresolvedError().asEffect(),
-                        onFailure: flow(
-                          Cause.findError,
-                          Result.match({
-                            onSuccess: Effect.fail,
-                            onFailure: () => new UnresolvedError().asEffect(),
-                          }),
-                        ),
-                      }),
-                  ),
+            }
+            const id = callId++
+            const deferred = yield* Deferred.make<
+              _["F"]["Success"]["Type"],
+              FnError<D["external"], keyof D["external"]>
+            >()
+            const span = yield* Tracing.current
+            const trace = span ? Tracing.toTraceEnvelope(span) : undefined
+            inflights[id] = { deferred, span }
+            yield* send({
+              _tag: "F.Payload",
+              id,
+              payload: { _tag, value } as never,
+              ...(trace && { trace }),
+            })
+            return yield* Effect.raceFirst(
+              Deferred.await(deferred),
+              Fiber.await(fiber).pipe(
+                Effect.flatMap(
+                  (exit): Effect.Effect<never, ClientError | UnresolvedError | S.SchemaError> =>
+                    Exit.match(exit, {
+                      onSuccess: () => new UnresolvedError(),
+                      onFailure: flow(
+                        Cause.findError,
+                        Result.match({
+                          onSuccess: Effect.fail,
+                          onFailure: () => new UnresolvedError(),
+                        }),
+                      ),
+                    }),
                 ),
-              )
-            },
-            span("f"),
-            Effect.scoped,
+              ),
+            )
+          }).pipe(
+            Boundary.span("fn", import.meta.url, {
+              kind: "client",
+              attributes: { _tag },
+            }),
             Effect.provide(encodingServices),
           )
 
-        return { events, f, end }
-      }).pipe(span("acquire", { attributes: { client: client.key } }), Effect.annotateLogs("client", client.key)),
+        return { state, events, fnRaw, end }
+      }).pipe(
+        Boundary.span("acquire", import.meta.url, {
+          attributes: { client: client.key },
+        }),
+        Effect.annotateLogs("client", client.key),
+      ),
     })
 
     return rcr
   }).pipe(Layer.effect(client))
 
-export const layerSocket = <Self, Id extends string, D extends ProtocolDefinition>({
+let clientId_: string | undefined
+const clientId = () => {
+  if (!clientId_) {
+    clientId_ = crypto.randomUUID()
+  }
+  return clientId_
+}
+
+export const layerSocket = <
+  Self,
+  Id extends string,
+  D extends ProtocolDefinition,
+  Reducers extends Reducer.Reducers<D>,
+  CR = never,
+>({
   client,
+  reducers,
   url,
   protocols,
   replay,
+  onConnect,
 }: {
   readonly client: Client<Self, Id, D>
-  readonly url?: string | undefined
-  readonly protocols?: string | Array<string> | undefined
+  readonly reducers: Reducers
   readonly replay?: ReplayConfig | undefined
+  readonly onConnect?: undefined | ((state: S.Struct<D["state"]>["Type"]) => Effect.Effect<void, never, CR>)
+  readonly protocols?: string | Array<string> | undefined
+  readonly url?: string | undefined
 }): Layer.Layer<
   Self,
   never,
   | Socket.WebSocketConstructor
   | Protocol<D>["Actor"]["DecodingServices"]
   | Protocol<D>["F"]["Payload"]["EncodingServices"]
+  | Reducer.Reducers.Services<Self, Reducers>
+  | CR
 > => {
   const { F, Actor } = client.protocol
   const encodeFPayload = encodeJsonString(F.Payload)
   const decodeActor = decodeJsonString(Actor)
 
-  return make<Self, Id, D, Socket.WebSocketConstructor>(
+  return make<Self, Id, D, Reducers, Socket.WebSocketConstructor, CR>({
     client,
-    Effect.gen(function* () {
+    reducers,
+    onConnect,
+    replay,
+    build: Effect.gen(function* () {
       const socket = yield* Socket.makeWebSocket(url ?? "/", {
-        protocols: ["liminal", Encoding.encodeBase64Url(client.key), ...(protocols ? Array.ensure(protocols) : [])],
+        protocols: [
+          "liminal",
+          clientId(),
+          Encoding.encodeBase64Url(client.key),
+          ...(protocols ? Array.ensure(protocols) : []),
+        ],
       })
       return {
-        listen: Effect.fnUntraced(function* (publish) {
-          yield* socket
-            .runRaw((raw) =>
-              pipe(
-                raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw,
-                decodeActor,
-                Effect.andThen(publish),
-              ),
-            )
-            .pipe(
-              Effect.catchIf(
-                Socket.isSocketError,
-                Effect.fnUntraced(function* (cause) {
-                  const { reason } = cause
-                  if (reason._tag === "SocketCloseError" && reason.code === 1000) {
-                    yield* debug("Socket.Disconnected")
-                    return yield* publish({ _tag: "Disconnect" })
-                  }
-                  yield* debug(`SocketErrored.${reason._tag}`, { cause })
-                  return yield* new ConnectionError({ cause })
-                }),
-              ),
-            )
-        }, span("listen")),
+        listen: Effect.fnUntraced(
+          function* (publish) {
+            yield* socket
+              .runRaw((raw) =>
+                pipe(
+                  raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw,
+                  decodeActor,
+                  Effect.andThen(publish),
+                ),
+              )
+              .pipe(
+                Effect.catchIf(
+                  Socket.isSocketError,
+                  Effect.fnUntraced(function* (cause) {
+                    const { reason } = cause
+                    if (reason._tag === "SocketCloseError" && reason.code === 1000) {
+                      return yield* publish({ _tag: "Disconnect" })
+                    }
+                    yield* Effect.annotateLogs(Effect.logDebug(`SocketErrored.${reason._tag}`), { cause })
+                    return yield* new ConnectionError({ cause })
+                  }),
+                ),
+              )
+          },
+          Boundary.span("listen", import.meta.url),
+        ),
         send: Effect.fnUntraced(
           function* (v) {
             const write = yield* socket.writer
             const message = yield* encodeFPayload(v)
             yield* write(message).pipe(
-              Effect.catchTag("SocketError", (cause) => new ConnectionError({ cause }).asEffect()),
+              Effect.catchTags({
+                SocketError: (cause) => new ConnectionError({ cause }),
+              }),
             )
           },
-          span("send"),
+          Boundary.span("send", import.meta.url),
           Effect.scoped,
         ),
       }
     }),
-    replay,
-  )
+  })
 }
 
-export const layerWorker = <Self, Id extends string, D extends ProtocolDefinition, T extends Protocol<D>>({
+export const layerWorker = <
+  Self,
+  Id extends string,
+  D extends ProtocolDefinition,
+  Reducers extends Reducer.Reducers<D>,
+  T extends Protocol<D>,
+  CR = never,
+>({
   client,
+  reducers,
   replay,
+  onConnect,
 }: {
   readonly client: Client<Self, Id, D>
+  readonly reducers: Reducers
   readonly replay?: ReplayConfig | undefined
+  readonly onConnect?: undefined | ((state: S.Struct<D["state"]>["Type"]) => Effect.Effect<void, never, CR>)
 }): Layer.Layer<
   Self,
   never,
-  Worker.WorkerPlatform | Worker.Spawner | T["Actor"]["DecodingServices"] | T["F"]["Payload"]["EncodingServices"]
-> =>
-  make<Self, Id, D, Worker.WorkerPlatform | Worker.Spawner>(
+  | Worker.WorkerPlatform
+  | Worker.Spawner
+  | T["Actor"]["DecodingServices"]
+  | T["Client"]["EncodingServices"]
+  | Reducer.Reducers.Services<Self, Reducers>
+> => {
+  const { Actor, Client: ClientM } = client.protocol
+  const encodeClient = encodeJsonString(ClientM)
+  const decodeActor = decodeJsonString(Actor)
+
+  return make<Self, Id, D, Reducers, Worker.WorkerPlatform | Worker.Spawner, CR>({
     client,
-    Effect.gen(function* () {
+    reducers,
+    onConnect,
+    replay,
+    build: Effect.gen(function* () {
       const platform = yield* Worker.WorkerPlatform
-      const backing = yield* platform
-        .spawn<T["Actor"]["Type"], T["Client"]["Type"]>(0)
-        .pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()))
+      const backing = yield* platform.spawn<string, string>(0).pipe(
+        Effect.catchTags({
+          WorkerError: (cause) => new ConnectionError({ cause }),
+        }),
+      )
 
       const send = (message: T["Client"]["Type"]) =>
-        backing.send(message).pipe(
-          Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()),
-          span("send"),
+        encodeClient(message).pipe(
+          Effect.flatMap((encoded) => backing.send(encoded)),
+          Effect.catchTags({
+            WorkerError: (cause) => new ConnectionError({ cause }),
+          }),
+          Boundary.span("send", import.meta.url),
         )
 
       return {
-        listen: Effect.fnUntraced(function* (publish) {
-          const stop = yield* Deferred.make<void>()
-          yield* backing
-            .run(
-              Effect.fnUntraced(function* (message) {
-                yield* publish(message)
-                if (message._tag === "Disconnect" || message._tag === "Audition.Failure") {
-                  yield* Deferred.succeed(stop, void 0)
-                }
-              }),
-              {
-                onSpawn: backing
-                  .send({
-                    _tag: "Audition.Payload",
-                    client: client.key,
-                  })
-                  .pipe(Effect.orDie),
-              },
-            )
-            .pipe(
-              Effect.raceFirst(Deferred.await(stop)),
-              Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()),
-            )
-        }, span("listen")),
+        listen: Effect.fnUntraced(
+          function* (publish) {
+            const stop = yield* Deferred.make<void>()
+            const audition = yield* encodeClient({
+              _tag: "Audition.Payload",
+              client: client.key,
+            })
+            yield* backing
+              .run(
+                Effect.fnUntraced(function* (raw) {
+                  const message = yield* decodeActor(raw)
+                  yield* publish(message)
+                  if (message._tag === "Disconnect" || message._tag === "Audition.Failure") {
+                    yield* Deferred.succeed(stop, void 0)
+                  }
+                }),
+                {
+                  onSpawn: backing.send(audition).pipe(Effect.orDie),
+                },
+              )
+              .pipe(
+                Effect.raceFirst(Deferred.await(stop)),
+                Effect.catchTags({
+                  WorkerError: (cause) => new ConnectionError({ cause }),
+                }),
+              )
+          },
+          Boundary.span("listen", import.meta.url),
+        ),
         send,
       }
     }),
-    replay,
-  )
+  })
+}