dfx 0.51.0 → 0.51.2

package/src/DiscordGateway/DiscordWS.ts

@@ -1,11 +1,10 @@
-import {
-  LiveWS,
-  Reconnect,
-  WS,
-  WebSocketCloseError,
-  WebSocketError,
-} from "dfx/DiscordGateway/WS"
+import { LiveWS, Reconnect, WS } from "dfx/DiscordGateway/WS"
 import WebSocket from "isomorphic-ws"
+import * as Discord from "dfx/types"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import { Tag } from "@effect/data/Context"
+import * as Ref from "@effect/io/Ref"
 
 export type Message = Discord.GatewayPayload | Reconnect
 
@@ -13,8 +12,8 @@ export interface OpenOpts {
   url?: string
   version?: number
   encoding?: DiscordWSCodec
-  outbound: Effect<never, never, Message>
-  onConnecting?: Effect<never, never, void>
+  outbound: Effect.Effect<never, never, Message>
+  onConnecting?: Effect.Effect<never, never, void>
 }
 
 export interface DiscordWSCodec {
@@ -29,9 +28,9 @@ export const LiveJsonDiscordWSCodec = Layer.succeed(DiscordWSCodec, {
   decode: p => JSON.parse(p.toString("utf8")),
 })
 
-const make = Do($ => {
-  const ws = $(WS.accessWith(identity))
-  const encoding = $(DiscordWSCodec.accessWith(identity))
+const make = Effect.gen(function* (_) {
+  const ws = yield* _(WS)
+  const encoding = yield* _(DiscordWSCodec)
 
   const connect = ({
     url = "wss://gateway.discord.gg/",
@@ -39,22 +38,23 @@ const make = Do($ => {
     outbound,
     onConnecting,
   }: OpenOpts) =>
-    Do($ => {
-      const urlRef = $(
+    Effect.gen(function* (_) {
+      const urlRef = yield* _(
         Ref.make(`${url}?v=${version}&encoding=${encoding.type}`),
       )
       const setUrl = (url: string) =>
-        urlRef.set(`${url}?v=${version}&encoding=${encoding.type}`)
-      const takeOutbound = outbound.map(a =>
-        a === Reconnect ? a : encoding.encode(a),
+        Ref.set(urlRef, `${url}?v=${version}&encoding=${encoding.type}`)
+      const takeOutbound = Effect.map(outbound, msg =>
+        msg === Reconnect ? msg : encoding.encode(msg),
       )
-      const socket = $(ws.connect(urlRef, takeOutbound, onConnecting))
-      const take = socket.take.map(encoding.decode)
+      const socket = yield* _(ws.connect(urlRef, takeOutbound, onConnecting))
+      const take = Effect.map(socket.take, encoding.decode)
 
-      const run = socket.run.retryWhile(
-        _ =>
-          (_._tag === "WebSocketCloseError" && _.code < 2000) ||
-          (_._tag === "WebSocketError" && _.reason === "open-timeout"),
+      const run = Effect.retryWhile(
+        socket.run,
+        e =>
+          (e._tag === "WebSocketCloseError" && e.code < 2000) ||
+          (e._tag === "WebSocketError" && e.reason === "open-timeout"),
       )
 
       return {
@@ -67,6 +67,9 @@ const make = Do($ => {
   return { connect } as const
 })
 
-export interface DiscordWS extends Effect.Success<typeof make> {}
+export interface DiscordWS extends Effect.Effect.Success<typeof make> {}
 export const DiscordWS = Tag<DiscordWS>()
-export const LiveDiscordWS = LiveWS >> Layer.effect(DiscordWS, make)
+export const LiveDiscordWS = Layer.provide(
+  LiveWS,
+  Layer.effect(DiscordWS, make),
+)

package/src/DiscordGateway/Shard/heartbeats.ts

@@ -1,44 +1,64 @@
 import { millis } from "@effect/data/Duration"
-import * as SendEvents from "./sendEvents.js"
-import * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
-import { Reconnect } from "../WS.js"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Queue from "@effect/io/Queue"
+import * as Ref from "@effect/io/Ref"
+import * as Schedule from "@effect/io/Schedule"
+import type * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
+import * as SendEvents from "dfx/DiscordGateway/Shard/sendEvents"
+import { Reconnect } from "dfx/DiscordGateway/WS"
+import type * as Discord from "dfx/types"
+import * as EffectU from "dfx/utils/Effect"
 
-const payload = (ref: Ref<boolean>, seqRef: Ref<Maybe<number>>) =>
-  seqRef.get
-    .map(a => SendEvents.heartbeat(a.getOrNull))
-    .tap(() => ref.set(false))
+const payload = (
+  ref: Ref.Ref<boolean>,
+  seqRef: Ref.Ref<Option.Option<number>>,
+) =>
+  Ref.get(seqRef).pipe(
+    Effect.map(o => SendEvents.heartbeat(Option.getOrNull(o))),
+    Effect.tap(() => Ref.set(ref, false)),
+  )
 
-const payloadOrReconnect = (ref: Ref<boolean>, seqRef: Ref<Maybe<number>>) =>
-  ref.get.flatMap(
-    (acked): Effect<never, never, DiscordWS.Message> =>
+const payloadOrReconnect = (
+  ref: Ref.Ref<boolean>,
+  seqRef: Ref.Ref<Option.Option<number>>,
+) =>
+  Effect.flatMap(
+    Ref.get(ref),
+    (acked): Effect.Effect<never, never, DiscordWS.Message> =>
       acked ? payload(ref, seqRef) : Effect.succeed(Reconnect),
   )
 
 export const send = (
-  hellos: Dequeue<Discord.GatewayPayload>,
-  acks: Dequeue<Discord.GatewayPayload>,
-  seqRef: Ref<Maybe<number>>,
-  send: (p: DiscordWS.Message) => Effect<never, never, boolean>,
+  hellos: Queue.Dequeue<Discord.GatewayPayload>,
+  acks: Queue.Dequeue<Discord.GatewayPayload>,
+  seqRef: Ref.Ref<Option.Option<number>>,
+  send: (p: DiscordWS.Message) => Effect.Effect<never, never, boolean>,
 ) =>
-  Do($ => {
-    const ackedRef = $(Ref.make(true))
+  Effect.gen(function* (_) {
+    const ackedRef = yield* _(Ref.make(true))
 
-    const heartbeats = hellos
-      .take()
-      .tap(() => ackedRef.set(true))
-      .foreverSwitch(p =>
-        payloadOrReconnect(ackedRef, seqRef)
-          .tap(send)
-          .schedule(
+    const heartbeats = EffectU.foreverSwitch(
+      Queue.take(hellos).pipe(Effect.tap(() => Ref.set(ackedRef, true))),
+      p =>
+        payloadOrReconnect(ackedRef, seqRef).pipe(
+          Effect.tap(send),
+          Effect.schedule(
             Schedule.duration(
               millis(p.d!.heartbeat_interval * Math.random()),
-            ).andThen(Schedule.fixed(millis(p.d!.heartbeat_interval))),
+            ).pipe(
+              Schedule.andThen(Schedule.fixed(millis(p.d!.heartbeat_interval))),
+            ),
           ),
-      )
+        ),
+    )
 
-    const run = acks.take().tap(() => ackedRef.set(true)).forever
+    const run = Queue.take(acks).pipe(
+      Effect.tap(() => Ref.set(ackedRef, true)),
+      Effect.forever,
+    )
 
-    return $(
+    return yield* _(
       Effect.all(run, heartbeats, {
         concurrency: "unbounded",
         discard: true,

package/src/DiscordGateway/Shard/identify.ts

@@ -1,20 +1,23 @@
-import * as SendEvents from "./sendEvents.js"
-import * as OS from "os"
 import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Ref from "@effect/io/Ref"
+import * as SendEvents from "dfx/DiscordGateway/Shard/sendEvents"
+import type * as Discord from "dfx/types"
+import * as OS from "os"
 
 export interface Options {
-  token: string
-  intents: number
-  shard: [number, number]
-  presence?: Discord.UpdatePresence
+  readonly token: string
+  readonly intents: number
+  readonly shard: [number, number]
+  readonly presence?: Discord.UpdatePresence
 }
 
 export interface Requirements {
-  latestReady: Ref<Maybe<Discord.ReadyEvent>>
-  latestSequence: Ref<Maybe<number>>
+  readonly latestReady: Ref.Ref<Option.Option<Discord.ReadyEvent>>
+  readonly latestSequence: Ref.Ref<Option.Option<number>>
 }
 
-const identify = ({ token, intents, shard, presence }: Options) =>
+const identify = ({ intents, presence, shard, token }: Options) =>
   SendEvents.identify({
     token,
     intents,
@@ -36,19 +39,20 @@ const resume = (token: string, ready: Discord.ReadyEvent, seq: number) =>
 
 export const identifyOrResume = (
   opts: Options,
-  ready: Ref<Maybe<Discord.ReadyEvent>>,
-  seq: Ref<Maybe<number>>,
-) =>
-  Do($ => {
-    const readyEvent = $(ready.get)
-    const seqNumber = $(seq.get)
-
-    return Option.all({
-      readyEvent,
-      seqNumber,
-    }).match({
-      onNone: () => identify(opts),
-      onSome: ({ readyEvent, seqNumber }) =>
-        resume(opts.token, readyEvent, seqNumber),
-    })
-  })
+  ready: Ref.Ref<Option.Option<Discord.ReadyEvent>>,
+  seq: Ref.Ref<Option.Option<number>>,
+): Effect.Effect<
+  never,
+  never,
+  | Discord.GatewayPayload<Discord.Identify>
+  | Discord.GatewayPayload<Discord.Resume>
+> =>
+  Effect.map(
+    Effect.all(Ref.get(ready), Ref.get(seq)),
+    ([readyEvent, seqNumber]) =>
+      Option.match(Option.all({ readyEvent, seqNumber }), {
+        onNone: () => identify(opts),
+        onSome: ({ readyEvent, seqNumber }) =>
+          resume(opts.token, readyEvent, seqNumber),
+      }),
+  )

package/src/DiscordGateway/Shard/invalidSession.ts

@@ -1,10 +1,12 @@
-import { Message } from "../DiscordWS.js"
-import { Reconnect } from "../WS.js"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Ref from "@effect/io/Ref"
+import { Message } from "dfx/DiscordGateway/DiscordWS"
+import { Reconnect } from "dfx/DiscordGateway/WS"
+import * as Discord from "dfx/types"
 
 export const fromPayload = (
   p: Discord.GatewayPayload,
-  latestReady: Ref<Maybe<Discord.ReadyEvent>>,
-) =>
-  (p.d ? Effect.unit : latestReady.set(Maybe.none())).map(
-    (): Message => Reconnect,
-  )
+  latestReady: Ref.Ref<Option.Option<Discord.ReadyEvent>>,
+): Effect.Effect<never, never, Message> =>
+  Effect.as(p.d ? Effect.unit : Ref.set(latestReady, Option.none()), Reconnect)

package/src/DiscordGateway/Shard/sendEvents.ts

@@ -1,4 +1,4 @@
-import { Discord } from "dfx/_common"
+import * as Discord from "dfx/types"
 
 export const heartbeat = (
   d: Discord.Heartbeat,

package/src/DiscordGateway/Shard/utils.ts

@@ -1,17 +1,41 @@
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Ref from "@effect/io/Ref"
+import * as Discord from "dfx/types"
+import * as Stream from "@effect/stream/Stream"
+
 export const opCode =
-  <R, E>(source: Stream<R, E, Discord.GatewayPayload>) =>
-  <T = any>(code: Discord.GatewayOpcode) =>
-    source.filter((p): p is Discord.GatewayPayload<T> => p.op === code)
+  <R, E>(source: Stream.Stream<R, E, Discord.GatewayPayload>) =>
+  <T = any>(
+    code: Discord.GatewayOpcode,
+  ): Stream.Stream<R, E, Discord.GatewayPayload<T>> =>
+    source.pipe(
+      Stream.filter((p): p is Discord.GatewayPayload<T> => p.op === code),
+    )
 
 const maybeUpdateRef =
-  <T>(f: (p: Discord.GatewayPayload) => Maybe<T>, ref: Ref<Maybe<T>>) =>
-  (_: Discord.GatewayPayload) =>
-    f(_).match({
+  <T>(
+    f: (p: Discord.GatewayPayload) => Option.Option<T>,
+    ref: Ref.Ref<Option.Option<T>>,
+  ) =>
+  (_: Discord.GatewayPayload): Effect.Effect<never, never, void> =>
+    Option.match(f(_), {
       onNone: () => Effect.unit,
-      onSome: a => ref.set(Maybe.some(a)),
+      onSome: a => Ref.set(ref, Option.some(a)),
     })
 
-export const latest = <T>(f: (p: Discord.GatewayPayload) => Maybe<T>) =>
-  Ref.make<Maybe<T>>(Maybe.none()).map(
+export const latest = <T>(
+  f: (p: Discord.GatewayPayload) => Option.Option<T>,
+): Effect.Effect<
+  never,
+  never,
+  readonly [
+    Ref.Ref<Option.Option<T>>,
+    (_: Discord.GatewayPayload<any>) => Effect.Effect<never, never, void>,
+  ]
+> =>
+  Effect.map(
+    Ref.make<Option.Option<T>>(Option.none()),
+
     ref => [ref, maybeUpdateRef(f, ref)] as const,
   )

package/src/DiscordGateway/Shard.ts

@@ -1,12 +1,23 @@
 import { DiscordConfig } from "dfx/DiscordConfig"
 import { LiveRateLimiter, RateLimiter } from "dfx/RateLimit"
-import { DiscordWS, LiveDiscordWS, Message } from "./DiscordWS.js"
-import * as Heartbeats from "./Shard/heartbeats.js"
-import * as Identify from "./Shard/identify.js"
-import * as InvalidSession from "./Shard/invalidSession.js"
-import * as Utils from "./Shard/utils.js"
-import { Reconnect } from "./WS.js"
+import { DiscordWS, LiveDiscordWS, Message } from "dfx/DiscordGateway/DiscordWS"
+import * as Heartbeats from "dfx/DiscordGateway/Shard/heartbeats"
+import * as Identify from "dfx/DiscordGateway/Shard/identify"
+import * as InvalidSession from "dfx/DiscordGateway/Shard/invalidSession"
+import * as Utils from "dfx/DiscordGateway/Shard/utils"
+import { Reconnect } from "dfx/DiscordGateway/WS"
 import { Log } from "dfx/Log"
+import * as Discord from "dfx/types"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import { Tag } from "@effect/data/Context"
+import * as Option from "@effect/data/Option"
+import * as Hub from "@effect/io/Hub"
+import * as Queue from "@effect/io/Queue"
+import * as Ref from "@effect/io/Ref"
+import * as Duration from "@effect/data/Duration"
+import * as Chunk from "@effect/data/Chunk"
+import * as ConfigSecret from "@effect/io/Config/Secret"
 
 const enum Phase {
   Connecting,
@@ -14,54 +25,56 @@ const enum Phase {
   Connected,
 }
 
-export const make = Do($ => {
-  const { token, gateway } = $(DiscordConfig.accessWith(identity))
-  const limiter = $(RateLimiter.accessWith(identity))
-  const dws = $(DiscordWS.accessWith(identity))
-  const log = $(Log.accessWith(identity))
+export const make = Effect.gen(function* (_) {
+  const { token, gateway } = yield* _(DiscordConfig)
+  const limiter = yield* _(RateLimiter)
+  const dws = yield* _(DiscordWS)
+  const log = yield* _(Log)
 
   const connect = (
     shard: [id: number, count: number],
-    hub: Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
-    sendQueue: Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
+    hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
+    sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
   ) =>
-    Do($ => {
-      const outboundQueue = $(Queue.unbounded<Message>())
-      const pendingQueue = $(Queue.unbounded<Message>())
-      const phase = $(Ref.make(Phase.Connecting))
+    Effect.gen(function* (_) {
+      const outboundQueue = yield* _(Queue.unbounded<Message>())
+      const pendingQueue = yield* _(Queue.unbounded<Message>())
+      const phase = yield* _(Ref.make(Phase.Connecting))
       const setPhase = (p: Phase) =>
-        phase.set(p).zipLeft(log.debug("Shard", shard, "phase", p))
-      const outbound = outboundQueue
-        .take()
-        .tap(() =>
-          limiter.maybeWait("dfx.shard.send", Duration.minutes(1), 120),
-        )
+        Effect.zipLeft(Ref.set(phase, p), log.debug("Shard", shard, "phase", p))
+      const outbound = Effect.zipLeft(
+        Queue.take(outboundQueue),
+        limiter.maybeWait("dfx.shard.send", Duration.minutes(1), 120),
+      )
 
       const send = (p: Message) =>
-        phase.get.flatMap(_ =>
-          _ === Phase.Connected
-            ? outboundQueue.offer(p)
-            : pendingQueue.offer(p),
+        Effect.flatMap(Ref.get(phase), phase =>
+          phase === Phase.Connected
+            ? Queue.offer(outboundQueue, p)
+            : Queue.offer(pendingQueue, p),
         )
 
       const heartbeatSend = (p: Message) =>
-        phase.get.flatMap(_ =>
-          _ !== Phase.Connecting
-            ? outboundQueue.offer(p)
+        Effect.flatMap(Ref.get(phase), phase =>
+          phase !== Phase.Connecting
+            ? Queue.offer(outboundQueue, p)
             : Effect.succeed(false),
         )
 
-      const prioritySend = (p: Message) => outboundQueue.offer(p)
+      const prioritySend = (p: Message) => Queue.offer(outboundQueue, p)
 
-      const resume = setPhase(Phase.Connected)
-        .zipRight(pendingQueue.takeAll())
-        .tap(_ => outboundQueue.offerAll(_)).asUnit
+      const resume = setPhase(Phase.Connected).pipe(
+        Effect.zipRight(Queue.takeAll(pendingQueue)),
+        Effect.tap(_ => Queue.offerAll(outboundQueue, _)),
+        Effect.asUnit,
+      )
 
-      const onConnecting = outboundQueue
-        .takeAll()
-        .tap(_ =>
-          pendingQueue.offerAll(
-            _.filter(
+      const onConnecting = Queue.takeAll(outboundQueue).pipe(
+        Effect.tap(msgs =>
+          Queue.offerAll(
+            pendingQueue,
+            Chunk.filter(
+              msgs,
               msg =>
                 msg !== Reconnect &&
                 msg.op !== Discord.GatewayOpcode.IDENTIFY &&
@@ -69,39 +82,42 @@ export const make = Do($ => {
                 msg.op !== Discord.GatewayOpcode.HEARTBEAT,
             ),
           ),
-        )
-        .zipRight(setPhase(Phase.Connecting))
+        ),
+        Effect.zipRight(setPhase(Phase.Connecting)),
+      )
 
-      const socket = $(dws.connect({ outbound, onConnecting }))
+      const socket = yield* _(dws.connect({ outbound, onConnecting }))
 
-      const [latestReady, updateLatestReady] = $(
+      const [latestReady, updateLatestReady] = yield* _(
         Utils.latest(p =>
-          Maybe.some(p)
-            .filter(
+          Option.some(p).pipe(
+            Option.filter(
               (p): p is Discord.GatewayPayload<Discord.ReadyEvent> =>
                 p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
-            )
-            .map(p => p.d!),
+            ),
+            Option.map(p => p.d!),
+          ),
         ),
       )
-      const [latestSequence, updateLatestSequence] = $(
-        Utils.latest(p => Maybe.fromNullable(p.s)),
+      const [latestSequence, updateLatestSequence] = yield* _(
+        Utils.latest(p => Option.fromNullable(p.s)),
       )
       const maybeUpdateUrl = (p: Discord.GatewayPayload) =>
-        Maybe.some(p)
-          .filter(
+        Option.some(p).pipe(
+          Option.filter(
             (p): p is Discord.GatewayPayload<Discord.ReadyEvent> =>
               p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
-          )
-          .map(p => p.d!)
-          .match({
+          ),
+          Option.map(p => p.d!),
+          Option.match({
             onNone: () => Effect.unit,
             onSome: ({ resume_gateway_url }) =>
               socket.setUrl(resume_gateway_url),
-          })
+          }),
+        )
 
-      const hellos = $(Queue.unbounded<Discord.GatewayPayload>())
-      const acks = $(Queue.unbounded<Discord.GatewayPayload>())
+      const hellos = yield* _(Queue.unbounded<Discord.GatewayPayload>())
+      const acks = yield* _(Queue.unbounded<Discord.GatewayPayload>())
 
       // heartbeats
       const heartbeats = Heartbeats.send(
@@ -114,7 +130,7 @@ export const make = Do($ => {
       // identify
       const identify = Identify.identifyOrResume(
         {
-          token: token.value,
+          token: ConfigSecret.value(token),
           shard,
           intents: gateway.intents,
           presence: gateway.presence,
@@ -124,45 +140,47 @@ export const make = Do($ => {
       )
 
       const onPayload = (p: Discord.GatewayPayload) =>
-        Do($ => {
-          $(
-            updateLatestReady(p)
-              .zip(updateLatestSequence(p), { parallel: true })
-              .zip(maybeUpdateUrl(p)),
-          )
-
-          let effect = Effect.unit
-
-          switch (p.op) {
-            case Discord.GatewayOpcode.HELLO:
-              effect = identify
-                .tap(prioritySend)
-                .zip(setPhase(Phase.Handshake).zipRight(hellos.offer(p)), {
-                  parallel: true,
-                })
-              break
-            case Discord.GatewayOpcode.HEARTBEAT_ACK:
-              effect = acks.offer(p)
-              break
-            case Discord.GatewayOpcode.INVALID_SESSION:
-              effect = InvalidSession.fromPayload(p, latestReady).tap(send)
-              break
-            case Discord.GatewayOpcode.DISPATCH:
-              if (p.t === "READY" || p.t === "RESUMED") {
-                effect = resume.zipRight(hub.publish(p))
-              } else {
-                effect = hub.publish(p)
-              }
-              break
-          }
-
-          $(effect)
-        })
-
-      const drainSendQueue = sendQueue.take().tap(send).forever
+        Effect.tap(
+          Effect.all(
+            updateLatestReady(p),
+            updateLatestSequence(p),
+            maybeUpdateUrl(p),
+            { discard: true },
+          ),
+          () => {
+            switch (p.op) {
+              case Discord.GatewayOpcode.HELLO:
+                return Effect.all(
+                  Effect.tap(identify, prioritySend),
+                  setPhase(Phase.Handshake),
+                  Queue.offer(hellos, p),
+                  { discard: true },
+                )
+              case Discord.GatewayOpcode.HEARTBEAT_ACK:
+                return Queue.offer(acks, p)
+              case Discord.GatewayOpcode.INVALID_SESSION:
+                return Effect.tap(
+                  InvalidSession.fromPayload(p, latestReady),
+                  send,
+                )
+              case Discord.GatewayOpcode.DISPATCH:
+                if (p.t === "READY" || p.t === "RESUMED") {
+                  return Effect.zipRight(resume, Hub.publish(hub, p))
+                }
+                return Hub.publish(hub, p)
+            }
+
+            return Effect.unit
+          },
+        )
+
+      const drainSendQueue = Queue.take(sendQueue).pipe(
+        Effect.tap(send),
+        Effect.forever,
+      )
 
       const run = Effect.all(
-        socket.take.flatMap(onPayload).forever,
+        socket.take.pipe(Effect.flatMap(onPayload), Effect.forever),
         heartbeats,
         drainSendQueue,
         socket.run,
@@ -175,10 +193,12 @@ export const make = Do($ => {
   return { connect } as const
 })
 
-export interface Shard extends Effect.Success<typeof make> {}
+export interface Shard extends Effect.Effect.Success<typeof make> {}
 export const Shard = Tag<Shard>()
-export const LiveShard =
-  (LiveDiscordWS + LiveRateLimiter) >> Layer.effect(Shard, make)
+export const LiveShard = Layer.provide(
+  Layer.merge(LiveDiscordWS, LiveRateLimiter),
+  Layer.effect(Shard, make),
+)
 
 export interface RunningShard
-  extends Effect.Success<ReturnType<Shard["connect"]>> {}
+  extends Effect.Effect.Success<ReturnType<Shard["connect"]>> {}

package/src/DiscordGateway/ShardStore.ts

@@ -1,12 +1,19 @@
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import { Tag } from "@effect/data/Context"
+import * as Option from "@effect/data/Option"
+
 export interface ClaimIdContext {
   sharderCount: number
   totalCount: number
 }
 
 export interface ShardStore {
-  claimId: (ctx: ClaimIdContext) => Effect<never, never, Maybe<number>>
-  allClaimed: (totalCount: number) => Effect<never, never, boolean>
-  heartbeat?: (shardId: number) => Effect<never, never, void>
+  claimId: (
+    ctx: ClaimIdContext,
+  ) => Effect.Effect<never, never, Option.Option<number>>
+  allClaimed: (totalCount: number) => Effect.Effect<never, never, boolean>
+  heartbeat?: (shardId: number) => Effect.Effect<never, never, void>
 }
 export const ShardStore = Tag<ShardStore>()
 
@@ -18,12 +25,12 @@ const memoryStore = (): ShardStore => {
     claimId: ({ totalCount }) =>
       Effect.sync(() => {
         if (currentId >= totalCount) {
-          return Maybe.none()
+          return Option.none()
         }
 
         const id = currentId
         currentId++
-        return Maybe.some(id)
+        return Option.some(id)
       }),
 
     allClaimed: totalCount => Effect.sync(() => currentId >= totalCount),