liminal 0.17.0 → 0.17.1

package/Protocol.ts

@@ -0,0 +1,142 @@
+import { Schema as S } from "effect"
+
+import type { FieldsRecord } from "./_types.ts"
+import type { MethodDefinition } from "./Method.ts"
+
+export declare namespace Call {
+  export namespace Payload {
+    export type Type<MethodDefinitions extends Record<string, MethodDefinition.Any>> = {
+      readonly _tag: "Call.Payload"
+
+      readonly id: number
+
+      readonly payload: {
+        [K in keyof MethodDefinitions]: {
+          readonly _tag: K
+          readonly value: S.Struct<MethodDefinitions[K]["payload"]>["Type"]
+        }
+      }[keyof MethodDefinitions]
+    }
+
+    export type Encoded<MethodDefinitions extends Record<string, MethodDefinition.Any>> = {
+      readonly _tag: "Call.Payload"
+
+      readonly id: number
+
+      readonly payload: {
+        [K in keyof MethodDefinitions]: {
+          readonly _tag: K
+          readonly value: S.Struct<MethodDefinitions[K]["payload"]>["Encoded"]
+        }
+      }[keyof MethodDefinitions]
+    }
+  }
+
+  export namespace Success {
+    export type Type<MethodDefinitions extends Record<string, MethodDefinition.Any>> = {
+      readonly _tag: "Call.Success"
+
+      readonly id: number
+
+      readonly value: {
+        readonly [K in keyof MethodDefinitions]: {
+          readonly _tag: K
+          readonly value: MethodDefinitions[K]["success"]["Type"]
+        }
+      }[keyof MethodDefinitions]
+    }
+
+    export type Encoded<MethodDefinitions extends Record<string, MethodDefinition.Any>> = {
+      readonly _tag: "Call.Success"
+
+      readonly id: number
+
+      readonly value: {
+        readonly [K in keyof MethodDefinitions]: {
+          readonly _tag: K
+          readonly value: MethodDefinitions[K]["success"]["Encoded"]
+        }
+      }[keyof MethodDefinitions]
+    }
+  }
+
+  export namespace Failure {
+    export type Type<MethodDefinitions extends Record<string, MethodDefinition.Any>> = {
+      readonly _tag: "Call.Failure"
+
+      readonly id: number
+
+      readonly cause: {
+        readonly [K in keyof MethodDefinitions]: {
+          readonly _tag: K
+          readonly value: MethodDefinitions[K]["failure"]["Type"]
+        }
+      }[keyof MethodDefinitions]
+    }
+
+    export type Encoded<MethodDefinitions extends Record<string, MethodDefinition.Any>> = {
+      readonly _tag: "Call.Failure"
+
+      readonly id: number
+
+      readonly cause: {
+        readonly [K in keyof MethodDefinitions]: {
+          readonly _tag: K
+          readonly value: MethodDefinitions[K]["failure"]["Encoded"]
+        }
+      }[keyof MethodDefinitions]
+    }
+  }
+}
+
+export declare namespace Event {
+  export type Type<EventDefinitions extends FieldsRecord> = {
+    readonly _tag: "Event"
+
+    readonly event: FieldsRecord.TaggedMember.Type<EventDefinitions>
+  }
+
+  export type Encoded<EventDefinitions extends FieldsRecord> = {
+    readonly _tag: "Event"
+
+    readonly event: FieldsRecord.TaggedMember.Encoded<EventDefinitions>
+  }
+}
+
+export const Audition = {
+  Success: S.TaggedStruct("Audition.Success", {}),
+  Failure: S.TaggedStruct("Audition.Failure", {
+    expected: S.String,
+    actual: S.String,
+  }),
+}
+
+export const Disconnect = S.TaggedStruct("Disconnect", {})
+
+export const TransportFailure = S.TaggedStruct("TransportFailure", {
+  cause: S.Unknown,
+})
+
+export declare namespace Actor {
+  export type Type<
+    MethodDefinitions extends Record<string, MethodDefinition.Any>,
+    EventDefinitions extends FieldsRecord,
+  > =
+    | typeof Audition.Success.Type
+    | typeof Audition.Failure.Type
+    | Call.Success.Type<MethodDefinitions>
+    | Call.Failure.Type<MethodDefinitions>
+    | Event.Type<EventDefinitions>
+    | typeof Disconnect.Type
+
+  export type Encoded<
+    MethodDefinitions extends Record<string, MethodDefinition.Any>,
+    EventDefinitions extends FieldsRecord,
+  > =
+    | typeof Audition.Success.Encoded
+    | typeof Audition.Failure.Encoded
+    | Call.Success.Encoded<MethodDefinitions>
+    | Call.Failure.Encoded<MethodDefinitions>
+    | Event.Encoded<EventDefinitions>
+    | typeof Disconnect.Encoded
+}

package/Send.ts

@@ -0,0 +1,8 @@
+import { Schema as S, ParseResult, Effect } from "effect"
+
+import type { FieldsRecord } from "./_types.ts"
+
+export type Send<ActorSelf, EventDefinitions extends FieldsRecord> = <K extends keyof EventDefinitions>(
+  tag: K,
+  payload: S.Struct<EventDefinitions[K]>["Type"],
+) => Effect.Effect<void, ParseResult.ParseError, ActorSelf>

package/_constants.ts

@@ -0,0 +1 @@
+export const SecWebSocketProtocol = "Sec-WebSocket-Protocol" as const

package/_types.ts

@@ -0,0 +1,27 @@
+import { Schema as S } from "effect"
+
+export type SchemaAll = S.Schema<any, any> | S.Schema<any, never> | S.Schema<never, any> | S.Schema<never, never>
+
+export type PropertySignatureAll<Key extends PropertyKey = PropertyKey> =
+  | S.PropertySignature<S.PropertySignature.Token, any, Key, S.PropertySignature.Token, any, boolean>
+  | S.PropertySignature<S.PropertySignature.Token, never, Key, S.PropertySignature.Token, any, boolean>
+  | S.PropertySignature<S.PropertySignature.Token, any, Key, S.PropertySignature.Token, never, boolean>
+  | S.PropertySignature<S.PropertySignature.Token, never, Key, S.PropertySignature.Token, never, boolean>
+
+export type Field = SchemaAll | PropertySignatureAll
+
+export type Fields = { readonly [x: keyof any]: Field }
+
+export type FieldsRecord = Record<string, Fields>
+
+export declare namespace FieldsRecord {
+  export namespace TaggedMember {
+    export type Type<T extends FieldsRecord, K extends keyof T = keyof T> = {
+      [K_ in K]: { readonly _tag: K_ } & S.Struct<T[K_]>["Type"]
+    }[K]
+
+    export type Encoded<T extends FieldsRecord, K extends keyof T = keyof T> = {
+      [K_ in K]: { readonly _tag: K_ } & S.Struct<T[K_]>["Encoded"]
+    }[K]
+  }
+}

package/_util/Mutex.ts

@@ -0,0 +1,13 @@
+import { Context, Effect, Layer } from "effect"
+
+export class Mutex extends Context.Tag("liminal/Mutex")<
+  Mutex,
+  <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+>() {}
+
+export const layer = Effect.gen(function* () {
+  const mutex = yield* Effect.makeSemaphore(1)
+  return mutex.withPermits(1)
+}).pipe(Layer.effect(Mutex))
+
+export const task = <A, E, R>(effect: Effect.Effect<A, E, R>) => Mutex.pipe(Effect.flatMap((f) => f(effect)))

package/_util/phantom.ts

@@ -0,0 +1 @@
+export const phantom = {} as { "": never }

package/dist/Accumulator.d.ts

@@ -0,0 +1,22 @@
+import { Types, Option, Ref, PubSub, Stream, Effect, Context, Layer } from "effect";
+declare const TypeId: "~liminal/Accumulator";
+export interface Service<State> {
+    readonly ref: Ref.Ref<State>;
+    readonly pubsub: PubSub.PubSub<State>;
+}
+export interface AccumulatorLayerConfig<Item, E, R, State, E2, R2, E3, R3> {
+    readonly source: Stream.Stream<Item, E, R>;
+    readonly reduce: (item: Item) => (state: State) => Effect.Effect<State, E2, R2>;
+    readonly initial: (item: Item) => Effect.Effect<Option.Option<State>, E3, R3>;
+}
+export type Reduce<State, Item, K extends Types.Tags<Item> = Types.Tags<Item>, E = never, R = never> = (item: Types.ExtractTag<Item, K>) => (accumulator: State) => Effect.Effect<State, E, R>;
+export interface Accumulator<Self, Id extends string, State> extends Context.Tag<Self, Service<State>> {
+    new (_: never): Context.TagClassShape<Id, Service<State>>;
+    readonly [TypeId]: typeof TypeId;
+    readonly get: Effect.Effect<State, never, Self>;
+    readonly stream: Stream.Stream<State, never, Self>;
+    readonly reducer: <Item>() => <K extends Types.Tags<Item>, E, R>(_tag: K, f: Reduce<State, Item, K, E, R>) => Reduce<State, Item, K, E, R>;
+    readonly layer: <Item, E, R, E2, R2, E3, R3>(config: AccumulatorLayerConfig<Item, E, R, State, E2, R2, E3, R3>) => Layer.Layer<Self, E | E2 | E3, R | R2 | R3>;
+}
+export declare const Service: <Self, State>() => <Id extends string>(id: Id) => Accumulator<Self, Id, State>;
+export {};

package/dist/Accumulator.js

@@ -0,0 +1,33 @@
+import { Deferred, Types, Option, Ref, PubSub, Stream, Effect, Context, Layer } from "effect";
+const TypeId = "~liminal/Accumulator";
+export const Service = () => (id) => {
+    const tag = Context.Tag(id)();
+    const get = tag.pipe(Effect.map(({ ref }) => ref), Effect.flatMap(Ref.get));
+    const stream = tag.pipe(Effect.map(({ pubsub }) => Stream.fromPubSub(pubsub)), Stream.unwrap);
+    const reducer = () => (_tag, f) => f;
+    const layer = ({ source, initial, reduce, }) => Effect.gen(function* () {
+        const semaphore = yield* Effect.makeSemaphore(1);
+        const deferred = yield* Deferred.make();
+        const pubsub = yield* PubSub.unbounded({ replay: 1 });
+        yield* source.pipe(Stream.runForEach(Effect.fn(function* (item) {
+            if (!(yield* Deferred.isDone(deferred))) {
+                const match = yield* initial(item);
+                if (Option.isSome(match)) {
+                    const { value } = match;
+                    yield* Deferred.succeed(deferred, value);
+                }
+                return;
+            }
+            const current = yield* Ref.get(ref);
+            const reduced = yield* reduce(item)(current);
+            yield* Ref.set(ref, reduced);
+            yield* pubsub.publish(reduced);
+        }, semaphore.withPermits(1))), Effect.forkScoped);
+        const initial_ = yield* Deferred.await(deferred);
+        const ref = yield* Ref.make(initial_);
+        yield* pubsub.publish(initial_);
+        return { ref, pubsub };
+    }).pipe(Layer.scoped(tag));
+    return Object.assign(tag, { [TypeId]: TypeId, get, stream, reducer, layer });
+};
+//# sourceMappingURL=Accumulator.js.map

package/dist/Accumulator.js.map

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

package/dist/Actor.d.ts

@@ -0,0 +1,30 @@
+import { Context, Schema as S, Effect } from "effect";
+import type { FieldsRecord, Fields } from "./_types.ts";
+import type * as ActorClient from "./Client.ts";
+import type * as ClientHandle from "./ClientHandle.ts";
+import type { MethodDefinition } from "./Method.ts";
+import * as Method from "./Method.ts";
+import type { Send } from "./Send.ts";
+export declare const TypeId: "~liminal/Actor";
+export interface Service<ActorSelf, NameA, AttachmentFields extends Fields, EventDefinitions extends FieldsRecord> {
+    readonly name: NameA;
+    readonly currentClient: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>;
+    readonly clients: ReadonlySet<ClientHandle.ClientHandle<ActorSelf, AttachmentFields, EventDefinitions>>;
+}
+export interface ActorDefinition<NameA, AttachmentFields extends Fields, ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> {
+    readonly name: S.Schema<NameA, string>;
+    readonly attachments: AttachmentFields;
+    readonly client: ActorClient.Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;
+}
+export interface Actor<ActorSelf, ActorId extends string, NameA, AttachmentFields extends Fields, ActorClientSelf, ActorClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> extends Context.Tag<ActorSelf, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>> {
+    new (_: never): Context.TagClassShape<ActorId, Service<ActorSelf, NameA, AttachmentFields, EventDefinitions>>;
+    readonly [TypeId]: typeof TypeId;
+    readonly definition: ActorDefinition<NameA, AttachmentFields, ActorClientSelf, ActorClientId, MethodDefinitions, EventDefinitions>;
+    readonly schema: {
+        readonly attachments: S.Schema<S.Struct<AttachmentFields>["Type"], S.Struct<AttachmentFields>["Encoded"]>;
+    };
+    readonly sendAll: Send<ActorSelf, EventDefinitions>;
+    readonly evict: Effect.Effect<void, never, ActorSelf>;
+    readonly handler: <K extends keyof MethodDefinitions, R>(tag: K, f: Method.Handler<MethodDefinitions[K], R>) => Method.Handler<MethodDefinitions[K], R>;
+}
+export declare const Service: <ActorSelf>() => <ActorId extends string, NameA, AttachmentFields extends Fields, ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord>(id: ActorId, definition: ActorDefinition<NameA, AttachmentFields, ClientSelf, ClientId, MethodDefinitions, EventDefinitions>) => Actor<ActorSelf, ActorId, NameA, AttachmentFields, ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;

package/dist/Actor.js

@@ -0,0 +1,31 @@
+import { Context, Schema as S, Effect } from "effect";
+import * as Method from "./Method.js";
+export const TypeId = "~liminal/Actor";
+export const Service = () => (id, definition) => {
+    const tag = Context.Tag(id)();
+    const sendAll = Effect.fnUntraced(function* (key, payload) {
+        const { clients } = yield* tag;
+        yield* Effect.forEach(clients, (client) => client.send(key, payload), {
+            concurrency: "unbounded",
+        });
+    });
+    // TODO: more eviction
+    const evict = Effect.gen(function* () {
+        const { clients } = yield* tag;
+        for (const client of clients) {
+            yield* client.disconnect;
+        }
+    });
+    const handler = (_tag, f) => f;
+    return Object.assign(tag, {
+        [TypeId]: TypeId,
+        definition,
+        schema: {
+            attachments: S.Struct(definition.attachments),
+        },
+        sendAll,
+        evict,
+        handler,
+    });
+};
+//# sourceMappingURL=Actor.js.map

package/dist/Actor.js.map

@@ -0,0 +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,KAAK,MAAM,MAAM,aAAa,CAAA;AAGrC,MAAM,CAAC,MAAM,MAAM,GAAG,gBAAyB,CAAA;AA8D/C,MAAM,CAAC,MAAM,OAAO,GAClB,GAAc,EAAE,CAChB,CASE,EAAW,EACX,UAA+G,EACA,EAAE;IACjH,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,EAA4E,CAAA;IAEvG,MAAM,OAAO,GAAsC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,OAAO;QAC1F,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAA;QAC9B,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE;YACpE,WAAW,EAAE,WAAW;SACzB,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,sBAAsB;IACtB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAChC,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC,CAAC,GAAG,CAAA;QAC9B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAA;QAC1B,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,MAAM,OAAO,GAAG,CACd,IAAO,EACP,CAA0C,EACD,EAAE,CAAC,CAAC,CAAA;IAE/C,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;QACxB,CAAC,MAAM,CAAC,EAAE,MAAM;QAChB,UAAU;QACV,MAAM,EAAE;YACN,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAU;SACvD;QACD,OAAO;QACP,KAAK;QACL,OAAO;KACR,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/dist/Audition.d.ts

@@ -0,0 +1,18 @@
+import { Pipeable, Stream } from "effect";
+import type { FieldsRecord } from "./_types.ts";
+import type { F } from "./F.ts";
+import type * as Method from "./Method.ts";
+import * as Client from "./Client.ts";
+import { type ClientError } from "./errors.ts";
+declare const TypeId: "~liminal/Audition";
+export interface Audition<ClientSelf, MethodDefinitions extends Record<string, Method.MethodDefinition.Any>, Event> extends Pipeable.Pipeable {
+    readonly [TypeId]: typeof TypeId;
+    readonly events: Stream.Stream<Event, ClientError, ClientSelf>;
+    readonly f: F<ClientSelf, MethodDefinitions>;
+}
+export declare const empty: Audition<never, never, never>;
+export declare const add: {
+    <ClientSelf, ClientId extends string, ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, ClientEventDefinitions extends FieldsRecord>(client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>): <AuditionSelf, AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, AuditionEvent>(audition: Audition<AuditionSelf, AuditionMethodDefinitions, AuditionEvent>) => Audition<AuditionSelf | ClientSelf, Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>, AuditionEvent | FieldsRecord.TaggedMember.Type<ClientEventDefinitions>>;
+    <AuditionClientSelf, AuditionMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, AuditionEvent, ClientSelf, ClientId extends string, ClientMethodDefinitions extends Record<string, Method.MethodDefinition.Any>, ClientEventDefinitions extends FieldsRecord>(audition: Audition<AuditionClientSelf, AuditionMethodDefinitions, AuditionEvent>, client: Client.Client<ClientSelf, ClientId, ClientMethodDefinitions, ClientEventDefinitions>): Audition<AuditionClientSelf | ClientSelf, Method.MethodDefinition.Merge<AuditionMethodDefinitions, ClientMethodDefinitions>, AuditionEvent | FieldsRecord.TaggedMember.Type<ClientEventDefinitions>>;
+};
+export {};

package/dist/Audition.js

@@ -0,0 +1,27 @@
+import { Pipeable, Stream, Effect, Function, Console } from "effect";
+import * as Client from "./Client.js";
+import { AuditionError } from "./errors.js";
+const TypeId = "~liminal/Audition";
+export const empty = {
+    [TypeId]: TypeId,
+    pipe() {
+        return Pipeable.pipeArguments(this, arguments);
+    },
+    events: Stream.fail(AuditionError.make()),
+    f: () => () => AuditionError.make(),
+};
+export const add = Function.dual(2, (audition, client) => {
+    const f = (method) => (payload) => audition
+        .f(method)(payload)
+        .pipe(Effect.catchTag("AuditionError", () => client.f(method)(payload)));
+    const events = audition.events.pipe(Stream.catchTag("AuditionError", () => Effect.succeed(client.events).pipe(Effect.tap(() => Console.log(`Auditioning ${client.key}`)), Stream.unwrap)));
+    return {
+        [TypeId]: TypeId,
+        pipe() {
+            return Pipeable.pipeArguments(this, arguments);
+        },
+        events,
+        f,
+    };
+});
+//# sourceMappingURL=Audition.js.map

package/dist/Audition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Audition.js","sourceRoot":"","sources":["../Audition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAMpE,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAA;AAE7D,MAAM,MAAM,GAAG,mBAA4B,CAAA;AAW3C,MAAM,CAAC,MAAM,KAAK,GAAkC;IAClD,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,aAAa,CAAC,IAAI,EAAE,CAAC;IACzC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,aAAa,CAAC,IAAI,EAAE;CACpC,CAAA;AAED,MAAM,CAAC,MAAM,GAAG,GA+BZ,QAAQ,CAAC,IAAI,CACf,CAAC,EACD,CASE,QAA0E,EAC1E,MAA4F,EAK5F,EAAE;IACF,MAAM,CAAC,GAGH,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,CAC1B,QAAQ;SACL,CAAC,CAAC,MAAe,CAAC,CAAC,OAAO,CAAC;SAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,MAAe,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;IAErF,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,OAAO,CAAC,GAAG,CAAC,eAAe,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,EAC1D,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"}

package/dist/Client.d.ts

@@ -0,0 +1,65 @@
+import { Socket, Worker } from "@effect/platform";
+import { Context, Effect, Layer, RcRef, Scope, Stream, Schema as S } from "effect";
+import type { FieldsRecord } from "./_types.ts";
+import { type ClientError, ConnectionError } from "./errors.ts";
+import { type F } from "./F.ts";
+import type { MethodDefinition } from "./Method.ts";
+import * as Protocol from "./Protocol.ts";
+export declare const TypeId: "~liminal/Client";
+export interface ClientDefinition<MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> {
+    readonly methods: MethodDefinitions;
+    readonly events: EventDefinitions;
+}
+export interface ReplayConfig {
+    readonly mode: "startup" | "all-subscribers";
+    readonly limit?: number | undefined;
+}
+export interface TransportSession<ClientSelf, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> {
+    readonly events: Stream.Stream<FieldsRecord.TaggedMember.Type<EventDefinitions>, ClientError>;
+    readonly f: F<ClientSelf, MethodDefinitions>;
+    readonly endEvents: Effect.Effect<void>;
+}
+export type Service<ClientSelf, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> = RcRef.RcRef<TransportSession<ClientSelf, MethodDefinitions, EventDefinitions>, ClientError>;
+export interface Spec<MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> {
+    Call: {
+        Payload: Protocol.Call.Payload.Type<MethodDefinitions>;
+        Success: Protocol.Call.Success.Type<MethodDefinitions>;
+        Failure: Protocol.Call.Failure.Type<MethodDefinitions>;
+    };
+    Event: FieldsRecord.TaggedMember.Type<EventDefinitions>;
+    Actor: Protocol.Actor.Type<MethodDefinitions, EventDefinitions>;
+}
+export interface ClientSchema<MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> {
+    readonly call: {
+        readonly payload: S.Schema<Protocol.Call.Payload.Type<MethodDefinitions>, Protocol.Call.Payload.Encoded<MethodDefinitions>>;
+        readonly success: S.Schema<Protocol.Call.Success.Type<MethodDefinitions>, Protocol.Call.Success.Encoded<MethodDefinitions>>;
+        readonly failure: S.Schema<Protocol.Call.Failure.Type<MethodDefinitions>, Protocol.Call.Failure.Encoded<MethodDefinitions>>;
+    };
+    readonly event: S.Schema<Protocol.Event.Type<EventDefinitions>, Protocol.Event.Encoded<EventDefinitions>>;
+    readonly actor: S.Schema<Protocol.Actor.Type<MethodDefinitions, EventDefinitions>, Protocol.Actor.Encoded<MethodDefinitions, EventDefinitions>>;
+}
+export interface Client<ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> extends Context.Tag<ClientSelf, Service<ClientSelf, MethodDefinitions, EventDefinitions>> {
+    new (_: never): Context.TagClassShape<ClientId, Service<ClientSelf, MethodDefinitions, EventDefinitions>>;
+    readonly [TypeId]: typeof TypeId;
+    readonly definition: ClientDefinition<MethodDefinitions, EventDefinitions>;
+    readonly schema: ClientSchema<MethodDefinitions, EventDefinitions>;
+    readonly events: Stream.Stream<FieldsRecord.TaggedMember.Type<EventDefinitions>, ClientError, ClientSelf>;
+    readonly endEvents: Effect.Effect<void, never, ClientSelf>;
+    readonly f: F<ClientSelf, MethodDefinitions>;
+    readonly invalidate: Effect.Effect<void, never, ClientSelf>;
+}
+export declare const Service: <ClientSelf>() => <ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord>(id: ClientId, definition: ClientDefinition<MethodDefinitions, EventDefinitions>) => Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;
+export interface Transport<MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord> {
+    readonly listen: (publish: (message: Protocol.Actor.Type<MethodDefinitions, EventDefinitions> | typeof Protocol.TransportFailure.Type) => Effect.Effect<void, never>) => Effect.Effect<void, never, Scope.Scope>;
+    readonly send: (v: Protocol.Call.Payload.Type<MethodDefinitions>) => Effect.Effect<void, ConnectionError, never>;
+}
+export declare const layerSocket: <ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord>({ client, url, protocols, replay, }: {
+    readonly client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;
+    readonly url?: string | undefined;
+    readonly protocols?: string | Array<string> | undefined;
+    readonly replay?: ReplayConfig | undefined;
+}) => Layer.Layer<ClientSelf, never, Socket.WebSocketConstructor>;
+export declare const layerWorker: <ClientSelf, ClientId extends string, MethodDefinitions extends Record<string, MethodDefinition.Any>, EventDefinitions extends FieldsRecord>({ client, replay, }: {
+    readonly client: Client<ClientSelf, ClientId, MethodDefinitions, EventDefinitions>;
+    readonly replay?: ReplayConfig | undefined;
+}) => Layer.Layer<ClientSelf, never, Worker.PlatformWorker | Worker.Spawner>;