dfx 0.86.0 → 0.87.0

package/src/DiscordGateway/WS.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import type * as Duration from "effect/Duration"
 import { identity, pipe } from "effect/Function"
 import * as Effect from "effect/Effect"
@@ -51,7 +51,7 @@ const offer = (
   ws: globalThis.WebSocket,
   queue: Queue.Enqueue<WebSocket.Data>,
 ) =>
-  Effect.async<never, WebSocketError | WebSocketCloseError, never>(resume => {
+  Effect.async<never, WebSocketError | WebSocketCloseError>(resume => {
     ws.addEventListener("message", message => {
       Queue.unsafeOffer(queue, message.data)
     })
@@ -75,11 +75,11 @@ const waitForOpen = (
         return Effect.unit
       }
 
-      return Effect.async<never, never, void>(resume => {
+      return Effect.async<void>(resume => {
         ws.addEventListener("open", () => resume(Effect.unit), {
           once: true,
         })
-      })
+      });
     }),
     {
       onTimeout: () => new WebSocketError("open-timeout"),
@@ -89,7 +89,7 @@ const waitForOpen = (
 
 const send = (
   ws: globalThis.WebSocket,
-  take: Effect.Effect<never, never, Message>,
+  take: Effect.Effect<Message>,
 ) =>
   pipe(
     take,
@@ -119,8 +119,8 @@ const wsImpl = {
     urlRef,
   }: {
     readonly urlRef: Ref.Ref<string>
-    readonly takeOutbound: Effect.Effect<never, never, Message>
-    readonly onConnecting?: Effect.Effect<never, never, void>
+    readonly takeOutbound: Effect.Effect<Message>
+    readonly onConnecting?: Effect.Effect<void>
     readonly openTimeout?: Duration.DurationInput
     readonly reconnectWhen?: Predicate<WebSocketError | WebSocketCloseError>
   }) =>
@@ -182,5 +182,5 @@ const wsImpl = {
 export interface WS {
   readonly _: unique symbol
 }
-export const WS = Tag<WS, typeof wsImpl>("dfx/DiscordGateway/WS")
+export const WS = GenericTag<WS, typeof wsImpl>("dfx/DiscordGateway/WS")
 export const WSLive = Layer.succeed(WS, wsImpl)

package/src/DiscordGateway.ts

@@ -2,7 +2,7 @@ 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 { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import type * as HashSet from "effect/HashSet"
 import * as Layer from "effect/Layer"
@@ -14,25 +14,21 @@ export type TypeId = typeof TypeId
 export interface DiscordGateway {
   readonly [TypeId]: TypeId
 
-  readonly dispatch: Stream.Stream<
-    never,
-    never,
-    Discord.GatewayPayload<Discord.ReceiveEvent>
-  >
+  readonly dispatch: Stream.Stream<Discord.GatewayPayload<Discord.ReceiveEvent>>
   readonly fromDispatch: <K extends keyof Discord.ReceiveEvents>(
     event: K,
-  ) => Stream.Stream<never, never, Discord.ReceiveEvents[K]>
+  ) => Stream.Stream<Discord.ReceiveEvents[K]>
   readonly handleDispatch: <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>
+    handle: (event: Discord.ReceiveEvents[K]) => Effect.Effect<A, E, R>,
+  ) => Effect.Effect<never, E, R>
   readonly send: (
     payload: Discord.GatewayPayload<Discord.SendEvent>,
-  ) => Effect.Effect<never, never, boolean>
-  readonly shards: Effect.Effect<never, never, HashSet.HashSet<RunningShard>>
+  ) => Effect.Effect<boolean>
+  readonly shards: Effect.Effect<HashSet.HashSet<RunningShard>>
 }
 
-export const DiscordGateway = Tag<DiscordGateway>(TypeId)
+export const DiscordGateway = GenericTag<DiscordGateway>("dfx/DiscordGateway")
 
 export const make = Effect.gen(function* (_) {
   const sharder = yield* _(Sharder)

package/src/DiscordREST/types.ts

@@ -3,11 +3,7 @@ import type * as Http from "@effect/platform/HttpClient"
 import type { DiscordRESTError } from "dfx/DiscordREST"
 
 export interface ResponseWithData<A> extends Http.response.ClientResponse {
-  readonly json: Effect.Effect<never, Http.error.ResponseError, A>
+  readonly json: Effect.Effect<A, Http.error.ResponseError>
 }
 
-export type RestResponse<T> = Effect.Effect<
-  never,
-  DiscordRESTError,
-  ResponseWithData<T>
->
+export type RestResponse<T> = Effect.Effect<ResponseWithData<T>, DiscordRESTError>

package/src/DiscordREST.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import { millis } from "effect/Duration"
 import { pipe } from "effect/Function"
@@ -155,15 +155,11 @@ const make = Effect.gen(function* (_) {
 
   const executor = <A = unknown>(
     request: Http.request.ClientRequest,
-  ): Effect.Effect<never, DiscordRESTError, ResponseWithData<A>> =>
+  ): Effect.Effect<ResponseWithData<A>, DiscordRESTError> =>
     requestRateLimit(request.url, request).pipe(
       Effect.zipLeft(globalRateLimit),
       Effect.zipRight(
-        httpExecutor(request) as Effect.Effect<
-          never,
-          DiscordRESTError,
-          ResponseWithData<A>
-        >,
+        httpExecutor(request) as Effect.Effect<ResponseWithData<A>, DiscordRESTError>,
       ),
       Effect.tap(response => updateBuckets(request, response)),
       Effect.catchTag("DiscordRESTError", e => {
@@ -261,10 +257,10 @@ 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>>
+  ) => Effect.Effect<ResponseWithData<A>, DiscordRESTError>
 }
 
-export const DiscordREST = Tag<DiscordREST, DiscordRESTService>(
+export const DiscordREST = GenericTag<DiscordREST, DiscordRESTService>(
   "dfx/DiscordREST",
 )
 export const DiscordRESTLive = Layer.effect(DiscordREST, make).pipe(

package/src/Helpers/permissions.ts

@@ -112,7 +112,7 @@ export const applyOverwrites =
 interface RolesCache<E> {
   getForParent: (
     parentId: string,
-  ) => Effect.Effect<never, E, ReadonlyMap<string, Discord.Role>>
+  ) => Effect.Effect<ReadonlyMap<string, Discord.Role>, E>
 }
 
 export const hasInChannel =

package/src/Interactions/builder.ts

@@ -24,12 +24,12 @@ export class InteractionBuilder<R, E, TE> {
         handler: D.InteractionDefinition<R, E>,
         transform: (
           self: Effect.Effect<any, any, any>,
-        ) => Effect.Effect<R, TE, void>,
+        ) => Effect.Effect<void, TE, R>,
       ]
     >,
     readonly transform: (
       self: Effect.Effect<any, any, any>,
-    ) => Effect.Effect<R, TE, void>,
+    ) => Effect.Effect<void, TE, R>,
   ) {}
 
   add<R1, E1>(definition: D.InteractionDefinition<R1, E1>) {
@@ -47,7 +47,7 @@ export class InteractionBuilder<R, E, TE> {
   }
 
   private transformTransform<R1, E1>(
-    f: (selr: Effect.Effect<R, TE, void>) => Effect.Effect<R1, E1, void>,
+    f: (selr: Effect.Effect<void, TE, R>) => Effect.Effect<void, E1, R1>,
   ) {
     return new InteractionBuilder<R1, E, E1>(
       Chunk.map(this.definitions, ([d, t]) => [d as any, _ => f(t(_)) as any]),
@@ -57,8 +57,8 @@ export class InteractionBuilder<R, E, TE> {
 
   private transformHandlers<R1, E1>(
     f: (
-      selr: Effect.Effect<R, E, Discord.InteractionResponse>,
-    ) => Effect.Effect<R1, E1, Discord.InteractionResponse>,
+      selr: Effect.Effect<Discord.InteractionResponse, E, R>,
+    ) => Effect.Effect<Discord.InteractionResponse, E1, R1>,
   ) {
     return new InteractionBuilder<
       R1,
@@ -79,7 +79,7 @@ export class InteractionBuilder<R, E, TE> {
   }
 
   catchAllCause<R1, E1>(
-    f: (cause: Cause.Cause<TE>) => Effect.Effect<R1, E1, void>,
+    f: (cause: Cause.Cause<TE>) => Effect.Effect<void, E1, R1>,
   ) {
     return this.transformTransform<R | R1, E1>(Effect.catchAllCause(f))
   }
@@ -87,24 +87,24 @@ export class InteractionBuilder<R, E, TE> {
   catchAllCauseRespond<R1, E1>(
     f: (
       cause: Cause.Cause<E>,
-    ) => Effect.Effect<R1, E1, Discord.InteractionResponse>,
+    ) => Effect.Effect<Discord.InteractionResponse, E1, R1>,
   ) {
     return this.transformHandlers<R | R1, E1>(Effect.catchAllCause(f))
   }
 
-  catchAll<R1, E1>(f: (error: TE) => Effect.Effect<R1, E1, void>) {
+  catchAll<R1, E1>(f: (error: TE) => Effect.Effect<void, E1, R1>) {
     return this.transformTransform<R | R1, E1>(Effect.catchAll(f))
   }
 
   catchAllRespond<R1, E1>(
-    f: (error: E) => Effect.Effect<R1, E1, Discord.InteractionResponse>,
+    f: (error: E) => Effect.Effect<Discord.InteractionResponse, E1, R1>,
   ) {
     return this.transformHandlers<R | R1, E1>(Effect.catchAll(f))
   }
 
   catchTag<T extends ExtractTag<E>, R1, E1>(
     tag: T,
-    f: (error: Extract<TE, { _tag: T }>) => Effect.Effect<R1, E1, void>,
+    f: (error: Extract<TE, { _tag: T }>) => Effect.Effect<void, E1, R1>,
   ) {
     return this.transformTransform<R | R1, Exclude<TE, { _tag: T }> | E1>(
       _ => catchTag(_ as any, tag, f as any) as any,
@@ -115,7 +115,7 @@ export class InteractionBuilder<R, E, TE> {
     tag: T,
     f: (
       error: Extract<E, { _tag: T }>,
-    ) => Effect.Effect<R1, E1, Discord.InteractionResponse>,
+    ) => Effect.Effect<Discord.InteractionResponse, E1, R1>,
   ) {
     return this.transformHandlers<R | R1, Exclude<E, { _tag: T }> | E1>(
       _ => catchTag(_ as any, tag, f as any) as any,

package/src/Interactions/context.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import type * as HashMap from "effect/HashMap"
 import * as Option from "effect/Option"
 import * as Arr from "effect/ReadonlyArray"
@@ -9,14 +9,14 @@ import type * as Discord from "dfx/types"
 export interface DiscordInteraction {
   readonly _: unique symbol
 }
-export const Interaction = Tag<DiscordInteraction, Discord.Interaction>(
+export const Interaction = GenericTag<DiscordInteraction, Discord.Interaction>(
   "dfx/Interactions/Interaction",
 )
 
 export interface DiscordApplicationCommand {
   readonly _: unique symbol
 }
-export const ApplicationCommand = Tag<
+export const ApplicationCommand = GenericTag<
   DiscordApplicationCommand,
   Discord.ApplicationCommandDatum
 >("dfx/Interactions/ApplicationCommand")
@@ -24,7 +24,7 @@ export const ApplicationCommand = Tag<
 export interface DiscordMessageComponent {
   readonly _: unique symbol
 }
-export const MessageComponentData = Tag<
+export const MessageComponentData = GenericTag<
   DiscordMessageComponent,
   Discord.MessageComponentDatum
 >("dfx/Interactions/MessageComponentData")
@@ -32,7 +32,7 @@ export const MessageComponentData = Tag<
 export interface DiscordModalSubmit {
   readonly _: unique symbol
 }
-export const ModalSubmitData = Tag<
+export const ModalSubmitData = GenericTag<
   DiscordModalSubmit,
   Discord.ModalSubmitDatum
 >("dfx/Interactions/ModalSubmitData")
@@ -43,7 +43,7 @@ export interface DiscordFocusedOption {
 export interface FocusedOptionContext {
   readonly focusedOption: Discord.ApplicationCommandInteractionDataOption
 }
-export const FocusedOptionContext = Tag<
+export const FocusedOptionContext = GenericTag<
   DiscordFocusedOption,
   FocusedOptionContext
 >("dfx/Interactions/FocusedOptionContext")
@@ -54,7 +54,7 @@ export interface DiscordSubCommand {
 export interface SubCommandContext {
   readonly command: Discord.ApplicationCommandInteractionDataOption
 }
-export const SubCommandContext = Tag<DiscordSubCommand, SubCommandContext>(
+export const SubCommandContext = GenericTag<DiscordSubCommand, SubCommandContext>(
   "dfx/Interactions/SubCommandContext",
 )
 
@@ -68,7 +68,7 @@ export class ResolvedDataNotFound {
 
 export const resolvedValues = <A>(
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-): Effect.Effect<DiscordInteraction, ResolvedDataNotFound, ReadonlyArray<A>> =>
+): Effect.Effect<ReadonlyArray<A>, ResolvedDataNotFound, DiscordInteraction> =>
   Effect.flatMap(Interaction, ix =>
     Effect.mapError(
       IxHelpers.resolveValues(f)(ix),
@@ -79,7 +79,7 @@ export const resolvedValues = <A>(
 export const resolved = <A>(
   name: string,
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-): Effect.Effect<DiscordInteraction, ResolvedDataNotFound, A> =>
+): Effect.Effect<A, ResolvedDataNotFound, DiscordInteraction> =>
   Effect.flatMap(Interaction, ix =>
     Effect.mapError(
       IxHelpers.resolveOptionValue(name, f)(ix),
@@ -100,29 +100,25 @@ export class SubCommandNotFound {
 export const handleSubCommands = <
   NER extends Record<
     string,
-    Effect.Effect<any, any, Discord.InteractionResponse>
+    Effect.Effect<Discord.InteractionResponse, any, any>
   >,
 >(
   commands: NER,
-): Effect.Effect<
-  | Exclude<
-      [NER[keyof NER]] extends [
-        { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
-      ]
-        ? R
-        : never,
-      SubCommandContext
-    >
-  | Discord.Interaction
-  | Discord.ApplicationCommandDatum,
-  | ([NER[keyof NER]] extends [
-      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
+): Effect.Effect<Discord.InteractionResponse, | ([NER[keyof NER]] extends [
+    { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
+  ]
+    ? E
+    : never)
+| SubCommandNotFound, | Exclude<
+    [NER[keyof NER]] extends [
+      { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
     ]
-      ? E
-      : never)
-  | SubCommandNotFound,
-  Discord.InteractionResponse
-> =>
+      ? R
+      : never,
+    SubCommandContext
+  >
+| Discord.Interaction
+| Discord.ApplicationCommandDatum> =>
   ApplicationCommand.pipe(
     Effect.flatMap(data =>
       Effect.mapError(
@@ -138,15 +134,15 @@ export const handleSubCommands = <
   )
 
 export const currentSubCommand: Effect.Effect<
-  DiscordSubCommand,
+  Discord.ApplicationCommandInteractionDataOption,
   never,
-  Discord.ApplicationCommandInteractionDataOption
+  DiscordSubCommand
 > = Effect.map(SubCommandContext, _ => _.command)
 
 export const optionsMap: Effect.Effect<
-  DiscordApplicationCommand,
+  HashMap.HashMap<string, string | undefined>,
   never,
-  HashMap.HashMap<string, string | undefined>
+  DiscordApplicationCommand
 > = Effect.map(ApplicationCommand, IxHelpers.optionsMap)
 
 export class RequiredOptionNotFound {

package/src/Interactions/definitions.ts

@@ -65,13 +65,13 @@ export const guild = <
 export class MessageComponent<R, E> {
   readonly _tag = "MessageComponent"
   constructor(
-    readonly predicate: (customId: string) => Effect.Effect<R, E, boolean>,
-    readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>,
+    readonly predicate: (customId: string) => Effect.Effect<boolean, E, R>,
+    readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
 export const messageComponent = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect.Effect<R1, E1, boolean>,
+  pred: (customId: string) => Effect.Effect<boolean, E1, R1>,
   handle: CommandHandler<R2, E2, Discord.InteractionResponse>,
 ) =>
   new MessageComponent<
@@ -82,14 +82,14 @@ export const messageComponent = <R1, R2, E1, E2>(
 export class ModalSubmit<R, E> {
   readonly _tag = "ModalSubmit"
   constructor(
-    readonly predicate: (customId: string) => Effect.Effect<R, E, boolean>,
-    readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>,
+    readonly predicate: (customId: string) => Effect.Effect<boolean, E, R>,
+    readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
 export const modalSubmit = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect.Effect<R1, E1, boolean>,
-  handle: Effect.Effect<R2, E2, Discord.InteractionResponse>,
+  pred: (customId: string) => Effect.Effect<boolean, E1, R1>,
+  handle: Effect.Effect<Discord.InteractionResponse, E2, R2>,
 ) =>
   new ModalSubmit<
     Exclude<R1 | R2, DiscordInteraction | DiscordModalSubmit>,
@@ -102,8 +102,8 @@ export class Autocomplete<R, E> {
     readonly predicate: (
       data: Discord.ApplicationCommandDatum,
       focusedOption: Discord.ApplicationCommandInteractionDataOption,
-    ) => Effect.Effect<R, E, boolean>,
-    readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>,
+    ) => Effect.Effect<boolean, E, R>,
+    readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
@@ -111,8 +111,8 @@ export const autocomplete = <R1, R2, E1, E2>(
   pred: (
     data: Discord.ApplicationCommandDatum,
     focusedOption: Discord.ApplicationCommandInteractionDataOption,
-  ) => Effect.Effect<R1, E1, boolean>,
-  handle: Effect.Effect<R2, E2, Discord.InteractionResponse>,
+  ) => Effect.Effect<boolean, E1, R1>,
+  handle: Effect.Effect<Discord.InteractionResponse, E2, R2>,
 ) =>
   new Autocomplete<
     Exclude<
@@ -135,33 +135,33 @@ type DeepReadonlyObject<T> = {
 }
 
 export type CommandHandler<R, E, A = any> =
-  | Effect.Effect<R, E, Discord.InteractionResponse>
+  | Effect.Effect<Discord.InteractionResponse, E, R>
   | CommandHandlerFn<R, E, A>
 
 export interface CommandHelper<A> {
   resolve: <T>(
     name: AllResolvables<A>["name"],
     f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-  ) => Effect.Effect<DiscordInteraction, ResolvedDataNotFound, T>
+  ) => Effect.Effect<T, ResolvedDataNotFound, DiscordInteraction>
 
   option: (
     name: AllCommandOptions<A>["name"],
   ) => Effect.Effect<
-    DiscordApplicationCommand,
+    Option.Option<Discord.ApplicationCommandInteractionDataOption>,
     never,
-    Option.Option<Discord.ApplicationCommandInteractionDataOption>
+    DiscordApplicationCommand
   >
 
   optionValue: <N extends AllRequiredCommandOptions<A>["name"]>(
     name: N,
-  ) => Effect.Effect<DiscordApplicationCommand, never, CommandValue<A, N>>
+  ) => Effect.Effect<CommandValue<A, N>, never, DiscordApplicationCommand>
 
   optionValueOptional: <N extends AllCommandOptions<A>["name"]>(
     name: N,
   ) => Effect.Effect<
-    DiscordApplicationCommand,
+    Option.Option<CommandValue<A, N>>,
     never,
-    Option.Option<CommandValue<A, N>>
+    DiscordApplicationCommand
   >
 
   subCommands: <
@@ -169,33 +169,29 @@ export interface CommandHelper<A> {
       ? never
       : Record<
           SubCommandNames<A>,
-          Effect.Effect<any, any, Discord.InteractionResponse>
+          Effect.Effect<Discord.InteractionResponse, any, any>
         >,
   >(
     commands: NER,
-  ) => Effect.Effect<
-    | Exclude<
-        [NER[keyof NER]] extends [
-          { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
-        ]
-          ? R
-          : never,
-        SubCommandContext
-      >
-    | DiscordInteraction
-    | DiscordApplicationCommand,
-    [NER[keyof NER]] extends [
-      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-    ]
-      ? E
-      : never,
-    Discord.InteractionResponse
-  >
+  ) => Effect.Effect<Discord.InteractionResponse, [NER[keyof NER]] extends [
+    { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
+  ]
+    ? E
+    : never, | Exclude<
+      [NER[keyof NER]] extends [
+        { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
+      ]
+        ? R
+        : never,
+      SubCommandContext
+    >
+  | DiscordInteraction
+  | DiscordApplicationCommand>
 }
 
 export type CommandHandlerFn<R, E, A> = (
   i: CommandHelper<A>,
-) => Effect.Effect<R, E, Discord.InteractionResponse>
+) => Effect.Effect<Discord.InteractionResponse, E, R>
 
 interface CommandOption {
   readonly type: any

package/src/Interactions/gateway.ts

@@ -1,5 +1,5 @@
 import * as Chunk from "effect/Chunk"
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import { pipe } from "effect/Function"
 import * as Effect from "effect/Effect"
@@ -37,20 +37,12 @@ export const setInteractionsSync = (enabled: boolean) =>
 export const run =
   <R, R2, E, TE, E2>(
     postHandler: (
-      effect: Effect.Effect<
-        R | DiscordREST | DiscordInteraction,
-        TE | DiscordRESTError | DefinitionNotFound,
-        void
-      >,
-    ) => Effect.Effect<R2, E2, void>,
+      effect: Effect.Effect<void, TE | DiscordRESTError | DefinitionNotFound, R | DiscordREST | DiscordInteraction>,
+    ) => Effect.Effect<void, E2, R2>,
   ) =>
   (
     ix: InteractionBuilder<R, E, TE>,
-  ): Effect.Effect<
-    DiscordREST | DiscordGateway | Exclude<R2, DiscordInteraction>,
-    E2 | DiscordRESTError | Http.error.ResponseError,
-    never
-  > =>
+  ): Effect.Effect<never, E2 | DiscordRESTError | Http.error.ResponseError, DiscordREST | DiscordGateway | Exclude<R2, DiscordInteraction>> =>
     Effect.gen(function* (_) {
       const GlobalApplicationCommand = ix.definitions.pipe(
         Chunk.map(_ => _[0]),
@@ -160,13 +152,13 @@ const makeRegistry = Effect.gen(function* (_) {
 export interface InteractionsRegistryService {
   readonly register: <E>(
     ix: InteractionBuilder<never, E, never>,
-  ) => Effect.Effect<never, never, void>
+  ) => Effect.Effect<void>
 }
 export interface InteractionsRegistry {
   readonly _: unique symbol
 }
 
-export const InteractionsRegistry = Tag<
+export const InteractionsRegistry = GenericTag<
   InteractionsRegistry,
   InteractionsRegistryService
 >("dfx/Interactions/InteractionsRegistry")

package/src/Interactions/handlers.ts

@@ -12,23 +12,19 @@ export class DefinitionNotFound {
   constructor(readonly interaction: Discord.Interaction) {}
 }
 
-type Handler<R, E, A> = Effect.Effect<
-  R | Ctx.DiscordInteraction,
-  E | DefinitionNotFound,
-  A
->
+type Handler<R, E, A> = Effect.Effect<A, E | DefinitionNotFound, R | Ctx.DiscordInteraction>
 
 export const handlers = <R, E, TE, A, B>(
   definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect.Effect<R, E, A>) => Effect.Effect<R, TE, B>,
+      transform: (self: Effect.Effect<A, E, R>) => Effect.Effect<B, TE, R>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect.Effect<R, E, A>,
+  ) => Effect.Effect<A, E, R>,
 ): Record<
   Discord.InteractionType,
   (i: Discord.Interaction) => Handler<R, E, B>

package/src/Interactions/utils.ts

@@ -10,7 +10,7 @@ export type DefinitionFlattened<R, E, TE, A> = D.InteractionDefinition<
 > extends infer D
   ? {
       [K in keyof D]: K extends "handle"
-        ? (_: Discord.Interaction) => Effect.Effect<R, TE, A>
+        ? (_: Discord.Interaction) => Effect.Effect<A, TE, R>
         : D[K]
     }
   : never
@@ -32,13 +32,13 @@ export const flattenDefinitions = <R, E, TE, A, B>(
   definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect.Effect<R, E, A>) => Effect.Effect<R, TE, B>,
+      transform: (self: Effect.Effect<A, E, R>) => Effect.Effect<B, TE, R>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect.Effect<R, E, A>,
+  ) => Effect.Effect<A, E, R>,
 ) =>
   Chunk.map(definitions, ([definition, transform]) => ({
     ...definition,
@@ -83,10 +83,10 @@ export const splitDefinitions = <R, E, TE, A>(
     Chunk.reduce(
       {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
       (acc, d) =>
-        ({
+        (({
           ...acc,
-          [d.command.name]: d,
-        }) as any,
+          [d.command.name]: d
+        }) as any),
     ),
   )