dfx 0.77.3 → 0.78.0

package/src/DiscordGateway/WS.ts

@@ -1,12 +1,13 @@
 import { Tag } from "effect/Context"
-import * as Duration from "effect/Duration"
-import { pipe } from "effect/Function"
+import type * as Duration from "effect/Duration"
+import { identity, pipe } from "effect/Function"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Queue from "effect/Queue"
 import * as Ref from "effect/Ref"
-import { Log } from "dfx/Log"
 import WebSocket from "isomorphic-ws"
+import type { Predicate } from "effect/Predicate"
+import * as Schedule from "effect/Schedule"
 
 export const Reconnect = Symbol()
 export type Reconnect = typeof Reconnect
@@ -49,16 +50,10 @@ const socket = (urlRef: Ref.Ref<string>) =>
 const offer = (
   ws: globalThis.WebSocket,
   queue: Queue.Enqueue<WebSocket.Data>,
-  log: Log,
 ) =>
   Effect.async<never, WebSocketError | WebSocketCloseError, never>(resume => {
     ws.addEventListener("message", message => {
-      Effect.runFork(
-        Effect.zipRight(
-          log.debug("WS", "receive", message.data),
-          Queue.offer(queue, message.data),
-        ),
-      )
+      Queue.unsafeOffer(queue, message.data)
     })
 
     ws.addEventListener("error", cause => {
@@ -70,7 +65,10 @@ const offer = (
     })
   })
 
-const waitForOpen = (ws: globalThis.WebSocket, timeout: Duration.Duration) =>
+const waitForOpen = (
+  ws: globalThis.WebSocket,
+  timeout: Duration.DurationInput,
+) =>
   Effect.timeoutFail(
     Effect.suspend(() => {
       if (ws.readyState === WebSocket.OPEN) {
@@ -92,11 +90,10 @@ const waitForOpen = (ws: globalThis.WebSocket, timeout: Duration.Duration) =>
 const send = (
   ws: globalThis.WebSocket,
   take: Effect.Effect<never, never, Message>,
-  log: Log,
 ) =>
   pipe(
     take,
-    Effect.tap(data => log.debug("WS", "send", data)),
+    Effect.tap(data => Effect.logTrace(data)),
     Effect.tap(data => {
       if (data === Reconnect) {
         return Effect.failSync(() => {
@@ -110,30 +107,50 @@ const send = (
       })
     }),
     Effect.forever,
+    Effect.annotateLogs("method", "send"),
   )
 
-const make = Effect.gen(function* (_) {
-  const log = yield* _(Log)
-
-  const connect = (
-    url: Ref.Ref<string>,
-    takeOutbound: Effect.Effect<never, never, Message>,
+const wsImpl = {
+  connect: ({
     onConnecting = Effect.unit,
-    openTimeout = Duration.seconds(3),
-  ) =>
+    openTimeout = "3 seconds",
+    reconnectWhen,
+    takeOutbound,
+    urlRef,
+  }: {
+    readonly urlRef: Ref.Ref<string>
+    readonly takeOutbound: Effect.Effect<never, never, Message>
+    readonly onConnecting?: Effect.Effect<never, never, void>
+    readonly openTimeout?: Duration.DurationInput
+    readonly reconnectWhen?: Predicate<WebSocketError | WebSocketCloseError>
+  }) =>
     Effect.gen(function* (_) {
-      const queue = yield* _(Queue.unbounded<WebSocket.Data>())
+      const scope = yield* _(Effect.scope)
+      const queue = yield* _(
+        Effect.acquireRelease(
+          Queue.unbounded<WebSocket.Data>(),
+          Queue.shutdown,
+        ),
+      )
+      const take = Effect.annotateLogs(
+        Effect.tap(Queue.take(queue), data => Effect.logTrace(data)),
+        {
+          package: "dfx",
+          module: "DiscordGateway/WS",
+          method: "take",
+        },
+      )
 
       const run = pipe(
         onConnecting,
-        Effect.zipRight(socket(url)),
+        Effect.zipRight(socket(urlRef)),
         Effect.flatMap(ws =>
           Effect.all(
             [
-              offer(ws, queue, log),
+              offer(ws, queue),
               Effect.zipRight(
                 waitForOpen(ws, openTimeout),
-                send(ws, takeOutbound, log),
+                send(ws, takeOutbound),
               ),
             ],
             { concurrency: "unbounded", discard: true },
@@ -141,14 +158,29 @@ const make = Effect.gen(function* (_) {
         ),
         Effect.scoped,
         Effect.retryWhile(isReconnect),
+        reconnectWhen ? Effect.retryWhile(reconnectWhen) : identity,
+        Effect.catchAllCause(Effect.logError),
+        Effect.repeat(
+          Schedule.exponential("500 millis").pipe(
+            Schedule.union(Schedule.spaced("30 seconds")),
+          ),
+        ),
+        Effect.forkIn(scope),
       )
 
-      return { run, take: Queue.take(queue) } as const
-    })
+      yield* _(run)
 
-  return { connect } as const
-})
+      return { take } as const
+    }).pipe(
+      Effect.annotateLogs({
+        package: "dfx",
+        module: "DiscordGateway/WS",
+      }),
+    ),
+} as const
 
-export interface WS extends Effect.Effect.Success<typeof make> {}
-export const WS = Tag<WS>()
-export const WSLive = Layer.effect(WS, make)
+export interface WS {
+  readonly _: unique symbol
+}
+export const WS = Tag<WS, typeof wsImpl>("dfx/DiscordGateway/WS")
+export const WSLive = Layer.succeed(WS, wsImpl)

package/src/DiscordGateway.ts

@@ -1,42 +1,19 @@
+import { Messaging, MesssagingLive } from "dfx/DiscordGateway/Messaging"
+import type { RunningShard } from "dfx/DiscordGateway/Shard"
+import { Sharder, SharderLive } from "dfx/DiscordGateway/Sharder"
+import type * as Discord from "dfx/types"
 import { Tag } from "effect/Context"
-import type * as HashSet from "effect/HashSet"
 import * as Effect from "effect/Effect"
-import * as PubSub from "effect/PubSub"
+import type * as HashSet from "effect/HashSet"
 import * as Layer from "effect/Layer"
-import * as Queue from "effect/Queue"
-import * as Stream from "effect/Stream"
-import type { RunningShard } from "dfx/DiscordGateway/Shard"
-import { SharedLive, Sharder } from "dfx/DiscordGateway/Sharder"
-import type * as Discord from "dfx/types"
-import * as EffectUtils from "dfx/utils/Effect"
-import * as Schedule from "effect/Schedule"
-
-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,
-    )
+import type * as Stream from "effect/Stream"
 
-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 TypeId = Symbol.for("dfx/DiscordGateway")
+export type TypeId = typeof TypeId
 
 export interface DiscordGateway {
+  readonly [TypeId]: TypeId
+
   readonly dispatch: Stream.Stream<
     never,
     never,
@@ -54,50 +31,24 @@ export interface DiscordGateway {
   ) => Effect.Effect<never, never, boolean>
   readonly shards: Effect.Effect<never, never, HashSet.HashSet<RunningShard>>
 }
-export const DiscordGateway = Tag<DiscordGateway>()
+
+export const DiscordGateway = Tag<DiscordGateway>(TypeId)
 
 export const make = Effect.gen(function* (_) {
   const sharder = yield* _(Sharder)
-  const hub = yield* _(
-    PubSub.unbounded<Discord.GatewayPayload<Discord.ReceiveEvent>>(),
-  )
-
-  const sendQueue = yield* _(
-    Queue.unbounded<Discord.GatewayPayload<Discord.SendEvent>>(),
-  )
-  const send = (payload: Discord.GatewayPayload<Discord.SendEvent>) =>
-    sendQueue.offer(payload)
-
-  const dispatch = Stream.fromPubSub(hub)
-  const fromDispatch = fromDispatchFactory(dispatch)
-  const handleDispatch = handleDispatchFactory(hub)
-
-  yield* _(
-    sharder.run(hub, sendQueue),
-    Effect.tapErrorCause(_ => Effect.logError("fatal error, restarting", _)),
-    Effect.retry(
-      Schedule.exponential("1 seconds").pipe(
-        Schedule.union(Schedule.spaced("30 seconds")),
-      ),
-    ),
-    Effect.forkScoped,
-  )
+  const messaging = yield* _(Messaging)
 
   return DiscordGateway.of({
-    dispatch,
-    fromDispatch,
-    handleDispatch,
-    send,
+    [TypeId]: TypeId,
+    dispatch: messaging.dispatch,
+    fromDispatch: messaging.fromDispatch,
+    handleDispatch: messaging.handleDispatch,
+    send: messaging.send,
     shards: sharder.shards,
   })
-}).pipe(
-  Effect.annotateLogs({
-    package: "dfx",
-    service: "DiscordGateway",
-  }),
-)
+})
 
-export const DiscordGatewayLive = Layer.provide(
-  Layer.scoped(DiscordGateway, make),
-  SharedLive,
+export const DiscordGatewayLive = Layer.effect(DiscordGateway, make).pipe(
+  Layer.provide(MesssagingLive),
+  Layer.provide(SharderLive),
 )

package/src/DiscordREST.ts

@@ -16,7 +16,6 @@ import {
   retryAfter,
   routeFromConfig,
 } from "dfx/DiscordREST/utils"
-import { Log } from "dfx/Log"
 import { RateLimiterLive, RateLimiter, RateLimitStore } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
 import { LIB_VERSION } from "dfx/version"
@@ -33,7 +32,6 @@ const make = Effect.gen(function* (_) {
   const { rest, token } = yield* _(DiscordConfig)
 
   const http = yield* _(Http.client.Client)
-  const log = yield* _(Log)
   const store = yield* _(RateLimitStore)
   const { maybeWait } = yield* _(RateLimiter)
 
@@ -47,14 +45,13 @@ const make = Effect.gen(function* (_) {
   const badRoutesRef = yield* _(Ref.make(HashSet.empty<string>()))
   const tenMinutes = Duration.toMillis(Duration.minutes(10))
   const addBadRoute = (route: string) =>
-    log
-      .info("DiscordREST", "addBadRoute", route)
-      .pipe(
-        Effect.zipRight(Ref.update(badRoutesRef, HashSet.add(route))),
-        Effect.zipRight(
-          store.incrementCounter("dfx.rest.invalid", tenMinutes, 10000),
-        ),
-      )
+    Effect.logDebug("bad route").pipe(
+      Effect.zipRight(Ref.update(badRoutesRef, HashSet.add(route))),
+      Effect.zipRight(
+        store.incrementCounter("dfx.rest.invalid", tenMinutes, 10000),
+      ),
+      Effect.annotateLogs("route", route),
+    )
   const isBadRoute = (route: string) =>
     Effect.map(Ref.get(badRoutesRef), HashSet.has(route))
   const removeBadRoute = (route: string) =>
@@ -181,7 +178,11 @@ const make = Effect.gen(function* (_) {
             return Effect.zipRight(
               Effect.all(
                 [
-                  log.info("DiscordREST", "403", request.url),
+                  Effect.annotateLogs(
+                    Effect.logDebug("403"),
+                    "url",
+                    request.url,
+                  ),
                   addBadRoute(routeFromConfig(request.url, request.method)),
                   updateBuckets(request, response),
                 ],
@@ -191,26 +192,32 @@ const make = Effect.gen(function* (_) {
             )
 
           case 429:
-            return log
-              .info("DiscordREST", "429", request.url)
-              .pipe(
-                Effect.zipRight(
-                  addBadRoute(routeFromConfig(request.url, request.method)),
-                ),
-                Effect.zipRight(updateBuckets(request, response)),
-                Effect.zipRight(
-                  Effect.sleep(
-                    Option.getOrElse(retryAfter(response.headers), () =>
-                      Duration.seconds(5),
-                    ),
+            return Effect.annotateLogs(
+              Effect.logDebug("429"),
+              "url",
+              request.url,
+            ).pipe(
+              Effect.zipRight(
+                addBadRoute(routeFromConfig(request.url, request.method)),
+              ),
+              Effect.zipRight(updateBuckets(request, response)),
+              Effect.zipRight(
+                Effect.sleep(
+                  Option.getOrElse(retryAfter(response.headers), () =>
+                    Duration.seconds(5),
                   ),
                 ),
-                Effect.zipRight(executor<A>(request)),
-              )
+              ),
+              Effect.zipRight(executor<A>(request)),
+            )
         }
 
         return Effect.fail(e)
       }),
+      Effect.annotateLogs({
+        package: "dfx",
+        module: "DiscordREST",
+      }),
     )
 
   const routes = Discord.createRoutes<Partial<Http.request.Options.NoUrl>>(
@@ -246,14 +253,20 @@ const make = Effect.gen(function* (_) {
   }
 })
 
-export interface DiscordREST
+export interface DiscordREST {
+  readonly _: unique symbol
+}
+
+export interface DiscordRESTService
   extends Discord.Endpoints<Partial<Http.request.Options.NoUrl>> {
   readonly executor: <A = unknown>(
     request: Http.request.ClientRequest,
   ) => Effect.Effect<never, DiscordRESTError, ResponseWithData<A>>
 }
 
-export const DiscordREST = Tag<DiscordREST>()
+export const DiscordREST = Tag<DiscordREST, DiscordRESTService>(
+  "dfx/DiscordREST",
+)
 export const DiscordRESTLive = Layer.effect(DiscordREST, make).pipe(
   Layer.provide(RateLimiterLive),
   Layer.provide(Http.client.layer),

package/src/Interactions/context.ts

@@ -6,20 +6,57 @@ import * as Effect from "effect/Effect"
 import * as IxHelpers from "dfx/Helpers/interactions"
 import type * as Discord from "dfx/types"
 
-export const Interaction = Tag<Discord.Interaction>()
-export const ApplicationCommand = Tag<Discord.ApplicationCommandDatum>()
-export const MessageComponentData = Tag<Discord.MessageComponentDatum>()
-export const ModalSubmitData = Tag<Discord.ModalSubmitDatum>()
+export interface DiscordInteraction {
+  readonly _: unique symbol
+}
+export const Interaction = Tag<DiscordInteraction, Discord.Interaction>(
+  "dfx/Interactions/Interaction",
+)
+
+export interface DiscordApplicationCommand {
+  readonly _: unique symbol
+}
+export const ApplicationCommand = Tag<
+  DiscordApplicationCommand,
+  Discord.ApplicationCommandDatum
+>("dfx/Interactions/ApplicationCommand")
+
+export interface DiscordMessageComponent {
+  readonly _: unique symbol
+}
+export const MessageComponentData = Tag<
+  DiscordMessageComponent,
+  Discord.MessageComponentDatum
+>("dfx/Interactions/MessageComponentData")
 
+export interface DiscordModalSubmit {
+  readonly _: unique symbol
+}
+export const ModalSubmitData = Tag<
+  DiscordModalSubmit,
+  Discord.ModalSubmitDatum
+>("dfx/Interactions/ModalSubmitData")
+
+export interface DiscordFocusedOption {
+  readonly _: unique symbol
+}
 export interface FocusedOptionContext {
   readonly focusedOption: Discord.ApplicationCommandInteractionDataOption
 }
-export const FocusedOptionContext = Tag<FocusedOptionContext>()
+export const FocusedOptionContext = Tag<
+  DiscordFocusedOption,
+  FocusedOptionContext
+>("dfx/Interactions/FocusedOptionContext")
 
+export interface DiscordSubCommand {
+  readonly _: unique symbol
+}
 export interface SubCommandContext {
   readonly command: Discord.ApplicationCommandInteractionDataOption
 }
-export const SubCommandContext = Tag<SubCommandContext>()
+export const SubCommandContext = Tag<DiscordSubCommand, SubCommandContext>(
+  "dfx/Interactions/SubCommandContext",
+)
 
 export class ResolvedDataNotFound {
   readonly _tag = "ResolvedDataNotFound"
@@ -31,7 +68,7 @@ export class ResolvedDataNotFound {
 
 export const resolvedValues = <A>(
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-): Effect.Effect<Discord.Interaction, ResolvedDataNotFound, ReadonlyArray<A>> =>
+): Effect.Effect<DiscordInteraction, ResolvedDataNotFound, ReadonlyArray<A>> =>
   Effect.flatMap(Interaction, ix =>
     Effect.mapError(
       IxHelpers.resolveValues(f)(ix),
@@ -42,7 +79,7 @@ export const resolvedValues = <A>(
 export const resolved = <A>(
   name: string,
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-): Effect.Effect<Discord.Interaction, ResolvedDataNotFound, A> =>
+): Effect.Effect<DiscordInteraction, ResolvedDataNotFound, A> =>
   Effect.flatMap(Interaction, ix =>
     Effect.mapError(
       IxHelpers.resolveOptionValue(name, f)(ix),
@@ -101,13 +138,13 @@ export const handleSubCommands = <
   )
 
 export const currentSubCommand: Effect.Effect<
-  SubCommandContext,
+  DiscordSubCommand,
   never,
   Discord.ApplicationCommandInteractionDataOption
 > = Effect.map(SubCommandContext, _ => _.command)
 
 export const optionsMap: Effect.Effect<
-  Discord.ApplicationCommandDatum,
+  DiscordApplicationCommand,
   never,
   HashMap.HashMap<string, string | undefined>
 > = Effect.map(ApplicationCommand, IxHelpers.optionsMap)

package/src/Interactions/definitions.ts

@@ -1,7 +1,11 @@
 import type * as Option from "effect/Option"
 import type * as Effect from "effect/Effect"
 import type {
-  FocusedOptionContext,
+  DiscordApplicationCommand,
+  DiscordFocusedOption,
+  DiscordInteraction,
+  DiscordMessageComponent,
+  DiscordModalSubmit,
   ResolvedDataNotFound,
   SubCommandContext,
 } from "dfx/Interactions/context"
@@ -32,7 +36,7 @@ export const global = <
   handle: CommandHandler<R, E, A>,
 ) =>
   new GlobalApplicationCommand<
-    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
+    Exclude<R, DiscordInteraction | DiscordApplicationCommand>,
     E
   >(command as any, handle as any)
 
@@ -54,7 +58,7 @@ export const guild = <
   handle: CommandHandler<R, E, A>,
 ) =>
   new GuildApplicationCommand<
-    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
+    Exclude<R, DiscordInteraction | DiscordApplicationCommand>,
     E
   >(command as any, handle as any)
 
@@ -71,7 +75,7 @@ export const messageComponent = <R1, R2, E1, E2>(
   handle: CommandHandler<R2, E2, Discord.InteractionResponse>,
 ) =>
   new MessageComponent<
-    Exclude<R1 | R2, Discord.Interaction | Discord.MessageComponentDatum>,
+    Exclude<R1 | R2, DiscordInteraction | DiscordMessageComponent>,
     E1 | E2
   >(pred as any, handle as any)
 
@@ -88,7 +92,7 @@ export const modalSubmit = <R1, R2, E1, E2>(
   handle: Effect.Effect<R2, E2, Discord.InteractionResponse>,
 ) =>
   new ModalSubmit<
-    Exclude<R1 | R2, Discord.Interaction | Discord.ModalSubmitDatum>,
+    Exclude<R1 | R2, DiscordInteraction | DiscordModalSubmit>,
     E1 | E2
   >(pred as any, handle as any)
 
@@ -113,9 +117,7 @@ export const autocomplete = <R1, R2, E1, E2>(
   new Autocomplete<
     Exclude<
       R1 | R2,
-      | Discord.Interaction
-      | Discord.ApplicationCommandDatum
-      | FocusedOptionContext
+      DiscordInteraction | DiscordApplicationCommand | DiscordFocusedOption
     >,
     E1 | E2
   >(pred as any, handle as any)
@@ -124,10 +126,10 @@ export const autocomplete = <R1, R2, E1, E2>(
 type DeepReadonly<T> = T extends Array<infer R>
   ? ReadonlyArray<DeepReadonly<R>>
   : T extends Function
-  ? T
-  : T extends object
-  ? DeepReadonlyObject<T>
-  : T
+    ? T
+    : T extends object
+      ? DeepReadonlyObject<T>
+      : T
 type DeepReadonlyObject<T> = {
   readonly [P in keyof T]: DeepReadonly<T[P]>
 }
@@ -140,24 +142,24 @@ export interface CommandHelper<A> {
   resolve: <T>(
     name: AllResolvables<A>["name"],
     f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-  ) => Effect.Effect<Discord.Interaction, ResolvedDataNotFound, T>
+  ) => Effect.Effect<DiscordInteraction, ResolvedDataNotFound, T>
 
   option: (
     name: AllCommandOptions<A>["name"],
   ) => Effect.Effect<
-    Discord.ApplicationCommandDatum,
+    DiscordApplicationCommand,
     never,
     Option.Option<Discord.ApplicationCommandInteractionDataOption>
   >
 
   optionValue: <N extends AllRequiredCommandOptions<A>["name"]>(
     name: N,
-  ) => Effect.Effect<Discord.ApplicationCommandDatum, never, CommandValue<A, N>>
+  ) => Effect.Effect<DiscordApplicationCommand, never, CommandValue<A, N>>
 
   optionValueOptional: <N extends AllCommandOptions<A>["name"]>(
     name: N,
   ) => Effect.Effect<
-    Discord.ApplicationCommandDatum,
+    DiscordApplicationCommand,
     never,
     Option.Option<CommandValue<A, N>>
   >
@@ -180,8 +182,8 @@ export interface CommandHelper<A> {
           : never,
         SubCommandContext
       >
-    | Discord.Interaction
-    | Discord.ApplicationCommandDatum,
+    | DiscordInteraction
+    | DiscordApplicationCommand,
     [NER[keyof NER]] extends [
       { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
     ]
@@ -208,8 +210,8 @@ type SubCommands<A> = A extends {
 }
   ? A
   : A extends { readonly options: ReadonlyArray<CommandOption> }
-  ? SubCommands<A["options"][number]>
-  : never
+    ? SubCommands<A["options"][number]>
+    : never
 
 type SubCommandNames<A> = Option<SubCommands<A>>["name"]
 

package/src/Interactions/gateway.ts

@@ -16,9 +16,11 @@ import type {
 } from "dfx/Interactions/definitions"
 import type { DefinitionNotFound } from "dfx/Interactions/handlers"
 import { handlers } from "dfx/Interactions/handlers"
-import type { InteractionBuilder } from "dfx/Interactions/index"
+import type {
+  DiscordInteraction,
+  InteractionBuilder,
+} from "dfx/Interactions/index"
 import { builder, Interaction } from "dfx/Interactions/index"
-import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
 import * as Schedule from "effect/Schedule"
 import { globalValue } from "effect/GlobalValue"
@@ -36,7 +38,7 @@ export const run =
   <R, R2, E, TE, E2>(
     postHandler: (
       effect: Effect.Effect<
-        R | DiscordREST | Discord.Interaction,
+        R | DiscordREST | DiscordInteraction,
         TE | DiscordRESTError | DefinitionNotFound,
         void
       >,
@@ -45,7 +47,7 @@ export const run =
   (
     ix: InteractionBuilder<R, E, TE>,
   ): Effect.Effect<
-    DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
+    DiscordREST | DiscordGateway | Exclude<R2, DiscordInteraction>,
     E2 | DiscordRESTError | Http.error.ResponseError,
     never
   > =>
@@ -155,13 +157,19 @@ const makeRegistry = Effect.gen(function* (_) {
   }),
 )
 
-export interface InteractionsRegistry {
+export interface InteractionsRegistryService {
   readonly register: <E>(
     ix: InteractionBuilder<never, E, never>,
   ) => Effect.Effect<never, never, void>
 }
+export interface InteractionsRegistry {
+  readonly _: unique symbol
+}
 
-export const InteractionsRegistry = Tag<InteractionsRegistry>()
+export const InteractionsRegistry = Tag<
+  InteractionsRegistry,
+  InteractionsRegistryService
+>("dfx/Interactions/InteractionsRegistry")
 export const InteractionsRegistryLive = Layer.scoped(
   InteractionsRegistry,
   makeRegistry,

package/src/Interactions/handlers.ts

@@ -13,7 +13,7 @@ export class DefinitionNotFound {
 }
 
 type Handler<R, E, A> = Effect.Effect<
-  R | Discord.Interaction,
+  R | Ctx.DiscordInteraction,
   E | DefinitionNotFound,
   A
 >