feat(structure): add Structure abstractions and API

build.gradle.kts

@@ -13,6 +13,14 @@ allprojects {
             archiveBaseName.set("marinara-" + archiveBaseName.get())
         }
     }
+
+    repositories {
+        // Use Maven Central for resolving dependencies.
+        mavenCentral()
+        maven {
+            url = uri("https://git.tomatentum.net/api/packages/tueem/maven")
+        }
+    }
 }
 
 subprojects {

gradle/libs.versions.toml

@@ -8,11 +8,14 @@ javacord = "3.8.0"
 discord4j = "3.2.7"
 geantyref = "2.0.0"
 mockito = "5.15.2"
+cutin = "0.2.0"
 
 [libraries]
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
 slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j"}
+slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j"}
 javacord = { module = "org.javacord:javacord", version.ref = "javacord"}
 discord4j = { module = "com.discord4j:discord4j-core", version.ref = "discord4j"}
 geantyref = { module = "io.leangen.geantyref:geantyref", version.ref = "geantyref"}
 mockito = {module = "org.mockito:mockito-core", version.ref = "mockito"}
+cutin = {module = "net.tomatentum.cutin:lib", version.ref = "cutin"}

lib/build.gradle.kts

@@ -10,11 +10,6 @@ plugins {
     `java-library`
 }
 
-repositories {
-    // Use Maven Central for resolving dependencies.
-    mavenCentral()
-}
-
 dependencies {
     // Use JUnit Jupiter for testing.
     testImplementation(libs.junit.jupiter)
@@ -22,6 +17,7 @@ dependencies {
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     implementation(libs.slf4j)
     implementation(libs.geantyref)
+    api(libs.cutin)
 }
 
 // Apply a specific Java toolchain to ease working on different environments.

lib/src/main/java/net/tomatentum/marinara/Marinara.java

@@ -1,64 +1,84 @@
 package net.tomatentum.marinara;
 
-import org.slf4j.Logger;
+import java.util.Arrays;
+import java.util.List;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import net.tomatentum.cutin.MethodExecutor;
+import net.tomatentum.cutin.ProcessorMethodExecutor;
+import net.tomatentum.cutin.container.MethodContainer;
+import net.tomatentum.marinara.checks.CheckExecutionContext;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier;
+import net.tomatentum.marinara.container.InteractionCheckContainer;
+import net.tomatentum.marinara.container.InteractionMethodContainer;
 import net.tomatentum.marinara.interaction.InteractionType;
+import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
+import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
 import net.tomatentum.marinara.interaction.processor.AutocompleteInteractionProcessor;
 import net.tomatentum.marinara.interaction.processor.DirectInteractionProcessor;
-import net.tomatentum.marinara.reflection.MethodExecutor;
+import net.tomatentum.marinara.util.ObjectAggregator;
-import net.tomatentum.marinara.reflection.ProcessorMethodExecutor;
-import net.tomatentum.marinara.reflection.ReflectedMethodFactory;
-import net.tomatentum.marinara.reflection.ReflectedMethodFactoryImpl;
-import net.tomatentum.marinara.registry.InteractionCheckRegistry;
-import net.tomatentum.marinara.registry.InteractionRegistry;
-import net.tomatentum.marinara.util.LoggerUtil;
 import net.tomatentum.marinara.wrapper.IdentifierProvider;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
 public class Marinara {
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    private Logger logger = LoggerFactory.getLogger(getClass());
     
     public static Marinara load(LibraryWrapper wrapper) {
         return new Marinara(wrapper);
     }
 
     private LibraryWrapper wrapper;
-    private ReflectedMethodFactory reflectedMethodFactory;
+    private MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
-    private InteractionRegistry registry;
+    private MethodContainer<InteractionIdentifier, Object> interactionContainer;
-    private InteractionCheckRegistry checkRegistry;
+    private MethodExecutor<Object> interactionExecutor;
-    private MethodExecutor interactionExecutor;
 
     private Marinara(LibraryWrapper wrapper) {
         this.wrapper = wrapper;
-        this.reflectedMethodFactory = new ReflectedMethodFactoryImpl(this);
+        this.checkContainer = new InteractionCheckContainer();
-        this.registry = new InteractionRegistry(this);
+        this.interactionContainer = new InteractionMethodContainer(getCheckContainer(), getWrapper().getContextObjectProvider());
-        this.checkRegistry = new InteractionCheckRegistry();
         IdentifierProvider provider = wrapper.createIdentifierProvider();
-        this.interactionExecutor = (MethodExecutor) new ProcessorMethodExecutor()
+        ProcessorMethodExecutor<InteractionIdentifier, Object> exec = new ProcessorMethodExecutor<>(getInteractionContainer());
-            .addProcessor(new DirectInteractionProcessor(getRegistry(), provider, InteractionType.COMMAND, InteractionType.BUTTON))
+        exec
-            .addProcessor(new AutocompleteInteractionProcessor(this, provider));
+            .addProcessor(new DirectInteractionProcessor(provider, InteractionType.COMMAND, InteractionType.BUTTON))
+            .addProcessor(new AutocompleteInteractionProcessor(getWrapper(), provider));
+        this.interactionExecutor = exec;
         wrapper.subscribeInteractions(this.interactionExecutor::handle);
         logger.info("Marinara loaded successfully!");
     }
 
+    //TODO move to future interactionstructure module
+    public void registerCommands() {
+        List<InteractionIdentifier> slashIdentifiers = getInteractionContainer().identifiers().stream()
+            .filter(i -> i.type().equals(InteractionType.COMMAND))
+            .toList();
+
+        SlashCommandDefinition[] defs = new ObjectAggregator<InteractionIdentifier, RootCommandIdentifier, SlashCommandDefinition>(
+            i -> Arrays.asList((RootCommandIdentifier)i.rootNode()),
+            SlashCommandDefinition::addIdentifier,
+            SlashCommandDefinition::new)
+            .aggregate(slashIdentifiers)
+            .toArray(SlashCommandDefinition[]::new);
+
+        wrapper.getRegisterer().register(defs);
+    }
+
     public LibraryWrapper getWrapper() {
         return this.wrapper;
     }
 
-    public InteractionRegistry getRegistry() {
+    public MethodContainer<InteractionIdentifier, Object> getInteractionContainer() {
-        return this.registry;
+        return this.interactionContainer;
     }
 
-    public InteractionCheckRegistry getCheckRegistry() {
+    public MethodContainer<CheckMethodIdentifier, CheckExecutionContext> getCheckContainer() {
-        return this.checkRegistry;
+        return this.checkContainer;
     }
 
-    public ReflectedMethodFactory getReflectedMethodFactory() {
+    public MethodExecutor<Object> getInteractionExecutor() {
-        return this.reflectedMethodFactory;
-    }
-
-    public MethodExecutor getInteractionExecutor() {
         return interactionExecutor;
     }
     

lib/src/main/java/net/tomatentum/marinara/checks/AppliedCheck.java

@@ -1,50 +1,28 @@
 package net.tomatentum.marinara.checks;
 
 import java.lang.annotation.Annotation;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Arrays;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import net.tomatentum.marinara.util.LoggerUtil;
+import net.tomatentum.cutin.method.ReflectedMethod;
-import net.tomatentum.marinara.util.ReflectionUtil;
 
-public record AppliedCheck(InteractionCheck<?> check, Annotation annotation) {
+public record AppliedCheck(
+        Annotation annotation, 
+        ReflectedMethod<CheckMethodIdentifier, CheckExecutionContext> preExec,
+        ReflectedMethod<CheckMethodIdentifier, CheckExecutionContext> postExec
+    ) {
 
-    private static Logger logger = LoggerUtil.getLogger(AppliedCheck.class);
+    private static Logger logger = LoggerFactory.getLogger(AppliedCheck.class); 
 
     public boolean pre(Object context) {
-        Method[] methods = Arrays.stream(check.getClass().getMethods())
+        logger.debug("Running InteractionCheck preExec {} with annotation {}", preExec(), annotation());
-            .filter(x -> x.getName().equals("preExec"))
+        return (boolean) preExec().run(new CheckExecutionContext(annotation, context));
-            .filter(x -> !x.isBridge())
-            .toArray(s -> new Method[s]);
-        Method method = ReflectionUtil.getMostSpecificMethod(methods, context.getClass(), annotation.annotationType());
-        method.setAccessible(true);
-        try {
-            logger.debug("Executing pre check {} with context {}", check.getClass().getName(), context.toString());
-            boolean result = (boolean) method.invoke(check, context, annotation);
-            logger.debug("Pre Check {} {} with context {}", check.getClass().getName(), result ? "succeeded" : "failed", context.toString());
-            return result;
-        } catch (IllegalAccessException | InvocationTargetException | SecurityException e) {
-            logger.error("Failed executing pre-check", e);
-            return false;
-        }
     }
 
     public void post(Object context) {
-        Method[] methods = Arrays.stream(check.getClass().getMethods())
+        logger.debug("Running InteractionCheck postExec {} with annotation {}", postExec(), annotation());
-            .filter(x -> x.getName().equals("postExec"))
+        postExec().run(new CheckExecutionContext(annotation, context));
-            .filter(x -> !x.isBridge())
-            .toArray(s -> new Method[s]);
-        Method method = ReflectionUtil.getMostSpecificMethod(methods, context.getClass(), annotation.annotationType());
-        method.setAccessible(true);
-        try {
-            logger.debug("Executing post check {} with context {}", check.getClass().getName(), context.toString());
-            method.invoke(check, context, annotation);
-        } catch (IllegalAccessException | InvocationTargetException | SecurityException e) {
-            logger.error("Failed executing post-check", e);
-        }
     }
 
 }

lib/src/main/java/net/tomatentum/marinara/checks/CheckExecutionContext.java

@@ -0,0 +1,7 @@
+package net.tomatentum.marinara.checks;
+
+import java.lang.annotation.Annotation;
+
+public record CheckExecutionContext(Annotation annotation, Object originalContext) {
+    
+}

lib/src/main/java/net/tomatentum/marinara/checks/CheckMethodIdentifier.java

@@ -0,0 +1,27 @@
+package net.tomatentum.marinara.checks;
+
+import java.lang.reflect.Type;
+
+public record CheckMethodIdentifier(Type annotationType, CheckMethodType type) {
+
+    public enum CheckMethodType {
+        PRE("preExec"),
+        POST("postExec");
+
+        private String methodName;
+
+        private CheckMethodType(String methodName) {
+            this.methodName = methodName;
+        }
+
+        public String methodName() {
+            return this.methodName;
+        }
+    }
+
+    @Override
+    public final String toString() {
+        return "InteractionCheck(%s, %s)".formatted(annotationType, type);
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/checks/InteractionCheckMethod.java

@@ -0,0 +1,74 @@
+package net.tomatentum.marinara.checks;
+
+import java.util.Optional;
+import java.util.Set;
+
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
+import net.tomatentum.cutin.container.MethodContainer;
+import net.tomatentum.cutin.method.BestCandidateMethod;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType;
+import net.tomatentum.marinara.parser.InteractionCheckClassParser;
+
+public class InteractionCheckMethod extends BestCandidateMethod<CheckMethodIdentifier, CheckExecutionContext> {
+
+    private CheckMethodIdentifier identifier;
+
+    public InteractionCheckMethod(
+            String methodName, 
+            Object containingObject,
+            CheckMethodIdentifier identifier
+        ) {
+        super(methodName, containingObject);
+        this.identifier = identifier;
+    }
+
+    @Override
+    public Object getParameter(CheckExecutionContext context, int index) {
+        switch (index) {
+            case 0:
+                return context.originalContext();
+            case 1:
+                return context.annotation();
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public CheckMethodIdentifier identifier() {
+        return this.identifier;
+    }
+
+    public static class InteractionCheckMethodFactory extends BestCandidateMethod.Factory<CheckMethodIdentifier, CheckExecutionContext> {
+
+        private CheckMethodType type;
+
+        public InteractionCheckMethodFactory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> methodContainer, CheckMethodType type) {
+            super(methodContainer, type.methodName());
+            this.type = type;
+        }
+
+        @Override
+        public void addParser(Set<MethodParser> parsers) {
+            parsers.add(
+                new InteractionCheckClassParser()
+            );
+        }
+
+        @Override
+        protected Optional<BestCandidateMethod<CheckMethodIdentifier, CheckExecutionContext>> bcProduce(
+                    String methodName,
+                    Object containingObject,
+                    ParserResults parserResults
+                ) {
+
+            CheckMethodIdentifier identifier = new CheckMethodIdentifier(parserResults.get(InteractionCheckClassParser.class), type);
+            if (identifier.annotationType() == null)
+                return null;
+            return Optional.of(new InteractionCheckMethod(methodName, containingObject, identifier));
+        }
+
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/container/InteractionCheckContainer.java

@@ -0,0 +1,19 @@
+package net.tomatentum.marinara.container;
+
+import net.tomatentum.cutin.ReflectedMethodFactoryImpl;
+import net.tomatentum.cutin.container.LoneMethodContainer;
+import net.tomatentum.marinara.checks.CheckExecutionContext;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType;
+import net.tomatentum.marinara.checks.InteractionCheckMethod.InteractionCheckMethodFactory;
+
+public class InteractionCheckContainer extends LoneMethodContainer<CheckMethodIdentifier, CheckExecutionContext> {
+    
+    public InteractionCheckContainer() {
+        super(new ReflectedMethodFactoryImpl<>());
+        super.factory()
+            .addFactory(new InteractionCheckMethodFactory(this, CheckMethodType.PRE))
+            .addFactory(new InteractionCheckMethodFactory(this, CheckMethodType.POST));
+    }
+
+}

lib/src/main/java/net/tomatentum/marinara/container/InteractionMethodContainer.java

@@ -0,0 +1,38 @@
+package net.tomatentum.marinara.container;
+
+import net.tomatentum.cutin.ReflectedMethodFactory;
+import net.tomatentum.cutin.ReflectedMethodFactoryImpl;
+import net.tomatentum.cutin.container.MethodContainer;
+import net.tomatentum.cutin.container.MultiMethodContainer;
+import net.tomatentum.cutin.method.ReflectedMethod;
+import net.tomatentum.marinara.checks.CheckExecutionContext;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier;
+import net.tomatentum.marinara.interaction.components.methods.ButtonInteractionMethod;
+import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+import net.tomatentum.marinara.wrapper.ContextObjectProvider;
+import net.tomatentum.marinara.interaction.methods.AutoCompleteInteractionMethod;
+import net.tomatentum.marinara.interaction.methods.SlashCommandInteractionMethod;
+
+public class InteractionMethodContainer extends MultiMethodContainer<InteractionIdentifier, Object> {
+
+
+    private static ReflectedMethodFactory<InteractionIdentifier, Object> createFactory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkRegistry, ContextObjectProvider cop) {
+        return new ReflectedMethodFactoryImpl<InteractionIdentifier, Object>()
+            .addFactory(new AutoCompleteInteractionMethod.Factory(checkRegistry, cop))
+            .addFactory(new SlashCommandInteractionMethod.Factory(checkRegistry, cop))
+            .addFactory(new ButtonInteractionMethod.Factory(checkRegistry, cop));
+    }
+
+    public InteractionMethodContainer(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkRegistry, ContextObjectProvider cop) {
+        super(createFactory(checkRegistry, cop));
+    }
+
+    @Override
+    public MethodContainer<InteractionIdentifier, Object> addMethod(ReflectedMethod<InteractionIdentifier, Object> method) {
+        super.identifiers().stream()
+            .filter(method.identifier()::equals)
+            .forEach(i -> InteractionIdentifier.tryAddDescriptions(i, method.identifier()));
+        return super.addMethod(method);
+    }
+
+}

lib/src/main/java/net/tomatentum/marinara/interaction/annotation/Button.java

@@ -5,8 +5,15 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import net.tomatentum.marinara.structure.data.ButtonStructureData.ButtonStyle;
+
 @Target({ElementType.METHOD})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Button {
     public String value(); //aka customId
+    public String label() default "default_button";
+    public ButtonStyle style() default ButtonStyle.PRIMARY;
+    public String url() default "";
+    public boolean disabled() default false;
+    public String emoji() default "";
 }

lib/src/main/java/net/tomatentum/marinara/interaction/commands/SlashCommandDefinition.java

@@ -5,6 +5,7 @@ import java.util.List;
 import java.util.Set;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import net.tomatentum.marinara.interaction.commands.annotation.CommandChoices;
 import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
@@ -14,7 +15,6 @@ import net.tomatentum.marinara.interaction.commands.choice.EnumChoices;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
 import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
 import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
-import net.tomatentum.marinara.util.LoggerUtil;
 
 public class SlashCommandDefinition {
 
@@ -30,7 +30,7 @@ public class SlashCommandDefinition {
     private RootCommandIdentifier rootIdentifier;
     private boolean isRootCommand;
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    private Logger logger = LoggerFactory.getLogger(getClass());
 
     public SlashCommandDefinition(RootCommandIdentifier rootIdentifier) {
         this.entries = new HashSet<>();

lib/src/main/java/net/tomatentum/marinara/interaction/components/methods/ButtonInteractionMethod.java

@@ -3,29 +3,48 @@ package net.tomatentum.marinara.interaction.components.methods;
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
-import net.tomatentum.marinara.Marinara;
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
+import net.tomatentum.cutin.container.MethodContainer;
+import net.tomatentum.cutin.method.ReflectedMethod;
+import net.tomatentum.marinara.checks.AppliedCheck;
+import net.tomatentum.marinara.checks.CheckExecutionContext;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier;
 import net.tomatentum.marinara.interaction.InteractionHandler;
 import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.annotation.Button;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
 import net.tomatentum.marinara.interaction.methods.InteractionMethod;
-import net.tomatentum.marinara.parser.AnnotationParser;
 import net.tomatentum.marinara.parser.ButtonParser;
-import net.tomatentum.marinara.reflection.ReflectedMethod;
+import net.tomatentum.marinara.parser.InteractionCheckParser;
+import net.tomatentum.marinara.wrapper.ContextObjectProvider;
 
 public class ButtonInteractionMethod extends InteractionMethod {
 
     private String customId;
+    private ContextObjectProvider cop;
 
-    private ButtonInteractionMethod(Method method, InteractionHandler handler, Marinara marinara) {
+    private ButtonInteractionMethod(
-        super(method, handler, marinara);
+            Method method, 
+            InteractionHandler handler,
+            List<AppliedCheck> appliedChecks,
+            String customId, 
+            ContextObjectProvider cop
+        ) {
+        super(method, handler, appliedChecks);
+        this.customId = customId;
+        this.cop = cop;
     }
 
     @Override
     public Object getParameter(Object context, int index) {
-        Class<?> type = method().getParameterTypes()[index+1];
+        Class<?> type = method().getParameterTypes()[index];
-        return marinara.getWrapper().getContextObjectProvider().getComponentContextObject(context, type);
+        Object superResult = super.getParameter(context, index);
+        if (superResult == null)
+            return this.cop.getComponentContextObject(context, type);
+        else
+            return superResult;
     }
 
     @Override
@@ -39,23 +58,33 @@ public class ButtonInteractionMethod extends InteractionMethod {
 
     public static class Factory extends InteractionMethod.Factory {
 
-        @Override
+        private ContextObjectProvider cop;
-        public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
-            ReflectedMethod rMethod = null;
-            if (method.isAnnotationPresent(Button.class) &&
-                (containingObject instanceof InteractionHandler iHandler)
-                )
-                rMethod = new ButtonInteractionMethod(method, iHandler, marinara);
 
-            return Optional.ofNullable(rMethod);
+        public Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
+            super(checkContainer);
+            this.cop = cop;
         }
 
         @Override
-        public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
+        public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
-            super.addParser(method, parser);
+            if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
+            String customId = parserResults.get(ButtonParser.class);
+            if (customId == null) return Optional.empty();
+            return Optional.of(new ButtonInteractionMethod(
+                method, 
+                (InteractionHandler) containingObject,
+                parserResults.get(InteractionCheckParser.class),
+                customId,
+                this.cop
+            ));
+        }
+
+        @Override
+        public void addParser(Set<MethodParser> parser) {
+            super.addParser(parser);
 
             parser.add(
-                new ButtonParser(method.method(), x -> ((ButtonInteractionMethod) method).customId = x)
+                new ButtonParser()
             );
         }
 

lib/src/main/java/net/tomatentum/marinara/interaction/ident/InteractionIdentifier.java

@@ -91,8 +91,8 @@ public class InteractionIdentifier {
     @Override
     public String toString() {
         if (parent() == null)
-            return name();
+            return name() + " - " + type();
-        return "%s.%s".formatted(name(), parent().toString());
+        return "%s:%s".formatted(name(), parent().toString());
     }
 
     public static class Builder {

lib/src/main/java/net/tomatentum/marinara/interaction/methods/AutoCompleteInteractionMethod.java

@@ -3,41 +3,51 @@ package net.tomatentum.marinara.interaction.methods;
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
-import net.tomatentum.marinara.Marinara;
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
+import net.tomatentum.cutin.container.MethodContainer;
+import net.tomatentum.cutin.method.ReflectedMethod;
+import net.tomatentum.marinara.checks.AppliedCheck;
+import net.tomatentum.marinara.checks.CheckExecutionContext;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier;
 import net.tomatentum.marinara.interaction.InteractionHandler;
 import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.annotation.AutoComplete;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
-import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.parser.AnnotationParser;
 import net.tomatentum.marinara.parser.AutocompleteParser;
-import net.tomatentum.marinara.reflection.ReflectedMethod;
+import net.tomatentum.marinara.parser.InteractionCheckParser;
+import net.tomatentum.marinara.wrapper.ContextObjectProvider;
 
 public class AutoCompleteInteractionMethod extends InteractionMethod {
 
     private String autocompleteRef;
+    private ContextObjectProvider cop;
 
-    private AutoCompleteInteractionMethod(Method method, 
+    private AutoCompleteInteractionMethod(
-        InteractionHandler handler, 
+            Method method, 
-        Marinara marinara
+            InteractionHandler handler,
+            List<AppliedCheck> appliedChecks,
+            String autocompleteRef,
+            ContextObjectProvider cop
         ) {
-        super(method, handler, marinara);
+        super(method, handler, appliedChecks);
+        this.autocompleteRef = autocompleteRef;
+        this.cop = cop;
     }
 
     @Override
     public Object getParameter(Object context, int index) {
-        Class<?> type = method().getParameterTypes()[index+1];
+        Class<?> type = method().getParameterTypes()[index];
-        Object contextObject = marinara.getWrapper().getContextObjectProvider().getInteractionContextObject(context, type);
+        Object contextObject = this.cop.getInteractionContextObject(context, type);
         if (contextObject != null)
             return contextObject;
 
-        Object autocompleteOptionValue = marinara.getWrapper().getContextObjectProvider().getAutocompleteFocusedOption(context).input();
+        Object autocompleteOptionValue = this.cop.getAutocompleteFocusedOption(context).input();
         if (type.isInstance(autocompleteOptionValue))
             return autocompleteOptionValue;
 
-        return null;
+        return super.getParameter(context, index);
     }
 
     @Override
@@ -51,24 +61,35 @@ public class AutoCompleteInteractionMethod extends InteractionMethod {
 
     public static class Factory extends InteractionMethod.Factory {
 
-        @Override
+        private ContextObjectProvider cop;
-        public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
-            ReflectedMethod rMethod = null;
-            if ((containingObject instanceof InteractionHandler iHandler) &&
-                method.isAnnotationPresent(AutoComplete.class) &&
-                !(method.isAnnotationPresent(SlashCommand.class) ||
-                method.isAnnotationPresent(SubCommand.class)))
-                rMethod = new AutoCompleteInteractionMethod(method, iHandler, marinara);
 
-            return Optional.ofNullable(rMethod);
+        public Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
+            super(checkContainer);
+            this.cop = cop;
         }
 
         @Override
-        public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
+        public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
-            super.addParser(method, parser);
+            if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
+            String[] autocompletes = parserResults.get(AutocompleteParser.class);
+            if (autocompletes.length <= 0) return Optional.empty();
+            
+            return Optional.of(new AutoCompleteInteractionMethod(
+                method, 
+                (InteractionHandler) containingObject,
+                parserResults.get(InteractionCheckParser.class),
+                autocompletes[0],
+                cop
+            ));
+
+        }
+
+        @Override
+        public void addParser(Set<MethodParser> parser) {
+            super.addParser(parser);
 
             parser.add(
-                new AutocompleteParser(method.method(), x -> ((AutoCompleteInteractionMethod) method).autocompleteRef = x[0])
+                new AutocompleteParser()
             );
         }
 

lib/src/main/java/net/tomatentum/marinara/interaction/methods/InteractionMethod.java

@@ -1,31 +1,38 @@
 package net.tomatentum.marinara.interaction.methods;
 
 import java.lang.reflect.Method;
-import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
 
-import net.tomatentum.marinara.Marinara;
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.ReflectedMethodFactory;
+import net.tomatentum.cutin.container.MethodContainer;
+import net.tomatentum.cutin.method.ReflectedMethod;
 import net.tomatentum.marinara.checks.AppliedCheck;
+import net.tomatentum.marinara.checks.CheckExecutionContext;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier;
 import net.tomatentum.marinara.interaction.InteractionHandler;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.parser.AnnotationParser;
 import net.tomatentum.marinara.parser.InteractionCheckParser;
-import net.tomatentum.marinara.reflection.ReflectedMethod;
-import net.tomatentum.marinara.reflection.ReflectedMethodFactory;
 
-public abstract class InteractionMethod extends ReflectedMethod {
+public abstract class InteractionMethod extends ReflectedMethod<InteractionIdentifier, Object> {
 
-    protected Marinara marinara;
     protected List<AppliedCheck> appliedChecks;
 
     protected InteractionMethod(
         Method method, 
         InteractionHandler handler,
-        Marinara marinara
+        List<AppliedCheck> appliedChecks
         ) {
         super(method, handler);
-        this.marinara = marinara;
+        this.appliedChecks = appliedChecks;
-        this.appliedChecks = new ArrayList<>();
+    }
+
+    @Override
+    public Object getParameter(Object context, int index) {
+        if (index == 0)
+            return context;
+        return null;
     }
     
     @Override
@@ -41,23 +48,22 @@ public abstract class InteractionMethod extends ReflectedMethod {
         return result;
     }
 
-    public abstract InteractionIdentifier identifier();
-
-    public Marinara marinara() {
-        return this.marinara;
-    }
-
     public List<AppliedCheck> appliedChecks() {
         return this.appliedChecks;
     }
 
-    public abstract static class Factory implements ReflectedMethodFactory.Factory {
+    public abstract static class Factory implements ReflectedMethodFactory.Factory<InteractionIdentifier, Object> {
+
+        private MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
+
+        protected Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer) {
+            this.checkContainer = checkContainer;
+        }
 
         @Override
-        public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
+        public void addParser(Set<MethodParser> parser) {
-            InteractionMethod imethod = (InteractionMethod) method;
             parser.add(
-                new InteractionCheckParser(method.method(), imethod.appliedChecks::add, imethod.marinara().getCheckRegistry())
+                new InteractionCheckParser(this.checkContainer)
             );
         }
 

lib/src/main/java/net/tomatentum/marinara/interaction/methods/SlashCommandInteractionMethod.java

@@ -3,53 +3,82 @@ package net.tomatentum.marinara.interaction.methods;
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
-import net.tomatentum.marinara.Marinara;
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
+import net.tomatentum.cutin.container.MethodContainer;
+import net.tomatentum.cutin.method.ReflectedMethod;
+import net.tomatentum.marinara.checks.AppliedCheck;
+import net.tomatentum.marinara.checks.CheckExecutionContext;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier;
 import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
-import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
 import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
-import net.tomatentum.marinara.parser.AnnotationParser;
+import net.tomatentum.marinara.parser.InteractionCheckParser;
 import net.tomatentum.marinara.parser.SlashCommandParser;
-import net.tomatentum.marinara.reflection.ReflectedMethod;
+import net.tomatentum.marinara.wrapper.ContextObjectProvider;
 
 public class SlashCommandInteractionMethod extends InteractionMethod {
 
-    private SlashCommandIdentifier interactionIdentifier;
+    private SlashCommandIdentifier identifier;
+    private ContextObjectProvider cop;
 
-    private SlashCommandInteractionMethod(Method method, InteractionHandler handler, Marinara marinara) {
+    private SlashCommandInteractionMethod(
-        super(method, handler, marinara);
+            Method method, 
+            InteractionHandler handler,
+            List<AppliedCheck> appliedChecks,
+            SlashCommandIdentifier identifier,
+            ContextObjectProvider cop
+        ) {
+        super(method, handler, appliedChecks);
+        this.identifier = identifier;
+        this.cop = cop;
     }
 
     @Override
     public Object getParameter(Object context, int index) {
-        return marinara.getWrapper().getContextObjectProvider().convertCommandOption(context, interactionIdentifier.options()[index].name());
+        Object superResult = super.getParameter(context, index);
+        if (superResult == null)
+            return this.cop.convertCommandOption(context, identifier.options()[index-1].name());
+        else
+            return superResult;
     }
 
     @Override
     public InteractionIdentifier identifier() {
-        return interactionIdentifier;
+        return identifier;
     }
 
     public static class Factory extends InteractionMethod.Factory {
 
-        @Override
+        private ContextObjectProvider cop;
-        public Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject) {
+
-            ReflectedMethod rMethod = null;
+        public Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
-            if ((containingObject instanceof InteractionHandler iHandler) && 
+            super(checkContainer);
-                (method.isAnnotationPresent(SlashCommand.class) ||
+            this.cop = cop;
-                method.isAnnotationPresent(SubCommand.class)))
-                rMethod = new SlashCommandInteractionMethod(method, iHandler, marinara);
-            return Optional.ofNullable(rMethod);
         }
 
         @Override
-        public void addParser(ReflectedMethod method, List<AnnotationParser> parser) {
+        public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
-            super.addParser(method, parser);
+            if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
+            SlashCommandIdentifier ident = parserResults.get(SlashCommandParser.class);
+            if (ident == null) return Optional.empty();
+            return Optional.of(new SlashCommandInteractionMethod(
+                method, 
+                (InteractionHandler) containingObject,
+                parserResults.get(InteractionCheckParser.class),
+                ident,
+                cop
+            ));
+        }
+
+        @Override
+        public void addParser(Set<MethodParser> parser) {
+            super.addParser(parser);
 
             parser.add(
-                new SlashCommandParser(method.method(), x -> ((SlashCommandInteractionMethod) method).interactionIdentifier = x)
+                new SlashCommandParser()
             );
         }
 

lib/src/main/java/net/tomatentum/marinara/interaction/processor/AutocompleteInteractionProcessor.java

@@ -6,37 +6,38 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 
-import net.tomatentum.marinara.Marinara;
+import net.tomatentum.cutin.container.MethodContainer;
 import net.tomatentum.marinara.interaction.InteractionType;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
 import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
-import net.tomatentum.marinara.registry.InteractionEntry;
 import net.tomatentum.marinara.wrapper.IdentifierProvider;
+import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
 public class AutocompleteInteractionProcessor extends InteractionMethodProcessor {
 
-    private Marinara marinara;
+    private LibraryWrapper wrapper;
 
-    public AutocompleteInteractionProcessor(Marinara marinara, IdentifierProvider provider) {
+    public AutocompleteInteractionProcessor(LibraryWrapper wrapper, IdentifierProvider provider) {
         super(provider, Set.of(InteractionType.AUTOCOMPLETE));
-        this.marinara = marinara;
+        this.wrapper = wrapper;
     }
 
     @Override
-    public void processInteraction(Object context, InteractionIdentifier identifier) {
+    public void processInteraction(Object context, MethodContainer<InteractionIdentifier, Object> container, InteractionIdentifier identifier) {
-        Optional<InteractionEntry> entry = this.marinara.getRegistry().findFor(convertToCommandIdentifier(identifier));
+        Optional<InteractionIdentifier> oIdent = container.identifiers().stream()
-        if (entry.isPresent() && entry.get().identifier() instanceof SlashCommandIdentifier sIdent) {
+            .filter(i -> convertToCommandIdentifier(identifier).equals(i))
-            List<String> autocompleteRefs = Arrays.asList(this.marinara.getWrapper().getContextObjectProvider()
+            .findFirst();
+        if (oIdent.isPresent() && oIdent.get() instanceof SlashCommandIdentifier sIdent) {
+            List<String> autocompleteRefs = Arrays.asList(this.wrapper.getContextObjectProvider()
                 .getAutocompleteFocusedOption(context).getAutocompleteRefs(sIdent.options()));
-            List<Object> results = this.marinara.getRegistry().interactions().stream()
+            List<Object> results = container.methods().stream()
-                .filter(e -> e.type().equals(InteractionType.AUTOCOMPLETE))
+                .filter(m -> m.identifier().type().equals(InteractionType.AUTOCOMPLETE))
-                .filter(e -> autocompleteRefs.contains(e.identifier().name()))
+                .filter(m -> autocompleteRefs.contains(m.identifier().name()))
-                .map(e -> e.runAll(context))
+                .map(m -> m.run(context))
-                .flatMap(Arrays::stream)
                 .filter(Objects::nonNull)
                 .toList();
             if (!results.isEmpty())
-                marinara.getWrapper().respondAutocomplete(context, results);
+                this.wrapper.respondAutocomplete(context, results);
         }
     }
 

lib/src/main/java/net/tomatentum/marinara/interaction/processor/DirectInteractionProcessor.java

@@ -2,26 +2,21 @@ package net.tomatentum.marinara.interaction.processor;
 
 import java.util.Set;
 
+import net.tomatentum.cutin.container.MethodContainer;
 import net.tomatentum.marinara.interaction.InteractionType;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.registry.InteractionRegistry;
 import net.tomatentum.marinara.wrapper.IdentifierProvider;
 
 public class DirectInteractionProcessor extends InteractionMethodProcessor {
 
-    private InteractionRegistry registry;
 
-    public DirectInteractionProcessor(InteractionRegistry registry, IdentifierProvider provider, InteractionType... types) {
+    public DirectInteractionProcessor(IdentifierProvider provider, InteractionType... types) {
         super(provider, Set.of(types));
-        this.registry = registry;
     }
 
     @Override
-    protected void processInteraction(Object context, InteractionIdentifier identifier) {
+    protected void processInteraction(Object context, MethodContainer<InteractionIdentifier, Object> container, InteractionIdentifier identifier) {
-        this.registry.interactions().stream()
+        container.findFor(identifier).forEach(m -> m.run(context));
-            .filter(e -> e.identifier().equals(identifier))
-            .findFirst()
-            .ifPresent(e -> e.runAll(context));
     }
     
 }

lib/src/main/java/net/tomatentum/marinara/interaction/processor/InteractionMethodProcessor.java

@@ -3,16 +3,17 @@ package net.tomatentum.marinara.interaction.processor;
 import java.util.Set;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import net.tomatentum.cutin.MethodProcessor;
+import net.tomatentum.cutin.container.MethodContainer;
 import net.tomatentum.marinara.interaction.InteractionType;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.reflection.MethodProcessor;
-import net.tomatentum.marinara.util.LoggerUtil;
 import net.tomatentum.marinara.wrapper.IdentifierProvider;
 
-public abstract class InteractionMethodProcessor implements MethodProcessor {
+public abstract class InteractionMethodProcessor implements MethodProcessor<InteractionIdentifier, Object> {
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    private Logger logger = LoggerFactory.getLogger(getClass());
 
     private IdentifierProvider provider;
     private Set<InteractionType> types;
@@ -23,13 +24,16 @@ public abstract class InteractionMethodProcessor implements MethodProcessor {
     }
 
     @Override
-    public void process(Object context) {
+    public void process(Object context, MethodContainer<InteractionIdentifier, Object> container) {
         InteractionIdentifier identifier = this.provider.provide(context);
         if (!this.types.contains(identifier.type())) return;
         logger.debug("Processing {} : {} with context {}", identifier, identifier.type(), context);
-        this.processInteraction(context, identifier);
+        this.processInteraction(context, container, identifier);
     }
 
-    protected abstract void processInteraction(Object context, InteractionIdentifier identifier);
+    protected abstract void processInteraction(
+        Object context, 
+        MethodContainer<InteractionIdentifier, Object> container, 
+        InteractionIdentifier identifier);
     
 }

lib/src/main/java/net/tomatentum/marinara/parser/AnnotationParser.java

@@ -1,8 +0,0 @@
-package net.tomatentum.marinara.parser;
-
-import java.lang.reflect.Method;
-
-public interface AnnotationParser {
-    void parse();
-    Method getMethod();
-}

lib/src/main/java/net/tomatentum/marinara/parser/AutocompleteParser.java

@@ -2,32 +2,26 @@ package net.tomatentum.marinara.parser;
 
 import java.lang.reflect.Method;
 import java.util.Arrays;
-import java.util.function.Consumer;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.util.ReflectionUtil;
 import net.tomatentum.marinara.interaction.annotation.AutoComplete;
 
-public class AutocompleteParser implements AnnotationParser {
+public class AutocompleteParser implements MethodParser {
 
-    private Method method;
+    private Logger logger = LoggerFactory.getLogger(getClass());
-    private Consumer<String[]> consumer;
-
-    public AutocompleteParser(Method method, Consumer<String[]> consumer) {
-        this.method = method;
-        this.consumer = consumer;
-    }
 
     @Override
-    public void parse() {
+    public Object parse(Method method, Object containingObject) {
-        String[] autocompletes = Arrays.stream(this.method.getAnnotationsByType(AutoComplete.class))
+        String[] autoCompletes = Arrays.stream(method.getAnnotationsByType(AutoComplete.class))
             .map(AutoComplete::value)
             .toArray(String[]::new);
-            this.consumer.accept(autocompletes);
+        if (autoCompletes.length > 0)
-
+            logger.trace("Parsed AutoComplete annotations {} for method {}", autoCompletes, ReflectionUtil.getFullMethodName(method));
-    }
+        return autoCompletes;
-
-    @Override
-    public Method getMethod() {
-        return this.method;
     }
     
 }

lib/src/main/java/net/tomatentum/marinara/parser/ButtonParser.java

@@ -1,36 +1,27 @@
 package net.tomatentum.marinara.parser;
 
 import java.lang.reflect.Method;
-import java.util.function.Consumer;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.util.ReflectionUtil;
 import net.tomatentum.marinara.interaction.annotation.Button;
-import net.tomatentum.marinara.util.LoggerUtil;
-import net.tomatentum.marinara.util.ReflectionUtil;
 
-public class ButtonParser implements AnnotationParser {
+public class ButtonParser implements MethodParser {
     
-    private Method method;
+    private Logger logger = LoggerFactory.getLogger(getClass());
-    private Consumer<String> consumer;
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    public ButtonParser() {
-
-    public ButtonParser(Method method, Consumer<String> consumer) {
-        this.method = method;
-        this.consumer = consumer;
     }
 
     @Override
-    public void parse() {
+    public Object parse(Method method, Object containingObject) {
-        Button button = getMethod().getAnnotation(Button.class);
+        Button button = method.getAnnotation(Button.class);
-        logger.trace("Parsed Button annotation {} for method {}", button.toString(), ReflectionUtil.getFullMethodName(method));
+        if (button == null) return null;
-        this.consumer.accept(button.value());
+        logger.trace("Parsed Button annotation {} for method {}", button, ReflectionUtil.getFullMethodName(method));
-    }
+        return button.value();
-
-    @Override
-    public Method getMethod() {
-        return this.method;
     }
     
 }

lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckClassParser.java

@@ -0,0 +1,28 @@
+package net.tomatentum.marinara.parser;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import io.leangen.geantyref.GenericTypeReflector;
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.marinara.checks.InteractionCheck;
+
+public class InteractionCheckClassParser implements MethodParser {
+
+    private Logger logger = LoggerFactory.getLogger(getClass());
+
+    @Override
+    public Object parse(Method method, Object containingObject) {
+        ParameterizedType type = (ParameterizedType) GenericTypeReflector.getExactSuperType(containingObject.getClass(), InteractionCheck.class);
+        if (type == null) return null;
+        Type typeParam = type.getActualTypeArguments().length == 1 ? type.getActualTypeArguments()[0] : null;
+        if (typeParam != null)
+            logger.trace("Parsed InteractionCheck Annotation {}", typeParam);
+        return typeParam;
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckParser.java

@@ -3,49 +3,47 @@ package net.tomatentum.marinara.parser;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.Arrays;
-import java.util.Optional;
+import java.util.Objects;
-import java.util.function.Consumer;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.container.MethodContainer;
+import net.tomatentum.cutin.util.ReflectionUtil;
 import net.tomatentum.marinara.checks.AppliedCheck;
-import net.tomatentum.marinara.checks.InteractionCheck;
+import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.registry.InteractionCheckRegistry;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier;
-import net.tomatentum.marinara.util.LoggerUtil;
+import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType;
-import net.tomatentum.marinara.util.ReflectionUtil;
 
-public class InteractionCheckParser implements AnnotationParser {
+public class InteractionCheckParser implements MethodParser {
 
-    private InteractionCheckRegistry checkRegistry;
+    private MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
-    private Method method;
-    private Consumer<AppliedCheck> consumer;
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    private Logger logger = LoggerFactory.getLogger(getClass());
 
-    public InteractionCheckParser(Method method, Consumer<AppliedCheck> consumer, InteractionCheckRegistry checkRegistry) {
+    public InteractionCheckParser(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer) {
-        this.checkRegistry = checkRegistry;
+        this.checkContainer = checkContainer;
-        this.method = method;
-        this.consumer = consumer;
     }
 
     @Override
-    public void parse() {
+    public Object parse(Method method, Object containingObject) {
         Annotation[] annotations = method.getAnnotations();
-        Arrays.stream(annotations).forEach(this::convertAnnotation);
+        return Arrays.stream(annotations)
+            .map(a -> convertAnnotation(a, method))
+            .filter(Objects::nonNull)
+            .toList();
     }
 
-    private void convertAnnotation(Annotation annotation) {
+    private AppliedCheck convertAnnotation(Annotation annotation, Method method) {
-            Optional<InteractionCheck<?>> check = this.checkRegistry.getCheckFromAnnotation(annotation.annotationType());
+            var preExec = this.checkContainer.findFirstFor(new CheckMethodIdentifier(annotation.annotationType(), CheckMethodType.PRE));
-            if (check.isPresent())  {
+            var postExec = this.checkContainer.findFirstFor(new CheckMethodIdentifier(annotation.annotationType(), CheckMethodType.POST));
-                AppliedCheck appliedCheck = new AppliedCheck(check.get(), annotation);
+            if (preExec.isPresent() && postExec.isPresent())  {
-                logger.trace("Parsed InteractionCheck {} for annotation {} for method {}", check.getClass().getName(), annotation.toString(), ReflectionUtil.getFullMethodName(method));
+                AppliedCheck appliedCheck = new AppliedCheck(annotation, preExec.get(), postExec.get());
-                consumer.accept(appliedCheck);
+                logger.trace("Parsed InteractionCheck {} for annotation {} for method {}", preExec.get().containingObject(), annotation, ReflectionUtil.getFullMethodName(method));
+                return appliedCheck;
             }
-    }
+            return null;
-
-    @Override
-    public Method getMethod() {
-        return this.method;
     }
     
 }

lib/src/main/java/net/tomatentum/marinara/parser/SlashCommandParser.java

@@ -1,33 +1,28 @@
 package net.tomatentum.marinara.parser;
 
 import java.lang.reflect.Method;
-import java.util.function.Consumer;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.util.ReflectionUtil;
 import net.tomatentum.marinara.interaction.InteractionType;
 import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
-import net.tomatentum.marinara.util.LoggerUtil;
-import net.tomatentum.marinara.util.ReflectionUtil;
 
-public class SlashCommandParser implements AnnotationParser {
+public class SlashCommandParser implements MethodParser {
 
-    private Method method;
+    private Logger logger = LoggerFactory.getLogger(getClass());
-    private Consumer<SlashCommandIdentifier> consumer;
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    public SlashCommandParser() {
-
-    public SlashCommandParser(Method method, Consumer<SlashCommandIdentifier> consumer) {
-        this.method = method;
-        this.consumer = consumer;
     }
 
     @Override
-    public void parse() {
+    public Object parse(Method method, Object containingObject) {
+        if (!method.isAnnotationPresent(SlashCommand.class) && !method.isAnnotationPresent(SubCommand.class)) return null;
         this.checkValidCommandMethod(method);
 
         SlashCommand cmd = ReflectionUtil.getAnnotation(method, SlashCommand.class);
@@ -57,27 +52,22 @@ public class SlashCommandParser implements AnnotationParser {
                 .build();
         }
 
-        logger.trace("Parsed using SlashCommandParser for method {} with the result: {}", ReflectionUtil.getFullMethodName(method), lastIdentifier.toString());
+        logger.trace("Parsed using SlashCommandParser for method {} with the result: {}", ReflectionUtil.getFullMethodName(method), lastIdentifier);
-        consumer.accept((SlashCommandIdentifier) lastIdentifier);
+        return lastIdentifier;
-    }
-
-    @Override
-    public Method getMethod() {
-       return this.method;
     }
 
     private void checkValidCommandMethod(Method method) {
         if (method.isAnnotationPresent(SlashCommand.class) && 
             method.getDeclaringClass().isAnnotationPresent(SlashCommand.class)) {
-            throw new RuntimeException(method.getName() + ": Can't have ApplicationCommand Annotation on Class and Method");
+            throw new RuntimeException(method.getName() + ": Can't have SlashCommand Annotation on Class and Method");
         }
 
         if (!ReflectionUtil.isAnnotationPresent(method, SlashCommand.class))
-            throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Class or Method");
+            throw new RuntimeException(method.getName() + ": Missing SlashCommand Annotation on either Class or Method");
 
         if ((method.isAnnotationPresent(SubCommand.class) && 
             !ReflectionUtil.isAnnotationPresent(method, SlashCommand.class))) {
-            throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Method or Class");
+            throw new RuntimeException(method.getName() + ": Missing SlashCommand Annotation on either Method or Class");
         }
     }
     

lib/src/main/java/net/tomatentum/marinara/reflection/MethodExecutor.java

@@ -1,7 +0,0 @@
-package net.tomatentum.marinara.reflection;
-
-public interface MethodExecutor {
-
-    void handle(Object context);
-
-}

lib/src/main/java/net/tomatentum/marinara/reflection/MethodProcessor.java

@@ -1,7 +0,0 @@
-package net.tomatentum.marinara.reflection;
-
-public interface MethodProcessor {
-
-    void process(Object context);
-    
-}

lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorContainer.java

@@ -1,7 +0,0 @@
-package net.tomatentum.marinara.reflection;
-
-public interface ProcessorContainer {
-
-    ProcessorContainer addProcessor(MethodProcessor processor);
-    
-}

lib/src/main/java/net/tomatentum/marinara/reflection/ProcessorMethodExecutor.java

@@ -1,32 +0,0 @@
-package net.tomatentum.marinara.reflection;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import org.slf4j.Logger;
-
-import net.tomatentum.marinara.util.LoggerUtil;
-
-public class ProcessorMethodExecutor implements MethodExecutor, ProcessorContainer {
-
-    private Logger logger = LoggerUtil.getLogger(getClass());
-
-    private Set<MethodProcessor> processors;
-
-    public ProcessorMethodExecutor() {
-        this.processors = new HashSet<>();
-    }
-
-    @Override
-    public ProcessorContainer addProcessor(MethodProcessor processor) {
-        processors.add(processor);
-        return this;
-    }
-
-    @Override
-    public void handle(Object context) {
-        logger.debug("Received {} interaction ", context);
-        processors.forEach(x -> x.process(context));
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethod.java

@@ -1,66 +0,0 @@
-package net.tomatentum.marinara.reflection;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.security.InvalidParameterException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.slf4j.Logger;
-
-import net.tomatentum.marinara.util.LoggerUtil;
-import net.tomatentum.marinara.util.ReflectionUtil;
-
-public abstract class ReflectedMethod {
-
-    private Logger logger = LoggerUtil.getLogger(getClass());
-
-    private Method method;
-    private Object containingObject;
-
-    public ReflectedMethod(Method method, Object containingObject) {
-        if (!Arrays.asList(containingObject.getClass().getMethods()).contains(method))
-            throw new InvalidParameterException("Method does not apply to specified handler");
-        this.method = method;
-        this.containingObject = containingObject;
-    }
-
-    public abstract Object getParameter(Object context, int index);
-
-    public Object run(Object context) {
-        method.setAccessible(true);
-        try {
-            return method.invoke(containingObject, getParameters(context));
-        }catch (IllegalAccessException | InvocationTargetException ex) {
-            logger.error("ReflectedMethod failed to run", ex);
-            return null;
-        }
-    }
-
-    public Method method() {
-        return this.method;
-    }
-
-    public Object containingObject() {
-        return this.containingObject;
-    }
-
-    private Object[] getParameters(Object context) {
-        int parameterCount = method.getParameterCount();
-        List<Object> parameters = new ArrayList<>();
-        
-        for (int i = 0; i < parameterCount; i++) {
-            Object parameter;
-            if (i == 0) {
-                parameter = context;
-            }else
-                parameter = getParameter(context, i-1);
-
-            logger.trace("Found parameter {}={} for method {}", parameter != null ? parameter.getClass().toString() : " ", parameter, ReflectionUtil.getFullMethodName(method));
-            parameters.add(parameter);   
-        }
-        return parameters.toArray();
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactory.java

@@ -1,20 +0,0 @@
-package net.tomatentum.marinara.reflection;
-
-import java.lang.reflect.Method;
-import java.util.List;
-import java.util.Optional;
-
-import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.parser.AnnotationParser;
-
-public interface ReflectedMethodFactory {
-    Optional<ReflectedMethod> produce(Method method, Object containingClass);
-    ReflectedMethodFactory addFactory(Factory factory);
-
-    public interface Factory {
-
-        Optional<ReflectedMethod> produce(Marinara marinara, Method method, Object containingObject);
-        void addParser(ReflectedMethod method, List<AnnotationParser> parser);
-
-    }
-}

lib/src/main/java/net/tomatentum/marinara/reflection/ReflectedMethodFactoryImpl.java

@@ -1,62 +0,0 @@
-package net.tomatentum.marinara.reflection;
-
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-import org.slf4j.Logger;
-
-import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.parser.AnnotationParser;
-import net.tomatentum.marinara.util.LoggerUtil;
-import net.tomatentum.marinara.util.ReflectionUtil;
-
-public class ReflectedMethodFactoryImpl implements ReflectedMethodFactory {
-
-    private Logger logger = LoggerUtil.getLogger(getClass());
-
-    private Marinara marinara;
-    private List<Factory> factories;
-
-    public ReflectedMethodFactoryImpl(Marinara marinara) {
-        this(marinara, new ArrayList<>());
-    }
-
-    public ReflectedMethodFactoryImpl(Marinara marinara, List<Factory> factories) {
-        this.marinara = marinara;
-        this.factories = factories;
-    }
-
-    @Override
-    public Optional<ReflectedMethod> produce(Method method, Object containingClass) {
-        Optional<ReflectedMethod> imethod = this.factories.stream()
-            .map(f -> factoryProduce(f, method, containingClass))
-            .filter(Optional::isPresent)
-            .map(Optional::get)
-            .findFirst();
-
-        if (imethod.isEmpty()) {
-            logger.debug("Could not produce a ReflectedMethod for Method {}", ReflectionUtil.getFullMethodName(method));
-        }
-
-        return imethod;
-    }
-
-    @Override
-    public ReflectedMethodFactory addFactory(Factory factory) {
-        this.factories.add(factory);
-        return this;
-    }
-
-    private Optional<ReflectedMethod> factoryProduce(Factory factory, Method method, Object containingClass) {
-        List<AnnotationParser> parser = new ArrayList<>();
-        Optional<ReflectedMethod> m = factory.produce(this.marinara, method, containingClass);
-        m.ifPresent(x -> {
-            factory.addParser(x, parser); 
-            parser.forEach(AnnotationParser::parse);
-        });
-        return m;
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/registry/InteractionCheckRegistry.java

@@ -1,40 +0,0 @@
-package net.tomatentum.marinara.registry;
-
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-import org.slf4j.Logger;
-
-import io.leangen.geantyref.GenericTypeReflector;
-import net.tomatentum.marinara.checks.InteractionCheck;
-import net.tomatentum.marinara.util.LoggerUtil;
-
-public class InteractionCheckRegistry {
-    
-    private List<InteractionCheck<?>> checks;
-
-    private Logger logger = LoggerUtil.getLogger(getClass());
-
-    public InteractionCheckRegistry() {
-        this.checks = new ArrayList<>();
-    }
-
-    public void addCheck(InteractionCheck<?> check) {
-        checks.add(check);
-        logger.info("Registered Check {}", check.getClass().getName());
-    }
-
-    public Optional<InteractionCheck<?>> getCheckFromAnnotation(Type annotation) {
-        for (InteractionCheck<?> interactionCheck : checks) {
-            ParameterizedType type = (ParameterizedType) GenericTypeReflector.getExactSuperType(interactionCheck.getClass(), InteractionCheck.class);
-            Type typeParam = type.getActualTypeArguments()[0];
-            if (typeParam.equals(annotation))
-                return Optional.of(interactionCheck);
-        }
-        return Optional.empty();
-    }
-
-}

lib/src/main/java/net/tomatentum/marinara/registry/InteractionEntry.java

@@ -1,90 +0,0 @@
-package net.tomatentum.marinara.registry;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Stream;
-
-import org.slf4j.Logger;
-
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.methods.InteractionMethod;
-import net.tomatentum.marinara.util.LoggerUtil;
-
-public class InteractionEntry {
-
-    public static InteractionEntry findEntry(Set<InteractionEntry> entries, InteractionIdentifier identifier) {
-        Optional<InteractionEntry> oentry = entries.stream()
-            .filter(i -> i.identifier().equals(identifier))
-            .findFirst();
-
-        InteractionEntry entry = oentry.orElse(new InteractionEntry(identifier));
-        if (oentry.isEmpty()) entries.add(entry);
-        return entry;
-    }
-
-    private InteractionIdentifier identifier;
-    private Set<InteractionMethod> methods;
-
-    private Logger logger = LoggerUtil.getLogger(getClass());
-
-    public InteractionEntry(InteractionIdentifier identifier) {
-        this.identifier = identifier;
-        this.methods = new HashSet<>();
-    }
-
-    public InteractionEntry addMethod(InteractionMethod method) {
-        InteractionIdentifier midentifier = method.identifier();
-
-        if (!this.identifier().equals(midentifier))
-            throw new IllegalArgumentException("Method's identifier did not equal the entry's identifier");
-
-        this.methods.add(method);
-        InteractionIdentifier.tryAddDescriptions(midentifier, midentifier);
-        logger.debug("Added method {} to entry {}", method.method().getName(), this.identifier);
-        return this;
-    }
-
-    public Object[] runAll(Object context) {
-        return this.methods.stream()
-            .map(x -> {
-                logger.debug("Running Method {} from {} with context {}", x, this, context);
-                return x.run(context);
-            })
-            .flatMap(o -> o instanceof Object[] oArray ? Arrays.stream(oArray) : Stream.<Object>of(o))
-            .toArray();
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (!(obj instanceof InteractionEntry))
-            return false;
-        InteractionEntry other = (InteractionEntry) obj;
-        return other.identifier().equals(identifier());
-    }
-
-    @Override
-    public int hashCode() {
-        return this.identifier().hashCode();
-    }
-
-    @Override
-    public String toString() {
-        return "InteractionEntry(%s)".formatted(identifier().toString());
-    }
-
-    public InteractionType type() {
-        return identifier().type();
-    }
-
-    public InteractionIdentifier identifier() {
-        return identifier;
-    }
-
-    public Set<InteractionMethod> methods() {
-        return methods;
-    }
-
-}

lib/src/main/java/net/tomatentum/marinara/registry/InteractionRegistry.java

@@ -1,80 +0,0 @@
-package net.tomatentum.marinara.registry;
-
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-
-import org.slf4j.Logger;
-
-import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
-import net.tomatentum.marinara.interaction.components.methods.ButtonInteractionMethod;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
-import net.tomatentum.marinara.util.LoggerUtil;
-import net.tomatentum.marinara.util.ObjectAggregator;
-import net.tomatentum.marinara.interaction.methods.AutoCompleteInteractionMethod;
-import net.tomatentum.marinara.interaction.methods.InteractionMethod;
-import net.tomatentum.marinara.interaction.methods.SlashCommandInteractionMethod;
-import net.tomatentum.marinara.reflection.ReflectedMethod;
-
-public class InteractionRegistry {
-    private Logger logger = LoggerUtil.getLogger(getClass());
-    private Set<InteractionEntry> interactions;
-    private Marinara marinara;
-
-    public InteractionRegistry(Marinara marinara) {
-        this.interactions = new HashSet<>();
-        this.marinara = marinara;
-        marinara.getReflectedMethodFactory()
-            .addFactory(new AutoCompleteInteractionMethod.Factory())
-            .addFactory(new SlashCommandInteractionMethod.Factory())
-            .addFactory(new ButtonInteractionMethod.Factory());
-
-    }
-    
-    public void addInteractions(InteractionHandler interactionHandler) {
-        for (Method method : interactionHandler.getClass().getDeclaredMethods()) {
-            Optional<ReflectedMethod> rMethod = this.marinara.getReflectedMethodFactory().produce(method, interactionHandler);
-            rMethod.ifPresent(x -> {
-                if (x instanceof InteractionMethod) {
-                    InteractionMethod iMethod = (InteractionMethod) x;
-                    InteractionEntry.findEntry(interactions, iMethod.identifier()).addMethod(iMethod);
-                    logger.debug("Added {} method from {}", iMethod.method().getName(), interactionHandler.getClass().getSimpleName());                    
-                }
-            });
-        }
-        logger.info("Added all Interactions from {}", interactionHandler.getClass().getSimpleName());
-    }
-
-    public void registerCommands() {
-        List<InteractionIdentifier> slashIdentifiers = interactions.stream()
-            .filter((x) -> x.type().equals(InteractionType.COMMAND))
-            .map((x) -> x.identifier())
-            .toList();
-
-        SlashCommandDefinition[] defs = new ObjectAggregator<InteractionIdentifier, RootCommandIdentifier, SlashCommandDefinition>(
-            i -> Arrays.asList((RootCommandIdentifier)i.rootNode()),
-            SlashCommandDefinition::addIdentifier,
-            SlashCommandDefinition::new)
-            .aggregate(slashIdentifiers)
-            .toArray(SlashCommandDefinition[]::new);
-
-        marinara.getWrapper().getRegisterer().register(defs);
-    }
-
-    public Optional<InteractionEntry> findFor(InteractionIdentifier identifier) {
-        return this.interactions.stream()
-            .filter(x -> x.identifier().equals(identifier))
-            .findFirst();
-    }
-
-    public Set<InteractionEntry> interactions() {
-        return this.interactions;
-    }
-}

lib/src/main/java/net/tomatentum/marinara/structure/ComponentStructureMethod.java

@@ -0,0 +1,64 @@
+package net.tomatentum.marinara.structure;
+
+import java.lang.reflect.Method;
+import java.util.Optional;
+import java.util.Set;
+
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.ReflectedMethodFactory;
+import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
+import net.tomatentum.cutin.method.ReflectedMethod;
+import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+import net.tomatentum.marinara.structure.parser.ComponentStructureParser;
+
+public class ComponentStructureMethod extends ReflectedMethod<InteractionIdentifier, Void> {
+
+    private InteractionIdentifier identifier;
+
+    private ComponentStructureMethod(
+            Method method, 
+            Object containingObject,
+            InteractionIdentifier identifier
+        ) {
+        super(method, containingObject);
+        this.identifier = identifier;
+    }
+
+    @Override
+    public Object getParameter(Void context, int index) {
+        return null;
+    }
+
+    @Override
+    public InteractionIdentifier identifier() {
+        return this.identifier;
+    }
+
+    public static class Factory implements ReflectedMethodFactory.Factory<InteractionIdentifier, Void> {
+
+        private Class<? extends Object> buttonClass;
+
+        public Factory(Class<? extends Object> buttonClass) {
+            this.buttonClass = buttonClass;
+        }
+
+        @Override
+        public void addParser(Set<MethodParser> parser) {
+            parser.add(new ComponentStructureParser(buttonClass));
+        }
+
+        @Override
+        public Optional<ReflectedMethod<InteractionIdentifier, Void>> produce(
+                Method method, 
+                Object containingObject,
+                ParserResults parserResults) {
+            InteractionIdentifier identifier = parserResults.get(ComponentStructureParser.class);
+            if (identifier == null)
+                return Optional.empty();
+            
+            return Optional.of(new ComponentStructureMethod(method, containingObject, identifier));
+        }
+
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/structure/MethodStructureProvider.java

@@ -0,0 +1,39 @@
+package net.tomatentum.marinara.structure;
+
+import java.util.Optional;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import net.tomatentum.cutin.ReflectedMethodFactoryImpl;
+import net.tomatentum.cutin.container.LoneMethodContainer;
+import net.tomatentum.cutin.method.ReflectedMethod;
+import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+
+public class MethodStructureProvider<B extends Object> 
+    extends LoneMethodContainer<InteractionIdentifier, Void>
+    implements StructureProvider<B> {
+
+    private Logger logger = LoggerFactory.getLogger(getClass());
+
+    private Class<? extends B> buttonClass;
+
+    public MethodStructureProvider(Class<? extends B> buttonClass) {
+        super(new ReflectedMethodFactoryImpl<>());
+        super.factory().addFactory(new ComponentStructureMethod.Factory(buttonClass));
+        this.buttonClass = buttonClass;
+    }
+
+    @Override
+    public B button(InteractionIdentifier identifier) {
+        Optional<ReflectedMethod<InteractionIdentifier, Void>> method = super.findFirstFor(identifier);
+        if (method.isEmpty()) return null;
+        try {
+            return buttonClass.cast(method.get().run(null));
+        }catch (ClassCastException ex) {
+            logger.warn("Structure Method {} return type did not match expected {}", method.get(), buttonClass);
+            return null;
+        }
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/structure/PriorityStructureProvider.java

@@ -0,0 +1,31 @@
+package net.tomatentum.marinara.structure;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+
+public class PriorityStructureProvider<B extends Object> implements StructureProvider<B> {
+
+    private Map<Short, StructureProvider<B>> providerMap;
+
+    public PriorityStructureProvider() {
+        this.providerMap = new TreeMap<>();
+    }
+
+    public PriorityStructureProvider<B> addProvider(StructureProvider<B> provider, short priority) {
+        this.providerMap.put(priority, provider);
+        return this;
+    }
+
+    @Override
+    public B button(InteractionIdentifier identifier) {
+        for (short priority : this.providerMap.keySet()) {
+            B result = this.providerMap.get(priority).button(identifier);
+            if (result != null)
+                return result;
+        }
+        return null;
+    }
+
+}

lib/src/main/java/net/tomatentum/marinara/structure/StaticStructureProvider.java

@@ -0,0 +1,31 @@
+package net.tomatentum.marinara.structure;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+import net.tomatentum.marinara.structure.data.ButtonStructureData;
+import net.tomatentum.marinara.wrapper.ComponentStructureConverter;
+
+public class StaticStructureProvider<B extends Object> implements StructureProvider<B> {
+
+    private ComponentStructureConverter<B> converter;
+
+    private Map<InteractionIdentifier, B> buttonMap;
+
+    public StaticStructureProvider(ComponentStructureConverter<B> converter) {
+        this.converter = converter;
+        this.buttonMap = new HashMap<>();
+    }
+
+    public StaticStructureProvider<B> addButton(InteractionIdentifier identifier, ButtonStructureData data) {
+        this.buttonMap.put(identifier, this.converter.convertButton(data));
+        return this;
+    }
+    
+    @Override
+    public B button(InteractionIdentifier identifier) {
+        return this.buttonMap.get(identifier);
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/structure/StructureProvider.java

@@ -0,0 +1,7 @@
+package net.tomatentum.marinara.structure;
+
+import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+
+public interface StructureProvider<B extends Object> {
+    B button(InteractionIdentifier identifier);
+}

lib/src/main/java/net/tomatentum/marinara/structure/annotation/ComponentStructure.java

@@ -0,0 +1,5 @@
+package net.tomatentum.marinara.structure.annotation;
+
+public @interface ComponentStructure {
+    public String customId();
+}

lib/src/main/java/net/tomatentum/marinara/structure/data/ButtonStructureData.java

@@ -0,0 +1,26 @@
+package net.tomatentum.marinara.structure.data;
+
+import net.tomatentum.marinara.interaction.annotation.Button;
+
+public record ButtonStructureData(
+    String customId, 
+    String label,
+    ButtonStyle style,
+    String url,
+    boolean disabled,
+    String emoji
+    ) {
+
+    public ButtonStructureData(Button button) {
+        this(button.value(), button.label(), button.style(), button.url(), button.disabled(), button.emoji());
+    }
+
+    public enum ButtonStyle {
+        PRIMARY,
+        SECONDARY,
+        SUCCESS,
+        DANGER,
+        LINK;
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/structure/parser/ComponentStructureParser.java

@@ -0,0 +1,44 @@
+package net.tomatentum.marinara.structure.parser;
+
+import java.lang.reflect.Method;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import net.tomatentum.cutin.MethodParser;
+import net.tomatentum.cutin.util.ReflectionUtil;
+import net.tomatentum.marinara.interaction.InteractionType;
+import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+import net.tomatentum.marinara.structure.annotation.ComponentStructure;
+
+public class ComponentStructureParser implements MethodParser {
+
+    private Logger logger = LoggerFactory.getLogger(getClass());
+
+    private Class<? extends Object> buttonClass;
+
+    public ComponentStructureParser(Class<? extends Object> buttonClass) {
+        this.buttonClass = buttonClass;
+    }
+
+    @Override
+    public Object parse(Method method, Object containingObject) {
+        if (!method.isAnnotationPresent(ComponentStructure.class)) 
+            return null;
+        InteractionIdentifier.Builder builder = InteractionIdentifier.builder()
+            .name(method.getAnnotation(ComponentStructure.class).customId());
+
+        if (buttonClass.isAssignableFrom(method.getReturnType()))
+            builder.type(InteractionType.BUTTON);
+
+        if (builder.type() == null) {
+            logger.error("Structure Method {} return type did not match any of the required {}", String.join(","), buttonClass);
+            return null;
+        }
+
+        logger.trace("Parsed Structure Method of {} with result {}", ReflectionUtil.getFullMethodName(method), builder.build());
+        return builder.build();
+
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/util/LoggerUtil.java

@@ -1,17 +0,0 @@
-package net.tomatentum.marinara.util;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.slf4j.helpers.NOPLoggerFactory;
-
-public class LoggerUtil {
-    public static Logger getLogger(String name) {
-        if (LoggerFactory.getILoggerFactory() instanceof NOPLoggerFactory)
-            return new SimpleLogger(name);
-        return LoggerFactory.getLogger(name);
-    }
-
-    public static Logger getLogger(Class<?> clazz) {
-        return getLogger(clazz.getName());
-    }
-}

lib/src/main/java/net/tomatentum/marinara/util/ReflectionUtil.java

@@ -1,107 +0,0 @@
-package net.tomatentum.marinara.util;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
-
-public final class ReflectionUtil {
-
-    public static <T extends Annotation> boolean isAnnotationPresent(Method method, Class<T> annotationClass) {
-        if (method.isAnnotationPresent(annotationClass) || method.getDeclaringClass().isAnnotationPresent(annotationClass))
-            return true;
-
-        return false;
-    }
-
-    public static <T extends Annotation> T getAnnotation(Method method, Class<T> annotationClass) {
-        return method.isAnnotationPresent(annotationClass) ? 
-            method.getAnnotation(annotationClass) : 
-            method.getDeclaringClass().getAnnotation(annotationClass);
-    }
-
-    public static int getCastDepth(Class<?> child, Class<?> parent) {
-
-        if (parent.equals(Object.class))
-            return Integer.MAX_VALUE;
-
-        if (!parent.isAssignableFrom(child)) {
-            throw new IllegalArgumentException("The specified class is not a child class of the specified parent.");
-        }
-
-        int depth = 0;
-        Class<?> curr = child;
-        List<Class<?>> parents = new ArrayList<>();
-
-        while (!curr.equals(parent)) {
-            depth++;
-            parents.add(curr.getSuperclass());
-            parents.addAll(Arrays.asList(curr.getInterfaces()));
-
-            for (Class<?> currParent : parents) {
-                if (currParent != null && parent.isAssignableFrom(currParent)) {
-                    curr = currParent;
-                    break;
-                }
-            }
-            parents.clear();
-        }
-
-        return depth;
-    }
-    
-    public static Method getMostSpecificMethod(Method[] methods, Class<?>... parameters) {
-        List<Method> compatibleMethods = Arrays.stream(methods)
-            .filter(x -> isMethodCallable(x, parameters))
-            .toList();
-
-        if (compatibleMethods.size() == 0)
-            throw new IllegalArgumentException("There are no compatible Methods provided");
-
-        for (int i = 0; i < parameters.length; i++) {
-            final int currI = i;
-            Class<?>[] parameterTypes = compatibleMethods.stream()
-                .map(x -> x.getParameterTypes()[currI])
-                .toArray(x -> new Class[x]);
-
-            Class<?> mostSpecific = getMostSpecificClass(parameterTypes, parameters[i]);
-
-            compatibleMethods = compatibleMethods.stream()
-                .filter(x -> Objects.equals(x.getParameterTypes()[currI], mostSpecific))
-                .toList();
-        }
-        
-        return compatibleMethods.getFirst();
-    }
-
-    public static Class<?> getMostSpecificClass(Class<?>[] classes, Class<?> base) {
-        int min = Integer.MAX_VALUE;
-        Class<?> currMostSpecific = null;
-        for (Class<?> currClass : classes) {
-            int currCastDepth = getCastDepth(base, currClass);
-            if (currCastDepth <= min) {
-                min = currCastDepth;
-                currMostSpecific = currClass;
-            }
-        }
-        return currMostSpecific;
-    }
-
-    public static boolean isMethodCallable(Method method, Class<?>... parameters) {
-        if (!Objects.equals(method.getParameterCount(), parameters.length))
-            return false;
-
-        Class<?>[] methodParams = method.getParameterTypes();
-        for (int i = 0; i < parameters.length; i++) {
-            if (!methodParams[i].isAssignableFrom(parameters[i]))
-                return false;
-        }
-        return true;
-    }
-
-    public static String getFullMethodName(Method method) {
-        return method.getDeclaringClass().getName() + "." + method.getName();
-    }
-}

lib/src/main/java/net/tomatentum/marinara/util/SimpleLogger.java

@@ -1,55 +0,0 @@
-package net.tomatentum.marinara.util;
-
-import org.slf4j.Marker;
-import org.slf4j.event.Level;
-import org.slf4j.helpers.LegacyAbstractLogger;
-import org.slf4j.helpers.MessageFormatter;
-
-public class SimpleLogger extends LegacyAbstractLogger {
-
-    private String name;
-
-    public SimpleLogger(String name) {
-        this.name = name;
-    }
-
-    @Override
-    public boolean isTraceEnabled() {
-        return true;
-    }
-
-    @Override
-    public boolean isDebugEnabled() {
-        return true;
-    }
-
-    @Override
-    public boolean isInfoEnabled() {
-        return true;
-    }
-
-    @Override
-    public boolean isWarnEnabled() {
-        return true;
-    }
-
-    @Override
-    public boolean isErrorEnabled() {
-        return true;
-    }
-
-    @Override
-    protected String getFullyQualifiedCallerName() {
-        return this.name;
-    }
-
-    @Override
-    protected void handleNormalizedLoggingCall(Level level, Marker marker, String messagePattern, Object[] arguments,
-            Throwable throwable) {
-        String formatted = MessageFormatter.basicArrayFormat(messagePattern, arguments);
-        System.out.println("[%s] %s => %s".formatted(level, this.name, formatted));
-    }
-
-
-    
-}

lib/src/main/java/net/tomatentum/marinara/wrapper/CommandConverter.java

@@ -5,6 +5,7 @@ import java.util.Arrays;
 import java.util.List;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
 import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
@@ -12,7 +13,6 @@ import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptio
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
 import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
 import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
-import net.tomatentum.marinara.util.LoggerUtil;
 
 public class CommandConverter<A extends Object, O extends Object, C extends Object> {
 
@@ -20,7 +20,7 @@ public class CommandConverter<A extends Object, O extends Object, C extends Obje
         return new CommandConverter<>(spec);
     }
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    private Logger logger = LoggerFactory.getLogger(getClass());
 
     private Spec<A, O, C> spec;
 

lib/src/main/java/net/tomatentum/marinara/wrapper/CommandRegisterer.java

@@ -5,9 +5,9 @@ import java.util.Set;
 import java.util.stream.Collectors;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
-import net.tomatentum.marinara.util.LoggerUtil;
 import net.tomatentum.marinara.util.ObjectAggregator;
 
 public class CommandRegisterer<A extends Object> {
@@ -16,7 +16,7 @@ public class CommandRegisterer<A extends Object> {
         return new CommandRegisterer<A>(strategy, converter);
     }
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    private Logger logger = LoggerFactory.getLogger(getClass());
 
     private Strategy<A> strategy;
     private CommandConverter<A, ?, ?> converter;
@@ -29,13 +29,17 @@ public class CommandRegisterer<A extends Object> {
     public void register(SlashCommandDefinition[] slashDefs) {
         Set<ServerCommandList<A>> serverCommands = new ObjectAggregator<SlashCommandDefinition, Long, ServerCommandList<A>>(
                 def -> Arrays.stream(def.serverIds()).boxed().toList(),
-                (l, o) -> l.add(converter.convert(o)),
+                (l, o) -> {
+                    logger.debug("Added {} for server ({}) registration.", o.rootIdentifier(), l.serverId());
+                    l.add(converter.convert(o));
+                },
                 ServerCommandList::new)
             .aggregate(Arrays.asList(slashDefs)).stream()
             .collect(Collectors.toSet());
 
         Set<A> globalCommands = Arrays.stream(slashDefs)
             .filter(x -> x.serverIds().length <= 0)
+            .peek(c -> logger.debug("Added {} for global registration.", c.rootIdentifier()))
             .map(converter::convert)
             .collect(Collectors.toSet());
 

lib/src/main/java/net/tomatentum/marinara/wrapper/ComponentStructureConverter.java

@@ -0,0 +1,9 @@
+package net.tomatentum.marinara.wrapper;
+
+import net.tomatentum.marinara.structure.data.ButtonStructureData;
+
+public interface ComponentStructureConverter<B extends Object> {
+
+    B convertButton(ButtonStructureData data);
+    
+}

lib/src/main/java/net/tomatentum/marinara/wrapper/IdentifierProvider.java

@@ -8,11 +8,11 @@ import java.util.List;
 import java.util.Map;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import io.leangen.geantyref.GenericTypeReflector;
+import net.tomatentum.cutin.util.ReflectionUtil;
 import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.util.LoggerUtil;
-import net.tomatentum.marinara.util.ReflectionUtil;
 
 public class IdentifierProvider {
 
@@ -20,8 +20,9 @@ public class IdentifierProvider {
         return new IdentifierProvider(Arrays.asList(converter));
     }
 
+    private Logger logger = LoggerFactory.getLogger(getClass());
+
     private Map<Class<?>, Converter<?>> converter;
-    private Logger logger = LoggerUtil.getLogger(getClass());
 
     private IdentifierProvider(List<Converter<?>> converter) {
         this.converter = new HashMap<>();
@@ -47,7 +48,9 @@ public class IdentifierProvider {
         @SuppressWarnings("unchecked")
         Converter<Object> conv = (Converter<Object>) converter.get(type);
 
-        return conv.convert(context);
+        InteractionIdentifier result = conv.convert(context);
+        logger.trace("Converted {} to {} using {}", context, result, conv);
+        return result;
     }
 
     @FunctionalInterface

wrapper/discord4j/build.gradle.kts

@@ -10,11 +10,6 @@ plugins {
     `java-library`
 }
 
-repositories {
-    // Use Maven Central for resolving dependencies.
-    mavenCentral()
-}
-
 dependencies {
     // Use JUnit Jupiter for testing.
     testImplementation(libs.junit.jupiter)
@@ -22,6 +17,8 @@ dependencies {
     testImplementation(libs.discord4j)
 
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    testImplementation(libs.slf4j.simple)
+
     implementation(libs.slf4j)
     implementation(libs.discord4j) {
         exclude(module="discord4j-voice")

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/Discord4JWrapper.java

@@ -4,6 +4,7 @@ import java.util.List;
 import java.util.function.UnaryOperator;
 
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import discord4j.core.GatewayDiscordClient;
 import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
@@ -13,7 +14,6 @@ import discord4j.core.object.command.ApplicationCommandOption.Type;
 import discord4j.discordjson.json.ApplicationCommandOptionChoiceData;
 import discord4j.discordjson.json.ApplicationCommandRequest;
 
-import net.tomatentum.marinara.util.LoggerUtil;
 import net.tomatentum.marinara.wrapper.CommandConverter;
 import net.tomatentum.marinara.wrapper.CommandRegisterer;
 import net.tomatentum.marinara.wrapper.ContextObjectProvider;
@@ -37,7 +37,7 @@ public class Discord4JWrapper extends LibraryWrapper {
     private Discord4JContextObjectProvider contextObjectProvider;
     private CommandRegisterer<ApplicationCommandRequest> commandRegisterer;
 
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    private Logger logger = LoggerFactory.getLogger(getClass());
 
     public Discord4JWrapper(GatewayDiscordClient api) {
         this.contextObjectProvider = new Discord4JContextObjectProvider();

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/AutoCompleteTest.java

@@ -38,7 +38,7 @@ class AutoCompleteTest {
 
         LibraryWrapper wrapper = new Discord4JWrapper(null); //null okay as we don't use the discord API in this test.
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getRegistry().addInteractions(new TestAutocomplete());
+        marinara.getInteractionContainer().addAllMethods(new TestAutocomplete());
         wrapper.handleInteraction(autoCompleteEventMock);
         verify(autoCompleteEventMock).respondWithSuggestions(any());
     }

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/ButtonTest.java

@@ -13,15 +13,15 @@ import net.tomatentum.marinara.wrapper.LibraryWrapper;
 import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
 
 @TestInstance(Lifecycle.PER_CLASS)
-public class ButtonTest {
+class ButtonTest {
 
     @Test
-    public void testButtonExecution() {
+    void testButtonExecution() {
         ButtonInteractionEvent buttonEventMock = CommonMocks.getButtonEventMock("test");
 
         LibraryWrapper wrapper = new Discord4JWrapper(null); //null okay as we don't use the discord API in this test.
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getRegistry().addInteractions(new TestButton());
+        marinara.getInteractionContainer().addAllMethods(new TestButton());
         wrapper.handleInteraction(buttonEventMock);
         assertTrue(TestButton.didRun);
     }

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/InteractionCheckTest.java

@@ -24,16 +24,16 @@ import net.tomatentum.marinara.wrapper.discord4j.checks.PermissionCheck;
 import reactor.core.publisher.Mono;
 
 @TestInstance(Lifecycle.PER_CLASS)
-public class InteractionCheckTest {
+class InteractionCheckTest {
     
     @Test
-    public void testInteractionCheck() {
+    void testInteractionCheck() {
         ButtonInteractionEvent buttonEventMock = CommonMocks.getButtonEventMock("test");
 
         LibraryWrapper wrapper = new Discord4JWrapper(null);
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getCheckRegistry().addCheck(new TestInteractionCheck());
+        marinara.getCheckContainer().addAllMethods(new TestInteractionCheck());
-        marinara.getRegistry().addInteractions(new TestButton());
+        marinara.getInteractionContainer().addAllMethods(new TestButton());
         wrapper.handleInteraction(buttonEventMock);
 
         assertTrue(TestInteractionCheck.preExecuted);
@@ -42,7 +42,7 @@ public class InteractionCheckTest {
     }
 
     @Test
-    public void testPermissionCheck() {
+    void testPermissionCheck() {
         Member memberMock = mock();
         Interaction interactionMock = mock();
 
@@ -54,8 +54,8 @@ public class InteractionCheckTest {
 
         LibraryWrapper wrapper = new Discord4JWrapper(null);
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getCheckRegistry().addCheck(new PermissionCheck());
+        marinara.getCheckContainer().addAllMethods(new PermissionCheck());
-        marinara.getRegistry().addInteractions(new TestButton());
+        marinara.getInteractionContainer().addAllMethods(new TestButton());
 
         wrapper.handleInteraction(buttonEventMock);
         assertFalse(TestButton.didPermRun);

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/SlashCommandTest.java

@@ -21,10 +21,11 @@ import discord4j.core.object.command.ApplicationCommandOption.Type;
 import net.tomatentum.marinara.Marinara;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
-@TestInstance(Lifecycle.PER_CLASS)
-public class SlashCommandTest {
 
-    String DISCORD_TOKEN = System.getenv("DISCORD_TEST_TOKEN");
+@TestInstance(Lifecycle.PER_CLASS)
+class SlashCommandTest {
+
+    private static String DISCORD_TOKEN = System.getenv("DISCORD_TEST_TOKEN");
     GatewayDiscordClient client;
 
     @BeforeAll
@@ -41,8 +42,8 @@ public class SlashCommandTest {
     @Test
     void testSlashCommand() {
         Marinara marinara = Marinara.load(new Discord4JWrapper(client));
-        marinara.getRegistry().addInteractions(new TestCommand());
+        marinara.getInteractionContainer().addAllMethods(new TestCommand());
-        marinara.getRegistry().registerCommands();
+        marinara.registerCommands();
         System.out.println("Success!");
     }
     
@@ -64,7 +65,7 @@ public class SlashCommandTest {
         
         LibraryWrapper wrapper = new Discord4JWrapper(client);
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getRegistry().addInteractions(new TestCommand());
+        marinara.getInteractionContainer().addAllMethods(new TestCommand());
 
         wrapper.handleInteraction(eventMock);
     }

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestAutocomplete.java

@@ -2,8 +2,6 @@ package net.tomatentum.marinara.test.discord4j;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import java.util.Collections;
-
 import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
 import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
 import discord4j.discordjson.json.ApplicationCommandOptionChoiceData;
@@ -23,9 +21,8 @@ public class TestAutocomplete implements InteractionHandler {
                 autocompletes = @AutoComplete("testAuto")
             )
         )
-    @AutoComplete("testAuto")
     public void exec(ChatInputInteractionEvent context) {
-
+        // Not executed just there for autocomplete to work
     }
     
     @AutoComplete("testAuto")

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestCommand.java

@@ -26,7 +26,7 @@ public class TestCommand implements InteractionHandler {
         }
         )
     public void exec(ChatInputInteractionEvent event, String test) {
-        assertEquals(test, "test");
+        assertEquals("test", test);
         System.out.println("Success!");
     }
 }

wrapper/discord4j/src/test/resources/simplelogger.properties

@@ -0,0 +1,7 @@
+# SLF4J's SimpleLogger configuration file
+# Simple implementation of Logger that sends all enabled log messages, for all defined loggers, to System.err.
+
+# Default logging detail level for all instances of SimpleLogger.
+# Must be one of ("trace", "debug", "info", "warn", or "error").
+# If not specified, defaults to "info".
+org.slf4j.simpleLogger.defaultLogLevel=trace

wrapper/javacord/build.gradle.kts

@@ -10,17 +10,14 @@ plugins {
     `java-library`
 }
 
-repositories {
-    // Use Maven Central for resolving dependencies.
-    mavenCentral()
-}
-
 dependencies {
     // Use JUnit Jupiter for testing.
     testImplementation(libs.junit.jupiter)
     testImplementation(libs.mockito)
 
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    testImplementation(libs.slf4j.simple)
+
     implementation(libs.slf4j)
     implementation(libs.javacord)
     implementation(libs.geantyref)

wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/JavacordWrapper.java

@@ -7,12 +7,12 @@ import org.javacord.api.interaction.AutocompleteInteraction;
 import org.javacord.api.interaction.SlashCommandBuilder;
 import org.javacord.api.interaction.SlashCommandOptionChoice;
 import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import net.tomatentum.marinara.wrapper.CommandConverter;
 import net.tomatentum.marinara.wrapper.CommandRegisterer;
 import net.tomatentum.marinara.wrapper.ContextObjectProvider;
 import net.tomatentum.marinara.wrapper.IdentifierProvider;
-import net.tomatentum.marinara.util.LoggerUtil;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 import net.tomatentum.marinara.wrapper.javacord.identifierconverter.AutocompleteIdentifierConverter;
 import net.tomatentum.marinara.wrapper.javacord.identifierconverter.ButtonIdentifierConverter;
@@ -23,7 +23,7 @@ public class JavacordWrapper extends LibraryWrapper {
     private JavacordContextObjectProvider contextObjectProvider;
     private CommandRegisterer<SlashCommandBuilder> commandRegisterer;
     
-    private Logger logger = LoggerUtil.getLogger(getClass());
+    private Logger logger = LoggerFactory.getLogger(getClass());
 
     public JavacordWrapper(DiscordApi api) {
         this.contextObjectProvider = new JavacordContextObjectProvider();

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/AutoCompleteTest.java

@@ -16,10 +16,10 @@ import net.tomatentum.marinara.Marinara;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
 
-public class AutoCompleteTest {
+class AutoCompleteTest {
     
     @Test
-    public void testAutocomplete() {
+    void testAutocomplete() {
 
         SlashCommandInteractionOption optionMock = mock();
         AutocompleteInteraction autocompleteInteractionMock = mock();
@@ -33,7 +33,7 @@ public class AutoCompleteTest {
 
         LibraryWrapper wrapper = new JavacordWrapper(null); //null okay as we don't use the discord API in this test.
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getRegistry().addInteractions(new TestAutocomplete());
+        marinara.getInteractionContainer().addAllMethods(new TestAutocomplete());
         wrapper.handleInteraction(autocompleteInteractionMock);
         verify(autocompleteInteractionMock).respondWithChoices(any());
     }

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/ButtonTest.java

@@ -12,13 +12,13 @@ import net.tomatentum.marinara.wrapper.LibraryWrapper;
 import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
 
 @TestInstance(Lifecycle.PER_CLASS)
-public class ButtonTest {
+class ButtonTest {
 
     @Test
-    public void testButtonExecution() {
+    void testButtonExecution() {
         LibraryWrapper wrapper = new JavacordWrapper(null); //null okay as we don't use the discord API in this test.
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getRegistry().addInteractions(new TestButton());
+        marinara.getInteractionContainer().addAllMethods(new TestButton());
         wrapper.handleInteraction(CommonMocks.getButtonInteractionMock("test"));
         assertTrue(TestButton.didRun);
     }

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/InteractionCheckTest.java

@@ -19,25 +19,25 @@ import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
 import net.tomatentum.marinara.wrapper.javacord.checks.PermissionCheck;
 
 @TestInstance(Lifecycle.PER_CLASS)
-public class InteractionCheckTest {
+class InteractionCheckTest {
     
     @Test
-    public void testInteractionCheck() {
+    void testInteractionCheck() {
         LibraryWrapper wrapper = new JavacordWrapper(null);
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getCheckRegistry().addCheck(new TestInteractionCheck());
+        marinara.getCheckContainer().addAllMethods(new TestInteractionCheck());
-        marinara.getRegistry().addInteractions(new TestButton());
+        marinara.getInteractionContainer().addAllMethods(new TestButton());
         wrapper.handleInteraction(CommonMocks.getButtonInteractionMock("test"));
         assertTrue(TestInteractionCheck.preExecuted);
         assertTrue(TestInteractionCheck.postExecuted);
     }
 
     @Test
-    public void testPermissionCheck() {
+    void testPermissionCheck() {
         LibraryWrapper wrapper = new JavacordWrapper(null);
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getCheckRegistry().addCheck(new PermissionCheck());
+        marinara.getCheckContainer().addAllMethods(new PermissionCheck());
-        marinara.getRegistry().addInteractions(new TestButton());
+        marinara.getInteractionContainer().addAllMethods(new TestButton());
 
         Server serverMock = mock();
         ButtonInteraction buttonInteractionMock = CommonMocks.getButtonInteractionMock("permissionCheck", serverMock);

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/SlashCommandTest.java

@@ -20,7 +20,7 @@ import net.tomatentum.marinara.Marinara;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
 @TestInstance(Lifecycle.PER_CLASS)
-public class SlashCommandTest {
+class SlashCommandTest {
 
     String DISCORD_TOKEN = System.getenv("DISCORD_TEST_TOKEN");
     DiscordApi api;
@@ -41,8 +41,8 @@ public class SlashCommandTest {
     @Test
     void testSlashCommand() {
         Marinara marinara = Marinara.load(new JavacordWrapper(api));
-        marinara.getRegistry().addInteractions(new TestCommand());
+        marinara.getInteractionContainer().addAllMethods(new TestCommand());
-        marinara.getRegistry().registerCommands();
+        marinara.registerCommands();
         System.out.println("Success!");
     }
     
@@ -50,7 +50,7 @@ public class SlashCommandTest {
     void testSlashCommandExecution() {
         LibraryWrapper wrapper = new JavacordWrapper(api);
         Marinara marinara = Marinara.load(wrapper);
-        marinara.getRegistry().addInteractions(new TestCommand());
+        marinara.getInteractionContainer().addAllMethods(new TestCommand());
 
         SlashCommandInteractionOption optionMock = mock();
         SlashCommandInteraction interactionMock = mock();

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestAutocomplete.java

@@ -4,7 +4,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.Collections;
 
-import org.javacord.api.event.interaction.SlashCommandCreateEvent;
 import org.javacord.api.interaction.AutocompleteInteraction;
 import org.javacord.api.interaction.SlashCommandInteraction;
 
@@ -24,15 +23,14 @@ public class TestAutocomplete implements InteractionHandler {
                 autocompletes = @AutoComplete("testAuto")
             )
         )
-    @AutoComplete("testAuto")
     public void exec(SlashCommandInteraction context) {
-
+        //only here for command definition
     }
 
     @AutoComplete("testAuto")
     public void autocomplete(AutocompleteInteraction context, String value) {
         System.out.println("Success!");
-        assertEquals(value, "test");
+        assertEquals("test", value);
         context.respondWithChoices(Collections.emptyList());
     }
 

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestButton.java

@@ -16,8 +16,8 @@ import net.tomatentum.marinara.wrapper.javacord.checks.PermissionCheck.HasPermis
 
 public class TestButton implements InteractionHandler {
 
-
     public static boolean didRun = false;
+
     @Button("test")
     @TestCheck
     public void exec(ButtonInteraction interaction, TextChannel channel, Message message, User member, Server server) {

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/javacord/TestCommand.java

@@ -11,6 +11,7 @@ import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptio
 import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
 
 public class TestCommand implements InteractionHandler {
+
     @SlashCommand(
         name = "test", 
         description = "testingen",
@@ -27,7 +28,8 @@ public class TestCommand implements InteractionHandler {
         }
         )
     public void exec(SlashCommandInteraction interaction, String test) {
-        assertEquals(test, "test");
+        assertEquals("test", test);
         System.out.println("Success!");
     }
+    
 }

wrapper/javacord/src/test/resources/simplelogger.properties

@@ -0,0 +1,7 @@
+# SLF4J's SimpleLogger configuration file
+# Simple implementation of Logger that sends all enabled log messages, for all defined loggers, to System.err.
+
+# Default logging detail level for all instances of SimpleLogger.
+# Must be one of ("trace", "debug", "info", "warn", or "error").
+# If not specified, defaults to "info".
+org.slf4j.simpleLogger.defaultLogLevel=trace