liminal 0.17.5 → 0.17.7

package/Method.ts

@@ -6,17 +6,9 @@ export interface MethodDefinition<Payload extends S.Top, Success extends S.Top,
   readonly failure: Failure
 }
 
-export declare namespace MethodDefinition {
-  export type Any = MethodDefinition<S.Top, S.Top, S.Top>
+export type Any = MethodDefinition<S.Top, S.Top, S.Top>
 
-  export type Merge<T, U> = [T] extends [never]
-    ? U
-    : {
-        [K in keyof T & keyof U]: T[K] extends U[K] ? (U[K] extends T[K] ? T[K] : never) : never
-      }
-}
-
-export const define = <Payload extends S.Top, Success extends S.Top, Failure extends S.Top>({
+export const make = <Payload extends S.Top, Success extends S.Top, Failure extends S.Top>({
   payload,
   success,
   failure,
@@ -26,12 +18,12 @@ export const define = <Payload extends S.Top, Success extends S.Top, Failure ext
   readonly failure: Failure
 }): MethodDefinition<Payload, Success, Failure> => ({ payload, success, failure })
 
-export type Handler<MethodDefinition extends MethodDefinition.Any, R> = (
+export type Handler<MethodDefinition extends Any, R> = (
   payload: MethodDefinition["payload"]["Type"],
 ) => Effect.Effect<MethodDefinition["success"]["Type"], MethodDefinition["failure"]["Type"], R>
 
-export type Handlers<MethodDefinitions extends Record<string, MethodDefinition.Any>, R> = {
+export type Handlers<MethodDefinitions extends Record<string, Any>, R> = {
   [K in keyof MethodDefinitions]: Handler<MethodDefinitions[K], R>
 }
 
-export const handler = <M extends MethodDefinition.Any, R>(_method: M, f: Handler<M, R>): Handler<M, R> => f
+export const handler = <M extends Any, R>(_method: M, f: Handler<M, R>): Handler<M, R> => f

package/Protocol.ts

@@ -1,120 +1,137 @@
-import { Schema as S, Record } from "effect"
+import { Schema as S, Record, Types } 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"]
+  >
+}
+
+export interface Protocol<D extends ProtocolDefinition> {
+  readonly Audition: {
+    readonly Payload: S.TaggedStruct<"Audition.Payload", { client: S.String }>
+    readonly Success: S.TaggedStruct<"Audition.Success", {}>
+    readonly Failure: S.TaggedStruct<
+      "Audition.Failure",
+      {
+        expected: S.String
+        actual: 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 Client: S.Union<[this["Audition"]["Payload"], this["F"]["Payload"], this["Disconnect"]]>
+
+  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"],
     ]
   >
 }
 
 export const Disconnect = S.TaggedStruct("Disconnect", {})
 
-export const TransportFailure = S.TaggedStruct("TransportFailure", { cause: S.Unknown })
+const Audition = {
+  Payload: S.TaggedStruct("Audition.Payload", {
+    client: S.String,
+  }),
+  Success: S.TaggedStruct("Audition.Success", {}),
+  Failure: S.TaggedStruct("Audition.Failure", {
+    expected: S.String,
+    actual: 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 Client: T["Client"] = S.Union([Audition.Payload, F.Payload, Disconnect])
+
+  const Actor: T["Actor"] = S.Union([Audition.Success, Audition.Failure, F.Success, F.Failure, Event, Disconnect])
 
-  return { f, event, actor }
+  return { Audition, Event, F, Client, Actor, Disconnect }
 }

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/_util/schema.ts

@@ -0,0 +1,7 @@
+import { Schema as S, flow } from "effect"
+
+export type TopFromString = S.Codec<any, string, any, any>
+
+const toJsonStringCodec = flow(S.toCodecJson, S.fromJsonString)
+export const encodeJsonString = flow(toJsonStringCodec, S.encodeEffect)
+export const decodeJsonString = flow(toJsonStringCodec, S.decodeUnknownEffect)

package/dist/Actor.d.ts

@@ -1,29 +1,27 @@
 import { Context, Schema as S, Effect } from "effect";
+import type { TopFromString } from "./_util/schema.ts";
 import type * as ActorClient from "./Client.ts";
 import type * as ClientHandle from "./ClientHandle.ts";
-import type { MethodDefinition } from "./Method.ts";
 import type { Send } from "./Send.ts";
 import * as Method from "./Method.ts";
+import { type ProtocolDefinition } from "./Protocol.ts";
 export declare const TypeId: "~liminal/Actor";
-export interface Service<ActorSelf, NameA, AttachmentFields extends S.Struct.Fields, EventDefinitions extends Record<string, S.Struct.Fields>> {
-    readonly name: NameA;
-    readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>;
-    readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>>;
+export interface Service<ActorSelf, Name extends TopFromString, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
+    readonly name: Name["Type"];
+    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>> {
-    readonly name: S.Codec<NameA, string>;
+export interface ActorDefinition<Name extends TopFromString, AttachmentFields extends S.Struct.Fields, ClientSelf, ClientId extends string, D extends ProtocolDefinition> {
+    readonly name: Name;
     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, Name extends TopFromString, AttachmentFields extends S.Struct.Fields, ActorClientSelf, ActorClientId extends string, D extends ProtocolDefinition> extends Context.Service<ActorSelf, Service<ActorSelf, Name, AttachmentFields, D>> {
+    new (_: never): Context.ServiceClass.Shape<ActorId, Service<ActorSelf, Name, 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 sendAll: Send<ActorSelf, EventDefinitions>;
+    readonly definition: ActorDefinition<Name, AttachmentFields, ActorClientSelf, ActorClientId, D>;
+    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, Name extends TopFromString, D extends ProtocolDefinition, AttachmentFields extends S.Struct.Fields, ClientSelf, ClientId extends string>(id: ActorId, definition: ActorDefinition<Name, AttachmentFields, ClientSelf, ClientId, D>) => Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>;

package/dist/Actor.js

@@ -1,6 +1,7 @@
 import { Context, Schema as S, Effect } from "effect";
 import * as Diagnostic from "./_util/Diagnostic.js";
 import * as Method from "./Method.js";
+import {} from "./Protocol.js";
 const { span } = Diagnostic.module("Actor");
 export const TypeId = "~liminal/Actor";
 export const Service = () => (id, definition) => {
@@ -11,9 +12,6 @@ export const Service = () => (id, definition) => {
     return Object.assign(tag, {
         [TypeId]: TypeId,
         definition,
-        schema: {
-            attachments: S.Struct(definition.attachments),
-        },
         sendAll,
         disconnectAll,
         handler,

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;AACrC,OAAO,EAA2B,MAAM,eAAe,CAAA;AAEvD,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;AAE3C,MAAM,CAAC,MAAM,MAAM,GAAG,gBAAyB,CAAA;AAsD/C,MAAM,CAAC,MAAM,OAAO,GAClB,GAAc,EAAE,CAChB,CAQE,EAAW,EACX,UAA4E,EACA,EAAE;IAC9E,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,EAA4D,CAAC,EAAE,CAAC,CAAA;IAE3F,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,OAAO;QACP,aAAa;QACb,OAAO;KACR,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/dist/ActorTransport.d.ts

@@ -0,0 +1,7 @@
+import { Effect, Schema as S } from "effect";
+import type { Protocol, ProtocolDefinition } from "./Protocol.ts";
+export interface ActorTransport<Raw, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
+    readonly send: (transport: Raw, event: Protocol<D>["Event"]["Type"]) => Effect.Effect<void, S.SchemaError, Protocol<D>["Event"]["EncodingServices"]>;
+    readonly close: (transport: Raw) => Effect.Effect<void>;
+    readonly snapshot: (transport: Raw, attachments: S.Struct<AttachmentFields>["Type"]) => Effect.Effect<void, S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>;
+}

package/dist/ActorTransport.js

@@ -0,0 +1,2 @@
+import { Effect, Schema as S } from "effect";
+//# sourceMappingURL=ActorTransport.js.map

package/dist/ActorTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActorTransport.js","sourceRoot":"","sources":["../ActorTransport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,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, T extends Protocol<D>>({ 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 | T["Actor"]["DecodingServices"] | T["F"]["Payload"]["EncodingServices"]>;