dfx 0.86.0 → 0.88.0

package/src/DiscordGateway/DiscordWS.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Ref from "effect/Ref"
@@ -12,8 +12,8 @@ export interface OpenOpts {
   url?: string
   version?: number
   encoding?: DiscordWSCodec
-  outbound: Effect.Effect<never, never, Message>
-  onConnecting?: Effect.Effect<never, never, void>
+  outbound: Effect.Effect<Message>
+  onConnecting?: Effect.Effect<void>
 }
 
 export interface DiscordWSCodecService {
@@ -24,7 +24,7 @@ export interface DiscordWSCodecService {
 export interface DiscordWSCodec {
   readonly _: unique symbol
 }
-export const DiscordWSCodec = Tag<DiscordWSCodec, DiscordWSCodecService>(
+export const DiscordWSCodec = GenericTag<DiscordWSCodec, DiscordWSCodecService>(
   "dfx/DiscordGateway/DiscordWS/Codec",
 )
 export const JsonDiscordWSCodecLive = Layer.succeed(DiscordWSCodec, {
@@ -76,9 +76,10 @@ const make = Effect.gen(function* (_) {
 export interface DiscordWS {
   readonly _: unique symbol
 }
-export const DiscordWS = Tag<DiscordWS, Effect.Effect.Success<typeof make>>(
-  "dfx/DiscordGateway/DiscordWS",
-)
+export const DiscordWS = GenericTag<
+  DiscordWS,
+  Effect.Effect.Success<typeof make>
+>("dfx/DiscordGateway/DiscordWS")
 export const DiscordWSLive = Layer.provide(
   Layer.effect(DiscordWS, make),
   WSLive,

package/src/DiscordGateway/Messaging.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as PubSub from "effect/PubSub"
 import * as Layer from "effect/Layer"
@@ -9,11 +9,11 @@ import * as EffectUtils from "dfx/utils/Effect"
 
 const fromDispatchFactory =
   <R, E>(
-    source: Stream.Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>,
+    source: Stream.Stream<Discord.GatewayPayload<Discord.ReceiveEvent>, E, R>,
   ) =>
   <K extends keyof Discord.ReceiveEvents>(
     event: K,
-  ): Stream.Stream<R, E, Discord.ReceiveEvents[K]> =>
+  ): Stream.Stream<Discord.ReceiveEvents[K], E, R> =>
     Stream.map(
       Stream.filter(source, p => p.t === event),
       p => p.d! as any,
@@ -23,8 +23,8 @@ 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> =>
+    handle: (event: Discord.ReceiveEvents[K]) => Effect.Effect<A, E, R>,
+  ): Effect.Effect<never, E, R> =>
     EffectUtils.subscribeForEachPar(hub, _ => {
       if (_.t === event) {
         return handle(_.d as any)
@@ -66,7 +66,8 @@ export const make = Effect.gen(function* (_) {
 export interface Messsaging {
   readonly _: unique symbol
 }
-export const Messaging = Tag<Messsaging, Effect.Effect.Success<typeof make>>(
-  "dfx/DiscordGateway/Messaging",
-)
+export const Messaging = GenericTag<
+  Messsaging,
+  Effect.Effect.Success<typeof make>
+>("dfx/DiscordGateway/Messaging")
 export const MesssagingLive = Layer.scoped(Messaging, make)

package/src/DiscordGateway/Shard/heartbeats.ts

@@ -21,7 +21,7 @@ const payloadOrReconnect = (
 ) =>
   Effect.flatMap(
     Ref.get(ref),
-    (acked): Effect.Effect<never, never, DiscordWS.Message> =>
+    (acked): Effect.Effect<DiscordWS.Message> =>
       acked ? payload(seqRef) : Effect.succeed(Reconnect),
   )
 
@@ -29,7 +29,7 @@ export const send = (
   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>,
+  send: (p: DiscordWS.Message) => Effect.Effect<boolean>,
 ) =>
   Effect.flatMap(Ref.make(true), ackedRef => {
     const heartbeats = EffectU.foreverSwitch(

package/src/DiscordGateway/Shard/identify.ts

@@ -42,8 +42,6 @@ export const identifyOrResume = (
   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>
 > =>

package/src/DiscordGateway/Shard/invalidSession.ts

@@ -8,5 +8,5 @@ import type * as Discord from "dfx/types"
 export const fromPayload = (
   p: Discord.GatewayPayload,
   latestReady: Ref.Ref<Option.Option<Discord.ReadyEvent>>,
-): Effect.Effect<never, never, Message> =>
+): Effect.Effect<Message> =>
   Effect.as(p.d ? Effect.unit : Ref.set(latestReady, Option.none()), Reconnect)

package/src/DiscordGateway/Shard/utils.ts

@@ -5,10 +5,10 @@ import * as Stream from "effect/Stream"
 import type * as Discord from "dfx/types"
 
 export const opCode =
-  <R, E>(source: Stream.Stream<R, E, Discord.GatewayPayload>) =>
+  <R, E>(source: Stream.Stream<Discord.GatewayPayload, E, R>) =>
   <T = any>(
     code: Discord.GatewayOpcode,
-  ): Stream.Stream<R, E, Discord.GatewayPayload<T>> =>
+  ): Stream.Stream<Discord.GatewayPayload<T>, E, R> =>
     source.pipe(
       Stream.filter((p): p is Discord.GatewayPayload<T> => p.op === code),
     )
@@ -18,7 +18,7 @@ const maybeUpdateRef =
     f: (p: Discord.GatewayPayload) => Option.Option<T>,
     ref: Ref.Ref<Option.Option<T>>,
   ) =>
-  (_: Discord.GatewayPayload): Effect.Effect<never, never, void> =>
+  (_: Discord.GatewayPayload): Effect.Effect<void> =>
     Option.match(f(_), {
       onNone: () => Effect.unit,
       onSome: a => Ref.set(ref, Option.some(a)),
@@ -27,11 +27,9 @@ const maybeUpdateRef =
 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>,
+    (_: Discord.GatewayPayload<any>) => Effect.Effect<void>,
   ]
 > =>
   Effect.map(

package/src/DiscordGateway/Shard.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 Option from "effect/Option"
@@ -207,7 +207,7 @@ type ShardService = Effect.Effect.Success<typeof make>
 export interface Shard {
   readonly _: unique symbol
 }
-export const Shard = Tag<Shard, ShardService>("dfx/DiscordGateway/Shard")
+export const Shard = GenericTag<Shard, ShardService>("dfx/DiscordGateway/Shard")
 export const ShardLive = Layer.effect(Shard, make).pipe(
   Layer.provide(DiscordWSLive),
   Layer.provide(MesssagingLive),

package/src/DiscordGateway/ShardStore.ts

@@ -1,4 +1,4 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
@@ -9,16 +9,14 @@ export interface ClaimIdContext {
 }
 
 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>
+  claimId: (ctx: ClaimIdContext) => Effect.Effect<Option.Option<number>>
+  allClaimed: (totalCount: number) => Effect.Effect<boolean>
+  heartbeat?: (shardId: number) => Effect.Effect<void>
 }
 export interface ShardStore {
   readonly _: unique symbol
 }
-export const ShardStore = Tag<ShardStore, ShardStoreService>(
+export const ShardStore = GenericTag<ShardStore, ShardStoreService>(
   "dfx/DiscordGateway/ShardStore",
 )
 

package/src/DiscordGateway/Sharder.ts

@@ -5,7 +5,7 @@ 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 { GenericTag } from "effect/Context"
 import * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
@@ -47,7 +47,7 @@ const make = Effect.gen(function* (_) {
 
   const totalCount = config.shardCount ?? gateway.shards
   const currentCount = yield* _(Ref.make(0))
-  const claimId = (sharderCount: number): Effect.Effect<never, never, number> =>
+  const claimId = (sharderCount: number): Effect.Effect<number> =>
     pipe(
       store.claimId({
         totalCount,
@@ -59,7 +59,13 @@ const make = Effect.gen(function* (_) {
   const takeConfig = pipe(
     Ref.getAndUpdate(currentCount, _ => _ + 1),
     Effect.flatMap(claimId),
-    Effect.map(id => ({ id, totalCount }) as const),
+    Effect.map(
+      id =>
+        ({
+          id,
+          totalCount,
+        }) as const,
+    ),
   )
 
   const spawner = pipe(
@@ -105,7 +111,7 @@ const make = Effect.gen(function* (_) {
 export interface Sharder {
   readonly _: unique symbol
 }
-export const Sharder = Tag<Sharder, Effect.Effect.Success<typeof make>>(
+export const Sharder = GenericTag<Sharder, Effect.Effect.Success<typeof make>>(
   "dfx/DiscordGateway/Sharder",
 )
 export const SharderLive = Layer.scoped(Sharder, make).pipe(

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,7 +75,7 @@ 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,
         })
@@ -87,10 +87,7 @@ const waitForOpen = (
     },
   )
 
-const send = (
-  ws: globalThis.WebSocket,
-  take: Effect.Effect<never, never, Message>,
-) =>
+const send = (ws: globalThis.WebSocket, take: Effect.Effect<Message>) =>
   pipe(
     take,
     Effect.tap(data => Effect.logTrace(data)),
@@ -119,8 +116,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 +179,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

@@ -1,13 +1,14 @@
 import type * as Effect from "effect/Effect"
 import type * as Http from "@effect/platform/HttpClient"
 import type { DiscordRESTError } from "dfx/DiscordREST"
+import type { Scope } from "effect/Scope"
 
 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 interface RestResponse<T>
+  extends Effect.Effect<ResponseWithData<T>, DiscordRESTError, Scope> {
+  readonly json: Effect.Effect<T, DiscordRESTError | Http.error.ResponseError>
+  readonly asUnit: Effect.Effect<void, 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"
@@ -19,6 +19,8 @@ import {
 import { RateLimiterLive, RateLimiter, RateLimitStore } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
 import { LIB_VERSION } from "dfx/version"
+import type { Scope } from "effect/Scope"
+import * as Effectable from "effect/Effectable"
 
 export class DiscordRESTError {
   readonly _tag = "DiscordRESTError"
@@ -155,14 +157,14 @@ const make = Effect.gen(function* (_) {
 
   const executor = <A = unknown>(
     request: Http.request.ClientRequest,
-  ): Effect.Effect<never, DiscordRESTError, ResponseWithData<A>> =>
+  ): Effect.Effect<ResponseWithData<A>, DiscordRESTError, Scope> =>
     requestRateLimit(request.url, request).pipe(
       Effect.zipLeft(globalRateLimit),
       Effect.zipRight(
         httpExecutor(request) as Effect.Effect<
-          never,
+          ResponseWithData<A>,
           DiscordRESTError,
-          ResponseWithData<A>
+          Scope
         >,
       ),
       Effect.tap(response => updateBuckets(request, response)),
@@ -243,7 +245,7 @@ const make = Effect.gen(function* (_) {
         request = Http.request.unsafeJsonBody(request, params)
       }
 
-      return executor(request)
+      return new RestResponseImpl(executor(request))
     },
   )
 
@@ -253,6 +255,33 @@ const make = Effect.gen(function* (_) {
   }
 })
 
+class RestResponseImpl<T>
+  extends Effectable.Class<ResponseWithData<T>, DiscordRESTError, Scope>
+  implements RestResponse<T>
+{
+  constructor(
+    readonly response: Effect.Effect<
+      ResponseWithData<T>,
+      DiscordRESTError,
+      Scope
+    >,
+  ) {
+    super()
+  }
+
+  commit(): Effect.Effect<ResponseWithData<T>, DiscordRESTError, Scope> {
+    return this.response
+  }
+
+  get json() {
+    return Effect.scoped(Effect.flatMap(this.response, _ => _.json))
+  }
+
+  get asUnit() {
+    return Effect.scoped(this.response)
+  }
+}
+
 export interface DiscordREST {
   readonly _: unique symbol
 }
@@ -261,10 +290,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, Scope>
 }
 
-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,9 +54,10 @@ export interface DiscordSubCommand {
 export interface SubCommandContext {
   readonly command: Discord.ApplicationCommandInteractionDataOption
 }
-export const SubCommandContext = Tag<DiscordSubCommand, SubCommandContext>(
-  "dfx/Interactions/SubCommandContext",
-)
+export const SubCommandContext = GenericTag<
+  DiscordSubCommand,
+  SubCommandContext
+>("dfx/Interactions/SubCommandContext")
 
 export class ResolvedDataNotFound {
   readonly _tag = "ResolvedDataNotFound"
@@ -68,7 +69,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 +80,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,11 +101,18 @@ 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<
+  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 } },
@@ -114,14 +122,7 @@ export const handleSubCommands = <
       SubCommandContext
     >
   | Discord.Interaction
-  | Discord.ApplicationCommandDatum,
-  | ([NER[keyof NER]] extends [
-      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-    ]
-      ? E
-      : never)
-  | SubCommandNotFound,
-  Discord.InteractionResponse
+  | Discord.ApplicationCommandDatum
 > =>
   ApplicationCommand.pipe(
     Effect.flatMap(data =>
@@ -138,15 +139,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 {