liminal 0.17.14 → 0.17.16

package/ClientDirectory.ts

@@ -1,36 +1,43 @@
 import { Schema as S, Effect, Cause, Ref } from "effect"
+import * as Boundary from "liminal-util/Boundary"
+import type { TopFromString } from "liminal-util/schema"
 
-import type { TopFromString } from "./_util/schema.ts"
+import { phantom } from "./_util/phantom.ts"
 import type { Actor } from "./Actor.ts"
 import type { ActorTransport } from "./ActorTransport.ts"
+import * as ClientHandle from "./ClientHandle.ts"
 import type { ProtocolDefinition, Disconnect, Protocol } from "./Protocol.ts"
 
-import { diagnostic } from "./_diagnostic.ts"
-import { phantom } from "./_util/phantom.ts"
-import * as ClientHandle from "./ClientHandle.ts"
+export interface ClientEntry<Client, Handle> {
+  readonly client: Client
 
-const { span } = diagnostic("ClientDirectory")
+  readonly handle: Handle
+}
 
 export interface ClientDirectory<
-  Raw,
+  Key,
+  Client,
   ActorSelf,
   AttachmentFields extends S.Struct.Fields,
   D extends ProtocolDefinition,
 > {
   readonly "": {
     readonly Handle: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
+    readonly Entry: ClientEntry<Client, ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>>
   }
 
   readonly handles: ReadonlySet<this[""]["Handle"]>
 
   readonly register: (
-    raw: Raw,
+    client: Client,
     attachments: S.Struct<AttachmentFields>["Type"],
   ) => Effect.Effect<this[""]["Handle"], S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
 
-  readonly get: (raw: Raw) => Effect.Effect<this[""]["Handle"], Cause.NoSuchElementError>
+  readonly get: (key: Key) => Effect.Effect<this[""]["Handle"], Cause.NoSuchElementError>
+
+  readonly entry: (key: Key) => Effect.Effect<this[""]["Entry"], Cause.NoSuchElementError>
 
-  readonly unregister: (raw: Raw) => Effect.Effect<void>
+  readonly unregister: (key: Key) => Effect.Effect<void>
 }
 
 export interface HandleEncoders<T, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
@@ -44,7 +51,8 @@ export interface HandleEncoders<T, AttachmentFields extends S.Struct.Fields, D e
 }
 
 export const make = <
-  Raw,
+  Key,
+  Client,
   ActorSelf,
   ActorId extends string,
   Name extends TopFromString,
@@ -54,51 +62,65 @@ export const make = <
   D extends ProtocolDefinition,
 >(
   _actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>,
-  { send, close, snapshot }: ActorTransport<Raw, AttachmentFields, D>,
-): ClientDirectory<Raw, ActorSelf, AttachmentFields, D> => {
+  {
+    transport: { key, send, close, snapshot },
+  }: {
+    readonly transport: ActorTransport<Key, Client, AttachmentFields, D>
+  },
+): ClientDirectory<Key, Client, ActorSelf, AttachmentFields, D> => {
   type Handle = ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
+  type Entry = ClientEntry<Client, Handle>
 
-  const raws = new Map<Raw, Handle>()
+  const entries = new Map<Key, Entry>()
   const handles = new Set<Handle>()
 
-  const get = (raw: Raw) => Effect.fromNullishOr(raws.get(raw))
-
-  const register = Effect.fnUntraced(function* (raw: Raw, attachments: S.Struct<AttachmentFields>["Type"]) {
-    yield* snapshot(raw, attachments)
-    const attachmentsRef = yield* Ref.make(attachments)
-    const handle: Handle = {
-      attachments: Ref.get(attachmentsRef),
-      save: Effect.fnUntraced(function* (attachments) {
-        yield* Ref.set(attachmentsRef, attachments)
-        yield* snapshot(raw, attachments)
-      }),
-      send: (_tag, payload) =>
-        send(raw, {
-          _tag: "Event",
-          event: { _tag, ...payload } as never,
+  const entry = (key: Key) => Effect.fromNullishOr(entries.get(key))
+  const get = (key: Key) => entry(key).pipe(Effect.map(({ handle }) => handle))
+
+  const unregister = (key: Key) =>
+    Effect.sync(() => {
+      const current = entries.get(key)
+      if (current) {
+        entries.delete(key)
+        handles.delete(current.handle)
+      }
+    }).pipe(Boundary.span("unregister", import.meta.url))
+
+  const register = Effect.fnUntraced(
+    function* (client: Client, attachments: S.Struct<AttachmentFields>["Type"]) {
+      const clientKey = key(client)
+      yield* snapshot(client, attachments)
+      const attachmentsRef = yield* Ref.make(attachments)
+      const handle: Handle = {
+        attachments: Ref.get(attachmentsRef),
+        save: Effect.fnUntraced(function* (attachments) {
+          yield* Ref.set(attachmentsRef, attachments)
+          yield* snapshot(client, attachments)
         }),
-      disconnect: close(raw).pipe(
-        Effect.andThen(() =>
-          Effect.sync(() => {
-            raws.delete(raw)
-            handles.delete(handle)
+        send: (_tag, payload) =>
+          send(client, {
+            _tag: "Event",
+            event: { _tag, ...payload } as never,
           }),
-        ),
-      ),
-    }
-    raws.set(raw, handle)
-    handles.add(handle)
-    return handle
-  }, span("register"))
-
-  const unregister = (raw: Raw) =>
-    Effect.sync(() => {
-      const handle = raws.get(raw)
-      if (handle) {
-        raws.delete(raw)
-        handles.delete(handle)
+        disconnect: close(client).pipe(Effect.andThen(unregister(clientKey)), Effect.asVoid),
+      }
+      const previous = entries.get(clientKey)
+      if (previous) {
+        handles.delete(previous.handle)
       }
-    }).pipe(span("unregister"))
+      entries.set(clientKey, { client, handle })
+      handles.add(handle)
+      return handle
+    },
+    Boundary.span("register", import.meta.url),
+  )
 
-  return { ...phantom, handles, register, get, unregister }
+  return {
+    ...phantom,
+    handles,
+    register,
+    get,
+    entry,
+    unregister,
+  }
 }

package/ClientHandle.ts

@@ -2,20 +2,22 @@ import { Schema as S, Effect } from "effect"
 
 import type { ProtocolDefinition } from "./Protocol.ts"
 
-export interface Sender<ActorSelf, D extends ProtocolDefinition> {
-  readonly send: <K extends keyof D["events"]>(
-    tag: K,
-    payload: S.Struct<D["events"][K]>["Type"],
-  ) => Effect.Effect<void, S.SchemaError, ActorSelf | ReturnType<typeof S.TaggedUnion<D["events"]>>["EncodingServices"]>
+export type Send<D extends ProtocolDefinition, RIn> = <K extends keyof D["events"]>(
+  tag: K,
+  payload: S.Struct<D["events"][K]>["Type"],
+) => Effect.Effect<void, never, RIn | ReturnType<typeof S.TaggedUnion<D["events"]>>["EncodingServices"]>
 
-  readonly disconnect: Effect.Effect<void, never, ActorSelf>
+export interface Sender<D extends ProtocolDefinition, R> {
+  readonly send: Send<D, R>
+
+  readonly disconnect: Effect.Effect<void, never, R>
 }
 
 export interface ClientHandle<
   ActorSelf,
   AttachmentFields extends S.Struct.Fields,
   D extends ProtocolDefinition,
-> extends Sender<ActorSelf, D> {
+> extends Sender<D, ActorSelf> {
   readonly attachments: Effect.Effect<S.Struct<AttachmentFields>["Type"]>
 
   readonly save: (

package/ClientHandleEncoders.ts

@@ -0,0 +1,15 @@
+import { Schema as S, Effect } from "effect"
+
+import type { ProtocolDefinition, Disconnect, Protocol } from "./Protocol.ts"
+
+export interface HandleEncoders<T, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
+  readonly attachments: (
+    value: S.Struct<AttachmentFields>["Type"],
+  ) => Effect.Effect<T, S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
+
+  readonly event: (
+    value: Protocol<D>["Event"]["Type"],
+  ) => Effect.Effect<T, S.SchemaError, Protocol<D>["Event"]["EncodingServices"]>
+
+  readonly disconnect: Effect.Effect<T, S.SchemaError, (typeof Disconnect)["EncodingServices"]>
+}

package/Fn.ts

@@ -0,0 +1,94 @@
+import { Effect, Schema as S } from "effect"
+
+import type { ClientError, UnresolvedError } from "./errors.ts"
+import type { Methods } from "./Method.ts"
+
+export type FnPayload<External extends Methods, K extends keyof External> = External[K]["payload"]["Type"]
+
+export type FnError<External extends Methods, K extends keyof External> = [
+  External[K]["failure"]["Type"] | ClientError | S.SchemaError | UnresolvedError,
+][0]
+
+export type FnEffect<Self, External extends Methods, K extends keyof External> = Effect.Effect<
+  External[K]["success"]["Type"],
+  FnError<External, K>,
+  Self
+>
+
+export interface Fn<Self, Internal extends Methods> {
+  <K extends keyof Internal>(tag: K): (payload: FnPayload<Internal, K>) => FnEffect<Self, Internal, K>
+
+  <K extends keyof Internal, A>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+  ): (payload: FnPayload<Internal, K>) => A
+
+  <K extends keyof Internal, A, B>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+  ): (payload: FnPayload<Internal, K>) => B
+
+  <K extends keyof Internal, A, B, C>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+  ): (payload: FnPayload<Internal, K>) => C
+
+  <K extends keyof Internal, A, B, C, D>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+    d: (value: C, payload: FnPayload<Internal, K>) => D,
+  ): (payload: FnPayload<Internal, K>) => D
+
+  <K extends keyof Internal, A, B, C, D, E>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+    d: (value: C, payload: FnPayload<Internal, K>) => D,
+    e: (value: D, payload: FnPayload<Internal, K>) => E,
+  ): (payload: FnPayload<Internal, K>) => E
+}
+
+export interface FnNoSelf<Internal extends Methods> {
+  <K extends keyof Internal>(tag: K): (payload: FnPayload<Internal, K>) => FnEffect<never, Internal, K>
+
+  <K extends keyof Internal, A>(
+    tag: K,
+    a: (effect: FnEffect<never, Internal, K>, payload: FnPayload<Internal, K>) => A,
+  ): (payload: FnPayload<Internal, K>) => A
+
+  <K extends keyof Internal, A, B>(
+    tag: K,
+    a: (effect: FnEffect<never, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+  ): (payload: FnPayload<Internal, K>) => B
+
+  <K extends keyof Internal, A, B, C>(
+    tag: K,
+    a: (effect: FnEffect<never, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+  ): (payload: FnPayload<Internal, K>) => C
+
+  <K extends keyof Internal, A, B, C, D>(
+    tag: K,
+    a: (effect: FnEffect<never, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+    d: (value: C, payload: FnPayload<Internal, K>) => D,
+  ): (payload: FnPayload<Internal, K>) => D
+
+  <K extends keyof Internal, A, B, C, D, E>(
+    tag: K,
+    a: (effect: FnEffect<never, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+    d: (value: C, payload: FnPayload<Internal, K>) => D,
+    e: (value: D, payload: FnPayload<Internal, K>) => E,
+  ): (payload: FnPayload<Internal, K>) => E
+}

package/Method.ts

@@ -1,29 +1,19 @@
 import { Schema as S, Effect } from "effect"
 
-export interface MethodDefinition<Payload extends S.Top, Success extends S.Top, Failure extends S.Top> {
-  readonly payload: Payload
-  readonly success: Success
-  readonly failure: Failure
+export interface Method {
+  readonly payload: S.Top
+  readonly success: S.Top
+  readonly failure: S.Top
 }
 
-export type Any = MethodDefinition<S.Top, S.Top, S.Top>
+export type Methods = Record<string, Method>
 
-export const make = <Payload extends S.Top, Success extends S.Top, Failure extends S.Top>({
-  payload,
-  success,
-  failure,
-}: {
-  readonly payload: Payload
-  readonly success: Success
-  readonly failure: Failure
-}): MethodDefinition<Payload, Success, Failure> => ({ payload, success, failure })
+export type Handler<M extends Method, R> = (
+  payload: M["payload"]["Type"],
+) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], R>
 
-export type Handler<Method extends Any, R> = (
-  payload: Method["payload"]["Type"],
-) => Effect.Effect<Method["success"]["Type"], Method["failure"]["Type"], R>
+export const handler = <M extends Method, R>(_method: M, f: Handler<M, R>): Handler<M, R> => f
 
-export type Handlers<Methods extends Record<string, Any>, R> = {
-  [K in keyof Methods]: Handler<Methods[K], R>
+export type Handlers<Internal extends Methods, R> = {
+  readonly [K in keyof Internal]: Handler<Internal[K], R>
 }
-
-export const handler = <Method extends Any, R>(_method: Method, f: Handler<Method, R>): Handler<Method, R> => f

package/Protocol.ts

@@ -1,33 +1,24 @@
-import { Schema as S, Record, Types } from "effect"
+import { Schema as S, Record } from "effect"
 
-import type * as Method from "./Method.ts"
+import type { Methods } from "./Method.ts"
+import * as Tracing from "./Tracing.ts"
 
 export interface ProtocolDefinition<
-  Methods extends Record<string, Method.Any> = Record<string, Method.Any>,
+  State extends S.Struct.Fields = S.Struct.Fields,
+  External extends Methods = Methods,
   Events extends Record<string, S.Struct.Fields> = Record<string, S.Struct.Fields>,
 > {
-  readonly methods: Methods
+  readonly state: State
 
-  readonly events: Events
-}
+  readonly external: External
 
-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"]
-  >
+  readonly events: 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 Payload: S.TaggedStruct<"Audition.Payload", { readonly client: S.String }>
+    readonly Success: S.TaggedStruct<"Audition.Success", { readonly initial: S.Struct<D["state"]> }>
     readonly Failure: S.TaggedStruct<
       "Audition.Failure",
       {
@@ -43,6 +34,7 @@ export interface Protocol<D extends ProtocolDefinition> {
       readonly event: S.TaggedUnion<{
         readonly [K in keyof D["events"] & string]: S.TaggedStruct<K, D["events"][K]>
       }>
+      readonly trace: S.optional<typeof Tracing.TraceEnvelope>
     }
   >
 
@@ -52,8 +44,12 @@ export interface Protocol<D extends ProtocolDefinition> {
       {
         readonly id: S.Int
         readonly payload: S.TaggedUnion<{
-          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["payload"] }>
+          readonly [K in keyof D["external"] & string]: S.TaggedStruct<
+            K,
+            { readonly value: D["external"][K]["payload"] }
+          >
         }>
+        readonly trace: S.optional<typeof Tracing.TraceEnvelope>
       }
     >
 
@@ -62,7 +58,10 @@ export interface Protocol<D extends ProtocolDefinition> {
       {
         readonly id: S.Int
         readonly success: S.TaggedUnion<{
-          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["success"] }>
+          readonly [K in keyof D["external"] & string]: S.TaggedStruct<
+            K,
+            { readonly value: D["external"][K]["success"] }
+          >
         }>
       }
     >
@@ -72,7 +71,10 @@ export interface Protocol<D extends ProtocolDefinition> {
       {
         readonly id: S.Int
         readonly failure: S.TaggedUnion<{
-          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["failure"] }>
+          readonly [K in keyof D["external"] & string]: S.TaggedStruct<
+            K,
+            { readonly value: D["external"][K]["failure"] }
+          >
         }>
       }
     >
@@ -96,37 +98,43 @@ export interface Protocol<D extends ProtocolDefinition> {
 
 export const Disconnect = S.TaggedStruct("Disconnect", {})
 
-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,
-  }),
-}
+const AuditionPayload = S.TaggedStruct("Audition.Payload", {
+  client: S.String,
+})
+
+const AuditionFailure = S.TaggedStruct("Audition.Failure", {
+  expected: S.String,
+  actual: S.String,
+})
 
-export const Protocol = <D extends ProtocolDefinition>({ events, methods }: D): Protocol<D> => {
+export const Protocol = <D extends ProtocolDefinition>({ state, events, external }: D): Protocol<D> => {
   type T = Protocol<D>
 
+  const Audition = {
+    Payload: AuditionPayload,
+    Success: S.TaggedStruct("Audition.Success", { initial: S.Struct(state) }),
+    Failure: AuditionFailure,
+  }
+
   const F: T["F"] = {
     Payload: S.TaggedStruct("F.Payload", {
       id: S.Int,
-      payload: S.TaggedUnion(Record.map(methods, ({ payload: value }) => ({ value }))),
+      payload: S.TaggedUnion(Record.map(external, ({ payload: value }) => ({ value }))),
+      trace: S.optional(Tracing.TraceEnvelope),
     }) as never,
     Success: S.TaggedStruct("F.Success", {
       id: S.Int,
-      success: S.TaggedUnion(Record.map(methods, ({ success: value }) => ({ value }))),
+      success: S.TaggedUnion(Record.map(external, ({ success: value }) => ({ value }))),
     }) as never,
     Failure: S.TaggedStruct("F.Failure", {
       id: S.Int,
-      failure: S.TaggedUnion(Record.map(methods, ({ failure: value }) => ({ value }))),
+      failure: S.TaggedUnion(Record.map(external, ({ failure: value }) => ({ value }))),
     }) as never,
   }
 
   const Event: T["Event"] = S.TaggedStruct("Event", {
     event: S.TaggedUnion(events),
+    trace: S.optional(Tracing.TraceEnvelope),
   }) as never
 
   const Client: T["Client"] = S.Union([Audition.Payload, F.Payload, Disconnect])

package/Reducer.ts

@@ -0,0 +1,22 @@
+import { Schema as S, Types, Effect } from "effect"
+
+import type { ProtocolDefinition } from "./Protocol.ts"
+
+export type Reducer<D extends ProtocolDefinition, K extends keyof D["events"] = keyof D["events"]> = (
+  event: Types.ExtractTag<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], Extract<K, string>>,
+) => (state: S.Struct<D["state"]>["Type"]) => Effect.Effect<S.Struct<D["state"]>["Type"] | void, never, unknown>
+
+export type Reducers<D extends ProtocolDefinition> = {
+  readonly [K in keyof D["events"]]: Reducer<D, K>
+}
+
+export declare namespace Reducers {
+  export type Services<Self, D extends Record<string, Reducer<any, any>>> = Exclude<
+    {
+      readonly [K in keyof D]: D[K] extends (...args: any) => (...args: any) => Effect.Effect<any, any, infer R>
+        ? R
+        : never
+    }[keyof D],
+    Self
+  >
+}

package/Tracing.ts

@@ -0,0 +1,45 @@
+import { Effect, Schema as S, Tracer } from "effect"
+
+export const TraceEnvelope = S.Struct({
+  traceId: S.String,
+  spanId: S.String,
+  sampled: S.Boolean,
+})
+
+export const toTraceEnvelope = ({ traceId, spanId, sampled }: typeof TraceEnvelope.Type) => ({
+  traceId,
+  spanId,
+  sampled,
+})
+
+export const SessionId = S.String.check(S.isUUID()).pipe(S.brand("SessionId"))
+
+export const Session = S.Struct({
+  id: SessionId,
+  trace: TraceEnvelope,
+})
+
+export const parent = Effect.currentParentSpan.pipe(
+  Effect.catchTags({
+    NoSuchElementError: () => Effect.undefined,
+  }),
+)
+
+export const current = Effect.currentSpan.pipe(
+  Effect.catchTags({
+    NoSuchElementError: () => Effect.undefined,
+  }),
+)
+
+export const currentTrace = current.pipe(Effect.map((span) => (span ? toTraceEnvelope(span) : undefined)))
+
+export const sessionAttributes = ({ id }: typeof Session.Type) => ({ "liminal.session.id": id })
+
+export const sessionLink = (session: typeof Session.Type, attributes: Record<string, unknown> = {}) => ({
+  span: Tracer.externalSpan(session.trace),
+  attributes: {
+    "liminal.link": "session",
+    ...sessionAttributes(session),
+    ...attributes,
+  },
+})

package/dist/Actor.d.ts

@@ -1,8 +1,7 @@
 import { Context, Schema as S } from "effect";
-import type { TopFromString } from "./_util/schema.ts";
+import type { TopFromString } from "liminal-util/schema";
 import type * as ActorClient from "./Client.ts";
 import type { ClientHandle, Sender } from "./ClientHandle.ts";
-import * as Method from "./Method.ts";
 import { type ProtocolDefinition } from "./Protocol.ts";
 export declare const TypeId: "~liminal/Actor";
 export interface Service<ActorSelf, Name extends TopFromString, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
@@ -19,8 +18,7 @@ export interface Actor<ActorSelf, ActorId extends string, Name extends TopFromSt
     new (_: never): Context.ServiceClass.Shape<ActorId, Service<ActorSelf, Name, AttachmentFields, D>>;
     readonly [TypeId]: typeof TypeId;
     readonly definition: ActorDefinition<Name, AttachmentFields, ActorClientSelf, ActorClientId, D>;
-    readonly all: Sender<ActorSelf, D>;
-    readonly others: Sender<ActorSelf, D>;
-    readonly handler: <K extends keyof D["methods"], R>(tag: K, f: Method.Handler<D["methods"][K], R>) => Method.Handler<D["methods"][K], R>;
+    readonly all: Sender<D, ActorSelf>;
+    readonly others: Sender<D, ActorSelf>;
 }
 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,32 +1,28 @@
 import { Context, Schema as S, Effect } from "effect";
-import { diagnostic } from "./_diagnostic.js";
-import * as Method from "./Method.js";
+import * as Boundary from "liminal-util/Boundary";
 import {} from "./Protocol.js";
-const { span } = diagnostic("Actor");
 export const TypeId = "~liminal/Actor";
 export const Service = () => (id, definition) => {
     const tag = Context.Service()(id);
     const all = {
-        send: (key, payload) => tag.asEffect().pipe(Effect.flatMap(({ clients }) => Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" })), span("all.send")),
-        disconnect: tag.asEffect().pipe(Effect.flatMap(({ clients }) => Effect.forEach(clients, ({ disconnect }) => disconnect)), span("all.disconnect")),
+        send: (key, payload) => tag.pipe(Effect.flatMap(({ clients }) => Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" })), Boundary.span("send-all", import.meta.url)),
+        disconnect: tag.pipe(Effect.flatMap(({ clients }) => Effect.forEach(clients, ({ disconnect }) => disconnect)), Boundary.span("disconnect-all", import.meta.url)),
     };
     const others = {
         send: Effect.fnUntraced(function* (key, payload) {
             const { clients, currentClient } = yield* tag;
             yield* Effect.forEach(clients, (client) => (client === currentClient ? Effect.void : client.send(key, payload)), { concurrency: "unbounded" });
-        }, span("others.send")),
+        }, Boundary.span("send-others", import.meta.url)),
         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(Boundary.span("disconnect-others", import.meta.url)),
     };
-    const handler = (_tag, f) => f;
     return Object.assign(tag, {
         [TypeId]: TypeId,
         definition,
         all,
         others,
-        handler,
     });
 };
 //# sourceMappingURL=Actor.js.map

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;AAMrD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,EAA2B,MAAM,eAAe,CAAA;AAEvD,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;AAEpC,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,GAAG,GAAyB;QAChC,IAAI,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CACrB,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,UAAU,CAAC,CACjB;QACH,UAAU,EAAE,GAAG,CAAC,QAAQ,EAAE,CAAC,IAAI,CAC7B,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,gBAAgB,CAAC,CACvB;KACF,CAAA;IAED,MAAM,MAAM,GAAyB;QACnC,IAAI,EAAE,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,OAAO;YAC7C,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAA;YAC7C,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,OAAO,EACP,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAChF,EAAE,WAAW,EAAE,WAAW,EAAE,CAC7B,CAAA;QACH,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;YAC9B,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAA;YAC7C,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAA;QAC1G,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;KACnC,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,GAAG;QACH,MAAM;QACN,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;AACrD,OAAO,KAAK,QAAQ,MAAM,uBAAuB,CAAA;AAKjD,OAAO,EAA2B,MAAM,eAAe,CAAA;AAEvD,MAAM,CAAC,MAAM,MAAM,GAAG,gBAAyB,CAAA;AAiD/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,GAAG,GAAyB;QAChC,IAAI,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CACrB,GAAG,CAAC,IAAI,CACN,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,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAC3C;QACH,UAAU,EAAE,GAAG,CAAC,IAAI,CAClB,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,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CACjD;KACF,CAAA;IAED,MAAM,MAAM,GAAyB;QACnC,IAAI,EAAE,MAAM,CAAC,UAAU,CACrB,QAAQ,CAAC,EAAE,GAAG,EAAE,OAAO;YACrB,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAA;YAC7C,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CACnB,OAAO,EACP,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAChF,EAAE,WAAW,EAAE,WAAW,EAAE,CAC7B,CAAA;QACH,CAAC,EACD,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAC9C;QACD,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;YAC9B,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAA;YAC7C,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAA;QAC1G,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;KAC7D,CAAA;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;QACxB,CAAC,MAAM,CAAC,EAAE,MAAM;QAChB,UAAU;QACV,GAAG;QACH,MAAM;KACP,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/dist/ActorHandle.d.ts

@@ -0,0 +1,12 @@
+import { Schema as S, Effect, Cause, Encoding } from "effect";
+import { NativeRequest } from "effect-workerd";
+import { HttpServerResponse } from "effect/unstable/http";
+import type { TopFromString } from "liminal-util/schema";
+import type { Send } from "./ClientHandle.ts";
+import type { Methods } from "./Method.ts";
+import type { ProtocolDefinition } from "./Protocol.ts";
+export interface ActorHandle<NamespaceSelf, Internal extends Methods, Name extends TopFromString, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
+    readonly upgrade: (attachments: S.Struct<AttachmentFields>["Type"]) => Effect.Effect<HttpServerResponse.HttpServerResponse, S.SchemaError | Encoding.EncodingError | Cause.NoSuchElementError, NamespaceSelf | NativeRequest.NativeRequest | Name["EncodingServices"] | S.Struct<AttachmentFields>["EncodingServices"]>;
+    readonly call: <K extends keyof Internal, M extends Internal[K]>(method: K, payload: M["payload"]["Type"]) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], NamespaceSelf>;
+    readonly proxySendAll: Send<D, NamespaceSelf>;
+}