liminal 0.17.14 → 0.17.15

package/dist/Actor.d.ts

@@ -21,6 +21,6 @@ export interface Actor<ActorSelf, ActorId extends string, Name extends TopFromSt
     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 handler: <K extends keyof D["external"], R>(tag: K, f: Method.Handler<D["external"][K], R>) => Method.Handler<D["external"][K], R>;
 }
 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,24 +1,24 @@
 import { Context, Schema as S, Effect } from "effect";
-import { diagnostic } from "./_diagnostic.js";
+import * as Spanner from "liminal-util/Spanner";
 import * as Method from "./Method.js";
 import {} from "./Protocol.js";
-const { span } = diagnostic("Actor");
+const span = Spanner.make(import.meta.url);
 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.asEffect().pipe(Effect.flatMap(({ clients }) => Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" })), span("send-all")),
+        disconnect: tag.asEffect().pipe(Effect.flatMap(({ clients }) => Effect.forEach(clients, ({ disconnect }) => disconnect)), span("disconnect-all")),
     };
     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")),
+        }, 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 = (_tag, f) => f;
     return Object.assign(tag, {

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,OAAO,MAAM,sBAAsB,CAAA;AAK/C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,EAA2B,MAAM,eAAe,CAAA;AAEvD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AAE1C,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,CAAsC,EACD,EAAE,CAAC,CAAC,CAAA;IAE3C,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"}

package/dist/ActorTransport.d.ts

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

package/dist/Audition.d.ts

@@ -1,17 +1,24 @@
-import { Schema as S, Pipeable, Stream } from "effect";
-import type { F } from "./F.ts";
-import type { ProtocolDefinition } from "./Protocol.ts";
+import { Schema as S, Pipeable, Stream, Types } from "effect";
 import * as Client from "./Client.ts";
 import { type ClientError } from "./errors.ts";
+import type { Fn } from "./Fn.ts";
+import type { Methods } from "./Method.ts";
+import type { ProtocolDefinition } from "./Protocol.ts";
 declare const TypeId: "~liminal/Audition";
-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 f: F<ClientSelf, D>;
+    readonly state: Stream.Stream<State["Type"], ClientError | S.SchemaError, AuditionSelf | State["DecodingServices"]>;
+    readonly fn: Fn<AuditionSelf, External>;
+    readonly events: Stream.Stream<Event, ClientError | S.SchemaError, AuditionSelf>;
 }
-export declare 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 declare const empty: Audition<never, never, {}, never>;
+export declare 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>;
 export declare 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>>;
-    <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>>;
+    <ClientSelf, ClientId extends string, ClientD extends ProtocolDefinition>(client: Client.Client<ClientSelf, ClientId, 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"]>;
+    <AuditionSelf, State extends S.Union<ReadonlyArray<S.Top>> | never, External extends Methods, Event, ClientSelf, ClientId extends string, ClientD extends ProtocolDefinition>(audition: Audition<AuditionSelf, State, External, Event>, client: Client.Client<ClientSelf, ClientId, ClientD>): Audition<AuditionSelf | ClientSelf, MergeState<State, ClientD>, MergeMethods<External, ClientD["external"]>, Event | ReturnType<typeof S.TaggedUnion<ClientD["events"]>>["Type"]>;
 };
 export {};

package/dist/Audition.js

@@ -1,29 +1,45 @@
-import { Schema as S, Pipeable, Stream, Effect, Function } from "effect";
-import { diagnostic } from "./_diagnostic.js";
+import { Schema as S, Pipeable, Stream, Effect, Function, Types } from "effect";
 import * as Client from "./Client.js";
 import { AuditionError } from "./errors.js";
-const { debug, span } = diagnostic("Audition");
 const TypeId = "~liminal/Audition";
 export const empty = {
     [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 = (predicate) => (audition) => {
+    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 = Function.dual(2, (audition, client) => {
-    const f = (method) => (payload) => audition
-        .f(method)(payload)
-        .pipe(Effect.catchTag("AuditionError", () => client.f(method)(payload)), span("f"));
-    const events = audition.events.pipe(Stream.catchTag("AuditionError", () => Effect.succeed(client.events).pipe(Effect.tap(() => debug("AuditionStaged", { client: client.key })), Stream.unwrap)));
+    const fn = ((method, ...f) => Effect.fnUntraced(function* (payload) {
+        return yield* audition
+            .fn(method)(payload)
+            .pipe(Effect.catchTag("AuditionError", () => client.fn(method)(payload)));
+    }, ...f));
+    const events = audition.events.pipe(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 {
         [TypeId]: TypeId,
         pipe() {
             return Pipeable.pipeArguments(this, arguments);
         },
         events,
-        f,
+        fn,
+        state,
     };
 });
 //# sourceMappingURL=Audition.js.map

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,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAA;AAE7D,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,UAAU,CAAC,CAAA;AAE9C,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"}
+{"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,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE/E,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAA;AAK7D,MAAM,MAAM,GAAG,mBAA4B,CAAA;AAuB3C,MAAM,CAAC,MAAM,KAAK,GAAsC;IACtD,CAAC,MAAM,CAAC,EAAE,MAAM;IAChB,IAAI;QACF,OAAO,QAAQ,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAChD,CAAC;IACD,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,aAAa,EAAE,CAAC;IACvC,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,aAAa,EAAE,CAAC,QAAQ,EAAE;IAC9C,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,aAAa,EAAE,CAAC;CACzC,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAClB,CAAQ,SAAoC,EAAE,EAAE,CAChD,CACE,QAAwD,EACR,EAAE;IAClD,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,CAAA;IAChF,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IAEjD,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,EAAE,EAAE,QAAQ,CAAC,EAAE;QACf,KAAK;KACN,CAAA;AACH,CAAC,CAAA;AAEH,MAAM,CAAC,MAAM,GAAG,GA4BZ,QAAQ,CAAC,IAAI,CACf,CAAC,EACD,CASE,QAAwD,EACxD,MAAoD,EAMpD,EAAE;IACF,MAAM,EAAE,GAAG,CAAC,CAAC,MAAc,EAAE,GAAG,CAAQ,EAAE,EAAE,CAC1C,MAAM,CAAC,UAAU,CACf,QAAQ,CAAC,EAAE,OAAY;QACrB,OAAO,KAAK,CAAC,CAAC,QAAQ;aACnB,EAAE,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;aACnB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAC7E,CAAC,EACD,GAAG,CAAC,CACL,CAA+E,CAAA;IAElF,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,CACjC,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAC1F,CAAA;IAED,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAC/B,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CACzF,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,EAAE;QACF,KAAK;KACN,CAAA;AACH,CAAC,CACF,CAAA"}

package/dist/Client.d.ts

@@ -2,40 +2,47 @@ import { Context, Effect, Layer, RcRef, Scope, Stream, Schema as S } from "effec
 import { Socket } from "effect/unstable/socket";
 import { Worker } from "effect/unstable/workers";
 import { type ClientError } from "./errors.ts";
-import { type F } from "./F.ts";
+import type { Fn } from "./Fn.ts";
 import { Protocol, type ProtocolDefinition } from "./Protocol.ts";
+import * as Reducer from "./Reducer.ts";
 export declare const TypeId: "~liminal/Client";
 export interface ReplayConfig {
     readonly mode: "startup" | "all-subscribers";
     readonly limit?: number | undefined;
 }
-export interface Session<Self, D extends ProtocolDefinition> {
+export type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<{
+    readonly state: Stream.Stream<S.Struct<D["state"]>["Type"], ClientError | S.SchemaError>;
     readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError>;
-    readonly f: F<Self, D>;
+    readonly fnRaw: <K extends keyof D["external"], M extends D["external"][K]>(tag: K, payload: M["payload"]["Type"]) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], ClientSelf>;
     readonly end: Effect.Effect<void>;
-}
-export type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<Session<ClientSelf, D>, ClientError>;
+}, 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: D;
     readonly protocol: Protocol<D>;
+    readonly state: Stream.Stream<S.Struct<D["state"]>["Type"], ClientError | S.SchemaError, Self | S.Struct<D["state"]>["DecodingServices"]>;
     readonly events: Stream.Stream<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], ClientError | S.SchemaError, Self>;
-    readonly f: F<Self, D>;
+    readonly fn: Fn<Self, D["external"]>;
     readonly invalidate: Effect.Effect<void, never, Self>;
+    readonly reducer: <K extends keyof D["events"], R extends Reducer.Reducer<D, K>>(_tag: K, f: R) => R;
 }
 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"]>;
+export interface ClientTransport<D extends ProtocolDefinition, R> {
+    readonly listen: (publish: (message: Protocol<D>["Actor"]["Type"]) => Effect.Effect<void, ClientError, R>) => Effect.Effect<void, ClientError | S.SchemaError, Scope.Scope | Protocol<D>["Actor"]["DecodingServices"] | R>;
     readonly send: (message: Protocol<D>["F"]["Payload"]["Type"]) => Effect.Effect<void, ClientError | S.SchemaError, Protocol<D>["F"]["Payload"]["EncodingServices"]>;
 }
-export declare const layerSocket: <Self, Id extends string, D extends ProtocolDefinition>({ client, url, protocols, replay, }: {
+export declare const layerSocket: <Self, Id extends string, D extends ProtocolDefinition, Reducers extends Reducer.Reducers<D>, CR = never>({ client, reducers, url, protocols, replay, onConnect, }: {
     readonly client: Client<Self, Id, D>;
-    readonly url?: string | undefined;
-    readonly protocols?: string | Array<string> | undefined;
+    readonly reducers: Reducers;
     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, T extends Protocol<D>>({ client, replay, }: {
+    readonly onConnect?: undefined | ((state: S.Struct<D["state"]>["Type"]) => Effect.Effect<void, never, CR>);
+    readonly protocols?: string | Array<string> | undefined;
+    readonly url?: string | undefined;
+}) => Layer.Layer<Self, never, Socket.WebSocketConstructor | Protocol<D>["Actor"]["DecodingServices"] | Protocol<D>["F"]["Payload"]["EncodingServices"] | Reducer.Reducers.Services<Self, Reducers> | CR>;
+export declare const layerWorker: <Self, Id extends string, D extends ProtocolDefinition, Reducers extends Reducer.Reducers<D>, T extends Protocol<D>, CR = never>({ client, reducers, replay, onConnect, }: {
     readonly client: Client<Self, Id, D>;
+    readonly reducers: Reducers;
     readonly replay?: ReplayConfig | undefined;
-}) => Layer.Layer<Self, never, Worker.WorkerPlatform | Worker.Spawner | T["Actor"]["DecodingServices"] | T["F"]["Payload"]["EncodingServices"]>;
+    readonly onConnect?: undefined | ((state: S.Struct<D["state"]>["Type"]) => Effect.Effect<void, never, CR>);
+}) => Layer.Layer<Self, never, Worker.WorkerPlatform | Worker.Spawner | T["Actor"]["DecodingServices"] | T["F"]["Payload"]["EncodingServices"] | Reducer.Reducers.Services<Self, Reducers>>;

package/dist/Client.js

@@ -1,41 +1,47 @@
-import { Context, Encoding, Deferred, Effect, Layer, Option, PubSub, RcRef, Record, pipe, Ref, Scope, Stream, Take, Schema as S, Array, Struct, Fiber, Exit, Cause, Result, flow, } from "effect";
+import { Context, Encoding, Deferred, Effect, Layer, Option, PubSub, RcRef, Record, pipe, Ref, Scope, Stream, Take, Schema as S, Array, Fiber, Exit, Cause, Result, flow, Tracer, identity, Semaphore, } from "effect";
 import { Socket } from "effect/unstable/socket";
 import { Worker } from "effect/unstable/workers";
-import { diagnostic } from "./_diagnostic.js";
+import * as Spanner from "liminal-util/Spanner";
 import { decodeJsonString, encodeJsonString } from "./_util/schema.js";
 import { AuditionError, ConnectionError, UnresolvedError } from "./errors.js";
-import {} from "./F.js";
 import { Protocol } from "./Protocol.js";
-const { debug, span } = diagnostic("Client");
+import * as Reducer from "./Reducer.js";
+import * as Tracing from "./Tracing.js";
+const span = Spanner.make(import.meta.url);
 export const TypeId = "~liminal/Client";
 export const Service = () => (id, definition) => {
     const tag = Context.Service()(id);
     const protocol = Protocol(definition);
-    const events = tag.asEffect().pipe(Effect.flatMap(RcRef.get), Effect.map(Struct.get("events")), Stream.unwrap);
-    const f = (_tag) => Effect.fnUntraced(function* (value) {
-        const { f } = yield* tag.asEffect().pipe(Effect.flatMap(RcRef.get));
-        return yield* f(_tag)(value);
-    }, Effect.scoped);
+    const state = tag.asEffect().pipe(Effect.flatMap(RcRef.get), Effect.map(({ state }) => state), Stream.unwrap);
+    const events = tag.asEffect().pipe(Effect.flatMap(RcRef.get), Effect.map(({ events }) => events), Stream.unwrap);
+    const fn = ((_tag, ...f) => Effect.fnUntraced(function* (payload) {
+        const { fnRaw: fn } = yield* tag.asEffect().pipe(Effect.flatMap(RcRef.get));
+        return yield* fn(_tag, payload);
+    }, Effect.scoped, ...f));
     const invalidate = tag.asEffect().pipe(Effect.flatMap((rc) => RcRef.get(rc).pipe(Effect.flatMap(({ end }) => end), Effect.andThen(RcRef.invalidate(rc)))), Effect.scoped, Effect.ignore);
+    const reducer = (_event, f) => f;
     return Object.assign(tag, {
         [TypeId]: TypeId,
         definition,
         protocol,
+        state,
         events,
-        f,
+        fn,
         invalidate,
+        reducer,
     });
 };
-const make = (client, build, replay) => Effect.gen(function* () {
+const make = ({ build, client, reducers, onConnect, replay, }) => Effect.gen(function* () {
     const rcr = yield* RcRef.make({
         acquire: Effect.gen(function* () {
-            yield* debug("AcquisitionStarted");
             const { listen, send } = yield* build;
             const audition = yield* Deferred.make();
+            const stateDeferred = yield* Deferred.make();
             const inflights = {};
             let callId = 0;
             let takeCount = 0;
-            const pubsub = yield* PubSub.unbounded();
+            const eventsPubsub = yield* PubSub.unbounded();
+            const statePubsub = yield* PubSub.unbounded({ replay: 1 });
             const replayState = yield* Ref.make({
                 startupOpen: true,
                 buffer: [],
@@ -57,64 +63,93 @@ const make = (client, build, replay) => Effect.gen(function* () {
                         return { startupOpen, buffer };
                     });
                 }
-                yield* PubSub.publish(pubsub, eventTake);
+                yield* PubSub.publish(eventsPubsub, eventTake);
             });
             const outer = yield* Scope.Scope;
             const scope = yield* Scope.fork(outer, "sequential");
             const end = Scope.close(scope, Exit.void);
+            const reduceMutex = yield* Semaphore.make(1);
+            const reduceTask = Semaphore.withPermits(reduceMutex, 1);
             const fiber = yield* listen(Effect.fnUntraced(function* (message) {
                 switch (message._tag) {
                     case "Audition.Success": {
-                        yield* debug("Audition.Succeeded");
+                        const { initial } = message;
+                        yield* PubSub.publish(statePubsub, initial);
+                        const state = yield* Ref.make(initial);
+                        yield* Deferred.succeed(stateDeferred, state);
                         yield* Deferred.succeed(audition, void 0);
+                        yield* onConnect?.(initial) ?? Effect.void;
                         return;
                     }
                     case "Audition.Failure": {
                         const { expected, actual } = message;
-                        yield* debug("Audition.Failed", { expected, actual });
                         return yield* new AuditionError({ value: { expected, actual } });
                     }
                     case "Event": {
                         const { event } = message;
-                        yield* debug("Event.Emitted", { event });
-                        yield* publishTake([event], true);
+                        const { _tag } = event;
+                        const reducer = reducers[_tag];
+                        const state = yield* Deferred.await(stateDeferred);
+                        yield* Effect.gen(function* () {
+                            const current = yield* Ref.get(state);
+                            const reduced = yield* reducer(event)(current).pipe(Effect.provideService(client, rcr));
+                            if (reduced) {
+                                yield* PubSub.publish(statePubsub, reduced);
+                                yield* Ref.set(state, reduced);
+                            }
+                        }).pipe(reduceTask);
+                        const parent = message.trace ? Tracer.externalSpan(message.trace) : undefined;
+                        yield* publishTake([event], true).pipe(span("enqueue-event", {
+                            attributes: { _tag },
+                            kind: "consumer",
+                            parent,
+                        }));
                         return;
                     }
                     case "F.Success":
                     case "F.Failure": {
                         const { id } = message;
-                        const deferred = inflights[id];
-                        if (deferred) {
+                        const inflight = inflights[id];
+                        if (inflight) {
                             delete inflights[id];
-                            switch (message._tag) {
-                                case "F.Success": {
-                                    const { _tag, value } = message.success;
-                                    yield* debug("Call.Succeeded", { id, _tag, value });
-                                    yield* Deferred.succeed(deferred, value);
-                                    return;
-                                }
-                                case "F.Failure": {
-                                    const { _tag, value } = message.failure;
-                                    yield* debug("Call.Failed", { id, _tag, value });
-                                    yield* Deferred.fail(deferred, value);
-                                    return;
+                            return yield* Effect.gen(function* () {
+                                switch (message._tag) {
+                                    case "F.Success": {
+                                        const { value } = message.success;
+                                        yield* Deferred.succeed(inflight.deferred, value);
+                                        return;
+                                    }
+                                    case "F.Failure": {
+                                        const { _tag, value } = message.failure;
+                                        yield* Effect.annotateLogs(Effect.logDebug("Call.Failed"), { id, _tag });
+                                        yield* Deferred.fail(inflight.deferred, value);
+                                        return;
+                                    }
                                 }
-                            }
+                            }).pipe(inflight.span ? Effect.withParentSpan(inflight.span, { captureStackTrace: false }) : identity);
                         }
                         return;
                     }
                     case "Disconnect": {
-                        yield* debug("Disconnected");
                         return;
                     }
                 }
             })).pipe(Effect.ensuring(Effect.all([
-                debug("Client.Closed", { unresolved: Record.keys(inflights).length }),
+                Effect.sync(() => Record.keys(inflights).length).pipe(Effect.flatMap((unresolved) => unresolved === 0
+                    ? Effect.void
+                    : Effect.annotateLogs(Effect.logDebug("Client.Closed"), { unresolved }))),
                 Deferred.succeed(audition, void 0),
                 RcRef.invalidate(rcr),
             ], { concurrency: "unbounded" })), Effect.forkScoped, Effect.provideService(Scope.Scope, scope));
+            const interrupt = Stream.interruptWhen(Fiber.await(fiber).pipe(Effect.flatMap(Exit.match({
+                onSuccess: () => Effect.void,
+                onFailure: flow(Cause.findError, Result.match({
+                    onSuccess: Effect.fail,
+                    onFailure: () => Effect.void,
+                })),
+            }))));
             const events = Effect.gen(function* () {
-                const queue = yield* PubSub.subscribe(pubsub);
+                const queue = yield* PubSub.subscribe(eventsPubsub);
                 const live = (replayCount) => Stream.fromSubscription(queue).pipe(Stream.filter((entry) => entry.seq > replayCount), Stream.map((entry) => entry.take), Stream.flattenTake);
                 if (!replay) {
                     return live(-1);
@@ -134,16 +169,11 @@ const make = (client, build, replay) => Effect.gen(function* () {
                 return buffer.length === 0
                     ? live(replayCount)
                     : Stream.concat(Stream.fromIterable(buffer).pipe(Stream.map((entry) => entry.take), Stream.flattenTake), live(replayCount));
-            }).pipe(Stream.unwrap, Stream.interruptWhen(Fiber.await(fiber).pipe(Effect.flatMap(Exit.match({
-                onSuccess: () => Effect.void,
-                onFailure: flow(Cause.findError, Result.match({
-                    onSuccess: Effect.fail,
-                    onFailure: () => Effect.void,
-                })),
-            })))));
-            yield* Deferred.await(audition);
+            }).pipe(Stream.unwrap, interrupt);
+            const state = Stream.fromPubSub(statePubsub).pipe(interrupt);
             const encodingServices = yield* Effect.context();
-            const f = (_tag) => Effect.fnUntraced(function* (value) {
+            yield* Deferred.await(audition);
+            const fnRaw = (_tag, value) => Effect.gen(function* () {
                 const exit = fiber.pollUnsafe();
                 if (exit) {
                     return yield* Exit.match(exit, {
@@ -155,82 +185,99 @@ const make = (client, build, replay) => Effect.gen(function* () {
                     });
                 }
                 const id = callId++;
-                const inflight = yield* Deferred.make();
-                inflights[id] = inflight;
+                const deferred = yield* Deferred.make();
+                const span = yield* Tracing.current;
+                const trace = span ? Tracing.toTraceEnvelope(span) : undefined;
+                inflights[id] = { deferred, span };
                 yield* send({
                     _tag: "F.Payload",
                     id,
                     payload: { _tag, value },
+                    ...(trace && { trace }),
                 });
-                return yield* Effect.raceFirst(Deferred.await(inflight), Fiber.await(fiber).pipe(Effect.flatMap((exit) => Exit.match(exit, {
+                return yield* Effect.raceFirst(Deferred.await(deferred), Fiber.await(fiber).pipe(Effect.flatMap((exit) => Exit.match(exit, {
                     onSuccess: () => new UnresolvedError().asEffect(),
                     onFailure: flow(Cause.findError, Result.match({
                         onSuccess: Effect.fail,
                         onFailure: () => new UnresolvedError().asEffect(),
                     })),
                 }))));
-            }, span("f"), Effect.scoped, Effect.provide(encodingServices));
-            return { events, f, end };
+            }).pipe(span("fn", {
+                kind: "client",
+                attributes: { _tag },
+            }), Effect.provide(encodingServices));
+            return { state, events, fnRaw, end };
         }).pipe(span("acquire", { attributes: { client: client.key } }), Effect.annotateLogs("client", client.key)),
     });
     return rcr;
 }).pipe(Layer.effect(client));
-export const layerSocket = ({ client, url, protocols, replay, }) => {
+export const layerSocket = ({ client, reducers, url, protocols, replay, onConnect, }) => {
     const { F, Actor } = client.protocol;
     const encodeFPayload = encodeJsonString(F.Payload);
     const decodeActor = decodeJsonString(Actor);
-    return make(client, Effect.gen(function* () {
-        const socket = yield* Socket.makeWebSocket(url ?? "/", {
-            protocols: ["liminal", Encoding.encodeBase64Url(client.key), ...(protocols ? Array.ensure(protocols) : [])],
-        });
+    return make({
+        client,
+        reducers,
+        onConnect,
+        replay,
+        build: Effect.gen(function* () {
+            const socket = yield* Socket.makeWebSocket(url ?? "/", {
+                protocols: ["liminal", Encoding.encodeBase64Url(client.key), ...(protocols ? Array.ensure(protocols) : [])],
+            });
+            return {
+                listen: Effect.fnUntraced(function* (publish) {
+                    yield* socket
+                        .runRaw((raw) => pipe(raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw, decodeActor, Effect.andThen(publish)))
+                        .pipe(Effect.catchIf(Socket.isSocketError, Effect.fnUntraced(function* (cause) {
+                        const { reason } = cause;
+                        if (reason._tag === "SocketCloseError" && reason.code === 1000) {
+                            return yield* publish({ _tag: "Disconnect" });
+                        }
+                        yield* Effect.annotateLogs(Effect.logDebug(`SocketErrored.${reason._tag}`), { cause });
+                        return yield* new ConnectionError({ cause });
+                    })));
+                }, span("listen")),
+                send: Effect.fnUntraced(function* (v) {
+                    const write = yield* socket.writer;
+                    const message = yield* encodeFPayload(v);
+                    yield* write(message).pipe(Effect.catchTag("SocketError", (cause) => new ConnectionError({ cause }).asEffect()));
+                }, span("send"), Effect.scoped),
+            };
+        }),
+    });
+};
+export const layerWorker = ({ client, reducers, replay, onConnect, }) => make({
+    client,
+    reducers,
+    onConnect,
+    replay,
+    build: Effect.gen(function* () {
+        const platform = yield* Worker.WorkerPlatform;
+        const backing = yield* platform
+            .spawn(0)
+            .pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()));
+        const send = (message) => backing.send(message).pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()), span("send"));
         return {
             listen: Effect.fnUntraced(function* (publish) {
-                yield* socket
-                    .runRaw((raw) => pipe(raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw, decodeActor, Effect.andThen(publish)))
-                    .pipe(Effect.catchIf(Socket.isSocketError, Effect.fnUntraced(function* (cause) {
-                    const { reason } = cause;
-                    if (reason._tag === "SocketCloseError" && reason.code === 1000) {
-                        yield* debug("Socket.Disconnected");
-                        return yield* publish({ _tag: "Disconnect" });
+                const stop = yield* Deferred.make();
+                yield* backing
+                    .run(Effect.fnUntraced(function* (message) {
+                    yield* publish(message);
+                    if (message._tag === "Disconnect" || message._tag === "Audition.Failure") {
+                        yield* Deferred.succeed(stop, void 0);
                     }
-                    yield* debug(`SocketErrored.${reason._tag}`, { cause });
-                    return yield* new ConnectionError({ cause });
-                })));
+                }), {
+                    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: Effect.fnUntraced(function* (v) {
-                const write = yield* socket.writer;
-                const message = yield* encodeFPayload(v);
-                yield* write(message).pipe(Effect.catchTag("SocketError", (cause) => new ConnectionError({ cause }).asEffect()));
-            }, span("send"), Effect.scoped),
+            send,
         };
-    }), replay);
-};
-export const layerWorker = ({ client, replay, }) => make(client, Effect.gen(function* () {
-    const platform = yield* Worker.WorkerPlatform;
-    const backing = yield* platform
-        .spawn(0)
-        .pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()));
-    const send = (message) => backing.send(message).pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()), span("send"));
-    return {
-        listen: Effect.fnUntraced(function* (publish) {
-            const stop = yield* Deferred.make();
-            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({
-                    _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,
-    };
-}), replay);
+    }),
+});
 //# sourceMappingURL=Client.js.map