liminal 0.17.5 → 0.17.7

package/Actor.ts

@@ -1,12 +1,13 @@
 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 Diagnostic from "./_util/Diagnostic.ts"
 import * as Method from "./Method.ts"
+import { type ProtocolDefinition } from "./Protocol.ts"
 
 const { span } = Diagnostic.module("Actor")
 
@@ -14,86 +15,72 @@ export const TypeId = "~liminal/Actor" as const
 
 export interface Service<
   ActorSelf,
-  NameA,
+  Name extends TopFromString,
   AttachmentFields extends S.Struct.Fields,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
+  D extends ProtocolDefinition,
 > {
-  readonly name: NameA
+  readonly name: Name["Type"]
 
-  readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>
+  readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
 
-  readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>>
+  readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>>
 }
 
 export interface ActorDefinition<
-  NameA,
+  Name extends TopFromString,
   AttachmentFields extends S.Struct.Fields,
   ClientSelf,
   ClientId extends string,
-  MethodDefinitions extends Record<string, MethodDefinition.Any>,
-  EventDefinitions extends Record<string, S.Struct.Fields>,
+  D extends ProtocolDefinition,
 > {
-  readonly name: S.Codec<NameA, string>
+  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,
+  Name extends TopFromString,
   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>>
+  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 definition: ActorDefinition<Name, AttachmentFields, ActorClientSelf, ActorClientId, D>
 
-  readonly sendAll: Send<ActorSelf, EventDefinitions>
+  readonly sendAll: Send<ActorSelf, D>
 
   readonly disconnectAll: Effect.Effect<void, never, ActorSelf>
 
-  readonly handler: <K extends keyof MethodDefinitions, R>(
+  readonly handler: <K extends keyof D["methods"], R>(
     tag: K,
-    f: Method.Handler<MethodDefinitions[K], R>,
-  ) => Method.Handler<MethodDefinitions[K], R>
+    f: Method.Handler<D["methods"][K], R>,
+  ) => Method.Handler<D["methods"][K], R>
 }
 
 export const Service =
   <ActorSelf>() =>
   <
     ActorId extends string,
-    NameA,
+    Name extends TopFromString,
+    D extends ProtocolDefinition,
     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> => {
-    const tag = Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>()(id)
+    definition: ActorDefinition<Name, AttachmentFields, ClientSelf, ClientId, D>,
+  ): Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D> => {
+    const tag = Context.Service<ActorSelf, Service<ActorSelf, Name, AttachmentFields, D>>()(id)
 
-    const sendAll: Send<ActorSelf, EventDefinitions> = (key, payload) =>
+    const sendAll: Send<ActorSelf, D> = (key, payload) =>
       tag.asEffect().pipe(
         Effect.flatMap(({ clients }) =>
           Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" }),
@@ -106,17 +93,14 @@ export const Service =
       span("disconnectAll"),
     )
 
-    const handler = <K extends keyof MethodDefinitions, R>(
+    const handler = <K extends keyof D["methods"], R>(
       _tag: K,
-      f: Method.Handler<MethodDefinitions[K], R>,
-    ): Method.Handler<MethodDefinitions[K], R> => f
+      f: Method.Handler<D["methods"][K], R>,
+    ): Method.Handler<D["methods"][K], R> => f
 
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
-      schema: {
-        attachments: S.Struct(definition.attachments) as never,
-      },
       sendAll,
       disconnectAll,
       handler,

package/ActorTransport.ts

@@ -0,0 +1,17 @@
+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/Audition.ts

@@ -1,7 +1,7 @@
 import { Schema as S, Pipeable, Stream, Effect, Function } from "effect"
 
 import type { F } from "./F.ts"
-import type * as Method from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
 
 import * as Diagnostic from "./_util/Diagnostic.ts"
 import * as Client from "./Client.ts"
@@ -11,16 +11,19 @@ const { debug, span } = Diagnostic.module("Audition")
 
 const TypeId = "~liminal/Audition" as const
 
-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 events: Stream.Stream<
+    ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"],
+    ClientError | S.SchemaError,
+    ClientSelf
+  >
 
-  readonly f: F<ClientSelf, MethodDefinitions>
+  readonly f: F<ClientSelf, D>
 }
 
-export const empty: Audition<never, never, never> = {
+export const empty: Audition<never, never> = {
   [TypeId]: TypeId,
   pipe() {
     return Pipeable.pipeArguments(this, arguments)
@@ -30,62 +33,38 @@ export const empty: Audition<never, never, never> = {
 }
 
 export 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"]
-  >
+  <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,
-    AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    AuditionEvent,
+    AuditionD extends ProtocolDefinition,
     ClientSelf,
     ClientId extends string,
-    ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    ClientEventDefinitions extends Record<string, S.Struct.Fields>,
+    ClientD extends ProtocolDefinition,
   >(
-    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"]
-  >
+    audition: Audition<AuditionClientSelf, AuditionD>,
+    client: Client.Client<ClientSelf, ClientId, ClientD>,
+  ): Audition<AuditionClientSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>>
 } = Function.dual(
   2,
   <
     AuditionSelf,
-    AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    AuditionEvent,
+    AuditionD extends ProtocolDefinition,
     ClientSelf,
     ClientId extends string,
-    ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>,
-    ClientEventDefinitions extends Record<string, S.Struct.Fields>,
+    ClientD extends ProtocolDefinition,
   >(
-    audition: Audition<AuditionSelf, AuditionMethodDefinitions, AuditionEvent>,
-    client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>,
-  ): Audition<
-    AuditionSelf | ClientSelf,
-    Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>,
-    AuditionEvent | ReturnType<typeof S.TaggedUnion<ClientEventDefinitions>>["Type"]
-  > => {
-    const f: F<
-      AuditionSelf | ClientSelf,
-      Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>
-    > = (method) => (payload) =>
+    audition: Audition<AuditionSelf, AuditionD>,
+    client: Client.Client<ClientSelf, ClientId, ClientD>,
+  ): Audition<AuditionSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>> => {
+    const f: F<AuditionSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>> = (method) => (payload) =>
       audition
-        .f(method as never)(payload)
+        .f(method)(payload)
         .pipe(
-          Effect.catchTag("AuditionError", () => client.f(method as never)(payload)),
+          Effect.catchTag("AuditionError", () => client.f(method)(payload)),
           span("f"),
         )
 

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # liminal
 
+## 0.17.7
+
+### Patch Changes
+
+- e5c54be: Decouple actor transport. Implement proper multi-actor instance browser registry.
+
+## 0.17.6
+
+### Patch Changes
+
+- d7b1da3: Simplify type-level representation of client protocol.
+
 ## 0.17.5
 
 ### Patch Changes