liminal 0.17.5 → 0.17.6

package/Protocol.ts

@@ -1,120 +1,161 @@
-import { Schema as S, Record } from "effect"
+import { flow, Schema as S, Record, Types, Effect, SchemaAST } from "effect"
 
-import type { MethodDefinition } from "./Method.ts"
+import type * as Method from "./Method.ts"
 
-export const AuditionSuccess = S.TaggedStruct("AuditionSuccess", {})
+export interface ProtocolDefinition<
+  Methods extends Record<string, Method.Any> = Record<string, Method.Any>,
+  Events extends Record<string, S.Struct.Fields> = Record<string, S.Struct.Fields>,
+> {
+  readonly methods: Methods
 
-export const AuditionFailure = S.TaggedStruct("AuditionFailure", {
-  client: S.String,
-  routed: S.String,
-})
+  readonly events: Events
+}
 
-export interface ProtocolSchemas<
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
-> {
-  readonly f: {
-    readonly payload: S.TaggedStruct<
-      "FPayload",
+export declare namespace ProtocolDefinition {
+  export type Merge<T extends ProtocolDefinition, U extends ProtocolDefinition> = ProtocolDefinition<
+    [T] extends [never]
+      ? U["methods"]
+      : {
+          [K in keyof T["methods"] & keyof U["methods"] as Types.Equals<T["methods"][K], U["methods"][K]> extends true
+            ? K
+            : never]: T["methods"][K]
+        },
+    [T] extends [never] ? U["events"] : T["events"] & U["events"]
+  >
+}
+
+const parseJson = flow(S.toCodecJson, S.fromJsonString)
+const decode = flow(parseJson, S.decodeUnknownEffect)
+const encode = flow(parseJson, S.encodeEffect)
+
+export interface Protocol<D extends ProtocolDefinition> {
+  readonly Audition: {
+    readonly Success: S.TaggedStruct<"Audition.Success", {}>
+    readonly Failure: S.TaggedStruct<
+      "Audition.Failure",
+      {
+        client: S.String
+        routed: S.String
+      }
+    >
+  }
+
+  readonly Event: S.TaggedStruct<
+    "Event",
+    {
+      readonly event: S.TaggedUnion<{
+        readonly [K in keyof D["events"] & string]: S.TaggedStruct<K, D["events"][K]>
+      }>
+    }
+  >
+
+  readonly F: {
+    readonly Payload: S.TaggedStruct<
+      "F.Payload",
       {
         readonly id: S.Int
         readonly payload: S.TaggedUnion<{
-          readonly [K in keyof MethodDefinitions & string]: S.TaggedStruct<
-            K,
-            { readonly value: MethodDefinitions[K]["payload"] }
-          >
+          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["payload"] }>
         }>
       }
     >
 
-    readonly success: S.TaggedStruct<
-      "FSuccess",
+    readonly Success: S.TaggedStruct<
+      "F.Success",
       {
         readonly id: S.Int
         readonly success: S.TaggedUnion<{
-          readonly [K in keyof MethodDefinitions & string]: S.TaggedStruct<
-            K,
-            { readonly value: MethodDefinitions[K]["success"] }
-          >
+          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["success"] }>
         }>
       }
     >
 
-    readonly failure: S.TaggedStruct<
-      "FFailure",
+    readonly Failure: S.TaggedStruct<
+      "F.Failure",
       {
         readonly id: S.Int
         readonly failure: S.TaggedUnion<{
-          readonly [K in keyof MethodDefinitions & string]: S.TaggedStruct<
-            K,
-            { readonly value: MethodDefinitions[K]["failure"] }
-          >
+          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["failure"] }>
         }>
       }
     >
   }
 
-  readonly event: S.TaggedStruct<
-    "Event",
-    {
-      readonly event: S.TaggedUnion<{
-        readonly [K in keyof EventDefinitions & string]: S.TaggedStruct<K, EventDefinitions[K]>
-      }>
-    }
-  >
+  readonly Disconnect: S.TaggedStruct<"Disconnect", {}>
 
-  readonly actor: S.Union<
+  readonly Actor: S.Union<
     [
-      typeof AuditionSuccess,
-      typeof AuditionFailure,
-      this["f"]["success"],
-      this["f"]["failure"],
-      this["event"],
-      typeof Disconnect,
+      this["Audition"]["Success"],
+      this["Audition"]["Failure"],
+      this["F"]["Success"],
+      this["F"]["Failure"],
+      this["Event"],
+      this["Disconnect"],
     ]
   >
+
+  readonly encodeFPayload: (
+    input: this["F"]["Payload"]["Type"],
+    options?: SchemaAST.ParseOptions,
+  ) => Effect.Effect<string, S.SchemaError, this["F"]["Payload"]["EncodingServices"]>
+
+  readonly decodeEvent: (
+    input: unknown,
+    options?: SchemaAST.ParseOptions,
+  ) => Effect.Effect<this["Event"]["Type"], S.SchemaError, this["Event"]["DecodingServices"]>
+
+  readonly decodeActor: (
+    input: unknown,
+    options?: SchemaAST.ParseOptions,
+  ) => Effect.Effect<this["Actor"]["Type"], S.SchemaError, this["Actor"]["DecodingServices"]>
 }
 
-export const Disconnect = S.TaggedStruct("Disconnect", {})
+const Disconnect = S.TaggedStruct("Disconnect", {})
 
-export const TransportFailure = S.TaggedStruct("TransportFailure", { cause: S.Unknown })
+const Audition = {
+  Success: S.TaggedStruct("Audition.Success", {}),
+  Failure: S.TaggedStruct("Audition.Failure", {
+    client: S.String,
+    routed: S.String,
+  }),
+}
 
-export const ProtocolSchemas = <
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
->(
-  methods: MethodDefinitions,
-  events: EventDefinitions,
-): ProtocolSchemas<MethodDefinitions, EventDefinitions> => {
-  type T = ProtocolSchemas<MethodDefinitions, EventDefinitions>
+export const Protocol = <D extends ProtocolDefinition>({ events, methods }: D): Protocol<D> => {
+  type T = Protocol<D>
 
-  const f: T["f"] = {
-    payload: S.TaggedStruct("FPayload", {
+  const F: T["F"] = {
+    Payload: S.TaggedStruct("F.Payload", {
       id: S.Int,
       payload: S.TaggedUnion(Record.map(methods, ({ payload: value }) => ({ value }))),
     }) as never,
-    success: S.TaggedStruct("FSuccess", {
+    Success: S.TaggedStruct("F.Success", {
       id: S.Int,
       success: S.TaggedUnion(Record.map(methods, ({ success: value }) => ({ value }))),
     }) as never,
-    failure: S.TaggedStruct("FFailure", {
+    Failure: S.TaggedStruct("F.Failure", {
       id: S.Int,
       failure: S.TaggedUnion(Record.map(methods, ({ failure: value }) => ({ value }))),
     }) as never,
   }
 
-  const event: T["event"] = S.TaggedStruct("Event", {
+  const Event: T["Event"] = S.TaggedStruct("Event", {
     event: S.TaggedUnion(events),
   }) as never
 
-  const actor: T["actor"] = S.Union([
-    AuditionSuccess,
-    AuditionFailure,
-    f.success,
-    f.failure,
-    event,
-    Disconnect,
-  ]) as never
+  const Actor: T["Actor"] = S.Union([Audition.Success, Audition.Failure, F.Success, F.Failure, Event, Disconnect])
+
+  const encodeFPayload = encode(F.Payload)
+  const decodeEvent = decode(Event)
+  const decodeActor = decode(Actor)
 
-  return { f, event, actor }
+  return {
+    Audition,
+    Event,
+    F,
+    Actor,
+    Disconnect,
+    encodeFPayload,
+    decodeEvent,
+    decodeActor,
+  }
 }

package/Send.ts

@@ -1,12 +1,8 @@
 import { Schema as S, Effect } from "effect"
 
-export type Send<ActorSelf, EventDefinitions extends Record<string, S.Struct.Fields>> = <
-  K extends keyof EventDefinitions,
->(
+import type { ProtocolDefinition } from "./Protocol.ts"
+
+export type Send<ActorSelf, D extends ProtocolDefinition> = <K extends keyof D["events"]>(
   tag: K,
-  payload: S.Struct<EventDefinitions[K]>["Type"],
-) => Effect.Effect<
-  void,
-  S.SchemaError,
-  ActorSelf | ReturnType<typeof S.TaggedUnion<EventDefinitions>>["EncodingServices"]
->
+  payload: S.Struct<D["events"][K]>["Type"],
+) => Effect.Effect<void, S.SchemaError, ActorSelf | ReturnType<typeof S.TaggedUnion<D["events"]>>["EncodingServices"]>

package/dist/Actor.d.ts

@@ -1,29 +1,29 @@
 import { Context, Schema as S, Effect } from "effect";
 import type * as ActorClient from "./Client.ts";
 import type * as ClientHandle from "./ClientHandle.ts";
-import type { MethodDefinition } from "./Method.ts";
+import type { ProtocolDefinition } from "./Protocol.ts";
 import type { Send } from "./Send.ts";
 import * as Method from "./Method.ts";
 export declare const TypeId: "~liminal/Actor";
-export interface Service<ActorSelf, NameA, AttachmentFields extends S.Struct.Fields, EventDefinitions extends Record<string, S.Struct.Fields>> {
+export interface Service<ActorSelf, NameA, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
     readonly name: NameA;
-    readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>;
-    readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>>;
+    readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>;
+    readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>>;
 }
-export interface ActorDefinition<NameA, AttachmentFields extends S.Struct.Fields, ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends Record<string, S.Struct.Fields>> {
+export interface ActorDefinition<NameA, AttachmentFields extends S.Struct.Fields, ClientSelf, ClientId extends string, D extends ProtocolDefinition> {
     readonly name: S.Codec<NameA, string>;
     readonly attachments: AttachmentFields;
-    readonly client: ActorClient.Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;
+    readonly client: ActorClient.Client<ClientSelf, ClientId, D>;
 }
-export interface Actor<ActorSelf, ActorId extends string, NameA, AttachmentFields extends S.Struct.Fields, ActorClientSelf, ActorClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends Record<string, S.Struct.Fields>> extends Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>> {
-    new (_: never): Context.ServiceClass.Shape<ActorId, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>;
+export interface Actor<ActorSelf, ActorId extends string, NameA, AttachmentFields extends S.Struct.Fields, ActorClientSelf, ActorClientId extends string, D extends ProtocolDefinition> extends Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, D>> {
+    new (_: never): Context.ServiceClass.Shape<ActorId, Service<ActorSelf, NameA, AttachmentFields, D>>;
     readonly [TypeId]: typeof TypeId;
-    readonly definition: ActorDefinition<NameA, AttachmentFields, ActorClientSelf, ActorClientId, MethodDefinitions, EventDefinitions>;
-    readonly schema: {
-        readonly attachments: S.Codec<S.Struct<AttachmentFields>["Type"], S.Struct<AttachmentFields>["Encoded"]>;
+    readonly definition: ActorDefinition<NameA, AttachmentFields, ActorClientSelf, ActorClientId, D>;
+    readonly protocol: {
+        readonly Attachments: S.Struct<AttachmentFields>;
     };
-    readonly sendAll: Send<ActorSelf, EventDefinitions>;
+    readonly sendAll: Send<ActorSelf, D>;
     readonly disconnectAll: Effect.Effect<void, never, ActorSelf>;
-    readonly handler: <K extends keyof MethodDefinitions, R>(tag: K, f: Method.Handler<MethodDefinitions[K], R>) => Method.Handler<MethodDefinitions[K], R>;
+    readonly handler: <K extends keyof D["methods"], R>(tag: K, f: Method.Handler<D["methods"][K], R>) => Method.Handler<D["methods"][K], R>;
 }
-export declare const Service: <ActorSelf>() => <ActorId extends string, NameA, AttachmentFields extends S.Struct.Fields, ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends Record<string, S.Struct.Fields>>(id: ActorId, definition: ActorDefinition<NameA, AttachmentFields, ClientSelf, ClientId, MethodDefinitions, EventDefinitions>) => Actor<ActorSelf, ActorId, NameA, AttachmentFields, ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;
+export declare const Service: <ActorSelf>() => <ActorId extends string, NameA, D extends ProtocolDefinition, AttachmentFields extends S.Struct.Fields, ClientSelf, ClientId extends string>(id: ActorId, definition: ActorDefinition<NameA, AttachmentFields, ClientSelf, ClientId, D>) => Actor<ActorSelf, ActorId, NameA, AttachmentFields, ClientSelf, ClientId, D>;

package/dist/Actor.js

@@ -11,8 +11,8 @@ export const Service = () => (id, definition) => {
     return Object.assign(tag, {
         [TypeId]: TypeId,
         definition,
-        schema: {
-            attachments: S.Struct(definition.attachments),
+        protocol: {
+            Attachments: S.Struct(definition.attachments),
         },
         sendAll,
         disconnectAll,

package/dist/Actor.js.map

@@ -1 +1 @@
-{"version":3,"file":"Actor.js","sourceRoot":"","sources":["../Actor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAOrD,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;AAE3C,MAAM,CAAC,MAAM,MAAM,GAAG,gBAAyB,CAAA;AAmE/C,MAAM,CAAC,MAAM,OAAO,GAClB,GAAc,EAAE,CAChB,CASE,EAAW,EACX,UAA+G,EACA,EAAE;IACjH,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,EAA4E,CAAC,EAAE,CAAC,CAAA;IAE3G,MAAM,OAAO,GAAsC,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CAClE,GAAG,CAAC,QAAQ,EAAE,CAAC,IAAI,CACjB,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAC7B,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC7F,EACD,IAAI,CAAC,SAAS,CAAC,CAChB,CAAA;IAEH,MAAM,aAAa,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC,IAAI,CACvC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EACxF,IAAI,CAAC,eAAe,CAAC,CACtB,CAAA;IAED,MAAM,OAAO,GAAG,CACd,IAAO,EACP,CAA0C,EACD,EAAE,CAAC,CAAC,CAAA;IAE/C,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;QACxB,CAAC,MAAM,CAAC,EAAE,MAAM;QAChB,UAAU;QACV,MAAM,EAAE;YACN,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAU;SACvD;QACD,OAAO;QACP,aAAa;QACb,OAAO;KACR,CAAC,CAAA;AACJ,CAAC,CAAA"}
+{"version":3,"file":"Actor.js","sourceRoot":"","sources":["../Actor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAOrD,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;AAE3C,MAAM,CAAC,MAAM,MAAM,GAAG,gBAAyB,CAAA;AAqD/C,MAAM,CAAC,MAAM,OAAO,GAClB,GAAc,EAAE,CAChB,CAQE,EAAW,EACX,UAA6E,EACA,EAAE;IAC/E,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,EAA6D,CAAC,EAAE,CAAC,CAAA;IAE5F,MAAM,OAAO,GAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CACnD,GAAG,CAAC,QAAQ,EAAE,CAAC,IAAI,CACjB,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAC7B,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,CAC7F,EACD,IAAI,CAAC,SAAS,CAAC,CAChB,CAAA;IAEH,MAAM,aAAa,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC,IAAI,CACvC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EACxF,IAAI,CAAC,eAAe,CAAC,CACtB,CAAA;IAED,MAAM,OAAO,GAAG,CACd,IAAO,EACP,CAAqC,EACD,EAAE,CAAC,CAAC,CAAA;IAE1C,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;QACxB,CAAC,MAAM,CAAC,EAAE,MAAM;QAChB,UAAU;QACV,QAAQ,EAAE;YACR,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC;SAC9C;QACD,OAAO;QACP,aAAa;QACb,OAAO;KACR,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/dist/Audition.d.ts

@@ -1,17 +1,17 @@
 import { Schema as S, Pipeable, Stream } from "effect";
 import type { F } from "./F.ts";
-import type * as Method from "./Method.ts";
+import type { ProtocolDefinition } from "./Protocol.ts";
 import * as Client from "./Client.ts";
 import { type ClientError } from "./errors.ts";
 declare const TypeId: "~liminal/Audition";
-export interface Audition<ClientSelf, MethodDefinitions extends Record<string, Method.MethodDefinition.Any>, Event> extends Pipeable.Pipeable {
+export interface Audition<ClientSelf, D extends ProtocolDefinition> extends Pipeable.Pipeable {
     readonly [TypeId]: typeof TypeId;
-    readonly events: Stream.Stream<Event, ClientError, ClientSelf>;
-    readonly f: F<ClientSelf, MethodDefinitions>;
+    readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError, ClientSelf>;
+    readonly f: F<ClientSelf, D>;
 }
-export declare const empty: Audition<never, never, never>;
+export declare const empty: Audition<never, never>;
 export declare const add: {
-    <ClientSelf, ClientId extends string, ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, ClientEventDefinitions extends Record<string, S.Struct.Fields>>(client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>): <AuditionSelf, AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, AuditionEvent>(audition: Audition<AuditionSelf, AuditionMethodDefinitions, AuditionEvent>) => Audition<AuditionSelf | ClientSelf, Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>, AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]>;
-    <AuditionClientSelf, AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, AuditionEvent, ClientSelf, ClientId extends string, ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, ClientEventDefinitions extends Record<string, S.Struct.Fields>>(audition: Audition<AuditionClientSelf, AuditionMethodDefinitions, AuditionEvent>, client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>): Audition<AuditionClientSelf | ClientSelf, Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>, AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]>;
+    <ClientSelf, ClientId extends string, ClientD extends ProtocolDefinition>(client: Client.Client<ClientSelf, ClientId, ClientD>): <AuditionSelf, AuditionD extends ProtocolDefinition>(audition: Audition<AuditionSelf, AuditionD>) => Audition<AuditionSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>>;
+    <AuditionClientSelf, AuditionD extends ProtocolDefinition, ClientSelf, ClientId extends string, ClientD extends ProtocolDefinition>(audition: Audition<AuditionClientSelf, AuditionD>, client: Client.Client<ClientSelf, ClientId, ClientD>): Audition<AuditionClientSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>>;
 };
 export {};

package/dist/Audition.js.map

@@ -1 +1 @@
-{"version":3,"file":"Audition.js","sourceRoot":"","sources":["../Audition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAKxE,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAA;AAE7D,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;AAErD,MAAM,MAAM,GAAG,mBAA4B,CAAA;AAW3C,MAAM,CAAC,MAAM,KAAK,GAAkC;IAClD,CAAC,MAAM,CAAC,EAAE,MAAM;IAChB,IAAI;QACF,OAAO,QAAQ,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAChD,CAAC;IACD,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,aAAa,EAAE,CAAC;IACxC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,aAAa,EAAE,CAAC,QAAQ,EAAE;CAC9C,CAAA;AAED,MAAM,CAAC,MAAM,GAAG,GA+BZ,QAAQ,CAAC,IAAI,CACf,CAAC,EACD,CASE,QAA0E,EAC1E,MAA4F,EAK5F,EAAE;IACF,MAAM,CAAC,GAGH,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,CAC1B,QAAQ;SACL,CAAC,CAAC,MAAe,CAAC,CAAC,OAAO,CAAC;SAC3B,IAAI,CACH,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,MAAe,CAAC,CAAC,OAAO,CAAC,CAAC,EAC1E,IAAI,CAAC,GAAG,CAAC,CACV,CAAA;IAEL,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CACjC,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE,CACpC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAChC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,EACjE,MAAM,CAAC,MAAM,CACd,CACF,CACF,CAAA;IAED,OAAO;QACL,CAAC,MAAM,CAAC,EAAE,MAAM;QAChB,IAAI;YACF,OAAO,QAAQ,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;QAChD,CAAC;QACD,MAAM;QACN,CAAC;KACF,CAAA;AACH,CAAC,CACF,CAAA"}
+{"version":3,"file":"Audition.js","sourceRoot":"","sources":["../Audition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAKxE,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAA;AAE7D,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;AAErD,MAAM,MAAM,GAAG,mBAA4B,CAAA;AAc3C,MAAM,CAAC,MAAM,KAAK,GAA2B;IAC3C,CAAC,MAAM,CAAC,EAAE,MAAM;IAChB,IAAI;QACF,OAAO,QAAQ,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAChD,CAAC;IACD,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,aAAa,EAAE,CAAC;IACxC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,aAAa,EAAE,CAAC,QAAQ,EAAE;CAC9C,CAAA;AAED,MAAM,CAAC,MAAM,GAAG,GAgBZ,QAAQ,CAAC,IAAI,CACf,CAAC,EACD,CAOE,QAA2C,EAC3C,MAAoD,EAC+B,EAAE;IACrF,MAAM,CAAC,GAA+E,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5G,QAAQ;SACL,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;SAClB,IAAI,CACH,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,EACjE,IAAI,CAAC,GAAG,CAAC,CACV,CAAA;IAEL,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CACjC,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE,CACpC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAChC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,EACjE,MAAM,CAAC,MAAM,CACd,CACF,CACF,CAAA;IAED,OAAO;QACL,CAAC,MAAM,CAAC,EAAE,MAAM;QAChB,IAAI;YACF,OAAO,QAAQ,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;QAChD,CAAC;QACD,MAAM;QACN,CAAC;KACF,CAAA;AACH,CAAC,CACF,CAAA"}

package/dist/Client.d.ts

@@ -1,46 +1,41 @@
 import { Context, Effect, Layer, RcRef, Scope, Stream, Schema as S } from "effect";
 import { Socket } from "effect/unstable/socket";
 import { Worker } from "effect/unstable/workers";
-import type { MethodDefinition } from "./Method.ts";
-import { type ClientError, ConnectionError } from "./errors.ts";
+import { type ClientError } from "./errors.ts";
 import { type F } from "./F.ts";
-import * as Protocol from "./Protocol.ts";
+import { Protocol, type ProtocolDefinition } from "./Protocol.ts";
 export declare const TypeId: "~liminal/Client";
-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";
     readonly limit?: number | undefined;
 }
-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>;
-    readonly f: F<ClientSelf, MethodDefinitions>;
+export interface Session<Self, D extends ProtocolDefinition> {
+    readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError>;
+    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 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 type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<Session<ClientSelf, D>, ClientError>;
+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 schema: Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>;
-    readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<EventDefinitions>>["Type"], ClientError, ClientSelf>;
-    readonly f: F<ClientSelf, MethodDefinitions>;
-    readonly invalidate: Effect.Effect<void, never, ClientSelf>;
+    readonly definition: D;
+    readonly protocol: Protocol<D>;
+    readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError, Self>;
+    readonly f: F<Self, D>;
+    readonly invalidate: Effect.Effect<void, never, Self>;
 }
-export declare 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>;
-export interface Transport<MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends Record<string, S.Struct.Fields>> {
-    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"]>;
-    readonly send: (message: Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["Type"]) => Effect.Effect<void, ConnectionError, Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]>;
+export declare const Service: <Self>() => <Id extends string, D extends ProtocolDefinition>(id: Id, definition: D) => Client<Self, Id, D>;
+export interface ClientTransport<D extends ProtocolDefinition> {
+    readonly listen: (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<D>["F"]["Payload"]["Type"]) => Effect.Effect<void, ClientError | S.SchemaError, Protocol<D>["F"]["Payload"]["EncodingServices"]>;
 }
-export declare const layerSocket: <ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends Record<string, S.Struct.Fields>>({ client, url, protocols, replay, }: {
-    readonly client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;
+export declare const layerSocket: <Self, Id extends string, D extends ProtocolDefinition>({ client, url, protocols, replay, }: {
+    readonly client: Client<Self, Id, D>;
     readonly url?: string | undefined;
     readonly protocols?: string | Array<string> | undefined;
     readonly replay?: ReplayConfig | undefined;
-}) => Layer.Layer<ClientSelf, never, Socket.WebSocketConstructor | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["actor"]["DecodingServices"] | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]>;
-export declare const layerWorker: <ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends Record<string, S.Struct.Fields>>({ client, replay, }: {
-    readonly client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;
+}) => Layer.Layer<Self, never, Socket.WebSocketConstructor | Protocol<D>["Actor"]["DecodingServices"] | Protocol<D>["F"]["Payload"]["EncodingServices"]>;
+export declare const layerWorker: <Self, Id extends string, D extends ProtocolDefinition>({ client, replay, }: {
+    readonly client: Client<Self, Id, D>;
     readonly replay?: ReplayConfig | undefined;
-}) => Layer.Layer<ClientSelf, never, Worker.WorkerPlatform | Worker.Spawner | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["actor"]["DecodingServices"] | Protocol.ProtocolSchemas<MethodDefinitions, EventDefinitions>["f"]["payload"]["EncodingServices"]>;
+}) => Layer.Layer<Self, never, Worker.WorkerPlatform | Worker.Spawner | Protocol<D>["Actor"]["DecodingServices"] | Protocol<D>["F"]["Payload"]["EncodingServices"]>;

package/dist/Client.js

@@ -1,14 +1,15 @@
-import { Context, Encoding, Deferred, Effect, Layer, Option, PubSub, RcRef, Record, pipe, Ref, Scope, Stream, Take, Schema as S, Array, Struct, Fiber, Exit, Cause, Result, flow, identity, } from "effect";
+import { Context, Encoding, Deferred, Effect, Layer, Option, PubSub, RcRef, Record, pipe, Ref, Scope, Stream, Take, Schema as S, Array, Struct, Fiber, Exit, Cause, Result, flow, } from "effect";
 import { Socket } from "effect/unstable/socket";
 import { Worker } from "effect/unstable/workers";
 import * as Diagnostic from "./_util/Diagnostic.js";
 import { AuditionError, ConnectionError, UnresolvedError } from "./errors.js";
 import {} from "./F.js";
-import * as Protocol from "./Protocol.js";
+import { Protocol } from "./Protocol.js";
 const { debug, span } = Diagnostic.module("Client");
 export const TypeId = "~liminal/Client";
 export const Service = () => (id, definition) => {
     const tag = Context.Service()(id);
+    const protocol = Protocol(definition);
     const events = tag.asEffect().pipe(Effect.flatMap(RcRef.get), Effect.map(Struct.get("events")), Stream.unwrap);
     const f = (_tag) => Effect.fnUntraced(function* (value) {
         const { f } = yield* tag.asEffect().pipe(Effect.flatMap(RcRef.get));
@@ -18,7 +19,7 @@ export const Service = () => (id, definition) => {
     return Object.assign(tag, {
         [TypeId]: TypeId,
         definition,
-        schema: Protocol.ProtocolSchemas(definition.methods, definition.events),
+        protocol,
         events,
         f,
         invalidate,
@@ -62,33 +63,38 @@ const make = (client, build, replay) => Effect.gen(function* () {
             const end = Scope.close(scope, Exit.void);
             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 { client, routed } = message;
+                        yield* debug("Audition.Failed", { client, routed });
+                        return yield* new AuditionError({ value: { client, routed } });
+                    }
                     case "Event": {
                         const { event } = message;
-                        yield* debug("EventEmitted", { event });
+                        yield* debug("Event.Emitted", { event });
                         yield* publishTake([event], 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;
-                                    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;
-                                    yield* debug("CallFailed", { id, _tag, value });
+                                    yield* debug("Call.Failed", { id, _tag, value });
                                     yield* Deferred.fail(deferred, value);
                                     return;
                                 }
@@ -96,23 +102,13 @@ const make = (client, build, replay) => Effect.gen(function* () {
                         }
                         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),
             ], { concurrency: "unbounded" })), Effect.forkScoped, Effect.provideService(Scope.Scope, scope));
@@ -152,7 +148,7 @@ const make = (client, build, replay) => Effect.gen(function* () {
                     return yield* Exit.match(exit, {
                         onSuccess: () => new UnresolvedError(),
                         onFailure: flow(Cause.findError, Result.match({
-                            onSuccess: identity,
+                            onSuccess: Effect.fail,
                             onFailure: () => new UnresolvedError(),
                         })),
                     });
@@ -161,7 +157,7 @@ const make = (client, build, replay) => Effect.gen(function* () {
                 const inflight = yield* Deferred.make();
                 inflights[id] = inflight;
                 yield* send({
-                    _tag: "FPayload",
+                    _tag: "F.Payload",
                     id,
                     payload: { _tag, value },
                 });
@@ -179,41 +175,27 @@ const make = (client, build, replay) => Effect.gen(function* () {
     return rcr;
 }).pipe(Layer.effect(client));
 export const layerSocket = ({ client, url, protocols, replay, }) => make(client, Effect.gen(function* () {
+    const { protocol } = client;
     const socket = yield* Socket.makeWebSocket(url ?? "/", {
         protocols: ["liminal", 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, S.decodeUnknownEffect(S.fromJsonString(S.toCodecJson(client.schema.actor))), Effect.andThen(publish)))
-                .pipe(Effect.catchTag("SocketError", Effect.fnUntraced(function* (cause) {
+                .runRaw((raw) => pipe(raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw, protocol.decodeActor, Effect.andThen(publish)))
+                .pipe(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" });
                 }
-            })), Effect.catchTag("SchemaError", Effect.die));
+                yield* debug(`SocketErrored.${reason._tag}`, { cause });
+                return yield* new ConnectionError({ cause });
+            })));
         }, 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* protocol.encodeFPayload(v);
             yield* write(message).pipe(Effect.catchTag("SocketError", (cause) => new ConnectionError({ cause }).asEffect()));
         }, span("send"), Effect.scoped),
     };
@@ -229,10 +211,10 @@ export const layerWorker = ({ client, replay, }) => make(client, Effect.gen(func
             const stop = yield* Deferred.make();
             yield* Effect.raceFirst(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(client.key).pipe(Effect.orDie) }), Deferred.await(stop)).pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()));
         }, span("listen")),
         send,
     };