liminal 0.17.14 → 0.17.16

package/dist/BrowserActorNamespace.js

@@ -0,0 +1,134 @@
+import { BrowserWorkerRunner } from "@effect/platform-browser";
+import { Effect, Exit, Layer, Option, Ref, Schema as S, Scope, Semaphore, Stream, Tracer } from "effect";
+import { WorkerRunner } from "effect/unstable/workers";
+import * as Boundary from "liminal-util/Boundary";
+import { encodeJsonString, decodeJsonString } from "liminal-util/schema";
+import * as ClientDirectory from "./ClientDirectory.js";
+import * as Method from "./Method.js";
+import * as Tracing from "./Tracing.js";
+export const make = Effect.fnUntraced(function* ({ actor, handlers, hydrate, introductions, }) {
+    const { definition: { client: { protocol: P, key: expected }, name: Name, }, } = actor;
+    const { Client: ClientM } = P;
+    const decodeClient = decodeJsonString(ClientM);
+    const encodeAuditionSuccess = encodeJsonString(P.Audition.Success);
+    const encodeAuditionFailure = encodeJsonString(P.Audition.Failure);
+    const encodeFSuccess = encodeJsonString(P.F.Success);
+    const encodeFFailure = encodeJsonString(P.F.Failure);
+    const encodeEvent = encodeJsonString(P.Event);
+    const entries = {};
+    const transport = {
+        key: ({ port }) => port,
+        send: ({ backing }, event) => {
+            const { _tag } = event.event;
+            return Effect.gen(function* () {
+                const trace = yield* Tracing.currentTrace;
+                yield* backing.send(0, yield* encodeEvent({ ...event, ...(trace && { trace }) }).pipe(Effect.catchTags({
+                    SchemaError: Effect.die,
+                })));
+            }).pipe(Boundary.span("send", import.meta.url, { attributes: { _tag }, kind: "producer" }));
+        },
+        close: ({ close }) => close,
+        snapshot: () => Effect.void,
+    };
+    const useEntries = yield* Semaphore.make(1).pipe(Effect.map((v) => v.withPermits(1)));
+    const getEntry = Effect.fnUntraced(function* (key) {
+        const existing = entries[key];
+        if (existing)
+            return existing;
+        const directory = ClientDirectory.make(actor, { transport });
+        const semaphore = yield* Semaphore.make(1);
+        const fresh = {
+            directory,
+            mutex: semaphore.withPermits(1),
+        };
+        entries[key] = fresh;
+        return fresh;
+    }, useEntries);
+    const outerScope = yield* Scope.Scope;
+    yield* introductions.pipe(Stream.runForEach(Effect.fnUntraced(function* ({ name, port, attachments }) {
+        const stateRef = yield* Ref.make(Option.none());
+        const scope = yield* Scope.fork(outerScope, "sequential");
+        const closeScope = Scope.close(scope, Exit.void);
+        const backing = yield* BrowserWorkerRunner.make(port).start();
+        yield* Scope.addFinalizer(scope, Effect.gen(function* () {
+            const state = yield* Ref.get(stateRef);
+            if (state._tag === "Some") {
+                const { key, entry: { directory }, } = state.value;
+                yield* directory.unregister(port);
+                if (directory.handles.size === 0) {
+                    delete entries[key];
+                }
+            }
+        }).pipe(useEntries));
+        yield* backing
+            .run(Effect.fnUntraced(function* (_portId, raw) {
+            const state = yield* Ref.get(stateRef);
+            const message = yield* decodeClient(raw);
+            if (state._tag === "None") {
+                if (message._tag !== "Audition.Payload") {
+                    return yield* Effect.die(undefined);
+                }
+                const { client: actual } = message;
+                if (actual !== expected) {
+                    yield* backing.send(0, yield* encodeAuditionFailure({
+                        _tag: "Audition.Failure",
+                        expected,
+                        actual,
+                    }));
+                    return yield* closeScope;
+                }
+                const key = yield* S.encodeEffect(Name)(name);
+                const entry = yield* getEntry(key);
+                const currentClient = yield* entry.directory.register({ port, backing, close: closeScope }, attachments);
+                const ActorLive = Layer.succeed(actor, {
+                    name,
+                    clients: entry.directory.handles,
+                    currentClient,
+                });
+                yield* Ref.set(stateRef, Option.some({ key, entry, currentClient, ActorLive }));
+                const initial = yield* hydrate.pipe(entry.mutex, Effect.scoped, Boundary.span("onConnect", import.meta.url), Effect.provide(ActorLive));
+                return yield* backing.send(0, yield* encodeAuditionSuccess({ _tag: "Audition.Success", initial }));
+            }
+            const { entry, ActorLive } = state.value;
+            if (message._tag === "Audition.Payload") {
+                return yield* Effect.die(undefined);
+            }
+            if (message._tag === "Disconnect") {
+                return yield* closeScope;
+            }
+            const { id, payload } = message;
+            const { _tag, value } = payload;
+            const parent = message.trace && Tracer.externalSpan(message.trace);
+            const transportSpan = yield* Tracing.parent;
+            yield* handlers[_tag](value).pipe(Effect.matchEffect({
+                onSuccess: (value) => encodeFSuccess({
+                    _tag: "F.Success",
+                    id,
+                    success: { _tag, value },
+                }),
+                onFailure: (value) => encodeFFailure({
+                    _tag: "F.Failure",
+                    id,
+                    failure: { _tag, value },
+                }),
+            }), Effect.andThen((v) => backing.send(0, v)), Boundary.span("handle", import.meta.url, {
+                attributes: { _tag },
+                kind: "server",
+                parent,
+                links: parent && transportSpan
+                    ? [
+                        {
+                            span: transportSpan,
+                            attributes: {
+                                "liminal.link": "transport",
+                                "liminal.transport": "worker",
+                            },
+                        },
+                    ]
+                    : undefined,
+            }), Effect.scoped, Effect.provide(ActorLive), entry.mutex);
+        }, Boundary.span("message", import.meta.url)))
+            .pipe(Effect.andThen(closeScope), Effect.catchCause((cause) => Effect.logError(cause).pipe(Effect.andThen(closeScope))), Boundary.span("backing", import.meta.url), Effect.forkScoped, Scope.provide(scope));
+    })));
+}, Boundary.span("make", import.meta.url));
+//# sourceMappingURL=BrowserActorNamespace.js.map

package/dist/BrowserActorNamespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BrowserActorNamespace.js","sourceRoot":"","sources":["../BrowserActorNamespace.ts"],"names":[],"mappings":"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"}

package/dist/Client.d.ts

@@ -2,40 +2,50 @@ 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, FnNoSelf } 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>;
-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>>;
+}, ClientError>;
+export interface Client<Self, Id extends string, D extends ProtocolDefinition> extends Context.Service<Self, Service<Self, D>> {
+    new (_: never): Context.ServiceClass.Shape<Id, Service<Self, D>> & {
+        readonly State: S.Struct<D["state"]>["Type"];
+    };
     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 fn: <ClientSelf, D extends ProtocolDefinition>(service: Service<ClientSelf, D>) => FnNoSelf<D["external"]>;
 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["Client"]["EncodingServices"] | Reducer.Reducers.Services<Self, Reducers>>;

package/dist/Client.js

@@ -1,41 +1,50 @@
-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 { decodeJsonString, encodeJsonString } from "./_util/schema.js";
+import * as Boundary from "liminal-util/Boundary";
+import { decodeJsonString, encodeJsonString } from "liminal-util/schema";
 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";
 export const TypeId = "~liminal/Client";
+export const fn = (service) => ((_tag, ...f) => Effect.fnUntraced(function* (payload) {
+    const { fnRaw: fn } = yield* RcRef.get(service);
+    return yield* fn(_tag, payload);
+}, Effect.scoped, ...f));
 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 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 state = tag.pipe(Effect.flatMap(RcRef.get), Effect.map(({ state }) => state), Stream.unwrap);
+    const events = tag.pipe(Effect.flatMap(RcRef.get), Effect.map(({ events }) => events), Stream.unwrap);
+    const fn = ((_tag, ...f) => Effect.fnUntraced(function* (payload) {
+        const { fnRaw: fn } = yield* tag.pipe(Effect.flatMap(RcRef.get));
+        return yield* fn(_tag, payload);
+    }, Effect.scoped, ...f));
+    const invalidate = tag.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 +66,95 @@ 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), 
+                            // TODO: rework error-handling
+                            Effect.catchDefect(() => Effect.succeed(undefined)));
+                            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(Boundary.span("enqueue-event", import.meta.url, {
+                            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 +174,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 +190,124 @@ 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, {
-                    onSuccess: () => new UnresolvedError().asEffect(),
+                return yield* Effect.raceFirst(Deferred.await(deferred), Fiber.await(fiber).pipe(Effect.flatMap((exit) => Exit.match(exit, {
+                    onSuccess: () => new UnresolvedError(),
                     onFailure: flow(Cause.findError, Result.match({
                         onSuccess: Effect.fail,
-                        onFailure: () => new UnresolvedError().asEffect(),
+                        onFailure: () => new UnresolvedError(),
                     })),
                 }))));
-            }, span("f"), Effect.scoped, Effect.provide(encodingServices));
-            return { events, f, end };
-        }).pipe(span("acquire", { attributes: { client: client.key } }), Effect.annotateLogs("client", client.key)),
+            }).pipe(Boundary.span("fn", import.meta.url, {
+                kind: "client",
+                attributes: { _tag },
+            }), Effect.provide(encodingServices));
+            return { state, events, fnRaw, end };
+        }).pipe(Boundary.span("acquire", import.meta.url, {
+            attributes: { client: client.key },
+        }), Effect.annotateLogs("client", client.key)),
     });
     return rcr;
 }).pipe(Layer.effect(client));
-export const layerSocket = ({ client, url, protocols, replay, }) => {
+let clientId_;
+const clientId = () => {
+    if (!clientId_) {
+        clientId_ = crypto.randomUUID();
+    }
+    return clientId_;
+};
+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 {
-            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" });
-                    }
-                    yield* debug(`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),
-        };
-    }), replay);
+    return make({
+        client,
+        reducers,
+        onConnect,
+        replay,
+        build: Effect.gen(function* () {
+            const socket = yield* Socket.makeWebSocket(url ?? "/", {
+                protocols: [
+                    "liminal",
+                    clientId(),
+                    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 });
+                    })));
+                }, Boundary.span("listen", import.meta.url)),
+                send: Effect.fnUntraced(function* (v) {
+                    const write = yield* socket.writer;
+                    const message = yield* encodeFPayload(v);
+                    yield* write(message).pipe(Effect.catchTags({
+                        SocketError: (cause) => new ConnectionError({ cause }),
+                    }));
+                }, Boundary.span("send", import.meta.url), Effect.scoped),
+            };
+        }),
+    });
+};
+export const layerWorker = ({ client, reducers, replay, onConnect, }) => {
+    const { Actor, Client: ClientM } = client.protocol;
+    const encodeClient = encodeJsonString(ClientM);
+    const decodeActor = decodeJsonString(Actor);
+    return make({
+        client,
+        reducers,
+        onConnect,
+        replay,
+        build: Effect.gen(function* () {
+            const platform = yield* Worker.WorkerPlatform;
+            const backing = yield* platform.spawn(0).pipe(Effect.catchTags({
+                WorkerError: (cause) => new ConnectionError({ cause }),
+            }));
+            const send = (message) => encodeClient(message).pipe(Effect.flatMap((encoded) => backing.send(encoded)), Effect.catchTags({
+                WorkerError: (cause) => new ConnectionError({ cause }),
+            }), Boundary.span("send", import.meta.url));
+            return {
+                listen: Effect.fnUntraced(function* (publish) {
+                    const stop = yield* Deferred.make();
+                    const audition = yield* encodeClient({
+                        _tag: "Audition.Payload",
+                        client: client.key,
+                    });
+                    yield* backing
+                        .run(Effect.fnUntraced(function* (raw) {
+                        const message = yield* decodeActor(raw);
+                        yield* publish(message);
+                        if (message._tag === "Disconnect" || message._tag === "Audition.Failure") {
+                            yield* Deferred.succeed(stop, void 0);
+                        }
+                    }), {
+                        onSpawn: backing.send(audition).pipe(Effect.orDie),
+                    })
+                        .pipe(Effect.raceFirst(Deferred.await(stop)), Effect.catchTags({
+                        WorkerError: (cause) => new ConnectionError({ cause }),
+                    }));
+                }, Boundary.span("listen", import.meta.url)),
+                send,
+            };
+        }),
+    });
 };
-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