liminal 0.17.13 → 0.17.15

package/workerd/WorkerdActorRuntime.ts

@@ -0,0 +1,422 @@
+import { DurableObject } from "cloudflare:workers"
+import {
+  Layer,
+  Effect,
+  Scope,
+  Schema as S,
+  Context,
+  ManagedRuntime,
+  ConfigProvider,
+  Duration,
+  flow,
+  Option,
+  Tracer,
+  pipe,
+  Exit,
+} from "effect"
+import { DoState } from "effect-workerd"
+import { Clock } from "effect-workerd/platform"
+import { SecWebSocketProtocol } from "effect-workerd/socket_util"
+import { Headers, FetchHttpClient, HttpClient, HttpTraceContext } from "effect/unstable/http"
+import { boundLayer } from "liminal-util/boundLayer"
+import { logCause } from "liminal-util/logCause"
+import * as Spanner from "liminal-util/Spanner"
+
+import { type TopFromString, encodeJsonString, decodeJsonString } from "../_util/schema.ts"
+import type { ActorTransport } from "../ActorTransport.ts"
+import * as ClientDirectory from "../ClientDirectory.ts"
+import type { ClientHandle } from "../ClientHandle.ts"
+import type { Handlers, Methods } from "../Method.ts"
+import type { ProtocolDefinition } from "../Protocol.ts"
+import * as Tracing from "../Tracing.ts"
+import { sessionAttributes, SessionId, sessionLink } from "../Tracing.ts"
+import type { ActorNamespace } from "./WorkerdActorNamespace.ts"
+
+const span = Spanner.make(import.meta.url)
+
+export interface ActorRuntimeDefinition<
+  NamespaceSelf,
+  NamespaceId extends string,
+  Internal extends Methods,
+  ActorSelf,
+  ActorId extends string,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  ClientSelf,
+  ClientId extends string,
+  D extends ProtocolDefinition,
+  PreludeROut,
+  PreludeE,
+  RunROut,
+  RunE,
+> {
+  readonly ""?: this["namespace"]["definition"]["actor"]["definition"]["client"]["protocol"]
+
+  readonly namespace: ActorNamespace<
+    NamespaceSelf,
+    NamespaceId,
+    Internal,
+    ActorSelf,
+    ActorId,
+    Name,
+    AttachmentFields,
+    ClientSelf,
+    ClientId,
+    D
+  >
+
+  readonly prelude: Layer.Layer<
+    | PreludeROut
+    | NonNullable<this[""]>["F"]["Payload"]["DecodingServices"]
+    | NonNullable<this[""]>["F"]["Success"]["EncodingServices"]
+    | NonNullable<this[""]>["F"]["Failure"]["EncodingServices"]
+    | NonNullable<this[""]>["Event"]["EncodingServices"]
+    | S.Struct<AttachmentFields>["DecodingServices"]
+    | S.Struct<AttachmentFields>["EncodingServices"]
+    | Name["EncodingServices"]
+    | Name["DecodingServices"],
+    PreludeE,
+    HttpClient.HttpClient
+  >
+
+  readonly layer: Layer.Layer<RunROut, RunE, ActorSelf | HttpClient.HttpClient | PreludeROut>
+
+  readonly external: Handlers<D["external"], ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope>
+
+  readonly internal: Handlers<Internal, ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope>
+
+  readonly hydrate: Effect.Effect<
+    S.Struct<D["state"]>["Type"],
+    never,
+    ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope
+  >
+
+  readonly onDisconnect: Effect.Effect<
+    void,
+    never,
+    ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope
+  >
+
+  readonly hibernation?: Duration.Input | undefined
+}
+
+export const make = <
+  NamespaceSelf,
+  NamespaceId extends string,
+  Internal extends Methods,
+  ActorSelf,
+  ActorId extends string,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+  ClientSelf,
+  ClientId extends string,
+  D extends ProtocolDefinition,
+  PreludeROut,
+  PreludeE,
+  RunROut,
+  RunE,
+>(
+  definition: ActorRuntimeDefinition<
+    NamespaceSelf,
+    NamespaceId,
+    Internal,
+    ActorSelf,
+    ActorId,
+    Name,
+    AttachmentFields,
+    ClientSelf,
+    ClientId,
+    D,
+    PreludeROut,
+    PreludeE,
+    RunROut,
+    RunE
+  >,
+): new (state: DurableObjectState<{}>, env: Cloudflare.Env) => DurableObject => {
+  const {
+    hibernation,
+    prelude,
+    external,
+    layer,
+    hydrate,
+    onDisconnect,
+    internal,
+    namespace: {
+      definition: { actor },
+    },
+  } = definition
+  const {
+    definition: {
+      name: Name,
+      client: { protocol: P },
+      attachments: AttachmentFields,
+    },
+  } = actor
+
+  const Attachments = S.Struct(AttachmentFields)
+  const SocketAttachment = S.Struct({
+    attachments: S.toCodecJson(Attachments),
+    session: Tracing.Session,
+  })
+  const encodeSocketAttachment = S.encodeEffect(SocketAttachment)
+  const decodeSocketAttachment = S.decodeUnknownEffect(SocketAttachment)
+  const decodeAttachmentsString = decodeJsonString(Attachments)
+  const encodeAuditionSuccess = encodeJsonString(P.Audition.Success)
+  const decodeClient = decodeJsonString(P.Client)
+  const encodeFSuccess = encodeJsonString(P.F.Success)
+  const encodeFFailure = encodeJsonString(P.F.Failure)
+  const encodeEvent = encodeJsonString(P.Event)
+
+  const transport: ActorTransport<
+    WebSocket,
+    {
+      readonly socket: WebSocket
+      readonly session: typeof Tracing.Session.Type
+    },
+    AttachmentFields,
+    D
+  > = {
+    key: ({ socket }) => socket,
+    send: ({ socket, session }, event) => {
+      const { _tag } = event.event as never
+      return Effect.gen(function* () {
+        const trace = yield* Tracing.currentTrace
+        const encoded = yield* encodeEvent({
+          ...event,
+          ...(trace && { trace }),
+        })
+        // @effect-diagnostics-next-line tryCatchInEffectGen:off
+        try {
+          socket.send(encoded)
+          // oxlint-disable-next-line no-unused-vars
+        } catch (_e) {}
+      }).pipe(
+        span("send", {
+          attributes: { _tag, ...sessionAttributes(session) },
+          kind: "producer",
+          links: [sessionLink(session)],
+        }),
+      )
+    },
+    close: ({ socket }) => Effect.sync(() => socket.close(1000)),
+    snapshot: ({ socket, session }, attachments) =>
+      encodeSocketAttachment({ attachments, session }).pipe(
+        Effect.andThen((v) => Effect.sync(() => socket.serializeAttachment(v))),
+      ),
+  }
+
+  class NameDecoded extends Context.Service<NameDecoded, Name["Type"]>()("liminal/WorkerdActorNamespace/NameDecoded") {}
+
+  return class extends DurableObject {
+    readonly run
+    readonly directory = ClientDirectory.make(actor, { transport })
+    readonly provideActor = (currentClient: ClientHandle<ActorSelf, AttachmentFields, D>) =>
+      flow(
+        Effect.provide(
+          Layer.provideMerge(
+            layer,
+            Effect.gen({ self: this }, function* () {
+              const name = yield* NameDecoded
+              return Layer.succeed(actor, {
+                name,
+                clients: this.directory.handles,
+                currentClient,
+              })
+            }).pipe(Layer.unwrap),
+          ),
+        ),
+        Effect.scoped,
+      )
+    constructor(state: DurableObjectState<{}>, env: Cloudflare.Env) {
+      super(state, env)
+      if (hibernation) {
+        Option.andThen(
+          Duration.fromInput(hibernation),
+          flow(Duration.toMillis, (timeout) => state.setHibernatableWebSocketEventTimeout(timeout)),
+        )
+      }
+
+      const Live = Layer.mergeAll(
+        FetchHttpClient.layer,
+        Layer.succeed(DoState.DoState, state),
+        Layer.effect(NameDecoded, S.decodeUnknownEffect(Name)(state.id.name)),
+      ).pipe(
+        Layer.provideMerge(
+          prelude.pipe(
+            Layer.provideMerge(
+              Layer.mergeAll(FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromUnknown(env))),
+            ),
+          ),
+        ),
+        Layer.provideMerge(Clock.layer),
+      )
+
+      const HydrateClientsLive = Effect.gen({ self: this }, function* () {
+        for (const socket of state.getWebSockets()) {
+          const { attachments, session } = yield* decodeSocketAttachment(socket.deserializeAttachment())
+          yield* this.directory
+            .register({ socket, session }, attachments)
+            .pipe(Effect.linkSpans(Tracer.externalSpan(session.trace), sessionLink(session).attributes))
+        }
+      }).pipe(span("hydrate"), Layer.effectDiscard)
+
+      const runtime = ManagedRuntime.make(HydrateClientsLive.pipe(Layer.provideMerge(Live), boundLayer("actor")))
+
+      this.run = flow(Effect.tapCause(logCause), runtime.runPromise)
+    }
+
+    override fetch(request: Request): Promise<Response> {
+      return Effect.gen({ self: this }, function* () {
+        const url = new URL(request.url)
+        const attachments = yield* decodeAttachmentsString(url.searchParams.get("__liminal_attachments"))
+        const { 0: webSocket, 1: server } = new WebSocketPair()
+        const state = yield* DoState.DoState
+        const session = {
+          id: SessionId.make(crypto.randomUUID()),
+          trace: yield* Effect.currentSpan.pipe(Effect.map(Tracing.toTraceEnvelope)),
+        }
+        const currentClient = yield* this.directory.register({ socket: server, session }, attachments)
+        state.acceptWebSocket(server)
+        const initial = yield* hydrate.pipe(
+          this.provideActor(currentClient),
+          span("hydrate", {
+            attributes: sessionAttributes(session),
+            links: [sessionLink(session)],
+          }),
+        )
+        server.send(yield* encodeAuditionSuccess({ _tag: "Audition.Success", initial }))
+        return new Response(null, {
+          status: 101,
+          webSocket,
+          headers: { [SecWebSocketProtocol]: "liminal" },
+        })
+      }).pipe(
+        span("fetch", {
+          kind: "server",
+          parent: pipe(request.headers, Headers.fromInput, HttpTraceContext.fromHeaders, Option.getOrUndefined),
+        }),
+        this.run,
+      )
+    }
+
+    override webSocketMessage(socket: WebSocket, raw: string | ArrayBuffer) {
+      Effect.gen({ self: this }, function* () {
+        const { client, handle: currentClient } = yield* this.directory.entry(socket)
+        const { session } = client
+        yield* Effect.annotateCurrentSpan(sessionAttributes(session))
+        const message = yield* decodeClient(raw instanceof ArrayBuffer ? new TextDecoder().decode(raw) : raw)
+        if (message._tag === "Audition.Payload") {
+          return yield* Effect.die(undefined)
+        }
+        if (message._tag === "Disconnect") {
+          yield* currentClient.disconnect
+          return yield* onDisconnect.pipe(
+            this.provideActor(currentClient),
+            span("disconnect", {
+              attributes: sessionAttributes(session),
+              links: [sessionLink(session)],
+            }),
+          )
+        }
+        const { id, payload } = message
+        const { _tag, value } = payload as never
+        const parent = message.trace ? Tracer.externalSpan(message.trace) : undefined
+        const transportSpan = yield* Tracing.parent
+        const links = [
+          sessionLink(session),
+          ...(parent && transportSpan
+            ? [
+                {
+                  span: transportSpan,
+                  attributes: {
+                    "liminal.link": "transport",
+                    "liminal.transport": "websocket",
+                  },
+                },
+              ]
+            : []),
+        ]
+        yield* external[_tag]!(value).pipe(
+          Effect.matchEffect({
+            onSuccess: (value) =>
+              encodeFSuccess({
+                _tag: "F.Success",
+                id,
+                success: { _tag, value } as never,
+              }),
+            onFailure: (value) =>
+              encodeFFailure({
+                _tag: "F.Failure",
+                id,
+                failure: { _tag, value } as never,
+              }),
+          }),
+          Effect.andThen((v) =>
+            Effect.try({
+              try: () => socket.send(v),
+              catch: () => {},
+            }),
+          ),
+          this.provideActor(currentClient),
+          span("handler", {
+            attributes: { _tag, ...sessionAttributes(session) },
+            kind: "server",
+            parent,
+            links,
+          }),
+        )
+      }).pipe(span("socket-message"), this.run)
+    }
+
+    override webSocketClose(socket: WebSocket, _code: number, _reason: string, _wasClean: boolean) {
+      Effect.gen({ self: this }, function* () {
+        const entry = yield* this.directory
+          .entry(socket)
+          .pipe(Effect.catchTag("NoSuchElementError", () => Effect.undefined))
+        if (!entry) {
+          return
+        }
+        const {
+          client: { session },
+          handle: currentClient,
+        } = entry
+        yield* Effect.annotateCurrentSpan(sessionAttributes(session))
+        yield* this.directory.unregister(socket)
+        yield* onDisconnect.pipe(
+          this.provideActor(currentClient),
+          span("disconnect", {
+            attributes: sessionAttributes(session),
+            links: [sessionLink(session)],
+          }),
+        )
+      }).pipe(span("socket-close"), this.run)
+    }
+
+    override webSocketError(socket: WebSocket, cause: unknown) {
+      Effect.gen({ self: this }, function* () {
+        const {
+          client: { session },
+          handle: currentClient,
+        } = yield* this.directory.entry(socket)
+        yield* Effect.annotateCurrentSpan(sessionAttributes(session))
+        yield* this.directory.unregister(socket)
+        yield* onDisconnect.pipe(
+          this.provideActor(currentClient),
+          span("disconnect", {
+            attributes: sessionAttributes(session),
+            links: [sessionLink(session)],
+          }),
+        )
+        yield* Effect.annotateLogs(Effect.logDebug("SocketErrored"), { cause })
+      }).pipe(span("socket-error"), this.run)
+    }
+
+    async rpc<K extends keyof Internal>(
+      method: K,
+      payload: Internal[K]["payload"]["Type"],
+    ): Promise<Exit.Exit<Internal[K]["success"]["Type"], Internal[K]["failure"]["Type"]>> {
+      const handler = internal[method]
+      return await handler(payload).pipe(this.provideActor(null!), span("fn-internal"), Effect.exit, this.run)
+    }
+  }
+}

package/workerd/index.ts

@@ -1 +1,3 @@
 export * as WorkerdActorNamespace from "./WorkerdActorNamespace.ts"
+export * as WorkerdActorRuntime from "./WorkerdActorRuntime.ts"
+export * from "./ActorHandle.ts"

package/Accumulator.ts

@@ -1,103 +0,0 @@
-import { Deferred, Types, Option, Ref, PubSub, Stream, Effect, Context, Layer, Semaphore } from "effect"
-
-import { diagnostic } from "./_diagnostic.ts"
-
-const { debug } = diagnostic("Accumulator")
-
-const TypeId = "~liminal/Accumulator" as const
-
-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.Service<Self, Service<State>> {
-  new (_: never): Context.ServiceClass.Shape<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 const Service =
-  <Self, State>() =>
-  <Id extends string>(id: Id): Accumulator<Self, Id, State> => {
-    const tag = Context.Service<Self, Service<State>>()(id)
-
-    const get = tag.asEffect().pipe(
-      Effect.map(({ ref }) => ref),
-      Effect.flatMap(Ref.get),
-    )
-
-    const stream = tag.asEffect().pipe(
-      Effect.map(({ pubsub }) => Stream.fromPubSub(pubsub)),
-      Stream.unwrap,
-    )
-
-    const reducer =
-      <Item>() =>
-      <K extends Types.Tags<Item>, E, R>(_tag: K, f: Reduce<State, Item, K, E, R>): Reduce<State, Item, K, E, R> =>
-        f
-
-    const layer = <Item, E, R, E2, R2, E3, R3>({
-      source,
-      initial,
-      reduce,
-    }: AccumulatorLayerConfig<Item, E, R, State, E2, R2, E3, R3>): Layer.Layer<Self, E | E2 | E3, R | R2 | R3> =>
-      Effect.gen(function* () {
-        const semaphore = yield* Semaphore.make(1)
-        const deferred = yield* Deferred.make<State>()
-        const pubsub = yield* PubSub.unbounded<State>({ 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)
-                  yield* debug("InitializedState", { state: value })
-                }
-                return
-              }
-              const current = yield* Ref.get(ref)
-              const reduced = yield* reduce(item)(current)
-              yield* Ref.set(ref, reduced)
-              yield* PubSub.publish(pubsub, reduced)
-              yield* debug("ReducedState", { item, previous: current, current: reduced })
-            }, semaphore.withPermits(1)),
-          ),
-          Effect.forkScoped,
-        )
-        const initial_ = yield* Deferred.await(deferred)
-        const ref = yield* Ref.make(initial_)
-        yield* PubSub.publish(pubsub, initial_)
-        return { ref, pubsub }
-      }).pipe(Layer.effect(tag))
-
-    return Object.assign(tag, { [TypeId]: TypeId, get, stream, reducer, layer })
-  }

package/F.ts

@@ -1,10 +0,0 @@
-import { Effect } from "effect"
-
-import type { FError } from "./errors.ts"
-import type { ProtocolDefinition } from "./Protocol.ts"
-
-export type F<Self, D extends ProtocolDefinition> = <Method extends keyof D["methods"]>(
-  method: Method,
-) => (
-  payload: D["methods"][Method]["payload"]["Type"],
-) => Effect.Effect<D["methods"][Method]["success"]["Type"], FError<D>, Self>

package/_diagnostic.ts

@@ -1,3 +0,0 @@
-import { factory } from "liminal-util/Diagnostic"
-
-export const diagnostic = factory("liminal")

package/_util/Mutex.ts

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

package/dist/Accumulator.d.ts

@@ -1,22 +0,0 @@
-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.Service<Self, Service<State>> {
-    new (_: never): Context.ServiceClass.Shape<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

@@ -1,37 +0,0 @@
-import { Deferred, Types, Option, Ref, PubSub, Stream, Effect, Context, Layer, Semaphore } from "effect";
-import { diagnostic } from "./_diagnostic.js";
-const { debug } = diagnostic("Accumulator");
-const TypeId = "~liminal/Accumulator";
-export const Service = () => (id) => {
-    const tag = Context.Service()(id);
-    const get = tag.asEffect().pipe(Effect.map(({ ref }) => ref), Effect.flatMap(Ref.get));
-    const stream = tag.asEffect().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* Semaphore.make(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);
-                    yield* debug("InitializedState", { state: value });
-                }
-                return;
-            }
-            const current = yield* Ref.get(ref);
-            const reduced = yield* reduce(item)(current);
-            yield* Ref.set(ref, reduced);
-            yield* PubSub.publish(pubsub, reduced);
-            yield* debug("ReducedState", { item, previous: current, current: reduced });
-        }, semaphore.withPermits(1))), Effect.forkScoped);
-        const initial_ = yield* Deferred.await(deferred);
-        const ref = yield* Ref.make(initial_);
-        yield* PubSub.publish(pubsub, initial_);
-        return { ref, pubsub };
-    }).pipe(Layer.effect(tag));
-    return Object.assign(tag, { [TypeId]: TypeId, get, stream, reducer, layer });
-};
-//# sourceMappingURL=Accumulator.js.map

package/dist/Accumulator.js.map

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

package/dist/F.d.ts

@@ -1,4 +0,0 @@
-import { Effect } from "effect";
-import type { FError } from "./errors.ts";
-import type { ProtocolDefinition } from "./Protocol.ts";
-export type F<Self, D extends ProtocolDefinition> = <Method extends keyof D["methods"]>(method: Method) => (payload: D["methods"][Method]["payload"]["Type"]) => Effect.Effect<D["methods"][Method]["success"]["Type"], FError<D>, Self>;

package/dist/F.js

@@ -1,2 +0,0 @@
-import { Effect } from "effect";
-//# sourceMappingURL=F.js.map

package/dist/F.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"F.js","sourceRoot":"","sources":["../F.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA"}

package/dist/_diagnostic.d.ts

@@ -1,4 +0,0 @@
-export declare const diagnostic: (module: string) => {
-    debug: (event: string, annotations?: Record<string, unknown>) => import("effect/Effect").Effect<void, never, never>;
-    span: (operation: string, options?: import("effect/Tracer").SpanOptions | undefined) => <A, E, R>(effect: import("effect/Effect").Effect<A, E, R>) => import("effect/Effect").Effect<A, E, Exclude<R, import("effect/Tracer").ParentSpan>>;
-};

package/dist/_diagnostic.js

@@ -1,3 +0,0 @@
-import { factory } from "liminal-util/Diagnostic";
-export const diagnostic = factory("liminal");
-//# sourceMappingURL=_diagnostic.js.map

package/dist/_diagnostic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_diagnostic.js","sourceRoot":"","sources":["../_diagnostic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAEjD,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAAA"}

package/dist/_util/Mutex.d.ts

@@ -1,7 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-declare const Mutex_base: Context.ServiceClass<Mutex, "liminal/Mutex", <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>>;
-export declare class Mutex extends Mutex_base {
-}
-export declare const layer: Layer.Layer<Mutex, never, never>;
-export declare const task: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Mutex>;
-export {};

package/dist/_util/Mutex.js

@@ -1,9 +0,0 @@
-import { Context, Effect, Layer, Semaphore } from "effect";
-export class Mutex extends Context.Service()("liminal/Mutex") {
-}
-export const layer = Effect.gen(function* () {
-    const mutex = yield* Semaphore.make(1);
-    return mutex.withPermits(1);
-}).pipe(Layer.effect(Mutex));
-export const task = (effect) => Mutex.asEffect().pipe(Effect.flatMap((f) => f(effect)));
-//# sourceMappingURL=Mutex.js.map