diff --git a/src/Interactions/context.ts b/src/Interactions/context.ts
index d0a6a58..cde89cb 100644
--- a/src/Interactions/context.ts
+++ b/src/Interactions/context.ts
@@ -43,12 +43,9 @@ export const ModalSubmitData = GenericTag<
 export interface DiscordFocusedOption {
   readonly _: unique symbol
 }
-export interface FocusedOptionContext {
-  readonly focusedOption: Discord.ApplicationCommandInteractionDataOption
-}
 export const FocusedOptionContext = GenericTag<
   DiscordFocusedOption,
-  FocusedOptionContext
+  Discord.ApplicationCommandInteractionDataOption
 >("dfx/Interactions/FocusedOptionContext")
 
 export interface DiscordSubCommand {
@@ -78,7 +75,7 @@ export const resolved = <A>(
 
 export const focusedOptionValue = Effect.map(
   FocusedOptionContext,
-  _ => _.focusedOption.value ?? "",
+  _ => _.value ?? "",
 )
 
 export class SubCommandNotFound extends TypeIdError(
diff --git a/src/Interactions/definitions.ts b/src/Interactions/definitions.ts
index 904716d..1693251 100644
--- a/src/Interactions/definitions.ts
+++ b/src/Interactions/definitions.ts
@@ -30,8 +30,7 @@ export class GlobalApplicationCommand<R, E> {
 export const global = <
   R,
   E,
-  const A extends
-    DeepReadonlyObject<Discord.CreateGlobalApplicationCommandParams>,
+  const A extends Discord.CreateGlobalApplicationCommandParams,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
@@ -52,8 +51,7 @@ export class GuildApplicationCommand<R, E> {
 export const guild = <
   R,
   E,
-  const A extends
-    DeepReadonlyObject<Discord.CreateGuildApplicationCommandParams>,
+  const A extends Discord.CreateGuildApplicationCommandParams,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
@@ -66,36 +64,36 @@ export const guild = <
 export class MessageComponent<R, E> {
   readonly _tag = "MessageComponent"
   constructor(
-    readonly predicate: (customId: string) => Effect.Effect<boolean, E, R>,
+    readonly predicate: (customId: string) => boolean,
     readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
-export const messageComponent = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect.Effect<boolean, E1, R1>,
-  handle: CommandHandler<R2, E2, Discord.InteractionResponse>,
+export const messageComponent = <R, E>(
+  pred: (customId: string) => boolean,
+  handle: CommandHandler<R, E, Discord.InteractionResponse>,
 ) =>
   new MessageComponent<
-    Exclude<R1 | R2, DiscordInteraction | DiscordMessageComponent | Scope>,
-    E1 | E2
-  >(pred as any, handle as any)
+    Exclude<R, DiscordInteraction | DiscordMessageComponent | Scope>,
+    E
+  >(pred, handle as any)
 
 export class ModalSubmit<R, E> {
   readonly _tag = "ModalSubmit"
   constructor(
-    readonly predicate: (customId: string) => Effect.Effect<boolean, E, R>,
+    readonly predicate: (customId: string) => boolean,
     readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
-export const modalSubmit = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect.Effect<boolean, E1, R1>,
-  handle: Effect.Effect<Discord.InteractionResponse, E2, R2>,
+export const modalSubmit = <R, E>(
+  pred: (customId: string) => boolean,
+  handle: Effect.Effect<Discord.InteractionResponse, E, R>,
 ) =>
   new ModalSubmit<
-    Exclude<R1 | R2, DiscordInteraction | DiscordModalSubmit | Scope>,
-    E1 | E2
-  >(pred as any, handle as any)
+    Exclude<R, DiscordInteraction | DiscordModalSubmit | Scope>,
+    E
+  >(pred, handle as any)
 
 export class Autocomplete<R, E> {
   readonly _tag = "Autocomplete"
@@ -103,42 +101,30 @@ export class Autocomplete<R, E> {
     readonly predicate: (
       data: Discord.ApplicationCommandDatum,
       focusedOption: Discord.ApplicationCommandInteractionDataOption,
-    ) => Effect.Effect<boolean, E, R>,
+    ) => boolean,
     readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
-export const autocomplete = <R1, R2, E1, E2>(
+export const autocomplete = <R, E>(
   pred: (
     data: Discord.ApplicationCommandDatum,
     focusedOption: Discord.ApplicationCommandInteractionDataOption,
-  ) => Effect.Effect<boolean, E1, R1>,
-  handle: Effect.Effect<Discord.InteractionResponse, E2, R2>,
+  ) => boolean,
+  handle: Effect.Effect<Discord.InteractionResponse, E, R>,
 ) =>
   new Autocomplete<
     Exclude<
-      R1 | R2,
+      R,
       | DiscordInteraction
       | DiscordApplicationCommand
       | DiscordFocusedOption
       | Scope
     >,
-    E1 | E2
-  >(pred as any, handle as any)
+    E
+  >(pred, handle as any)
 
 // ==== Command handler helpers
-type DeepReadonly<T> =
-  T extends Array<infer R>
-    ? ReadonlyArray<DeepReadonly<R>>
-    : T extends Function
-      ? T
-      : T extends object
-        ? DeepReadonlyObject<T>
-        : T
-type DeepReadonlyObject<T> = {
-  readonly [P in keyof T]: DeepReadonly<T[P]>
-}
-
 export type CommandHandler<R, E, A = any> =
   | Effect.Effect<Discord.InteractionResponse, E, R>
   | CommandHandlerFn<R, E, A>
diff --git a/src/Interactions/handlers.ts b/src/Interactions/handlers.ts
index c23208f..59a8434 100644
--- a/src/Interactions/handlers.ts
+++ b/src/Interactions/handlers.ts
@@ -1,5 +1,4 @@
 import type * as Chunk from "effect/Chunk"
-import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import * as IxHelpers from "dfx/Helpers/interactions"
 import * as Ctx from "dfx/Interactions/context"
@@ -40,91 +39,66 @@ export const handlers = <R, E, TE, A, B>(
     splitDefinitions(flattened)
 
   return {
-    [Discord.InteractionType.PING]: () =>
+    [Discord.InteractionType.PING]: _ =>
       Effect.succeed({
         type: Discord.InteractionCallbackType.PONG,
       } as any),
 
     [Discord.InteractionType.APPLICATION_COMMAND]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
-
-      return Option.match(Option.fromNullable(Commands[data.name]), {
-        onNone: () => Effect.fail(new DefinitionNotFound(i)),
-        onSome: command =>
-          Effect.provideService(
-            command.handle(i),
-            Ctx.ApplicationCommand,
-            data,
-          ) as Handler<Exclude<R, Scope>, E, B>,
-      })
+      const command = Commands[data.name]
+      if (command === undefined) {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      return Effect.provideService(
+        command.handle(i),
+        Ctx.ApplicationCommand,
+        data,
+      ) as Handler<Exclude<R, Scope>, E, B>
     },
 
     [Discord.InteractionType.MODAL_SUBMIT]: i => {
       const data = i.data as Discord.ModalSubmitDatum
-
-      return Effect.findFirst(ModalSubmit, _ =>
-        _.predicate(data.custom_id),
-      ).pipe(
-        Effect.flatMap(
-          Option.match({
-            onNone: () => Effect.fail(new DefinitionNotFound(i)),
-            onSome: match =>
-              Effect.provideService(
-                match.handle(i),
-                Ctx.ModalSubmitData,
-                data,
-              ) as Handler<R, E, B>,
-          }),
-        ),
+      const match = ModalSubmit.find(_ => _.predicate(data.custom_id))
+      if (match === undefined) {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      return Effect.provideService(
+        match.handle(i),
+        Ctx.ModalSubmitData,
+        data,
       ) as Handler<Exclude<R, Scope>, E, B>
     },
 
     [Discord.InteractionType.MESSAGE_COMPONENT]: i => {
       const data = i.data as Discord.MessageComponentDatum
-
-      return Effect.findFirst(MessageComponent, _ =>
-        _.predicate(data.custom_id),
-      ).pipe(
-        Effect.flatMap(
-          Option.match({
-            onNone: () => Effect.fail(new DefinitionNotFound(i)),
-            onSome: match =>
-              Effect.provideService(
-                match.handle(i),
-                Ctx.MessageComponentData,
-                data,
-              ) as Handler<R, E, B>,
-          }),
-        ),
+      const match = MessageComponent.find(_ => _.predicate(data.custom_id))
+      if (match === undefined) {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      return Effect.provideService(
+        match.handle(i),
+        Ctx.MessageComponentData,
+        data,
       ) as Handler<Exclude<R, Scope>, E, B>
     },
 
     [Discord.InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
-
-      return Option.match(IxHelpers.focusedOption(data), {
-        onNone: () => Effect.fail(new DefinitionNotFound(i)),
-        onSome: focusedOption =>
-          Effect.findFirst(Autocomplete, _ =>
-            _.predicate(data, focusedOption),
-          ).pipe(
-            Effect.flatMap(
-              Option.match({
-                onNone: () => Effect.fail(new DefinitionNotFound(i)),
-                onSome: match =>
-                  Effect.provideService(
-                    match.handle(i),
-                    Ctx.ApplicationCommand,
-                    data,
-                  ).pipe(
-                    Effect.provideService(Ctx.FocusedOptionContext, {
-                      focusedOption,
-                    }),
-                  ) as Handler<R, E, B>,
-              }),
-            ),
-          ),
-      }) as Handler<Exclude<R, Scope>, E, B>
+      const option = IxHelpers.focusedOption(data)
+      if (option._tag === "None") {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      const match = Autocomplete.find(_ => _.predicate(data, option.value))
+      if (match === undefined) {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      return match
+        .handle(i)
+        .pipe(
+          Effect.provideService(Ctx.ApplicationCommand, data),
+          Effect.provideService(Ctx.FocusedOptionContext, option.value),
+        ) as Handler<Exclude<R, Scope>, E, B>
     },
   }
 }
diff --git a/src/Interactions/index.ts b/src/Interactions/index.ts
index 25c0812..0f88b9b 100644
--- a/src/Interactions/index.ts
+++ b/src/Interactions/index.ts
@@ -1,4 +1,3 @@
-import * as Effect from "effect/Effect"
 import type * as Discord from "dfx/types"
 
 export { response } from "dfx/Helpers/interactions"
@@ -14,14 +13,13 @@ export {
 } from "dfx/Interactions/definitions"
 
 // Filters
-export const id = (query: string) => (customId: string) =>
-  Effect.succeed(query === customId)
+export const id = (query: string) => (customId: string) => query === customId
 
 export const idStartsWith = (query: string) => (customId: string) =>
-  Effect.succeed(customId.startsWith(query))
+  customId.startsWith(query)
 
 export const idRegex = (query: RegExp) => (customId: string) =>
-  Effect.succeed(query.test(customId))
+  query.test(customId)
 
 export const option =
   (command: string, optionName: string) =>
@@ -32,7 +30,7 @@ export const option =
       "name"
     >,
   ) =>
-    Effect.succeed(data.name === command && focusedOption.name === optionName)
+    data.name === command && focusedOption.name === optionName
 
 export const optionOnly =
   (optionName: string) =>
@@ -43,4 +41,4 @@ export const optionOnly =
       "name"
     >,
   ) =>
-    Effect.succeed(focusedOption.name === optionName)
+    focusedOption.name === optionName
diff --git a/src/Interactions/utils.ts b/src/Interactions/utils.ts
index 12350df..7d5c282 100644
--- a/src/Interactions/utils.ts
+++ b/src/Interactions/utils.ts
@@ -3,6 +3,7 @@ import * as Effect from "effect/Effect"
 import * as Ctx from "dfx/Interactions/context"
 import type * as D from "dfx/Interactions/definitions"
 import type * as Discord from "dfx/types"
+import * as ReadonlyArray from "effect/ReadonlyArray"
 
 export type DefinitionFlattened<R, E, TE, A> =
   D.InteractionDefinition<R, E> extends infer D
@@ -38,60 +39,66 @@ export const flattenDefinitions = <R, E, TE, A, B>(
     _: Discord.InteractionResponse,
   ) => Effect.Effect<A, E, R>,
 ) =>
-  Chunk.map(definitions, ([definition, transform]) => ({
-    ...definition,
-    handle: (i: Discord.Interaction) =>
-      Effect.scoped(
-        Effect.isEffect(definition.handle)
-          ? transform(
-              Effect.flatMap(definition.handle, _ => handleResponse(i, _)),
+  ReadonlyArray.map(
+    Chunk.toReadonlyArray(definitions),
+    ([definition, transform]) => ({
+      ...definition,
+      handle: Effect.isEffect(definition.handle)
+        ? (i: Discord.Interaction) =>
+            Effect.scoped(
+              transform(
+                Effect.flatMap(
+                  definition.handle as Effect.Effect<Discord.InteractionResponse>,
+                  _ => handleResponse(i, _),
+                ),
+              ),
             )
-          : transform(
-              Effect.flatMap(definition.handle(context), _ =>
-                handleResponse(i, _),
+        : (i: Discord.Interaction) =>
+            Effect.scoped(
+              transform(
+                Effect.flatMap(
+                  (
+                    definition.handle as (
+                      _: any,
+                    ) => Effect.Effect<Discord.InteractionResponse>
+                  )(context),
+                  _ => handleResponse(i, _),
+                ),
               ),
             ),
-      ),
-  }))
+    }),
+  )
 
 export const splitDefinitions = <R, E, TE, A>(
-  definitions: Chunk.Chunk<DefinitionFlattened<R, E, TE, A>>,
+  definitions: ReadonlyArray<DefinitionFlattened<R, E, TE, A>>,
 ) => {
-  const grouped = Chunk.reduce(
+  const grouped = ReadonlyArray.reduce(
     definitions,
     {
-      Autocomplete: Chunk.empty(),
-      GlobalApplicationCommand: Chunk.empty(),
-      GuildApplicationCommand: Chunk.empty(),
-      MessageComponent: Chunk.empty(),
-      ModalSubmit: Chunk.empty(),
+      Autocomplete: [],
+      GlobalApplicationCommand: [],
+      GuildApplicationCommand: [],
+      MessageComponent: [],
+      ModalSubmit: [],
+      Commands: {},
     } as {
-      [K in D.InteractionDefinition<R, E>["_tag"]]: Chunk.Chunk<
+      [K in D.InteractionDefinition<R, E>["_tag"]]: Array<
         Extract<DefinitionFlattened<R, E, TE, A>, { _tag: K }>
       >
+    } & {
+      readonly Commands: Record<string, DefinitionFlattenedCommand<R, E, TE, A>>
+    },
+    (acc, d) => {
+      acc[d._tag].push(d as any)
+      if (
+        d._tag === "GlobalApplicationCommand" ||
+        d._tag === "GuildApplicationCommand"
+      ) {
+        acc.Commands[d.command.name] = d as any
+      }
+      return acc
     },
-    (acc, d) => ({
-      ...acc,
-      [d._tag]: Chunk.append(acc[d._tag] as Chunk.Chunk<any>, d),
-    }),
-  )
-
-  const Commands = Chunk.appendAll(
-    grouped.GlobalApplicationCommand,
-    grouped.GuildApplicationCommand,
-  ).pipe(
-    Chunk.reduce(
-      {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
-      (acc, d) =>
-        ({
-          ...acc,
-          [d.command.name]: d,
-        }) as any,
-    ),
   )
 
-  return {
-    ...grouped,
-    Commands,
-  }
+  return grouped
 }