dfx 0.77.2 → 0.78.0

package/mjs/index.mjs

@@ -7,9 +7,8 @@ import * as Members from "dfx/Helpers/members";
 import * as Perms from "dfx/Helpers/permissions";
 import * as UI from "dfx/Helpers/ui";
 import * as Ix from "dfx/Interactions/index";
-import * as Log from "dfx/Log";
 import * as Discord from "dfx/types";
 export { DiscordREST, DiscordRESTLive } from "dfx/DiscordREST";
 export { MemoryRateLimitStoreLive, RateLimiterLive, RateLimiter, RateLimitStore } from "dfx/RateLimit";
-export { Cache, Discord, DiscordConfig, Flags, Intents, Ix, IxHelpers, Log, Members, Perms, UI };
+export { Cache, Discord, DiscordConfig, Flags, Intents, Ix, IxHelpers, Members, Perms, UI };
 //# sourceMappingURL=index.mjs.map

package/mjs/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["Cache","DiscordConfig","Flags","Intents","IxHelpers","Members","Perms","UI","Ix","Log","Discord","DiscordREST","DiscordRESTLive","MemoryRateLimitStoreLive","RateLimiterLive","RateLimiter","RateLimitStore"],"sources":["../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,WAAW;AAClC,OAAO,KAAKC,aAAa,MAAM,mBAAmB;AAClD,OAAO,KAAKC,KAAK,MAAM,mBAAmB;AAC1C,OAAO,KAAKC,OAAO,MAAM,qBAAqB;AAC9C,OAAO,KAAKC,SAAS,MAAM,0BAA0B;AACrD,OAAO,KAAKC,OAAO,MAAM,qBAAqB;AAC9C,OAAO,KAAKC,KAAK,MAAM,yBAAyB;AAChD,OAAO,KAAKC,EAAE,MAAM,gBAAgB;AACpC,OAAO,KAAKC,EAAE,MAAM,wBAAwB;AAC5C,OAAO,KAAKC,GAAG,MAAM,SAAS;AAC9B,OAAO,KAAKC,OAAO,MAAM,WAAW;AAEpC,SAASC,WAAW,EAAEC,eAAe,QAAQ,iBAAiB;AAE9D,SAEEC,wBAAwB,EACxBC,eAAe,EACfC,WAAW,EACXC,cAAc,QACT,eAAe;AAEtB,SACEhB,KAAK,EACLU,OAAO,EACPT,aAAa,EACbC,KAAK,EACLC,OAAO,EACPK,EAAE,EACFJ,SAAS,EACTK,GAAG,EACHJ,OAAO,EACPC,KAAK,EACLC,EAAE"}
+{"version":3,"file":"index.mjs","names":["Cache","DiscordConfig","Flags","Intents","IxHelpers","Members","Perms","UI","Ix","Discord","DiscordREST","DiscordRESTLive","MemoryRateLimitStoreLive","RateLimiterLive","RateLimiter","RateLimitStore"],"sources":["../src/index.ts"],"sourcesContent":[null],"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,WAAW;AAClC,OAAO,KAAKC,aAAa,MAAM,mBAAmB;AAClD,OAAO,KAAKC,KAAK,MAAM,mBAAmB;AAC1C,OAAO,KAAKC,OAAO,MAAM,qBAAqB;AAC9C,OAAO,KAAKC,SAAS,MAAM,0BAA0B;AACrD,OAAO,KAAKC,OAAO,MAAM,qBAAqB;AAC9C,OAAO,KAAKC,KAAK,MAAM,yBAAyB;AAChD,OAAO,KAAKC,EAAE,MAAM,gBAAgB;AACpC,OAAO,KAAKC,EAAE,MAAM,wBAAwB;AAC5C,OAAO,KAAKC,OAAO,MAAM,WAAW;AAEpC,SAASC,WAAW,EAAEC,eAAe,QAAQ,iBAAiB;AAE9D,SAEEC,wBAAwB,EACxBC,eAAe,EACfC,WAAW,EACXC,cAAc,QACT,eAAe;AAEtB,SACEf,KAAK,EACLS,OAAO,EACPR,aAAa,EACbC,KAAK,EACLC,OAAO,EACPK,EAAE,EACFJ,SAAS,EACTC,OAAO,EACPC,KAAK,EACLC,EAAE"}

package/mjs/version.mjs

@@ -1,2 +1,2 @@
-export const LIB_VERSION = "0.77.2";
+export const LIB_VERSION = "0.78.0";
 //# sourceMappingURL=version.mjs.map

package/mjs/webhooks.mjs

@@ -1,7 +1,6 @@
 import { DiscordRESTLive } from "dfx/DiscordREST";
-import * as Log from "dfx/Log";
 import { MemoryRateLimitStoreLive, RateLimiterLive } from "dfx/RateLimit";
 import * as Layer from "effect/Layer";
 export { BadWebhookSignature, WebhookConfig, WebhookParseError, makeHandler, makeSimpleHandler, layer as webhookLayer, layerConfig as webhookLayerConfig } from "dfx/Interactions/webhook";
-export const DiscordLive = /*#__PURE__*/Layer.mergeAll(DiscordRESTLive, RateLimiterLive).pipe( /*#__PURE__*/Layer.provide(MemoryRateLimitStoreLive), /*#__PURE__*/Layer.provideMerge(Log.LogLive));
+export const DiscordLive = /*#__PURE__*/Layer.mergeAll(DiscordRESTLive, RateLimiterLive).pipe( /*#__PURE__*/Layer.provide(MemoryRateLimitStoreLive));
 //# sourceMappingURL=webhooks.mjs.map

package/mjs/webhooks.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"webhooks.mjs","names":["DiscordRESTLive","Log","MemoryRateLimitStoreLive","RateLimiterLive","Layer","BadWebhookSignature","WebhookConfig","WebhookParseError","makeHandler","makeSimpleHandler","layer","webhookLayer","layerConfig","webhookLayerConfig","DiscordLive","mergeAll","pipe","provide","provideMerge","LogLive"],"sources":["../src/webhooks.ts"],"sourcesContent":[null],"mappings":"AAAA,SAASA,eAAe,QAAQ,iBAAiB;AACjD,OAAO,KAAKC,GAAG,MAAM,SAAS;AAC9B,SACEC,wBAAoD,EACpDC,eAAkC,QAC7B,eAAe;AACtB,OAAO,KAAKC,KAAK,MAAM,cAAc;AAErC,SACEC,mBAAmB,EACnBC,aAAa,EACbC,iBAAiB,EACjBC,WAAW,EACXC,iBAAiB,EACjBC,KAAK,IAAIC,YAAY,EACrBC,WAAW,IAAIC,kBAAkB,QAC5B,0BAA0B;AAEjC,OAAO,MAAMC,WAAW,gBAAGV,KAAK,CAACW,QAAQ,CACvCf,eAAe,EACfG,eAAe,CAChB,CAACa,IAAI,eAACZ,KAAK,CAACa,OAAO,CAACf,wBAAwB,CAAC,eAAEE,KAAK,CAACc,YAAY,CAACjB,GAAG,CAACkB,OAAO,CAAC,CAAC"}
+{"version":3,"file":"webhooks.mjs","names":["DiscordRESTLive","MemoryRateLimitStoreLive","RateLimiterLive","Layer","BadWebhookSignature","WebhookConfig","WebhookParseError","makeHandler","makeSimpleHandler","layer","webhookLayer","layerConfig","webhookLayerConfig","DiscordLive","mergeAll","pipe","provide"],"sources":["../src/webhooks.ts"],"sourcesContent":[null],"mappings":"AAAA,SAASA,eAAe,QAAQ,iBAAiB;AACjD,SACEC,wBAAoD,EACpDC,eAAkC,QAC7B,eAAe;AACtB,OAAO,KAAKC,KAAK,MAAM,cAAc;AAErC,SACEC,mBAAmB,EACnBC,aAAa,EACbC,iBAAiB,EACjBC,WAAW,EACXC,iBAAiB,EACjBC,KAAK,IAAIC,YAAY,EACrBC,WAAW,IAAIC,kBAAkB,QAC5B,0BAA0B;AAEjC,OAAO,MAAMC,WAAW,gBAAGV,KAAK,CAACW,QAAQ,CACvCd,eAAe,EACfE,eAAe,CAChB,CAACa,IAAI,eAACZ,KAAK,CAACa,OAAO,CAACf,wBAAwB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dfx",
-  "version": "0.77.2",
+  "version": "0.78.0",
   "description": "Effect-TS discord library",
   "license": "MIT",
   "repository": {
@@ -48,6 +48,6 @@
     "utf-8-validate": "^6.0.3",
     "zlib-sync": "^0.1.9"
   },
-  "gitHead": "100a9e2e0e2882c679f520fe645c6e8c28c3181e",
+  "gitHead": "efc2997291e09256e66f3654d4bc1ae3422291c8",
   "main": "./index.js"
 }

package/src/DiscordConfig.ts

@@ -10,8 +10,11 @@ import * as Discord from "dfx/types"
 const VERSION = 10
 
 export interface DiscordConfig {
+  readonly _: unique symbol
+}
+
+export interface DiscordConfigService {
   readonly token: ConfigSecret.ConfigSecret
-  readonly debug: boolean
   readonly rest: {
     readonly baseUrl: string
     readonly globalRateLimit: {
@@ -27,23 +30,22 @@ export interface DiscordConfig {
     readonly identifyRateLimit: readonly [window: number, limit: number]
   }
 }
-export const DiscordConfig = Tag<DiscordConfig>()
+export const DiscordConfig = Tag<DiscordConfig, DiscordConfigService>(
+  "dfx/DiscordConfig",
+)
 
 export interface MakeOpts {
   readonly token: ConfigSecret.ConfigSecret
-  readonly debug?: boolean
-  readonly rest?: Partial<DiscordConfig["rest"]>
-  readonly gateway?: Partial<DiscordConfig["gateway"]>
+  readonly rest?: Partial<DiscordConfigService["rest"]>
+  readonly gateway?: Partial<DiscordConfigService["gateway"]>
 }
 
 export const make = ({
-  debug = false,
   gateway,
   rest,
   token,
-}: MakeOpts): DiscordConfig => ({
+}: MakeOpts): DiscordConfigService => ({
   token,
-  debug,
   rest: {
     baseUrl: `https://discord.com/api/v${VERSION}`,
     ...(rest ?? {}),

package/src/DiscordGateway/DiscordWS.ts

@@ -16,12 +16,17 @@ export interface OpenOpts {
   onConnecting?: Effect.Effect<never, never, void>
 }
 
-export interface DiscordWSCodec {
+export interface DiscordWSCodecService {
   type: "json" | "etf"
   encode: (p: Discord.GatewayPayload) => string
   decode: (p: WebSocket.Data) => Discord.GatewayPayload
 }
-export const DiscordWSCodec = Tag<DiscordWSCodec>()
+export interface DiscordWSCodec {
+  readonly _: unique symbol
+}
+export const DiscordWSCodec = Tag<DiscordWSCodec, DiscordWSCodecService>(
+  "dfx/DiscordGateway/DiscordWS/Codec",
+)
 export const JsonDiscordWSCodecLive = Layer.succeed(DiscordWSCodec, {
   type: "json",
   encode: p => JSON.stringify(p),
@@ -47,18 +52,19 @@ const make = Effect.gen(function* (_) {
       const takeOutbound = Effect.map(outbound, msg =>
         msg === Reconnect ? msg : encoding.encode(msg),
       )
-      const socket = yield* _(ws.connect(urlRef, takeOutbound, onConnecting))
-      const take = Effect.map(socket.take, encoding.decode)
-
-      const run = Effect.retryWhile(
-        socket.run,
-        e =>
-          (e._tag === "WebSocketCloseError" && e.code < 2000) ||
-          (e._tag === "WebSocketError" && e.reason === "open-timeout"),
+      const socket = yield* _(
+        ws.connect({
+          urlRef,
+          takeOutbound,
+          onConnecting,
+          reconnectWhen: e =>
+            (e._tag === "WebSocketCloseError" && e.code < 2000) ||
+            (e._tag === "WebSocketError" && e.reason === "open-timeout"),
+        }),
       )
+      const take = Effect.map(socket.take, encoding.decode)
 
       return {
-        run,
         take,
         setUrl,
       } as const
@@ -67,8 +73,12 @@ const make = Effect.gen(function* (_) {
   return { connect } as const
 })
 
-export interface DiscordWS extends Effect.Effect.Success<typeof make> {}
-export const DiscordWS = Tag<DiscordWS>()
+export interface DiscordWS {
+  readonly _: unique symbol
+}
+export const DiscordWS = Tag<DiscordWS, Effect.Effect.Success<typeof make>>(
+  "dfx/DiscordGateway/DiscordWS",
+)
 export const DiscordWSLive = Layer.provide(
   Layer.effect(DiscordWS, make),
   WSLive,

package/src/DiscordGateway/Messaging.ts

@@ -0,0 +1,72 @@
+import { Tag } from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as PubSub from "effect/PubSub"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import * as Stream from "effect/Stream"
+import type * as Discord from "dfx/types"
+import * as EffectUtils from "dfx/utils/Effect"
+
+const fromDispatchFactory =
+  <R, E>(
+    source: Stream.Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>,
+  ) =>
+  <K extends keyof Discord.ReceiveEvents>(
+    event: K,
+  ): Stream.Stream<R, E, Discord.ReceiveEvents[K]> =>
+    Stream.map(
+      Stream.filter(source, p => p.t === event),
+      p => p.d! as any,
+    )
+
+const handleDispatchFactory =
+  (hub: PubSub.PubSub<Discord.GatewayPayload<Discord.ReceiveEvent>>) =>
+  <K extends keyof Discord.ReceiveEvents, R, E, A>(
+    event: K,
+    handle: (event: Discord.ReceiveEvents[K]) => Effect.Effect<R, E, A>,
+  ): Effect.Effect<R, E, never> =>
+    EffectUtils.subscribeForEachPar(hub, _ => {
+      if (_.t === event) {
+        return handle(_.d as any)
+      }
+      return Effect.unit as any
+    })
+
+export const make = Effect.gen(function* (_) {
+  const hub = yield* _(
+    Effect.acquireRelease(
+      PubSub.unbounded<Discord.GatewayPayload<Discord.ReceiveEvent>>(),
+      PubSub.shutdown,
+    ),
+  )
+
+  const sendQueue = yield* _(
+    Effect.acquireRelease(
+      Queue.unbounded<Discord.GatewayPayload<Discord.SendEvent>>(),
+      Queue.shutdown,
+    ),
+  )
+  const send = (payload: Discord.GatewayPayload<Discord.SendEvent>) =>
+    sendQueue.offer(payload)
+
+  const dispatch = Stream.fromPubSub(hub)
+  const fromDispatch = fromDispatchFactory(dispatch)
+  const handleDispatch = handleDispatchFactory(hub)
+
+  return {
+    hub,
+    sendQueue,
+    dispatch,
+    fromDispatch,
+    handleDispatch,
+    send,
+  } as const
+})
+
+export interface Messsaging {
+  readonly _: unique symbol
+}
+export const Messaging = Tag<Messsaging, Effect.Effect.Success<typeof make>>(
+  "dfx/DiscordGateway/Messaging",
+)
+export const MesssagingLive = Layer.scoped(Messaging, make)

package/src/DiscordGateway/Shard.ts

@@ -17,9 +17,9 @@ 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 { RateLimiterLive, RateLimiter } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
+import { Messaging, MesssagingLive } from "dfx/DiscordGateway/Messaging"
 
 const enum Phase {
   Connecting,
@@ -31,19 +31,18 @@ export const make = Effect.gen(function* (_) {
   const { gateway, token } = yield* _(DiscordConfig)
   const limiter = yield* _(RateLimiter)
   const dws = yield* _(DiscordWS)
-  const log = yield* _(Log)
+  const { hub, sendQueue } = yield* _(Messaging)
 
-  const connect = (
-    shard: [id: number, count: number],
-    hub: PubSub.PubSub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
-    sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
-  ) =>
+  const connect = (shard: [id: number, count: number]) =>
     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) =>
-        Effect.zipLeft(Ref.set(phase, p), log.debug("Shard", shard, "phase", p))
+        Effect.zipLeft(
+          Ref.set(phase, p),
+          Effect.annotateLogs(Effect.logTrace("phase transition"), "phase", p),
+        )
       const outbound = Effect.zipLeft(
         Queue.take(outboundQueue),
         limiter.maybeWait("dfx.shard.send", Duration.minutes(1), 120),
@@ -115,15 +114,23 @@ export const make = Effect.gen(function* (_) {
           },
         )
 
-      const hellos = yield* _(Queue.unbounded<Discord.GatewayPayload>())
-      const acks = yield* _(Queue.unbounded<Discord.GatewayPayload>())
+      const hellos = yield* _(
+        Effect.acquireRelease(
+          Queue.unbounded<Discord.GatewayPayload>(),
+          Queue.shutdown,
+        ),
+      )
+      const acks = yield* _(
+        Effect.acquireRelease(
+          Queue.unbounded<Discord.GatewayPayload>(),
+          Queue.shutdown,
+        ),
+      )
 
       // heartbeats
-      const heartbeats = Heartbeats.send(
-        hellos,
-        acks,
-        latestSequence,
-        heartbeatSend,
+      yield* _(
+        Heartbeats.send(hellos, acks, latestSequence, heartbeatSend),
+        Effect.forkScoped,
       )
 
       // identify
@@ -169,32 +176,43 @@ export const make = Effect.gen(function* (_) {
           }),
         )
 
-      const drainSendQueue = Effect.forever(
-        Effect.tap(Queue.take(sendQueue), send),
+      yield* _(
+        Queue.take(sendQueue),
+        Effect.tap(send),
+        Effect.forever,
+        Effect.forkScoped,
       )
 
-      const run = Effect.all(
-        [
-          Effect.forever(Effect.flatMap(socket.take, onPayload)),
-          heartbeats,
-          drainSendQueue,
-          socket.run,
-        ],
-        { discard: true, concurrency: "unbounded" },
+      yield* _(
+        socket.take,
+        Effect.flatMap(onPayload),
+        Effect.forever,
+        Effect.forkScoped,
       )
 
-      return { id: shard, send, run } as const
-    })
+      return { id: shard, send } as const
+    }).pipe(
+      Effect.annotateLogs({
+        package: "dfx",
+        module: "DiscordGateway/Shard",
+        shard,
+      }),
+    )
 
   return { connect } as const
 })
 
-export interface Shard extends Effect.Effect.Success<typeof make> {}
-export const Shard = Tag<Shard>()
-export const ShardLive = Layer.provide(
-  Layer.effect(Shard, make),
-  Layer.merge(DiscordWSLive, RateLimiterLive),
+type ShardService = Effect.Effect.Success<typeof make>
+
+export interface Shard {
+  readonly _: unique symbol
+}
+export const Shard = Tag<Shard, ShardService>("dfx/DiscordGateway/Shard")
+export const ShardLive = Layer.effect(Shard, make).pipe(
+  Layer.provide(DiscordWSLive),
+  Layer.provide(MesssagingLive),
+  Layer.provide(RateLimiterLive),
 )
 
 export interface RunningShard
-  extends Effect.Effect.Success<ReturnType<Shard["connect"]>> {}
+  extends Effect.Effect.Success<ReturnType<ShardService["connect"]>> {}

package/src/DiscordGateway/ShardStore.ts

@@ -8,17 +8,22 @@ export interface ClaimIdContext {
   totalCount: number
 }
 
-export interface ShardStore {
+export interface ShardStoreService {
   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>()
+export interface ShardStore {
+  readonly _: unique symbol
+}
+export const ShardStore = Tag<ShardStore, ShardStoreService>(
+  "dfx/DiscordGateway/ShardStore",
+)
 
 // Very basic shard id store, that does no health checks
-const memoryStore = (): ShardStore => {
+const memoryStore = (): ShardStoreService => {
   let currentId = 0
 
   return {

package/src/DiscordGateway/Sharder.ts

@@ -1,24 +1,19 @@
-import * as Chunk from "effect/Chunk"
+import { DiscordConfig } from "dfx/DiscordConfig"
+import type { RunningShard } from "dfx/DiscordGateway/Shard"
+import { Shard, ShardLive } from "dfx/DiscordGateway/Shard"
+import { ShardStore } from "dfx/DiscordGateway/ShardStore"
+import { DiscordREST, DiscordRESTLive } from "dfx/DiscordREST"
+import { RateLimiter, RateLimiterLive } from "dfx/RateLimit"
+import type * as Discord from "dfx/types"
 import { Tag } from "effect/Context"
 import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as HashSet from "effect/HashSet"
-import type * as Option from "effect/Option"
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import type * as PubSub from "effect/PubSub"
 import * as Layer from "effect/Layer"
-import type * as Queue from "effect/Queue"
+import type * as Option from "effect/Option"
 import * as Ref from "effect/Ref"
 import * as Schedule from "effect/Schedule"
-import { DiscordConfig } from "dfx/DiscordConfig"
-import type { RunningShard } from "dfx/DiscordGateway/Shard"
-import { ShardLive, Shard } from "dfx/DiscordGateway/Shard"
-import { ShardStore } from "dfx/DiscordGateway/ShardStore"
-import type { WebSocketCloseError, WebSocketError } from "dfx/DiscordGateway/WS"
-import { DiscordREST } from "dfx/DiscordREST"
-import { RateLimiterLive, RateLimiter } from "dfx/RateLimit"
-import type * as Discord from "dfx/types"
 
 const claimRepeatPolicy = Schedule.spaced("3 minutes").pipe(
   Schedule.whileInput((_: Option.Option<number>) => _._tag === "None"),
@@ -33,29 +28,6 @@ const make = Effect.gen(function* (_) {
   const shard = yield* _(Shard)
   const currentShards = yield* _(Ref.make(HashSet.empty<RunningShard>()))
 
-  const takeConfig = (totalCount: number) =>
-    Effect.gen(function* (_) {
-      const currentCount = yield* _(Ref.make(0))
-
-      const claimId = (
-        sharderCount: number,
-      ): Effect.Effect<never, never, number> =>
-        pipe(
-          store.claimId({
-            totalCount,
-            sharderCount,
-          }),
-          Effect.repeat(claimRepeatPolicy),
-          Effect.map(_ => _.value),
-        )
-
-      return pipe(
-        Ref.getAndUpdate(currentCount, _ => _ + 1),
-        Effect.flatMap(claimId),
-        Effect.map(id => ({ id, totalCount }) as const),
-      )
-    })
-
   const gateway = yield* _(
     rest.getGatewayBot(),
     Effect.flatMap(r => r.json),
@@ -73,68 +45,71 @@ const make = Effect.gen(function* (_) {
     ),
   )
 
-  const run = (
-    hub: PubSub.PubSub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
-    sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
-  ) =>
-    Effect.gen(function* (_) {
-      const deferred = yield* _(
-        Deferred.make<WebSocketError | WebSocketCloseError, never>(),
-      )
-      const take = yield* _(takeConfig(config.shardCount ?? gateway.shards))
-
-      const spawner = pipe(
-        take,
-        Effect.map(config => ({
-          ...config,
-          url: gateway.url,
-          concurrency: gateway.session_start_limit.max_concurrency,
-        })),
-        Effect.tap(({ concurrency, id }) =>
-          limiter.maybeWait(
-            `dfx.sharder.${id % concurrency}`,
-            Duration.millis(config.identifyRateLimit[0]),
-            config.identifyRateLimit[1],
-          ),
-        ),
-        Effect.flatMap(c =>
-          shard.connect([c.id, c.totalCount], hub, sendQueue),
-        ),
-        Effect.flatMap(shard =>
-          Effect.acquireUseRelease(
-            Ref.update(currentShards, HashSet.add(shard)),
-            () => shard.run,
-            () => Ref.update(currentShards, HashSet.remove(shard)),
-          ).pipe(
-            Effect.catchAllCause(_ => Deferred.failCause(deferred, _)),
-            Effect.fork,
-          ),
-        ),
-        Effect.forever,
-      )
+  const totalCount = config.shardCount ?? gateway.shards
+  const currentCount = yield* _(Ref.make(0))
+  const claimId = (sharderCount: number): Effect.Effect<never, never, number> =>
+    pipe(
+      store.claimId({
+        totalCount,
+        sharderCount,
+      }),
+      Effect.repeat(claimRepeatPolicy),
+      Effect.map(_ => _.value),
+    )
+  const takeConfig = pipe(
+    Ref.getAndUpdate(currentCount, _ => _ + 1),
+    Effect.flatMap(claimId),
+    Effect.map(id => ({ id, totalCount }) as const),
+  )
 
-      const spawners = Chunk.map(
-        Chunk.range(1, gateway.session_start_limit.max_concurrency),
-        () => spawner,
-      )
+  const spawner = pipe(
+    takeConfig,
+    Effect.map(config => ({
+      ...config,
+      url: gateway.url,
+      concurrency: gateway.session_start_limit.max_concurrency,
+    })),
+    Effect.tap(({ concurrency, id }) =>
+      limiter.maybeWait(
+        `dfx.sharder.${id % concurrency}`,
+        Duration.millis(config.identifyRateLimit[0]),
+        config.identifyRateLimit[1],
+      ),
+    ),
+    Effect.flatMap(c => shard.connect([c.id, c.totalCount])),
+    Effect.flatMap(shard => Ref.update(currentShards, HashSet.add(shard))),
+    Effect.forever,
+  )
 
-      return yield* _(
-        Effect.all(
-          [
-            Effect.all(spawners, { concurrency: "unbounded", discard: true }),
-            Deferred.await(deferred),
-          ],
-          { concurrency: "unbounded", discard: true },
-        ) as Effect.Effect<never, WebSocketError | WebSocketCloseError, never>,
-      )
-    })
+  yield* _(
+    Effect.replicateEffect(
+      spawner,
+      gateway.session_start_limit.max_concurrency,
+      { concurrency: "unbounded", discard: true },
+    ),
+    Effect.scoped,
+    Effect.catchAllCause(Effect.logError),
+    Effect.ensuring(Ref.set(currentShards, HashSet.empty())),
+    Effect.forever,
+    Effect.forkScoped,
+  )
 
-  return { shards: Ref.get(currentShards), run } as const
-})
+  return { shards: Ref.get(currentShards) } as const
+}).pipe(
+  Effect.annotateLogs({
+    package: "dfx",
+    module: "DiscordGateway/Sharder",
+  }),
+)
 
-export interface Sharder extends Effect.Effect.Success<typeof make> {}
-export const Sharder = Tag<Sharder>()
-export const SharedLive = Layer.provide(
-  Layer.effect(Sharder, make),
-  Layer.merge(RateLimiterLive, ShardLive),
+export interface Sharder {
+  readonly _: unique symbol
+}
+export const Sharder = Tag<Sharder, Effect.Effect.Success<typeof make>>(
+  "dfx/DiscordGateway/Sharder",
+)
+export const SharderLive = Layer.scoped(Sharder, make).pipe(
+  Layer.provide(DiscordRESTLive),
+  Layer.provide(RateLimiterLive),
+  Layer.provide(ShardLive),
 )