liminal 0.17.5 → 0.17.7

package/Client.ts

@@ -21,31 +21,20 @@ import {
   Cause,
   Result,
   flow,
-  identity,
 } from "effect"
 import { Socket } from "effect/unstable/socket"
 import { Worker } from "effect/unstable/workers"
 
-import type { MethodDefinition } from "./Method.ts"
-
 import * as Diagnostic from "./_util/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 * as Protocol from "./Protocol.ts"
+import { Protocol, type ProtocolDefinition } 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 Record<string, S.Struct.Fields>,
-> {
-  readonly methods: MethodDefinitions
-
-  readonly events: EventDefinitions
-}
-
 export interface ReplayConfig {
   readonly mode: "startup" | "all-subscribers"
 
@@ -58,60 +47,49 @@ interface EventTake<A, E> {
   readonly take: Take.Take<A, E>
 }
 
-export interface Session<
-  ClientSelf,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
-> {
-  readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<EventDefinitions>>["Type"], ClientError>
+export interface Session<Self, D extends ProtocolDefinition> {
+  readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError>
 
-  readonly f: F<ClientSelf, MethodDefinitions>
+  readonly f: F<Self, D>
 
   readonly end: Effect.Effect<void>
 }
 
-export type Service<
-  ClientSelf,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
-> = RcRef.RcRef<Session<ClientSelf, MethodDefinitions, EventDefinitions>, ClientError>
+export type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<Session<ClientSelf, D>, ClientError>
 
-export interface Client<
-  ClientSelf,
-  ClientId extends string,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  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>>
+export interface Client<Self, ClientId extends string, D extends ProtocolDefinition> extends Context.Service<
+  Self,
+  Service<Self, D>
+> {
+  new (_: never): Context.ServiceClass.Shape<ClientId, Service<Self, D>>
 
   readonly [TypeId]: typeof TypeId
 
-  readonly definition: ClientDefinition<MethodDefinitions, EventDefinitions>
+  readonly definition: D
 
-  readonly schema: Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>
+  readonly protocol: Protocol<D>
 
-  readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<EventDefinitions>>["Type"], ClientError, ClientSelf>
+  readonly events: Stream.Stream<
+    ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"],
+    ClientError | S.SchemaError,
+    Self
+  >
 
-  readonly f: F<ClientSelf, MethodDefinitions>
+  readonly f: F<Self, D>
 
-  readonly invalidate: Effect.Effect<void, never, ClientSelf>
+  readonly invalidate: Effect.Effect<void, never, Self>
 }
 
 export const Service =
-  <ClientSelf>() =>
-  <
-    ClientId extends string,
-    MethodDefinitions extends Record<string, MethodDefinition.Any>,
-    EventDefinitions extends Record<string, S.Struct.Fields>,
-  >(
-    id: ClientId,
-    definition: ClientDefinition<MethodDefinitions, EventDefinitions>,
-  ): Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions> => {
-    const tag = Context.Service<ClientSelf, Service<ClientSelf, MethodDefinitions, EventDefinitions>>()(id)
+  <Self>() =>
+  <Id extends string, D extends ProtocolDefinition>(id: Id, definition: D): Client<Self, Id, D> => {
+    const tag = Context.Service<Self, Service<Self, D>>()(id)
+
+    const protocol = Protocol(definition)
 
     const events = tag.asEffect().pipe(Effect.flatMap(RcRef.get), Effect.map(Struct.get("events")), Stream.unwrap)
 
-    const f: F<ClientSelf, MethodDefinitions> = (_tag) =>
+    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)
@@ -131,54 +109,33 @@ export const Service =
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
-      schema: Protocol.ProtocolSchemas(definition.methods, definition.events),
+      protocol,
       events,
       f,
       invalidate,
     })
   }
 
-export interface Transport<
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
-> {
+export interface ClientTransport<D extends ProtocolDefinition> {
   readonly listen: (
-    publish: (
-      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"]
-  >
+    publish: (message: Protocol<D>["Actor"]["Type"]) => Effect.Effect<void, ClientError>,
+  ) => Effect.Effect<void, ClientError | S.SchemaError, Scope.Scope | Protocol<D>["Actor"]["DecodingServices"]>
 
   readonly send: (
-    message: Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["Type"],
-  ) => Effect.Effect<
-    void,
-    ConnectionError,
-    Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]
-  >
+    message: Protocol<D>["F"]["Payload"]["Type"],
+  ) => Effect.Effect<void, ClientError | S.SchemaError, Protocol<D>["F"]["Payload"]["EncodingServices"]>
 }
 
-const make = <
-  ClientSelf,
-  ClientId extends string,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
-  R,
->(
-  client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>,
-  build: Effect.Effect<Transport<MethodDefinitions, EventDefinitions>, ClientError, R | Scope.Scope>,
+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,
 ) =>
   Effect.gen(function* () {
-    const rcr: RcRef.RcRef<Session<ClientSelf, MethodDefinitions, EventDefinitions>, ClientError> = yield* RcRef.make({
+    const rcr: RcRef.RcRef<Session<Self, D>, ClientError> = yield* RcRef.make({
       acquire: Effect.gen(function* () {
-        type _ = typeof client.schema
-        type Event = ReturnType<typeof S.TaggedUnion<EventDefinitions>>["Type"]
+        type _ = typeof client.protocol
+        type Event = ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"]
 
         yield* debug("AcquisitionStarted")
 
@@ -186,7 +143,7 @@ const make = <
 
         const audition = yield* Deferred.make<void>()
 
-        const inflights: Record<string, Deferred.Deferred<_["f"]["success"]["Type"], FError<MethodDefinitions>>> = {}
+        const inflights: Record<string, Deferred.Deferred<_["F"]["Success"]["Type"], FError<D>>> = {}
         let callId = 0
         let takeCount = 0
         const pubsub = yield* PubSub.unbounded<EventTake<Event, ClientError>>()
@@ -228,33 +185,38 @@ const make = <
         const fiber = yield* listen(
           Effect.fnUntraced(function* (message) {
             switch (message._tag) {
-              case "AuditionSuccess": {
-                yield* debug("AuditionSucceeded")
+              case "Audition.Success": {
+                yield* debug("Audition.Succeeded")
                 yield* Deferred.succeed(audition, void 0)
                 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("EventEmitted", { event })
+                yield* debug("Event.Emitted", { event })
                 yield* publishTake([event as never], true)
                 return
               }
-              case "FSuccess":
-              case "FFailure": {
+              case "F.Success":
+              case "F.Failure": {
                 const { id } = message
                 const deferred = inflights[id]
                 if (deferred) {
                   delete inflights[id]
                   switch (message._tag) {
-                    case "FSuccess": {
+                    case "F.Success": {
                       const { _tag, value } = message.success as never
-                      yield* debug("CallSucceeded", { id, _tag, value })
+                      yield* debug("Call.Succeeded", { id, _tag, value })
                       yield* Deferred.succeed(deferred, value)
                       return
                     }
-                    case "FFailure": {
+                    case "F.Failure": {
                       const { _tag, value } = message.failure as never
-                      yield* debug("CallFailed", { id, _tag, value })
+                      yield* debug("Call.Failed", { id, _tag, value })
                       yield* Deferred.fail(deferred, value)
                       return
                     }
@@ -262,27 +224,17 @@ const make = <
                 }
                 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 }),
+                debug("Client.Closed", { unresolved: Record.keys(inflights).length }),
                 Deferred.succeed(audition, void 0),
                 RcRef.invalidate(rcr),
               ],
@@ -353,9 +305,9 @@ const make = <
 
         yield* Deferred.await(audition)
 
-        const encodingServices = yield* Effect.context<_["f"]["payload"]["EncodingServices"]>()
+        const encodingServices = yield* Effect.context<_["F"]["Payload"]["EncodingServices"]>()
 
-        const f: F<ClientSelf, MethodDefinitions> = (_tag) =>
+        const f: F<Self, D> = (_tag) =>
           Effect.fnUntraced(
             function* (value) {
               const exit = fiber.pollUnsafe()
@@ -365,17 +317,17 @@ const make = <
                   onFailure: flow(
                     Cause.findError,
                     Result.match({
-                      onSuccess: identity,
+                      onSuccess: Effect.fail,
                       onFailure: () => new UnresolvedError(),
                     }),
                   ),
                 })
               }
               const id = callId++
-              const inflight = yield* Deferred.make<_["f"]["success"]["Type"], FError<MethodDefinitions>>()
+              const inflight = yield* Deferred.make<_["F"]["Success"]["Type"], FError<D>>()
               inflights[id] = inflight
               yield* send({
-                _tag: "FPayload",
+                _tag: "F.Payload",
                 id,
                 payload: { _tag, value } as never,
               })
@@ -383,7 +335,7 @@ const make = <
                 Deferred.await(inflight),
                 Fiber.await(fiber).pipe(
                   Effect.flatMap(
-                    (exit): Effect.Effect<never, ClientError | UnresolvedError> =>
+                    (exit): Effect.Effect<never, ClientError | UnresolvedError | S.SchemaError> =>
                       Exit.match(exit, {
                         onSuccess: () => new UnresolvedError().asEffect(),
                         onFailure: flow(
@@ -410,29 +362,28 @@ const make = <
     return rcr
   }).pipe(Layer.effect(client))
 
-export const layerSocket = <
-  ClientSelf,
-  ClientId extends string,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
->({
+export const layerSocket = <Self, Id extends string, D extends ProtocolDefinition>({
   client,
   url,
   protocols,
   replay,
 }: {
-  readonly client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>
+  readonly client: Client<Self, Id, D>
   readonly url?: string | undefined
   readonly protocols?: string | Array<string> | undefined
   readonly replay?: ReplayConfig | undefined
 }): Layer.Layer<
-  ClientSelf,
+  Self,
   never,
   | Socket.WebSocketConstructor
-  | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["actor"]["DecodingServices"]
-  | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]
-> =>
-  make<ClientSelf, ClientId, MethodDefinitions, EventDefinitions, Socket.WebSocketConstructor>(
+  | Protocol<D>["Actor"]["DecodingServices"]
+  | Protocol<D>["F"]["Payload"]["EncodingServices"]
+> => {
+  const { F, Actor } = client.protocol
+  const encodeFPayload = encodeJsonString(F.Payload)
+  const decodeActor = decodeJsonString(Actor)
+
+  return make<Self, Id, D, Socket.WebSocketConstructor>(
     client,
     Effect.gen(function* () {
       const socket = yield* Socket.makeWebSocket(url ?? "/", {
@@ -444,49 +395,29 @@ export const layerSocket = <
             .runRaw((raw) =>
               pipe(
                 raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw,
-                S.decodeUnknownEffect(S.fromJsonString(S.toCodecJson(client.schema.actor))),
+                decodeActor,
                 Effect.andThen(publish),
               ),
             )
             .pipe(
-              Effect.catchTag(
-                "SocketError",
+              Effect.catchIf(
+                Socket.isSocketError,
                 Effect.fnUntraced(function* (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 "SocketCloseError": {
-                      const { code, closeReason } = reason
-                      switch (code) {
-                        case 1000: {
-                          return yield* publish({ _tag: "Disconnect" })
-                        }
-                        case 4003: {
-                          return yield* S.decodeUnknownEffect(S.fromJsonString(Protocol.AuditionFailure))(
-                            closeReason,
-                          ).pipe(Effect.andThen(publish))
-                        }
-                      }
-                      yield* debug("SocketCloseError", { cause })
-                      return yield* publish({ _tag: "TransportFailure", 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 })
                 }),
               ),
-              Effect.catchTag("SchemaError", Effect.die),
             )
         }, span("listen")),
         send: Effect.fnUntraced(
           function* (v) {
             const write = yield* socket.writer
-            const message = yield* S.encodeEffect(S.fromJsonString(S.toCodecJson(client.schema.f.payload)))(v).pipe(
-              Effect.mapError((cause) => new ConnectionError({ cause })),
-            )
+            const message = yield* encodeFPayload(v)
             yield* write(message).pipe(
               Effect.catchTag("SocketError", (cause) => new ConnectionError({ cause }).asEffect()),
             )
@@ -498,37 +429,28 @@ export const layerSocket = <
     }),
     replay,
   )
+}
 
-export const layerWorker = <
-  ClientSelf,
-  ClientId extends string,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
->({
+export const layerWorker = <Self, Id extends string, D extends ProtocolDefinition, T extends Protocol<D>>({
   client,
   replay,
 }: {
-  readonly client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>
+  readonly client: Client<Self, Id, D>
   readonly replay?: ReplayConfig | undefined
 }): Layer.Layer<
-  ClientSelf,
+  Self,
   never,
-  | Worker.WorkerPlatform
-  | Worker.Spawner
-  | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["actor"]["DecodingServices"]
-  | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]
+  Worker.WorkerPlatform | Worker.Spawner | T["Actor"]["DecodingServices"] | T["F"]["Payload"]["EncodingServices"]
 > =>
-  make<ClientSelf, ClientId, MethodDefinitions, EventDefinitions, Worker.WorkerPlatform | Worker.Spawner>(
+  make<Self, Id, D, Worker.WorkerPlatform | Worker.Spawner>(
     client,
     Effect.gen(function* () {
-      type T = typeof client.schema
-
       const platform = yield* Worker.WorkerPlatform
       const backing = yield* platform
-        .spawn<T["actor"]["Type"], T["f"]["payload"]["Type"] | string>(0)
+        .spawn<T["Actor"]["Type"], T["Client"]["Type"]>(0)
         .pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()))
 
-      const send = (message: T["f"]["payload"]["Type"]) =>
+      const send = (message: T["Client"]["Type"]) =>
         backing.send(message).pipe(
           Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()),
           span("send"),
@@ -537,18 +459,27 @@ export const layerWorker = <
       return {
         listen: Effect.fnUntraced(function* (publish) {
           const stop = yield* Deferred.make<void>()
-          yield* Effect.raceFirst(
-            backing.run(
+          yield* backing
+            .run(
               Effect.fnUntraced(function* (message) {
                 yield* publish(message)
-                if (message._tag === "Disconnect" || message._tag === "AuditionFailure") {
+                if (message._tag === "Disconnect" || message._tag === "Audition.Failure") {
                   yield* Deferred.succeed(stop, void 0)
                 }
               }),
-              { onSpawn: backing.send(client.key).pipe(Effect.orDie) },
-            ),
-            Deferred.await(stop),
-          ).pipe(Effect.catchTag("WorkerError", (cause) => publish({ _tag: "TransportFailure", cause })))
+              {
+                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")),
         send,
       }

package/ClientDirectory.ts

@@ -0,0 +1,104 @@
+import { Schema as S, Effect, Cause, Ref } from "effect"
+
+import type { TopFromString } from "./_util/schema.ts"
+import type { Actor } from "./Actor.ts"
+import type { ActorTransport } from "./ActorTransport.ts"
+import type { ProtocolDefinition, Disconnect, Protocol } from "./Protocol.ts"
+
+import * as Diagnostic from "./_util/Diagnostic.ts"
+import { phantom } from "./_util/phantom.ts"
+import * as ClientHandle from "./ClientHandle.ts"
+
+const { span } = Diagnostic.module("ClientDirectory")
+
+export interface ClientDirectory<
+  Raw,
+  ActorSelf,
+  AttachmentFields extends S.Struct.Fields,
+  D extends ProtocolDefinition,
+> {
+  readonly "": {
+    readonly Handle: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
+  }
+
+  readonly handles: ReadonlySet<this[""]["Handle"]>
+
+  readonly register: (
+    raw: Raw,
+    attachments: S.Struct<AttachmentFields>["Type"],
+  ) => Effect.Effect<this[""]["Handle"], S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
+
+  readonly get: (raw: Raw) => Effect.Effect<this[""]["Handle"], Cause.NoSuchElementError>
+
+  readonly unregister: (raw: Raw) => Effect.Effect<void>
+}
+
+export interface HandleEncoders<T, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
+  attachments: (
+    value: S.Struct<AttachmentFields>["Type"],
+  ) => Effect.Effect<T, S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
+  event: (
+    value: Protocol<D>["Event"]["Type"],
+  ) => Effect.Effect<T, S.SchemaError, Protocol<D>["Event"]["EncodingServices"]>
+  disconnect: Effect.Effect<T, S.SchemaError, (typeof Disconnect)["EncodingServices"]>
+}
+
+export const make = <
+  Raw,
+  ActorSelf,
+  ActorId extends string,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  ClientSelf,
+  ClientId extends string,
+  D extends ProtocolDefinition,
+>(
+  _actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>,
+  { send, close, snapshot }: ActorTransport<Raw, AttachmentFields, D>,
+): ClientDirectory<Raw, ActorSelf, AttachmentFields, D> => {
+  type Handle = ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
+
+  const raws = new Map<Raw, Handle>()
+  const handles = new Set<Handle>()
+
+  const get = (raw: Raw) => Effect.fromNullishOr(raws.get(raw))
+
+  const register = Effect.fnUntraced(function* (raw: Raw, attachments: S.Struct<AttachmentFields>["Type"]) {
+    yield* snapshot(raw, attachments)
+    const attachmentsRef = yield* Ref.make(attachments)
+    const handle: Handle = ClientHandle.make({
+      attachments: Ref.get(attachmentsRef),
+      save: Effect.fnUntraced(function* (attachments) {
+        yield* Ref.set(attachmentsRef, attachments)
+        yield* snapshot(raw, attachments)
+      }),
+      send: (_tag, payload) =>
+        send(raw, {
+          _tag: "Event",
+          event: { _tag, ...payload } as never,
+        }),
+      disconnect: close(raw).pipe(
+        Effect.andThen(() =>
+          Effect.sync(() => {
+            raws.delete(raw)
+            handles.delete(handle)
+          }),
+        ),
+      ),
+    })
+    raws.set(raw, handle)
+    handles.add(handle)
+    return handle
+  }, span("register"))
+
+  const unregister = (raw: Raw) =>
+    Effect.sync(() => {
+      const handle = raws.get(raw)
+      if (handle) {
+        raws.delete(raw)
+        handles.delete(handle)
+      }
+    }).pipe(span("unregister"))
+
+  return { ...phantom, handles, register, get, unregister }
+}

package/ClientHandle.ts

@@ -1,17 +1,14 @@
 import { Schema as S, Effect } from "effect"
 
+import type { ProtocolDefinition } from "./Protocol.ts"
 import type { Send } from "./Send.ts"
 
 const TypeId = "~liminal/ClientHandle" as const
 
-export interface ClientHandle<
-  ActorSelf,
-  AttachmentFields extends S.Struct.Fields,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
-> {
+export interface ClientHandle<ActorSelf, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
   readonly [TypeId]: typeof TypeId
 
-  readonly send: Send<ActorSelf, EventDefinitions>
+  readonly send: Send<ActorSelf, D>
 
   readonly attachments: Effect.Effect<S.Struct<AttachmentFields>["Type"]>
 
@@ -22,17 +19,13 @@ export interface ClientHandle<
   readonly disconnect: Effect.Effect<void, never, ActorSelf>
 }
 
-export const make = <
-  ActorSelf,
-  AttachmentFields extends S.Struct.Fields,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
->({
+export const make = <ActorSelf, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition>({
   send,
   attachments,
   save,
   disconnect,
 }: {
-  readonly send: Send<ActorSelf, EventDefinitions>
+  readonly send: Send<ActorSelf, D>
 
   readonly attachments: Effect.Effect<S.Struct<AttachmentFields>["Type"]>
 
@@ -41,7 +34,7 @@ export const make = <
   ) => Effect.Effect<void, S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
 
   readonly disconnect: Effect.Effect<void, never, ActorSelf>
-}): ClientHandle<ActorSelf, AttachmentFields, EventDefinitions> => ({
+}): ClientHandle<ActorSelf, AttachmentFields, D> => ({
   [TypeId]: TypeId,
   send,
   attachments,

package/F.ts

@@ -1,12 +1,10 @@
-import { Record, Effect } from "effect"
+import { Effect } from "effect"
 
 import type { FError } from "./errors.ts"
-import type { MethodDefinition } from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
 
-export type F<ClientSelf, MethodDefinitions extends Record<string, MethodDefinition.Any>> = <
-  Method extends keyof MethodDefinitions,
->(
+export type F<Self, D extends ProtocolDefinition> = <Method extends keyof D["methods"]>(
   method: Method,
 ) => (
-  payload: MethodDefinitions[Method]["payload"]["Type"],
-) => Effect.Effect<MethodDefinitions[Method]["success"]["Type"], FError<MethodDefinitions>, ClientSelf>
+  payload: D["methods"][Method]["payload"]["Type"],
+) => Effect.Effect<D["methods"][Method]["success"]["Type"], FError<D>, Self>