liminal 0.17.13 → 0.17.15

package/Actor.ts

@@ -1,14 +1,13 @@
 import { Context, Schema as S, Effect } from "effect"
+import * as Spanner from "liminal-util/Spanner"
 
 import type { TopFromString } from "./_util/schema.ts"
 import type * as ActorClient from "./Client.ts"
 import type { ClientHandle, Sender } from "./ClientHandle.ts"
-
-import { diagnostic } from "./_diagnostic.ts"
 import * as Method from "./Method.ts"
 import { type ProtocolDefinition } from "./Protocol.ts"
 
-const { span } = diagnostic("Actor")
+const span = Spanner.make(import.meta.url)
 
 export const TypeId = "~liminal/Actor" as const
 
@@ -58,10 +57,10 @@ export interface Actor<
 
   readonly others: Sender<ActorSelf, D>
 
-  readonly handler: <K extends keyof D["methods"], R>(
+  readonly handler: <K extends keyof D["external"], R>(
     tag: K,
-    f: Method.Handler<D["methods"][K], R>,
-  ) => Method.Handler<D["methods"][K], R>
+    f: Method.Handler<D["external"][K], R>,
+  ) => Method.Handler<D["external"][K], R>
 }
 
 export const Service =
@@ -85,11 +84,11 @@ export const Service =
           Effect.flatMap(({ clients }) =>
             Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" }),
           ),
-          span("all.send"),
+          span("send-all"),
         ),
       disconnect: tag.asEffect().pipe(
         Effect.flatMap(({ clients }) => Effect.forEach(clients, ({ disconnect }) => disconnect)),
-        span("all.disconnect"),
+        span("disconnect-all"),
       ),
     }
 
@@ -101,17 +100,17 @@ export const Service =
           (client) => (client === currentClient ? Effect.void : client.send(key, payload)),
           { concurrency: "unbounded" },
         )
-      }, span("others.send")),
+      }, span("send-others")),
       disconnect: Effect.gen(function* () {
         const { clients, currentClient } = yield* tag
         yield* Effect.forEach(clients, (client) => (client === currentClient ? Effect.void : client.disconnect))
-      }).pipe(span("others.disconnect")),
+      }).pipe(span("disconnect-others")),
     }
 
-    const handler = <K extends keyof D["methods"], R>(
+    const handler = <K extends keyof D["external"], R>(
       _tag: K,
-      f: Method.Handler<D["methods"][K], R>,
-    ): Method.Handler<D["methods"][K], R> => f
+      f: Method.Handler<D["external"][K], R>,
+    ): Method.Handler<D["external"][K], R> => f
 
     return Object.assign(tag, {
       [TypeId]: TypeId,

package/ActorTransport.ts

@@ -2,16 +2,18 @@ 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> {
+export interface ActorTransport<Key, Client, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
+  readonly key: (client: Client) => Key
+
   readonly send: (
-    transport: Raw,
+    client: Client,
     event: Protocol<D>["Event"]["Type"],
   ) => Effect.Effect<void, S.SchemaError, Protocol<D>["Event"]["EncodingServices"]>
 
-  readonly close: (transport: Raw) => Effect.Effect<void>
+  readonly close: (client: Client) => Effect.Effect<void>
 
   readonly snapshot: (
-    transport: Raw,
+    client: Client,
     attachments: S.Struct<AttachmentFields>["Type"],
   ) => Effect.Effect<void, S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
 }

package/Audition.ts

@@ -1,80 +1,126 @@
-import { Schema as S, Pipeable, Stream, Effect, Function } from "effect"
+import { Schema as S, Pipeable, Stream, Effect, Function, Types } from "effect"
 
-import type { F } from "./F.ts"
-import type { ProtocolDefinition } from "./Protocol.ts"
-
-import { diagnostic } from "./_diagnostic.ts"
 import * as Client from "./Client.ts"
 import { type ClientError, AuditionError } from "./errors.ts"
-
-const { debug, span } = diagnostic("Audition")
+import type { Fn } from "./Fn.ts"
+import type { Methods } from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
 
 const TypeId = "~liminal/Audition" as const
 
-export interface Audition<ClientSelf, D extends ProtocolDefinition> extends Pipeable.Pipeable {
+export interface Audition<AuditionSelf, State extends S.Union<ReadonlyArray<S.Top>>, External extends Methods, Event>
+  extends Pipeable.Pipeable {
   readonly [TypeId]: typeof TypeId
 
-  readonly events: Stream.Stream<
-    ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"],
-    ClientError | S.SchemaError,
-    ClientSelf
-  >
+  readonly state: Stream.Stream<State["Type"], ClientError | S.SchemaError, AuditionSelf | State["DecodingServices"]>
+
+  readonly fn: Fn<AuditionSelf, External>
 
-  readonly f: F<ClientSelf, D>
+  readonly events: Stream.Stream<Event, ClientError | S.SchemaError, AuditionSelf>
 }
 
-export const empty: Audition<never, never> = {
+type MergeMethods<T extends Methods, U extends Methods> = [keyof T] extends [never]
+  ? U
+  : { [K in keyof T & keyof U]: Types.Equals<T[K], U[K]> extends true ? T[K] : never }
+
+type MergeState<State, D extends ProtocolDefinition> = [State] extends [never]
+  ? S.Union<[S.Struct<D["state"]>]>
+  : State extends S.Union<ReadonlyArray<S.Top>>
+    ? S.Union<[...State["members"], S.Struct<D["state"]>]>
+    : never
+
+export const empty: Audition<never, never, {}, never> = {
   [TypeId]: TypeId,
   pipe() {
     return Pipeable.pipeArguments(this, arguments)
   },
+  state: Stream.fail(new AuditionError()),
+  fn: () => () => new AuditionError().asEffect(),
   events: Stream.fail(new AuditionError()),
-  f: () => () => new AuditionError().asEffect(),
 }
 
+export const cycleOn =
+  <Event>(predicate: (event: Event) => boolean) =>
+  <AuditionSelf, State extends S.Union<ReadonlyArray<S.Top>>, External extends Methods>(
+    audition: Audition<AuditionSelf, State, External, Event>,
+  ): Audition<AuditionSelf, State, External, Event> => {
+    const events = audition.events.pipe(Stream.takeUntil(predicate), Stream.forever)
+    const state = audition.state.pipe(Stream.forever)
+
+    return {
+      [TypeId]: TypeId,
+      pipe() {
+        return Pipeable.pipeArguments(this, arguments)
+      },
+      events,
+      fn: audition.fn,
+      state,
+    }
+  }
+
 export const add: {
   <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>>
+  ): <AuditionSelf, State extends S.Union<ReadonlyArray<S.Top>> | never, External extends Methods, Event>(
+    audition: Audition<AuditionSelf, State, External, Event>,
+  ) => Audition<
+    AuditionSelf | ClientSelf,
+    MergeState<State, ClientD>,
+    MergeMethods<External, ClientD["external"]>,
+    Event | ReturnType<typeof S.TaggedUnion<ClientD["events"]>>["Type"]
+  >
   <
-    AuditionClientSelf,
-    AuditionD extends ProtocolDefinition,
+    AuditionSelf,
+    State extends S.Union<ReadonlyArray<S.Top>> | never,
+    External extends Methods,
+    Event,
     ClientSelf,
     ClientId extends string,
     ClientD extends ProtocolDefinition,
   >(
-    audition: Audition<AuditionClientSelf, AuditionD>,
+    audition: Audition<AuditionSelf, State, External, Event>,
     client: Client.Client<ClientSelf, ClientId, ClientD>,
-  ): Audition<AuditionClientSelf | ClientSelf, ProtocolDefinition.Merge<AuditionD, ClientD>>
+  ): Audition<
+    AuditionSelf | ClientSelf,
+    MergeState<State, ClientD>,
+    MergeMethods<External, ClientD["external"]>,
+    Event | ReturnType<typeof S.TaggedUnion<ClientD["events"]>>["Type"]
+  >
 } = Function.dual(
   2,
   <
     AuditionSelf,
-    AuditionD extends ProtocolDefinition,
+    State extends S.Union<ReadonlyArray<S.Top>>,
+    External extends Methods,
+    Event,
     ClientSelf,
     ClientId extends string,
     ClientD extends ProtocolDefinition,
   >(
-    audition: Audition<AuditionSelf, AuditionD>,
+    audition: Audition<AuditionSelf, State, External, Event>,
     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)(payload)
-        .pipe(
-          Effect.catchTag("AuditionError", () => client.f(method)(payload)),
-          span("f"),
-        )
+  ): Audition<
+    AuditionSelf | ClientSelf,
+    MergeState<State, ClientD>,
+    MergeMethods<External, ClientD["external"]>,
+    Event | ReturnType<typeof S.TaggedUnion<ClientD["events"]>>["Type"]
+  > => {
+    const fn = ((method: string, ...f: [any]) =>
+      Effect.fnUntraced(
+        function* (payload: any) {
+          return yield* audition
+            .fn(method)(payload)
+            .pipe(Effect.catchTag("AuditionError", () => client.fn(method)(payload)))
+        },
+        ...f,
+      )) as Fn<AuditionSelf | ClientSelf, MergeMethods<External, ClientD["external"]>>
 
     const events = audition.events.pipe(
-      Stream.catchTag("AuditionError", () =>
-        Effect.succeed(client.events).pipe(
-          Effect.tap(() => debug("AuditionStaged", { client: client.key })),
-          Stream.unwrap,
-        ),
-      ),
+      Stream.catchTag("AuditionError", () => Effect.succeed(client.events).pipe(Stream.unwrap)),
+    )
+
+    const state = audition.state.pipe(
+      Stream.catchTag("AuditionError", () => Effect.succeed(client.state).pipe(Stream.unwrap)),
     )
 
     return {
@@ -83,7 +129,8 @@ export const add: {
         return Pipeable.pipeArguments(this, arguments)
       },
       events,
-      f,
+      fn,
+      state,
     }
   },
 )

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # liminal
 
+## 0.17.15
+
+### Patch Changes
+
+- ab30d60: Move accumulator api directly into client and implement internal actor method bindings.
+- Updated dependencies [ab30d60]
+  - effect-workerd@0.0.5
+
+## 0.17.14
+
+### Patch Changes
+
+- d082441: Actor now inherits from DurableObject. Effect updated to beta 57.
+- Updated dependencies [d082441]
+  - effect-workerd@0.0.4
+
 ## 0.17.13
 
 ### Patch Changes