liminal 0.17.6 → 0.17.7

package/Actor.ts

@@ -1,19 +1,25 @@
 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 { ProtocolDefinition } from "./Protocol.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")
 
 export const TypeId = "~liminal/Actor" as const
 
-export interface Service<ActorSelf, NameA, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
-  readonly name: NameA
+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>
 
@@ -21,13 +27,13 @@ export interface Service<ActorSelf, NameA, AttachmentFields extends S.Struct.Fie
 }
 
 export interface ActorDefinition<
-  NameA,
+  Name extends TopFromString,
   AttachmentFields extends S.Struct.Fields,
   ClientSelf,
   ClientId extends string,
   D extends ProtocolDefinition,
 > {
-  readonly name: S.Codec<NameA, string>
+  readonly name: Name
 
   readonly attachments: AttachmentFields
 
@@ -37,21 +43,17 @@ export interface ActorDefinition<
 export interface Actor<
   ActorSelf,
   ActorId extends string,
-  NameA,
+  Name extends TopFromString,
   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>>
+> 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, D>
-
-  readonly protocol: {
-    readonly Attachments: S.Struct<AttachmentFields>
-  }
+  readonly definition: ActorDefinition<Name, AttachmentFields, ActorClientSelf, ActorClientId, D>
 
   readonly sendAll: Send<ActorSelf, D>
 
@@ -67,16 +69,16 @@ export const Service =
   <ActorSelf>() =>
   <
     ActorId extends string,
-    NameA,
+    Name extends TopFromString,
     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> => {
-    const tag = Context.Service<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, D>>()(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, D> = (key, payload) =>
       tag.asEffect().pipe(
@@ -99,9 +101,6 @@ export const Service =
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
-      protocol: {
-        Attachments: S.Struct(definition.attachments),
-      },
       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/CHANGELOG.md

@@ -1,5 +1,11 @@
 # liminal
 
+## 0.17.7
+
+### Patch Changes
+
+- e5c54be: Decouple actor transport. Implement proper multi-actor instance browser registry.
+
 ## 0.17.6
 
 ### Patch Changes

package/Client.ts

@@ -26,6 +26,7 @@ import { Socket } from "effect/unstable/socket"
 import { Worker } from "effect/unstable/workers"
 
 import * as Diagnostic from "./_util/Diagnostic.ts"
+import { decodeJsonString, encodeJsonString } from "./_util/schema.ts"
 import { type ClientError, AuditionError, ConnectionError, type FError, UnresolvedError } from "./errors.ts"
 import { type F } from "./F.ts"
 import { Protocol, type ProtocolDefinition } from "./Protocol.ts"
@@ -190,9 +191,9 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, R>(
                 return
               }
               case "Audition.Failure": {
-                const { client, routed } = message
-                yield* debug("Audition.Failed", { client, routed })
-                return yield* new AuditionError({ value: { client, routed } })
+                const { expected, actual } = message
+                yield* debug("Audition.Failed", { expected, actual })
+                return yield* new AuditionError({ value: { expected, actual } })
               }
               case "Event": {
                 const { event } = message
@@ -377,11 +378,14 @@ export const layerSocket = <Self, Id extends string, D extends ProtocolDefinitio
   | Socket.WebSocketConstructor
   | Protocol<D>["Actor"]["DecodingServices"]
   | Protocol<D>["F"]["Payload"]["EncodingServices"]
-> =>
-  make<Self, Id, D, Socket.WebSocketConstructor>(
+> => {
+  const { F, Actor } = client.protocol
+  const encodeFPayload = encodeJsonString(F.Payload)
+  const decodeActor = decodeJsonString(Actor)
+
+  return make<Self, Id, D, Socket.WebSocketConstructor>(
     client,
     Effect.gen(function* () {
-      const { protocol } = client
       const socket = yield* Socket.makeWebSocket(url ?? "/", {
         protocols: ["liminal", Encoding.encodeBase64Url(client.key), ...(protocols ? Array.ensure(protocols) : [])],
       })
@@ -391,7 +395,7 @@ export const layerSocket = <Self, Id extends string, D extends ProtocolDefinitio
             .runRaw((raw) =>
               pipe(
                 raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw,
-                protocol.decodeActor,
+                decodeActor,
                 Effect.andThen(publish),
               ),
             )
@@ -413,7 +417,7 @@ export const layerSocket = <Self, Id extends string, D extends ProtocolDefinitio
         send: Effect.fnUntraced(
           function* (v) {
             const write = yield* socket.writer
-            const message = yield* protocol.encodeFPayload(v)
+            const message = yield* encodeFPayload(v)
             yield* write(message).pipe(
               Effect.catchTag("SocketError", (cause) => new ConnectionError({ cause }).asEffect()),
             )
@@ -425,8 +429,9 @@ export const layerSocket = <Self, Id extends string, D extends ProtocolDefinitio
     }),
     replay,
   )
+}
 
-export const layerWorker = <Self, Id extends string, D extends ProtocolDefinition>({
+export const layerWorker = <Self, Id extends string, D extends ProtocolDefinition, T extends Protocol<D>>({
   client,
   replay,
 }: {
@@ -435,22 +440,17 @@ export const layerWorker = <Self, Id extends string, D extends ProtocolDefinitio
 }): Layer.Layer<
   Self,
   never,
-  | Worker.WorkerPlatform
-  | Worker.Spawner
-  | Protocol<D>["Actor"]["DecodingServices"]
-  | Protocol<D>["F"]["Payload"]["EncodingServices"]
+  Worker.WorkerPlatform | Worker.Spawner | T["Actor"]["DecodingServices"] | T["F"]["Payload"]["EncodingServices"]
 > =>
   make<Self, Id, D, Worker.WorkerPlatform | Worker.Spawner>(
     client,
     Effect.gen(function* () {
-      type T = Protocol<D>
-
       const platform = yield* Worker.WorkerPlatform
       const backing = yield* platform
-        .spawn<T["Actor"]["Type"], T["F"]["Payload"]["Type"] | string>(0)
+        .spawn<T["Actor"]["Type"], T["Client"]["Type"]>(0)
         .pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()))
 
-      const send = (message: T["F"]["Payload"]["Type"]) =>
+      const send = (message: T["Client"]["Type"]) =>
         backing.send(message).pipe(
           Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()),
           span("send"),
@@ -459,18 +459,27 @@ export const layerWorker = <Self, Id extends string, D extends ProtocolDefinitio
       return {
         listen: Effect.fnUntraced(function* (publish) {
           const stop = yield* Deferred.make<void>()
-          yield* Effect.raceFirst(
-            backing.run(
+          yield* backing
+            .run(
               Effect.fnUntraced(function* (message) {
                 yield* publish(message)
                 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) => new ConnectionError({ cause }).asEffect()))
+              {
+                onSpawn: backing
+                  .send({
+                    _tag: "Audition.Payload",
+                    client: client.key,
+                  })
+                  .pipe(Effect.orDie),
+              },
+            )
+            .pipe(
+              Effect.raceFirst(Deferred.await(stop)),
+              Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()),
+            )
         }, span("listen")),
         send,
       }

package/ClientDirectory.ts

@@ -0,0 +1,104 @@
+import { Schema as S, Effect, Cause, Ref } from "effect"
+
+import type { TopFromString } from "./_util/schema.ts"
+import type { Actor } from "./Actor.ts"
+import type { ActorTransport } from "./ActorTransport.ts"
+import type { ProtocolDefinition, Disconnect, Protocol } from "./Protocol.ts"
+
+import * as Diagnostic from "./_util/Diagnostic.ts"
+import { phantom } from "./_util/phantom.ts"
+import * as ClientHandle from "./ClientHandle.ts"
+
+const { span } = Diagnostic.module("ClientDirectory")
+
+export interface ClientDirectory<
+  Raw,
+  ActorSelf,
+  AttachmentFields extends S.Struct.Fields,
+  D extends ProtocolDefinition,
+> {
+  readonly "": {
+    readonly Handle: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
+  }
+
+  readonly handles: ReadonlySet<this[""]["Handle"]>
+
+  readonly register: (
+    raw: Raw,
+    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 unregister: (raw: Raw) => Effect.Effect<void>
+}
+
+export interface HandleEncoders<T, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
+  attachments: (
+    value: S.Struct<AttachmentFields>["Type"],
+  ) => Effect.Effect<T, S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
+  event: (
+    value: Protocol<D>["Event"]["Type"],
+  ) => Effect.Effect<T, S.SchemaError, Protocol<D>["Event"]["EncodingServices"]>
+  disconnect: Effect.Effect<T, S.SchemaError, (typeof Disconnect)["EncodingServices"]>
+}
+
+export const make = <
+  Raw,
+  ActorSelf,
+  ActorId extends string,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  ClientSelf,
+  ClientId extends string,
+  D extends ProtocolDefinition,
+>(
+  _actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>,
+  { send, close, snapshot }: ActorTransport<Raw, AttachmentFields, D>,
+): ClientDirectory<Raw, ActorSelf, AttachmentFields, D> => {
+  type Handle = ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
+
+  const raws = new Map<Raw, Handle>()
+  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 = ClientHandle.make({
+      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,
+        }),
+      disconnect: close(raw).pipe(
+        Effect.andThen(() =>
+          Effect.sync(() => {
+            raws.delete(raw)
+            handles.delete(handle)
+          }),
+        ),
+      ),
+    })
+    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)
+      }
+    }).pipe(span("unregister"))
+
+  return { ...phantom, handles, register, get, unregister }
+}

package/Protocol.ts

@@ -1,4 +1,4 @@
-import { flow, Schema as S, Record, Types, Effect, SchemaAST } from "effect"
+import { Schema as S, Record, Types } from "effect"
 
 import type * as Method from "./Method.ts"
 
@@ -24,18 +24,15 @@ export declare namespace ProtocolDefinition {
   >
 }
 
-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 Payload: S.TaggedStruct<"Audition.Payload", { client: S.String }>
     readonly Success: S.TaggedStruct<"Audition.Success", {}>
     readonly Failure: S.TaggedStruct<
       "Audition.Failure",
       {
-        client: S.String
-        routed: S.String
+        expected: S.String
+        actual: S.String
       }
     >
   }
@@ -83,6 +80,8 @@ export interface Protocol<D extends ProtocolDefinition> {
 
   readonly Disconnect: S.TaggedStruct<"Disconnect", {}>
 
+  readonly Client: S.Union<[this["Audition"]["Payload"], this["F"]["Payload"], this["Disconnect"]]>
+
   readonly Actor: S.Union<
     [
       this["Audition"]["Success"],
@@ -93,30 +92,18 @@ export interface Protocol<D extends ProtocolDefinition> {
       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"]>
 }
 
-const Disconnect = S.TaggedStruct("Disconnect", {})
+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", {
-    client: S.String,
-    routed: S.String,
+    expected: S.String,
+    actual: S.String,
   }),
 }
 
@@ -142,20 +129,9 @@ export const Protocol = <D extends ProtocolDefinition>({ events, methods }: D):
     event: S.TaggedUnion(events),
   }) 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])
 
-  const encodeFPayload = encode(F.Payload)
-  const decodeEvent = decode(Event)
-  const decodeActor = decode(Actor)
-
-  return {
-    Audition,
-    Event,
-    F,
-    Actor,
-    Disconnect,
-    encodeFPayload,
-    decodeEvent,
-    decodeActor,
-  }
+  return { Audition, Event, F, Client, Actor, Disconnect }
 }

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 { ProtocolDefinition } from "./Protocol.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, D extends ProtocolDefinition> {
-    readonly name: NameA;
+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, D extends ProtocolDefinition> {
-    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, D>;
 }
-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>>;
+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, D>;
-    readonly protocol: {
-        readonly Attachments: S.Struct<AttachmentFields>;
-    };
+    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 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, 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>;
+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,
-        protocol: {
-            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;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"}
+{"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/Client.d.ts

@@ -35,7 +35,7 @@ export declare const layerSocket: <Self, Id extends string, D extends ProtocolDe
     readonly protocols?: string | Array<string> | undefined;
     readonly replay?: ReplayConfig | undefined;
 }) => 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, }: {
+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<Self, never, Worker.WorkerPlatform | Worker.Spawner | Protocol<D>["Actor"]["DecodingServices"] | Protocol<D>["F"]["Payload"]["EncodingServices"]>;
+}) => Layer.Layer<Self, never, Worker.WorkerPlatform | Worker.Spawner | T["Actor"]["DecodingServices"] | T["F"]["Payload"]["EncodingServices"]>;