From 486dc14b224935cb00481bfa3db71447d109c145 Mon Sep 17 00:00:00 2001
From: hugeblank <hugeblank@gmail.com>
Date: Fri, 27 Sep 2024 04:42:35 -0700
Subject: [PATCH] feat!: Non-functional update cobalt

---
 .../java/dev/hugeblank/allium/Allium.java     |   8 +
 .../allium/api/WrappedLuaLibrary.java         |   6 +-
 .../allium/loader/EnvironmentManager.java     |  40 ++-
 .../hugeblank/allium/loader/PackageLib.java   |  28 +-
 .../dev/hugeblank/allium/loader/Script.java   |   3 +-
 .../allium/loader/ScriptExecutor.java         |   8 +-
 .../allium/loader/type/AlliumUserdata.java    |  44 ++++
 .../allium/loader/type/StaticBinder.java      | 249 ++++++++----------
 .../allium/loader/type/UDFFunctions.java      |  15 +-
 .../allium/loader/type/UserdataFactory.java   |  80 +++---
 .../loader/type/coercion/TypeCoercions.java   |  69 +----
 .../hugeblank/allium/util/JavaHelpers.java    |  43 +--
 bouquet/examples/hangman/main.lua             |   2 +-
 bouquet/examples/wailua/main.lua              |  48 ++--
 bouquet/examples/wetworks/wetworks.lua        |  43 ++-
 .../bouquet/BouquetAlliumExtensionClient.java |  13 +
 .../api/event/ClientEventHandlers.java        |   7 +-
 .../bouquet/api/event/ClientEvents.java       |  17 ++
 .../bouquet/api/lib/ClientEventsLib.java      |  20 --
 .../mixin/client/gui/hud/InGameHudMixin.java  |   6 +-
 .../network/ClientPlayerEntityMixin.java      |  17 --
 .../integrated/IntegratedServerMixin.java     |   5 +-
 .../resources/bouquet.client.mixins.json      |   1 -
 .../bouquet/BouquetAlliumExtension.java       |  10 +
 .../api/event/CommonEventHandlers.java        |  37 +--
 .../bouquet/api/event/CommonEvents.java       |  23 ++
 .../hugeblank/bouquet/api/event/Events.java   |   4 +
 .../api/event/ServerEventHandlers.java        |  33 ++-
 .../bouquet/api/event/ServerEvents.java       |  32 +++
 .../bouquet/api/lib/DefaultEventsLib.java     |  43 ++-
 .../hugeblank/bouquet/api/lib/JsonLib.java    |   5 +-
 .../bouquet/api/lib/commands/CommandsLib.java |   6 +-
 .../mixin/block/AbstractBlockMixin.java       |   8 +-
 .../mixin/command/CommandManagerMixin.java    |  14 +-
 .../mixin/entity/PlayerEntityMixin.java       |  22 ++
 .../mixin/server/MinecraftServerMixin.java    |   5 +-
 .../server/MinecraftServerSubclassMixin.java  |   5 +-
 .../mixin/server/PlayerManagerMixin.java      |   8 +-
 .../network/ServerPlayerEntityMixin.java      |  18 +-
 .../src/main/resources/bouquet.mixins.json    |   1 +
 bouquet/src/main/resources/fabric.mod.json    |   3 +
 41 files changed, 574 insertions(+), 475 deletions(-)
 create mode 100644 allium/src/main/java/dev/hugeblank/allium/loader/type/AlliumUserdata.java
 create mode 100644 bouquet/src/client/java/dev/hugeblank/bouquet/BouquetAlliumExtensionClient.java
 create mode 100644 bouquet/src/client/java/dev/hugeblank/bouquet/api/event/ClientEvents.java
 delete mode 100644 bouquet/src/client/java/dev/hugeblank/bouquet/api/lib/ClientEventsLib.java
 delete mode 100755 bouquet/src/client/java/dev/hugeblank/bouquet/mixin/client/network/ClientPlayerEntityMixin.java
 create mode 100644 bouquet/src/main/java/dev/hugeblank/bouquet/api/event/CommonEvents.java
 create mode 100644 bouquet/src/main/java/dev/hugeblank/bouquet/api/event/Events.java
 create mode 100644 bouquet/src/main/java/dev/hugeblank/bouquet/api/event/ServerEvents.java
 create mode 100644 bouquet/src/main/java/dev/hugeblank/bouquet/mixin/entity/PlayerEntityMixin.java

diff --git a/allium/src/main/java/dev/hugeblank/allium/Allium.java b/allium/src/main/java/dev/hugeblank/allium/Allium.java
index bdd21bc..cc7cb64 100755
--- a/allium/src/main/java/dev/hugeblank/allium/Allium.java
+++ b/allium/src/main/java/dev/hugeblank/allium/Allium.java
@@ -16,6 +16,7 @@
 import dev.hugeblank.allium.util.FileHelper;
 import dev.hugeblank.allium.util.Mappings;
 import dev.hugeblank.allium.util.YarnLoader;
+import net.fabricmc.api.EnvType;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.loader.api.FabricLoader;
 import net.fabricmc.loader.api.ModContainer;
@@ -62,6 +63,13 @@ public void onInitialize() {
                     initializer.getEntrypoint().onInitialize();
                     mods.add(initializer.getProvider());
                 });
+        if (FabricLoader.getInstance().getEnvironmentType() == EnvType.CLIENT) {
+            FabricLoader.getInstance().getEntrypointContainers(ID+"-client", AlliumExtension.class)
+                    .forEach((initializer) -> {
+                        initializer.getEntrypoint().onInitialize();
+                        mods.add(initializer.getProvider());
+                    });
+        }
         list(mods, "Initialized Extensions: ", (builder, mod) -> builder.append(mod.getMetadata().getId()));
 
         Set<Script> scripts = new HashSet<>();
diff --git a/allium/src/main/java/dev/hugeblank/allium/api/WrappedLuaLibrary.java b/allium/src/main/java/dev/hugeblank/allium/api/WrappedLuaLibrary.java
index a544613..9c89d8f 100644
--- a/allium/src/main/java/dev/hugeblank/allium/api/WrappedLuaLibrary.java
+++ b/allium/src/main/java/dev/hugeblank/allium/api/WrappedLuaLibrary.java
@@ -4,9 +4,7 @@
 import dev.hugeblank.allium.loader.type.UserdataFactory;
 import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
 import me.basiqueevangelist.enhancedreflection.api.EClass;
-import org.squiddev.cobalt.LuaState;
-import org.squiddev.cobalt.LuaTable;
-import org.squiddev.cobalt.LuaValue;
+import org.squiddev.cobalt.*;
 import org.squiddev.cobalt.function.LibFunction;
 
 /**
@@ -16,7 +14,7 @@
  */
 public interface WrappedLuaLibrary {
 
-    default LuaValue add(LuaState state, LuaTable globals) {
+    default LuaValue add(LuaState state, LuaTable globals) throws LuaError {
         LuaValue lib = UserdataFactory.of(EClass.fromJava(getClass())).createBound(this);
 
         LuaWrapped wrapped = getClass().getAnnotation(LuaWrapped.class);
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/EnvironmentManager.java b/allium/src/main/java/dev/hugeblank/allium/loader/EnvironmentManager.java
index c939cda..60eab0d 100644
--- a/allium/src/main/java/dev/hugeblank/allium/loader/EnvironmentManager.java
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/EnvironmentManager.java
@@ -8,8 +8,7 @@
 import org.squiddev.cobalt.*;
 import org.squiddev.cobalt.function.LibFunction;
 import org.squiddev.cobalt.function.VarArgFunction;
-import org.squiddev.cobalt.lib.Bit32Lib;
-import org.squiddev.cobalt.lib.CoreLibraries;
+import org.squiddev.cobalt.lib.*;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -24,23 +23,40 @@ public class EnvironmentManager {
         this.state = new LuaState();
     }
 
-    protected LuaTable createEnvironment(Script script) {
-        LuaTable globals = CoreLibraries.debugGlobals(state);
-        Bit32Lib.add(state, globals);
+    protected void createEnvironment(Script script) {
+        LuaTable globals = state.globals();
+        BaseLib.add(globals);
+        try {
+            TableLib.add(state, globals);
+            StringLib.add(state, globals);
+            CoroutineLib.add(state, globals);
+            MathLib.add(state, globals);
+            Utf8Lib.add(state, globals);
+            Bit32Lib.add(state, globals);
+
+            LibFunction.setGlobalLibrary(state, globals, "script",
+                    TypeCoercions.toLuaValue(script, EClass.fromJava(Script.class))
+            );
+        } catch (LuaError error) {
+            script.getLogger().error("Error loading library:", error);
+        }
 
-        LibFunction.setGlobalLibrary(state, globals, "script",
-                TypeCoercions.toLuaValue(script, EClass.fromJava(Script.class))
-        );
         globals.rawset( "print", new PrintMethod(script) );
         globals.rawset( "_HOST", ValueFactory.valueOf(Allium.ID + "_" + Allium.VERSION) );
 
-        INITIALIZERS.forEach(initializer -> initializer.init(script).add(state, globals));
-        LIBRARIES.forEach(library -> library.add(state, globals));
-
+        INITIALIZERS.forEach(initializer -> loadLibrary(script, state, globals, initializer.init(script)));
+        LIBRARIES.forEach(library -> loadLibrary(script, state, globals, library));
+    }
 
-        return globals;
+    private static void loadLibrary(Script script, LuaState state, LuaTable globals, WrappedLuaLibrary adder) {
+        try {
+            adder.add(state, globals);
+        } catch (LuaError error) {
+            script.getLogger().error("Error loading library:", error);
+        }
     }
 
+
     public static void registerLibrary(LibraryInitializer initializer) {
         INITIALIZERS.add(initializer);
     }
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/PackageLib.java b/allium/src/main/java/dev/hugeblank/allium/loader/PackageLib.java
index 44c9c56..252a7a3 100644
--- a/allium/src/main/java/dev/hugeblank/allium/loader/PackageLib.java
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/PackageLib.java
@@ -6,6 +6,7 @@
 import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
 import dev.hugeblank.allium.util.JavaHelpers;
 import org.squiddev.cobalt.*;
+import org.squiddev.cobalt.debug.DebugFrame;
 import org.squiddev.cobalt.function.*;
 
 import java.io.IOException;
@@ -31,11 +32,11 @@ public PackageLib(Script script) {
         // When writing a loader in Java, anywhere where a module value can't be determined `nil` should be returned.
         loaders = ValueFactory.listOf(
                 // Loader to check if module has a loader provided by preload table
-                RegisteredFunction.of("preload_loader", this::preloadLoader).create(),
+                RegisteredFunction.ofS("preload_loader", this::preloadLoader).create(),
                 // Loader to check the path internal to the script
-                RegisteredFunction.ofV("path_loader", this::pathLoader).create(),
+                RegisteredFunction.ofS("path_loader", this::pathLoader).create(),
                 // Loader to check the path assuming the first value in the path is a script ID
-                RegisteredFunction.ofV("external_script_loader", this::externScriptLoader).create(),
+                RegisteredFunction.ofS("external_script_loader", this::externScriptLoader).create(),
                 // Loader to check the class files
                 RegisteredFunction.of("java_loader", this::javaLoader).create()
 
@@ -43,19 +44,19 @@ public PackageLib(Script script) {
     }
 
     @Override
-    public LuaValue add(LuaState state, LuaTable globals) {
-        globals.rawset("require", RegisteredFunction.ofV("require", this::require).create());
+    public LuaValue add(LuaState state, LuaTable globals) throws LuaError {
+        globals.rawset("require", RegisteredFunction.ofS("require", this::require).create());
         return WrappedLuaLibrary.super.add(state, globals);
     }
 
-    public LuaValue preloadLoader(LuaState state, LuaValue arg) throws LuaError, UnwindThrowable {
-        if (preload.rawget(arg).isFunction()){
-            return preload.rawget(arg).checkFunction().call(state, arg);
+    public Varargs preloadLoader(LuaState state, DebugFrame frame, Varargs args) throws LuaError, UnwindThrowable {
+        if (preload.rawget(args.arg(1)) instanceof LuaFunction function){
+            return Dispatch.call(state, function);
         }
         return Constants.NIL;
     }
 
-    private Varargs pathLoader(LuaState state, Varargs args) throws LuaError, UnwindThrowable {
+    private Varargs pathLoader(LuaState state, DebugFrame frame, Varargs args) throws LuaError, UnwindThrowable {
         String modStr = args.arg(1).checkString();
         Entrypoint entrypoint = script.getManifest().entrypoints();
         for (Path path : getPathsFromModule(script, modStr)) {
@@ -69,7 +70,7 @@ private Varargs pathLoader(LuaState state, Varargs args) throws LuaError, Unwind
         return loadFromPaths(state, script, modStr);
     }
 
-    private Varargs externScriptLoader(LuaState state, Varargs args) throws LuaError, UnwindThrowable {
+    private Varargs externScriptLoader(LuaState state, DebugFrame frame, Varargs args) throws LuaError, UnwindThrowable {
         String[] path = args.arg(1).checkString().split("\\.");
         Script candidate = Script.getFromID(path[0]);
         if (candidate != null) {
@@ -142,14 +143,13 @@ private List<Path> getPathsFromModule(Script script, String modStr) {
         return pathList;
     }
 
-    private Varargs require(LuaState state, Varargs args) throws LuaError, UnwindThrowable {
+    private Varargs require(LuaState state, DebugFrame frame, Varargs args) throws LuaError, UnwindThrowable {
         LuaString mod = args.arg(1).checkLuaString();
         if (!loaded.rawget(mod).isNil()) return loaded.rawget(mod);
         for (int i = 1; i <= loaders.length(); i++) {
             LuaValue loader = loaders.rawget(i);
-            if (loader.isFunction()) {
-                LuaFunction f = loader.checkFunction();
-                Varargs contents = f.call(state, mod);
+            if (loader instanceof LuaFunction f) {
+                Varargs contents = Dispatch.call(state, f, mod);
                 if (contents != Constants.NIL) {
                     loaded.rawset(mod, contents.arg(1));
                     return contents;
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/Script.java b/allium/src/main/java/dev/hugeblank/allium/loader/Script.java
index 6348be7..4a1e450 100755
--- a/allium/src/main/java/dev/hugeblank/allium/loader/Script.java
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/Script.java
@@ -10,6 +10,7 @@
 import org.squiddev.cobalt.LuaValue;
 import org.squiddev.cobalt.UnwindThrowable;
 import org.squiddev.cobalt.compiler.CompileException;
+import org.squiddev.cobalt.function.Dispatch;
 import org.squiddev.cobalt.function.LuaFunction;
 
 import java.io.FileNotFoundException;
@@ -148,7 +149,7 @@ public LuaValue loadLibrary(LuaState state, Path mod) throws UnwindThrowable, Lu
         // Ensure the modules parent path is the root path, and that the module exists before loading
         try {
             LuaFunction loadValue = getExecutor().load(Files.newInputStream(mod), mod.getFileName().toString());
-            return loadValue.call(state);
+            return Dispatch.call(state, loadValue);
         } catch (FileNotFoundException e) {
             // This should never happen, but if it does, boy do I want to know.
             Allium.LOGGER.warn("File claimed to exist but threw a not found exception...", e);
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/ScriptExecutor.java b/allium/src/main/java/dev/hugeblank/allium/loader/ScriptExecutor.java
index baf3150..f9feb72 100755
--- a/allium/src/main/java/dev/hugeblank/allium/loader/ScriptExecutor.java
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/ScriptExecutor.java
@@ -11,11 +11,10 @@
 
 public class ScriptExecutor extends EnvironmentManager {
     protected final Script script;
-    protected final LuaTable globals;
 
     public ScriptExecutor(Script script) {
         this.script = script;
-        this.globals = createEnvironment(script);
+        createEnvironment(script);
     }
 
     public LuaState getState() {
@@ -56,12 +55,13 @@ public Varargs reload(InputStream dynamic) throws LuaError, CompileException, IO
         return null;
     }
 
-    public LuaFunction load(InputStream stream, String name) throws CompileException, IOException {
+    public LuaFunction load(InputStream stream, String name) throws CompileException, IOException, LuaError {
+        // TODO: Replacing using globals here with an empty table. Does it work?
         return LoadState.load(
                 state,
                 stream,
                 name,
-                this.globals
+                state.globals()
         );
     }
 
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/type/AlliumUserdata.java b/allium/src/main/java/dev/hugeblank/allium/loader/type/AlliumUserdata.java
new file mode 100644
index 0000000..f74c9e6
--- /dev/null
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/type/AlliumUserdata.java
@@ -0,0 +1,44 @@
+package dev.hugeblank.allium.loader.type;
+
+import me.basiqueevangelist.enhancedreflection.api.EClass;
+import org.squiddev.cobalt.LuaTable;
+import org.squiddev.cobalt.LuaUserdata;
+
+public class AlliumUserdata<T> extends LuaUserdata {
+    private final EClass<T> clazz;
+
+    AlliumUserdata(Object obj, LuaTable metatable, EClass<T> clazz) {
+        super(obj, metatable);
+        this.clazz = clazz;
+    }
+
+    AlliumUserdata(Object obj, LuaTable metatable, Class<T> clazz) {
+        this(obj, metatable, EClass.fromJava(clazz));
+    }
+
+    public EClass<T> instanceClass() {
+        return clazz;
+    }
+
+
+    public boolean instanceOf(Class<?> test) {
+        return clazz.isAssignableFrom(test);
+    }
+
+    public boolean instanceOf(EClass<?> test) {
+        return clazz.isAssignableFrom(test);
+    }
+
+    public <U> U toUserdata(EClass<U> test) {
+        return toUserdata(test.raw());
+    }
+
+    public <U> U toUserdata(Class<U> test) {
+        return test.cast(instance);
+    }
+
+    @Override
+    public T toUserdata() {
+        return clazz.cast(instance);
+    }
+}
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/type/StaticBinder.java b/allium/src/main/java/dev/hugeblank/allium/loader/type/StaticBinder.java
index a576d90..9a556ad 100644
--- a/allium/src/main/java/dev/hugeblank/allium/loader/type/StaticBinder.java
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/type/StaticBinder.java
@@ -28,154 +28,145 @@ private StaticBinder() {
 
     public static LuaUserdata bindClass(EClass<?> clazz) {
         Map<String, PropertyData<?>> cachedProperties = new HashMap<>();
-        GetClassFunction getClassFunc = new GetClassFunction(clazz);
+        LuaFunction getClassFunc = createGetClassFunction(clazz);
         LuaTable metatable = new LuaTable();
         EMethod indexImpl = clazz.methods().stream().filter(x -> x.isStatic() && x.hasAnnotation(LuaIndex.class)).findAny().orElse(null);
 
-        metatable.rawset("__pairs", new OneArgFunction() {
-            @Override
-            public LuaValue call(LuaState state, LuaValue arg) throws LuaError {
-                Stream.Builder<EMember> memberBuilder = Stream.builder();
-                clazz.methods().forEach(memberBuilder);
-                clazz.fields().forEach(memberBuilder);
-                Stream<Varargs> valueStream = memberBuilder.build().filter((member)->
-                        !clazz.hasAnnotation(LuaWrapped.class) ||
-                                (
-                                        clazz.hasAnnotation(LuaWrapped.class) &&
-                                                member.hasAnnotation(LuaWrapped.class)
-                                )
-                ).map((member)-> {
-                    String memberName = member.name();
-                    if (member.hasAnnotation(LuaWrapped.class)) {
-                        String[] names = AnnotationUtils.findNames(member);
-                        if (names != null && names.length > 0) {
-                            memberName = names[0];
-                        }
-                    }
-                    PropertyData<?> propertyData = cachedProperties.get(memberName);
-
-                    if (propertyData == null) { // caching
-                        propertyData = PropertyResolver.resolveProperty(clazz, memberName, member.isStatic());
-                        cachedProperties.put(memberName, propertyData);
+        metatable.rawset("__pairs", LibFunction.create((state) -> {
+            Stream.Builder<EMember> memberBuilder = Stream.builder();
+            clazz.methods().forEach(memberBuilder);
+            clazz.fields().forEach(memberBuilder);
+            Stream<Varargs> valueStream = memberBuilder.build().filter((member)->
+                    !clazz.hasAnnotation(LuaWrapped.class) ||
+                            (
+                                    clazz.hasAnnotation(LuaWrapped.class) &&
+                                            member.hasAnnotation(LuaWrapped.class)
+                            )
+            ).map((member)-> {
+                String memberName = member.name();
+                if (member.hasAnnotation(LuaWrapped.class)) {
+                    String[] names = AnnotationUtils.findNames(member);
+                    if (names != null && names.length > 0) {
+                        memberName = names[0];
                     }
+                }
+                PropertyData<?> propertyData = cachedProperties.get(memberName);
 
-                    if (!Allium.DEVELOPMENT) memberName = Allium.MAPPINGS.getYarn(memberName);
-                    try {
-                        return ValueFactory.varargsOf(LuaString.valueOf(memberName), propertyData.get(
-                                memberName,
-                                state,
-                                null,
-                                false
-                        ));
-                    } catch (LuaError e) {
-                        // I have no idea how this could happen, so it'll be interesting if we get an issue
-                        // report in the future with it...
-                        Allium.LOGGER.warn("Could not get property data for " + memberName, e);
-                        return Constants.NIL;
-                    }
-                });
+                if (propertyData == null) { // caching
+                    propertyData = PropertyResolver.resolveProperty(clazz, memberName, member.isStatic());
+                    cachedProperties.put(memberName, propertyData);
+                }
 
-                Iterator<Varargs> iterator = valueStream.iterator();
-                return new VarArgFunction() { // next
-                    public Varargs invoke(LuaState state, Varargs varargs) throws LuaError, UnwindThrowable {
-                        if (!iterator.hasNext()) return Constants.NIL;
-                        return iterator.next();
-                    }
-                };
-            }
-        });
+                if (!Allium.DEVELOPMENT) memberName = Allium.MAPPINGS.getYarn(memberName);
+                try {
+                    return ValueFactory.varargsOf(LuaString.valueOf(memberName), propertyData.get(
+                            memberName,
+                            state,
+                            null,
+                            false
+                    ));
+                } catch (LuaError e) {
+                    // I have no idea how this could happen, so it'll be interesting if we get an issue
+                    // report in the future with it...
+                    Allium.LOGGER.warn("Could not get property data for " + memberName, e);
+                    return Constants.NIL;
+                }
+            });
 
-        metatable.rawset("__index", new TwoArgFunction() {
-            @Override
-            public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2) throws LuaError {
-                if (arg2.isString()) {
-                    String name = arg2.checkString(); // mapped name
+            Iterator<Varargs> iterator = valueStream.iterator();
+            return new VarArgFunction() { // next
+                public Varargs invoke(LuaState state, Varargs varargs) throws LuaError, UnwindThrowable {
+                    if (!iterator.hasNext()) return Constants.NIL;
+                    return iterator.next();
+                }
+            };
+        }));
 
-                    if (name.equals("getClass")) {
-                        return getClassFunc;
-                    }
+        metatable.rawset("__index", LibFunction.create((state, arg1, arg2) -> {
+            if (arg2.isString()) {
+                String name = arg2.checkString(); // mapped name
 
-                    PropertyData<?> cachedProperty = cachedProperties.get(name);
+                if (name.equals("getClass")) {
+                    return getClassFunc;
+                }
 
-                    if (cachedProperty == null) {
-                        cachedProperty = PropertyResolver.resolveProperty(clazz, name, true);
+                PropertyData<?> cachedProperty = cachedProperties.get(name);
 
-                        cachedProperties.put(name, cachedProperty);
-                    }
+                if (cachedProperty == null) {
+                    cachedProperty = PropertyResolver.resolveProperty(clazz, name, true);
 
-                    if (cachedProperty != EmptyData.INSTANCE)
-                        return cachedProperty.get(name, state, null, false);
+                    cachedProperties.put(name, cachedProperty);
                 }
 
-                if (indexImpl != null) {
-                    var parameters = indexImpl.parameters();
-                    try {
-                        var jargs = ArgumentUtils.toJavaArguments(state, arg2, 1, parameters);
-
-                        if (jargs.length == parameters.size()) {
-                            try {
-                                var instance = TypeCoercions.toJava(state, arg1, clazz);
-                                EClassUse<?> ret = indexImpl.returnTypeUse().upperBound();
-                                Object out = indexImpl.invoke(instance, jargs);
-                                // If out is null, we can assume the index is nil
-                                if (out == null) throw new InvalidArgumentException();
-                                return TypeCoercions.toLuaValue(out, ret);
-                            } catch (IllegalAccessException e) {
-                                throw new LuaError(e);
-                            } catch (InvocationTargetException e) {
-                                var target = e.getTargetException();
-
-                                if (target instanceof LuaError err) {
-                                    throw err;
-                                } else if (target instanceof IndexOutOfBoundsException) {
-                                    // Continue.
-                                } else {
-                                    throw new LuaError(target);
-                                }
-                            } catch (InvalidArgumentException ignore) {}
-                        }
-                    } catch (InvalidArgumentException | IllegalArgumentException e) {
-                        // Continue.
+                if (cachedProperty != EmptyData.INSTANCE)
+                    return cachedProperty.get(name, state, null, false);
+            }
+
+            if (indexImpl != null) {
+                var parameters = indexImpl.parameters();
+                try {
+                    var jargs = ArgumentUtils.toJavaArguments(state, arg2, 1, parameters);
+
+                    if (jargs.length == parameters.size()) {
+                        try {
+                            var instance = TypeCoercions.toJava(state, arg1, clazz);
+                            EClassUse<?> ret = indexImpl.returnTypeUse().upperBound();
+                            Object out = indexImpl.invoke(instance, jargs);
+                            // If out is null, we can assume the index is nil
+                            if (out == null) throw new InvalidArgumentException();
+                            return TypeCoercions.toLuaValue(out, ret);
+                        } catch (IllegalAccessException e) {
+                            throw new LuaError(e);
+                        } catch (InvocationTargetException e) {
+                            var target = e.getTargetException();
+
+                            if (target instanceof LuaError err) {
+                                throw err;
+                            } else if (target instanceof IndexOutOfBoundsException) {
+                                // Continue.
+                            } else {
+                                throw new LuaError(target);
+                            }
+                        } catch (InvalidArgumentException ignore) {}
                     }
+                } catch (InvalidArgumentException | IllegalArgumentException e) {
+                    // Continue.
                 }
+            }
 
-                if (arg2.type() == Constants.TTABLE) {
-                    LuaTable table = arg2.checkTable();
-                    EClass<?>[] typeArgs = new EClass[table.length()];
-
-                    for (int i = 0; i < typeArgs.length; i++) {
-                        typeArgs[i] = JavaHelpers.asClass(table.rawget(i + 1));
-                    }
+            if (arg2.type() == Constants.TTABLE) {
+                LuaTable table = arg2.checkTable();
+                EClass<?>[] typeArgs = new EClass[table.length()];
 
-                    try {
-                        return bindClass(clazz.instantiateWith(List.of(typeArgs)));
-                    } catch (IllegalArgumentException e) {
-                        throw new LuaError(e);
-                    }
+                for (int i = 0; i < typeArgs.length; i++) {
+                    typeArgs[i] = JavaHelpers.asClass(table.rawget(i + 1));
                 }
 
-                return Constants.NIL;
+                try {
+                    return bindClass(clazz.instantiateWith(List.of(typeArgs)));
+                } catch (IllegalArgumentException e) {
+                    throw new LuaError(e);
+                }
             }
-        });
 
-        metatable.rawset("__newindex", new ThreeArgFunction() {
-            @Override
-            public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2, LuaValue arg3) throws LuaError {
-                String name = arg2.checkString(); // mapped name
+            return Constants.NIL;
+        }));
 
-                PropertyData<?> cachedProperty = cachedProperties.get(name);
+        metatable.rawset("__newindex", LibFunction.create((state, arg1, arg2, arg3) -> {
+            String name = arg2.checkString(); // mapped name
 
-                if (cachedProperty == null) {
-                    cachedProperty = PropertyResolver.resolveProperty(clazz, name, false);
+            PropertyData<?> cachedProperty = cachedProperties.get(name);
 
-                    cachedProperties.put(name, cachedProperty);
-                }
-
-                cachedProperty.set(name, state, null, arg3);
+            if (cachedProperty == null) {
+                cachedProperty = PropertyResolver.resolveProperty(clazz, name, false);
 
-                return Constants.NIL;
+                cachedProperties.put(name, cachedProperty);
             }
-        });
+
+            cachedProperty.set(name, state, null, arg3);
+
+            return Constants.NIL;
+        }));
 
         metatable.rawset("__call", new VarArgFunction() {
             @Override
@@ -227,17 +218,9 @@ private static Varargs createInstance(EClass<?> clazz, LuaState state, Varargs a
         throw new LuaError(error.toString());
     }
 
-    private static class GetClassFunction extends ZeroArgFunction {
-        private final EClass<?> clazz;
-
-        public GetClassFunction(EClass<?> clazz) {
-            super();
-            this.clazz = clazz;
-        }
-
-        @Override
-        public LuaValue call(LuaState state) {
-            return TypeCoercions.toLuaValue(clazz, EClass.fromJava(EClass.class).instantiateWith(List.of(clazz)));
-        }
+    private static LuaFunction createGetClassFunction(EClass<?> clazz) {
+        return LibFunction.create((state) -> TypeCoercions
+                .toLuaValue(clazz, EClass.fromJava(EClass.class).instantiateWith(List.of(clazz)))
+        );
     }
 }
\ No newline at end of file
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/type/UDFFunctions.java b/allium/src/main/java/dev/hugeblank/allium/loader/type/UDFFunctions.java
index 86e43bd..d46578c 100755
--- a/allium/src/main/java/dev/hugeblank/allium/loader/type/UDFFunctions.java
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/type/UDFFunctions.java
@@ -2,6 +2,7 @@
 
 import dev.hugeblank.allium.loader.type.coercion.TypeCoercions;
 import dev.hugeblank.allium.util.ArgumentUtils;
+import dev.hugeblank.allium.util.JavaHelpers;
 import me.basiqueevangelist.enhancedreflection.api.EClass;
 import me.basiqueevangelist.enhancedreflection.api.EMethod;
 import me.basiqueevangelist.enhancedreflection.api.typeuse.EClassUse;
@@ -38,7 +39,19 @@ public Varargs invoke(LuaState state, Varargs args) throws LuaError {
         );
 
         try {
-            T instance = boundReceiver != null || isStatic ? boundReceiver : args.arg(1).checkUserdata(clazz.raw());
+//            final T instance;
+//            if (boundReceiver != null || isStatic) {
+//                instance = boundReceiver;
+//            } else if (args.arg(1) instanceof AlliumUserdata<?> userdata) {
+//                try {
+//                    instance = userdata.toUserdata(clazz);
+//                } catch (ClassCastException e) {
+//                    throw new LuaError(e);
+//                }
+//            } else {
+//                throw new LuaError("Invocation has no instance"); // This should never happen.
+//            }
+            T instance = boundReceiver != null || isStatic ? boundReceiver : JavaHelpers.checkUserdata(args.arg(1), clazz.raw());
             for (EMethod method : matches) { // For each matched method from the index call
                 var parameters = method.parameters();
                 try {
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/type/UserdataFactory.java b/allium/src/main/java/dev/hugeblank/allium/loader/type/UserdataFactory.java
index f572537..37b3c40 100755
--- a/allium/src/main/java/dev/hugeblank/allium/loader/type/UserdataFactory.java
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/type/UserdataFactory.java
@@ -9,6 +9,7 @@
 import dev.hugeblank.allium.loader.type.property.PropertyData;
 import dev.hugeblank.allium.util.AnnotationUtils;
 import dev.hugeblank.allium.util.ArgumentUtils;
+import dev.hugeblank.allium.util.JavaHelpers;
 import me.basiqueevangelist.enhancedreflection.api.EClass;
 import me.basiqueevangelist.enhancedreflection.api.EMember;
 import me.basiqueevangelist.enhancedreflection.api.EMethod;
@@ -20,9 +21,6 @@
 import org.apache.commons.lang3.ArrayUtils;
 import org.jetbrains.annotations.Nullable;
 import org.squiddev.cobalt.*;
-import org.squiddev.cobalt.function.OneArgFunction;
-import org.squiddev.cobalt.function.ThreeArgFunction;
-import org.squiddev.cobalt.function.TwoArgFunction;
 import org.squiddev.cobalt.function.VarArgFunction;
 
 import java.lang.annotation.Annotation;
@@ -83,33 +81,34 @@ protected UserdataFactory(EClass<T> clazz) {
     private LuaTable createMetatable(boolean isBound) {
         LuaTable metatable = new LuaTable();
 
-        metatable.rawset("__tostring", new OneArgFunction() {
+        metatable.rawset("__tostring", new VarArgFunction() {
+
             @Override
-            public LuaValue call(LuaState state, LuaValue arg) throws LuaError {
+            public Varargs invoke(LuaState state, Varargs args) throws LuaError {
                 try {
-                    return TypeCoercions.toLuaValue(Objects.requireNonNull(TypeCoercions.toJava(state, arg, clazz)).toString());
+                    return TypeCoercions.toLuaValue(Objects.requireNonNull(TypeCoercions.toJava(state, args.arg(1), clazz)).toString());
                 } catch (InvalidArgumentException e) {
                     throw new LuaError(e);
                 }
             }
         });
 
-        metatable.rawset("__pairs", new OneArgFunction() {
+        metatable.rawset("__pairs", new VarArgFunction() {
             // Technically, pairs is kinda cringe. In order to properly deliver all key-value pairs, we have to parse
             // the ENTIRE class. At least we cache everything along the way? Still not ideal.
             @Override
-            public LuaValue call(LuaState state, LuaValue arg) throws LuaError {
+            public Varargs invoke(LuaState state, Varargs args) throws LuaError {
                 Stream.Builder<EMember> memberBuilder = Stream.builder();
                 clazz.methods().forEach(memberBuilder);
                 clazz.fields().forEach(memberBuilder);
                 try {
-                    var instance = clazz.cast(TypeCoercions.toJava(state, arg, clazz));
+                    var instance = clazz.cast(TypeCoercions.toJava(state, args.arg(1), clazz));
                     Stream<Varargs> valueStream = memberBuilder.build()
                             .filter((member)->
                                     !clazz.hasAnnotation(LuaWrapped.class) ||
                                             (
                                                     clazz.hasAnnotation(LuaWrapped.class) &&
-                                                    member.hasAnnotation(LuaWrapped.class)
+                                                            member.hasAnnotation(LuaWrapped.class)
                                             )
                             )
                             .map((member)-> {
@@ -145,7 +144,7 @@ public LuaValue call(LuaState state, LuaValue arg) throws LuaError {
 
                     Iterator<Varargs> iterator = valueStream.iterator();
                     return new VarArgFunction() { // next
-                        public Varargs invoke(LuaState state, Varargs varargs) throws LuaError, UnwindThrowable {
+                        public Varargs invoke(LuaState state, Varargs varargs) {
                             if (!iterator.hasNext()) return Constants.NIL;
                             return iterator.next();
                         }
@@ -156,10 +155,11 @@ public Varargs invoke(LuaState state, Varargs varargs) throws LuaError, UnwindTh
             }
         });
 
-        metatable.rawset("__index", new TwoArgFunction() {
+        metatable.rawset("__index", new VarArgFunction() {
+
             @Override
-            public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2) throws LuaError {
-                String name = arg2.checkString(); // mapped name
+            public LuaValue invoke(LuaState state, Varargs args) throws LuaError {
+                String name = args.arg(2).checkString(); // mapped name
 
                 if (name.equals("allium_java_class")) {
                     return UserdataFactory.of(EClass.fromJava(EClass.class)).create(clazz);
@@ -176,14 +176,15 @@ public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2) throws LuaErr
                 if (cachedProperty == EmptyData.INSTANCE && indexImpl != null) {
                     var parameters = indexImpl.parameters();
                     try {
-                        var jargs = ArgumentUtils.toJavaArguments(state, arg2, 1, parameters);
+                        var jargs = ArgumentUtils.toJavaArguments(state, args.arg(2), 1, parameters);
 
                         if (jargs.length == parameters.size()) {
                             try {
-                                var instance = TypeCoercions.toJava(state, arg1, clazz);
+                                var instance = TypeCoercions.toJava(state, args.arg(1), clazz);
                                 EClassUse<?> ret = indexImpl.returnTypeUse().upperBound();
                                 Object out = indexImpl.invoke(instance, jargs);
                                 return TypeCoercions.toLuaValue(out, ret);
+                            } catch (IndexOutOfBoundsException | InvalidArgumentException ignored) {
                             } catch (IllegalAccessException e) {
                                 throw new LuaError(e);
                             } catch (InvocationTargetException e) {
@@ -191,25 +192,23 @@ public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2) throws LuaErr
 
                                 if (target instanceof LuaError err) {
                                     throw err;
-                                } else if (target instanceof IndexOutOfBoundsException) {
-                                    // Continue.
                                 } else {
                                     throw new LuaError(target);
                                 }
-                            } catch (InvalidArgumentException ignore) {}
+                            }
                         }
                     } catch (InvalidArgumentException | IllegalArgumentException e) {
                         // Continue.
                     }
                 }
-                return cachedProperty.get(name, state, arg1.checkUserdata(clazz.raw()), isBound);
+                return cachedProperty.get(name, state, JavaHelpers.checkUserdata(args.arg(1), clazz.raw()), isBound);
             }
         });
 
-        metatable.rawset("__newindex", new ThreeArgFunction() {
+        metatable.rawset("__newindex", new VarArgFunction() {
             @Override
-            public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2, LuaValue arg3) throws LuaError {
-                String name = arg2.checkString(); // mapped name
+            public LuaValue invoke(LuaState state, Varargs args) throws LuaError {
+                String name = args.arg(2).checkString(); // mapped name
 
                 PropertyData<? super T> cachedProperty = cachedProperties.get(name);
 
@@ -222,11 +221,11 @@ public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2, LuaValue arg3
                 if (cachedProperty == EmptyData.INSTANCE && newIndexImpl != null) {
                     var parameters = newIndexImpl.parameters();
                     try {
-                        var jargs = ArgumentUtils.toJavaArguments(state, ValueFactory.varargsOf(arg1, arg2), 1, parameters);
+                        var jargs = ArgumentUtils.toJavaArguments(state, ValueFactory.varargsOf(args.arg(1), args.arg(2)), 1, parameters);
 
                         if (jargs.length == parameters.size()) {
                             try {
-                                var instance = TypeCoercions.toJava(state, arg1, clazz);
+                                var instance = TypeCoercions.toJava(state, args.arg(1), clazz);
                                 newIndexImpl.invoke(instance, jargs);
                                 return Constants.NIL;
                             } catch (IllegalAccessException e) {
@@ -242,7 +241,7 @@ public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2, LuaValue arg3
                         // Continue.
                     }
                 }
-                cachedProperty.set(name, state, arg1.checkUserdata(clazz.raw()), arg3);
+                cachedProperty.set(name, state, JavaHelpers.checkUserdata(args.arg(1), clazz.raw()), args.arg(3));
 
                 return Constants.NIL;
             }
@@ -263,23 +262,24 @@ public static <T> UserdataFactory<T> of(EClass<T> clazz) {
         return (UserdataFactory<T>) FACTORIES.computeIfAbsent(clazz, UserdataFactory::new);
     }
 
-    public static LuaUserdata getUserData(Object instance) {
-        return FACTORIES.computeIfAbsent(EClass.fromJava(instance.getClass()), UserdataFactory::new).create(instance);
+    @SuppressWarnings("unchecked")
+    public static <T> AlliumUserdata<T> getUserData(T instance) {
+        return (AlliumUserdata<T>) FACTORIES.computeIfAbsent(EClass.fromJava(instance.getClass()), UserdataFactory::new).create(instance);
     }
 
-    public LuaUserdata create(Object instance) {
-        return new LuaUserdata(instance, metatable);
+    public AlliumUserdata<T> create(Object instance) {
+        return new AlliumUserdata<>(instance, metatable, clazz);
     }
 
-    public LuaUserdata createBound(Object instance) {
+    public AlliumUserdata<T> createBound(Object instance) {
         if (boundMetatable == null)
             boundMetatable = createMetatable(true);
 
-        return new LuaUserdata(instance, boundMetatable);
+        return new AlliumUserdata<>(instance, boundMetatable, clazz);
     }
 
 
-    private static final class LessFunction extends TwoArgFunction {
+    private static final class LessFunction extends VarArgFunction {
         private final EClass<?> bound;
 
         public LessFunction(EClass<?> bound) {
@@ -288,15 +288,15 @@ public LessFunction(EClass<?> bound) {
 
         @SuppressWarnings("unchecked")
         @Override
-        public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2) throws LuaError {
-            Comparable<Object> cmp = arg1.checkUserdata(Comparable.class);
-            Object cmp2 = arg2.checkUserdata(bound.raw());
+        public LuaValue invoke(LuaState state, Varargs args) throws LuaError {
+            Comparable<Object> cmp = JavaHelpers.checkUserdata(args.arg(1), Comparable.class);
+            Object cmp2 = JavaHelpers.checkUserdata(args.arg(2), bound.raw());
 
             return ValueFactory.valueOf(cmp.compareTo(cmp2) < 0);
         }
     }
 
-    private static final class LessOrEqualFunction extends TwoArgFunction {
+    private static final class LessOrEqualFunction extends VarArgFunction {
         private final EClass<?> bound;
 
         public LessOrEqualFunction(EClass<?> bound) {
@@ -305,9 +305,9 @@ public LessOrEqualFunction(EClass<?> bound) {
 
         @SuppressWarnings("unchecked")
         @Override
-        public LuaValue call(LuaState state, LuaValue arg1, LuaValue arg2) throws LuaError {
-            Comparable<Object> cmp = arg1.checkUserdata(Comparable.class);
-            Object cmp2 = arg2.checkUserdata(bound.raw());
+        public LuaValue invoke(LuaState state, Varargs args) throws LuaError {
+            Comparable<Object> cmp = JavaHelpers.checkUserdata(args.arg(1), Comparable.class);
+            Object cmp2 = JavaHelpers.checkUserdata(args.arg(2), bound.raw());
 
             return ValueFactory.valueOf(cmp.compareTo(cmp2) < 0 || cmp.equals(cmp2));
         }
diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/type/coercion/TypeCoercions.java b/allium/src/main/java/dev/hugeblank/allium/loader/type/coercion/TypeCoercions.java
index e4b14ce..551ecbe 100755
--- a/allium/src/main/java/dev/hugeblank/allium/loader/type/coercion/TypeCoercions.java
+++ b/allium/src/main/java/dev/hugeblank/allium/loader/type/coercion/TypeCoercions.java
@@ -1,5 +1,6 @@
 package dev.hugeblank.allium.loader.type.coercion;
 
+import dev.hugeblank.allium.loader.type.AlliumUserdata;
 import dev.hugeblank.allium.loader.type.InvalidArgumentException;
 import dev.hugeblank.allium.loader.type.UDFFunctions;
 import dev.hugeblank.allium.loader.type.UserdataFactory;
@@ -52,67 +53,11 @@ public static Object toJava(LuaState state, LuaValue value, EClass<?> clatz) thr
 
         if (value.isNil())
             return null;
-
-        try {
-            return value.checkUserdata(clatz.wrapPrimitive().raw());
-        } catch (LuaError ignored) {}
-
-        clatz = clatz.unwrapPrimitive();
-
-        var deserializerFactory = FROM_LUA.get(clatz.raw());
-        if (deserializerFactory != null) {
-            var deserializer = deserializerFactory.apply(clatz);
-
-            if (deserializer != null) {
-                Object result = deserializer.fromLua(state, value);
-
-                if (result != null) return result;
-            }
-        }
-
-        if (clatz.type() == ClassType.ARRAY) {
-            try {
-                LuaTable table = value.checkTable();
-                int length = table.length();
-                Object arr = Array.newInstance(clatz.arrayComponent().raw(), table.length());
-                for (int i = 0; i < length; i++) {
-                    Array.set(arr, i, toJava(state, table.rawget(i + 1), clatz.arrayComponent()));
-                }
-                return clatz.cast(arr);
-            } catch (Exception e) {
-                throw new LuaError(
-                        "Expected table of "
-                                + clatz.arrayComponent()
-                                + "s, got "
-                                + value.typeName()
-                );
-            }
-        }
-
-        if (value.isFunction() && clatz.type() == ClassType.INTERFACE) { // Callbacks
-            var func = value.checkFunction();
-            EMethod ifaceMethod = null;
-
-            int unimplemented = 0;
-            for (var meth : clatz.methods()) {
-                if (meth.isAbstract()) {
-                    unimplemented++;
-                    ifaceMethod = meth;
-
-                    if (unimplemented > 1) {
-                        break;
-                    }
-                }
-            }
-
-            if (unimplemented == 1) {
-                return ProxyGenerator.getProxyFactory(clatz, ifaceMethod).apply(state, func);
-            } else {
-                return value.checkUserdata(clatz.raw());
-            }
-        }
-
-        throw new InvalidArgumentException("Couldn't convert " + value + " to java! Target type is " + clatz);
+        
+        if (value instanceof AlliumUserdata<?> userdata)
+            return userdata.toUserdata(clatz.wrapPrimitive());
+        
+        return null;
     }
 
     public static LuaValue toLuaValue(Object out) {
@@ -259,7 +204,7 @@ private static boolean canMatch(EType type, EType other) {
                 LuaTable table = new LuaTable();
 
                 for (Map.Entry<?, ?> entry : ((Map<?, ?>) map).entrySet()) {
-                    table.rawset(TypeCoercions.toLuaValue(entry.getKey(), keyUse), TypeCoercions.toLuaValue(entry.getValue(), valueUse));
+                    table.rawsetImpl(TypeCoercions.toLuaValue(entry.getKey(), keyUse), TypeCoercions.toLuaValue(entry.getValue(), valueUse));
                 }
 
                 return table;
diff --git a/allium/src/main/java/dev/hugeblank/allium/util/JavaHelpers.java b/allium/src/main/java/dev/hugeblank/allium/util/JavaHelpers.java
index 5c5d005..a28a5f0 100644
--- a/allium/src/main/java/dev/hugeblank/allium/util/JavaHelpers.java
+++ b/allium/src/main/java/dev/hugeblank/allium/util/JavaHelpers.java
@@ -1,10 +1,9 @@
 package dev.hugeblank.allium.util;
 
 import dev.hugeblank.allium.Allium;
+import dev.hugeblank.allium.loader.type.AlliumUserdata;
 import me.basiqueevangelist.enhancedreflection.api.EClass;
-import org.squiddev.cobalt.Constants;
-import org.squiddev.cobalt.LuaError;
-import org.squiddev.cobalt.LuaValue;
+import org.squiddev.cobalt.*;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -20,6 +19,18 @@ public static void addAutoComplete(String prefix) {
         AUTO_COMPLETE.add(prefix);
     }
 
+
+    public static <T> T checkUserdata(LuaValue value, Class<T> clazz) throws LuaError {
+        if (value instanceof AlliumUserdata<?> userdata) {
+            try {
+                return userdata.toUserdata(clazz);
+            } catch (Exception e) {
+                throw new LuaError(e);
+            }
+        }
+        throw new LuaError("value " + value + " is not an instance of AlliumUserData");
+    }
+
     public static EClass<?> getRawClass(String className) throws LuaError {
         var cachedClassName = CACHED_AUTO_COMPLETE.get(className);
 
@@ -52,32 +63,26 @@ public static EClass<?> getRawClass(String className) throws LuaError {
         }
 
         throw new LuaError("Couldn't find class \"" + className + "\"");
-
     }
 
-    @SuppressWarnings("unchecked")
     public static EClass<?> asClass(LuaValue value) throws LuaError {
         if (value.isString()) {
             return getRawClass(value.checkString());
         } else if (value.isNil()) {
             return null;
-        } else if (value.type() == Constants.TTABLE && value.checkTable().rawget("allium_java_class") != Constants.NIL) {
-            return value.checkTable().rawget("allium_java_class").checkUserdata(EClass.class);
-        } else {
-            try {
-                return value.checkUserdata(EClass.class);
-            } catch (LuaError ignored) {}
-            try {
-                return EClass.fromJava(value.checkUserdata(Class.class));
-            } catch (LuaError ignored) {}
-            try {
-                return EClass.fromJava(value.checkUserdata().getClass());
-            } catch (LuaError ignored) {}
+        } else if (value instanceof LuaTable table && table.rawget("allium_java_class") instanceof AlliumUserdata<?> userdata) {
+            return userdata.toUserdata(EClass.class);
+        } else if (value instanceof AlliumUserdata<?> userdata) {
+            if (userdata.instanceOf(EClass.class)) {
+                return userdata.toUserdata(EClass.class);
+            } else if (userdata.instanceOf(Class.class)) {
+                //noinspection unchecked
+                return EClass.fromJava(userdata.toUserdata(Class.class));
+            }
+            return EClass.fromJava(userdata.toUserdata().getClass());
         }
 
-
         throw new LuaError(new ClassNotFoundException());
     }
 
-
 }
\ No newline at end of file
diff --git a/bouquet/examples/hangman/main.lua b/bouquet/examples/hangman/main.lua
index e7f2362..5e393a7 100755
--- a/bouquet/examples/hangman/main.lua
+++ b/bouquet/examples/hangman/main.lua
@@ -39,7 +39,7 @@ end
 
 local builder = CommandManager.literal("hangman") -- Create the builder for the hangman command
 
-events.COMMAND_REGISTER:register(script, function(_, name, success)
+events.server.COMMAND_REGISTER:register(script, function(_, name, success)
     -- Let us know if the command was successfully registered
     if success and name:find("hangman") then
         print("/hangman command registered!")
diff --git a/bouquet/examples/wailua/main.lua b/bouquet/examples/wailua/main.lua
index 4e1ae73..32a2a35 100755
--- a/bouquet/examples/wailua/main.lua
+++ b/bouquet/examples/wailua/main.lua
@@ -2,36 +2,38 @@
 -- By hugeblank - Jul 9, 2022
 -- WAILA-like (What Am I Looking At) script exclusively for the client-side.
 -- This is a demonstration of how allium is not just for server sided use cases.
-local Text = java.import("net.minecraft.text.Text")
-local BlockPos = java.import("net.minecraft.util.math.BlockPos")
-local Registry = java.import("Registry")
+local Text = require("net.minecraft.text.Text")
+local BlockPos = require("net.minecraft.util.math.BlockPos")
+local Registries = require("net.minecraft.registry.Registries")
 
 local renderText -- The text to be shared between the render event and tick event
 
-events.CLIENT_RENDER_TAIL:register(script, function(client, matrices, tickDelta, scaledWidth, scaledHeight, textRenderer)
-    if renderText then -- If there's text, then draw it at the top center, account for the offset of the text
-        textRenderer:draw(matrices, renderText, (scaledWidth/2)-(textRenderer:getWidth(renderText)/2), 5, 0xffffff);
+events.client.GUI_RENDER_TAIL:register(script, function(client, context, hud)
+    if renderText then -- If there's text, then draw it at the top center
+        context:drawCenteredTextWithShadow(hud:getTextRenderer(), renderText, context:getScaledWindowWidth()/2, 5, 0xffffff)
         -- The position 5 was arbitrarily chosen, and was the first value I picked just to test. It worked perfectly.
         -- Exercise for the reader - Create a background frame behind the text, so it can be viewed on white backgrounds.
     end
 end)
 
-events.CLIENT_PLAYER_TICK:register(script, function(player)
-    -- Finally, use the block to get the identifier of the block
-    local identifier = Registry.BLOCK:getId(
-    -- Use the position to get the state, then the block attributed to that state
-            player.world:getBlockState(
-            -- Convert position to an actual BlockPos
-                    BlockPos(
-                    -- Get the block position the player is looking at <- START HERE read UP ^
-                            player:raycast(5, 0, false):getBlockPos()
-                    )
-            ):getBlock()
-    )
-    local namespace, path = identifier:getNamespace(),  identifier:getPath()
-    if namespace == "minecraft" and path == "air" then -- If we're just looking at air, don't create a text object.
-        renderText = nil
-    else -- Otherwise, pull the name of the block from the language.
-        renderText = Text.translatable("block."..namespace.."."..path)
+events.common.PLAYER_TICK:register(script, function(player)
+    if player:getWorld():isClient() then
+        -- Finally, use the block to get the identifier of the block
+        local identifier = Registries.BLOCK:getId(
+        -- Use the position to get the state, then the block attributed to that state
+                player.world:getBlockState(
+                -- Convert position to an actual BlockPos
+                        BlockPos(
+                        -- Get the block position the player is looking at <- START HERE read UP ^
+                                player:raycast(5, 0, false):getBlockPos()
+                        )
+                ):getBlock()
+        )
+        local namespace, path = identifier:getNamespace(),  identifier:getPath()
+        if namespace == "minecraft" and path == "air" then -- If we're just looking at air, don't create a text object.
+            renderText = nil
+        else -- Otherwise, pull the name of the block from the language.
+            renderText = Text.translatable("block."..namespace.."."..path)
+        end
     end
 end)
\ No newline at end of file
diff --git a/bouquet/examples/wetworks/wetworks.lua b/bouquet/examples/wetworks/wetworks.lua
index 0d7aad4..14b6e5a 100755
--- a/bouquet/examples/wetworks/wetworks.lua
+++ b/bouquet/examples/wetworks/wetworks.lua
@@ -5,25 +5,40 @@
 -- Try modifying, and running /reload!
 
 -- Import java classes
-local Items = java.import("Items")
-local Registry = java.import("Registry")
-local Identifier = java.import("Identifier")
-local SoundEvents = java.import("SoundEvents")
-local SoundCategory = java.import("SoundCategory")
-local EquipmentSlot = java.import("EquipmentSlot")
+local Items = require("net.minecraft.item.Items")
+local Registries = require("net.minecraft.registry.Registries")
+local Identifier = require("net.minecraft.util.Identifier")
+local SoundEvents = require("net.minecraft.sound.SoundEvents")
+local SoundCategory = require("net.minecraft.sound.SoundCategory")
+local EquipmentSlot = require("net.minecraft.entity.EquipmentSlot")
+
+local DataComponentTypes = require("net.minecraft.component.DataComponentTypes")
+local PotionContentsComponent = require("net.minecraft.component.type.PotionContentsComponent")
+local Potions = require("net.minecraft.potion.Potions")
+local ParticleTypes = require("net.minecraft.particle.ParticleTypes")
 
 -- Return a function that we can modify while the game is playing
-events.BLOCK_INTERACT:register(script, function(state, world, pos, player, hand, hitResult)
-    local concrete = Registry.BLOCK:getId(state:getBlock()):getPath() -- Get the name of the block interacted with
-    local mainHand = player:getEquippedStack(EquipmentSlot.MAINHAND) -- Get the main hand itemstack of the player
+events.common.BLOCK_INTERACT:register(script, function(state, world, pos, player, hand, hitResult)
+    local concrete = Registries.BLOCK:getId(state:getBlock()):getPath() -- Get the name of the block interacted with
+    local mainHandStack = player:getEquippedStack(EquipmentSlot.MAINHAND) -- Get the main hand itemstack of the player
     -- Check if the block name has 'concrete_powder' in it, then check if the main hand is holding a water bottle
-    if concrete:find("concrete_powder") and mainHand:isItemEqual(Items.POTION:getDefaultStack()) then
+    if concrete:find("concrete_powder") and mainHandStack:getOrDefault(DataComponentTypes.POTION_CONTENTS, PotionContentsComponent.DEFAULT):matches(Potions.WATER) then
         -- Replace the powder block with the concrete variant
-        world:setBlockState(pos, Registry.BLOCK:get(Identifier("minecraft:"..concrete:gsub("_powder", ""))):getDefaultState())
-        -- Play the water bottle emptying sound effect
-        world:playSound(nil, pos:getX(), pos:getY(), pos:getZ(), SoundEvents.ITEM_BOTTLE_FILL, SoundCategory.BLOCKS, 1, 1)
+        world:setBlockState(pos, Registries.BLOCK:get(Identifier.of("minecraft:"..concrete:gsub("_powder", ""))):getDefaultState())
+        -- Spawn some particles
+        if world:isClient() then
+            world:spawnParticles(ParticleTypes.SPLASH,
+                    pos:getX() + world.random:nextDouble(),
+                    pos:getY() + world.random:nextDouble(),
+                    pos:getZ() + world.random:nextDouble(),
+                    1, 0, 0, 0, 1
+            )
+        end
+        -- Play sound effects
+        world:playSound(nil, pos:getX(), pos:getY(), pos:getZ(), SoundEvents.ITEM_BOTTLE_EMPTY, SoundCategory.BLOCKS, 1, 1)
+        world:playSound(nil, pos:getX(), pos:getY(), pos:getZ(), SoundEvents.ENTITY_GENERIC_SPLASH, SoundCategory.BLOCKS, 1, 1)
         if (not player:isCreative()) then -- If the player isn't in creative
-            mainHand:setCount(0) -- Remove the water bottle
+            mainHandStack:setCount(0) -- Remove the water bottle
             player:equipStack(EquipmentSlot.MAINHAND, Items.GLASS_BOTTLE:getDefaultStack()) -- Replace it with an empty glass bottle
         end
     end
diff --git a/bouquet/src/client/java/dev/hugeblank/bouquet/BouquetAlliumExtensionClient.java b/bouquet/src/client/java/dev/hugeblank/bouquet/BouquetAlliumExtensionClient.java
new file mode 100644
index 0000000..e115226
--- /dev/null
+++ b/bouquet/src/client/java/dev/hugeblank/bouquet/BouquetAlliumExtensionClient.java
@@ -0,0 +1,13 @@
+package dev.hugeblank.bouquet;
+
+import dev.hugeblank.allium.api.AlliumExtension;
+import dev.hugeblank.bouquet.api.event.ClientEvents;
+import dev.hugeblank.bouquet.api.lib.DefaultEventsLib;
+import me.basiqueevangelist.enhancedreflection.api.EClass;
+
+public class BouquetAlliumExtensionClient implements AlliumExtension {
+    @Override
+    public void onInitialize() {
+        DefaultEventsLib.registerCategory("client", EClass.fromJava(ClientEvents.class)); // Register client events
+    }
+}
diff --git a/bouquet/src/client/java/dev/hugeblank/bouquet/api/event/ClientEventHandlers.java b/bouquet/src/client/java/dev/hugeblank/bouquet/api/event/ClientEventHandlers.java
index 32e565a..d102370 100755
--- a/bouquet/src/client/java/dev/hugeblank/bouquet/api/event/ClientEventHandlers.java
+++ b/bouquet/src/client/java/dev/hugeblank/bouquet/api/event/ClientEventHandlers.java
@@ -3,6 +3,7 @@
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.font.TextRenderer;
 import net.minecraft.client.gui.DrawContext;
+import net.minecraft.client.gui.hud.InGameHud;
 import net.minecraft.client.network.ClientPlayerEntity;
 
 // For all events that use classes that the server doesn't have.
@@ -10,12 +11,8 @@
 // We do this so registration goes without a hitch, the dummy method MUST never get called.
 
 public class ClientEventHandlers {
-    public interface PlayerTick {
-        void onPlayerTick(ClientPlayerEntity player);
-
-    }
 
     public interface GuiRender {
-        void onGuiRender(MinecraftClient client, DrawContext context, TextRenderer textRenderer);
+        void onGuiRender(MinecraftClient client, DrawContext context, InGameHud hud);
     }
 }
diff --git a/bouquet/src/client/java/dev/hugeblank/bouquet/api/event/ClientEvents.java b/bouquet/src/client/java/dev/hugeblank/bouquet/api/event/ClientEvents.java
new file mode 100644
index 0000000..cfa9864
--- /dev/null
+++ b/bouquet/src/client/java/dev/hugeblank/bouquet/api/event/ClientEvents.java
@@ -0,0 +1,17 @@
+package dev.hugeblank.bouquet.api.event;
+
+import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
+import net.minecraft.util.Identifier;
+
+@LuaWrapped
+public class ClientEvents implements Events {
+    @LuaWrapped public static final SimpleEventType<ClientEventHandlers.GuiRender> GUI_RENDER_HEAD;
+    @LuaWrapped public static final SimpleEventType<ClientEventHandlers.GuiRender> GUI_RENDER_TAIL;
+
+    static {
+        // The end of the client render cycle (renders below everything in the gui)
+        GUI_RENDER_HEAD = new SimpleEventType<>(Identifier.of("allium:client/render_head"));
+        // The end of the client render cycle (renders above everything in the gui)
+        GUI_RENDER_TAIL = new SimpleEventType<>(Identifier.of("allium:client/render_tail"));
+    }
+}
diff --git a/bouquet/src/client/java/dev/hugeblank/bouquet/api/lib/ClientEventsLib.java b/bouquet/src/client/java/dev/hugeblank/bouquet/api/lib/ClientEventsLib.java
deleted file mode 100644
index b707478..0000000
--- a/bouquet/src/client/java/dev/hugeblank/bouquet/api/lib/ClientEventsLib.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package dev.hugeblank.bouquet.api.lib;
-
-import dev.hugeblank.bouquet.api.event.ClientEventHandlers;
-import dev.hugeblank.bouquet.api.event.SimpleEventType;
-import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
-import net.minecraft.util.Identifier;
-
-@LuaWrapped(name = "events")
-public class ClientEventsLib {
-
-    @LuaWrapped public static final SimpleEventType<ClientEventHandlers.PlayerTick> PLAYER_TICK; // player gets ticked on the client
-    @LuaWrapped public static final SimpleEventType<ClientEventHandlers.GuiRender> GUI_RENDER_HEAD; // The end of the client render cycle (renders below everything in the gui)
-    @LuaWrapped public static final SimpleEventType<ClientEventHandlers.GuiRender> GUI_RENDER_TAIL; // The end of the client render cycle (renders above everything in the gui)
-
-    static {
-        PLAYER_TICK = new SimpleEventType<>(Identifier.of("allium:client_player_tick"));
-        GUI_RENDER_HEAD = new SimpleEventType<>(Identifier.of("allium:client_render_head"));
-        GUI_RENDER_TAIL = new SimpleEventType<>(Identifier.of("allium:client_render_tail"));
-    }
-}
diff --git a/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/client/gui/hud/InGameHudMixin.java b/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/client/gui/hud/InGameHudMixin.java
index 44f9680..e7db633 100755
--- a/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/client/gui/hud/InGameHudMixin.java
+++ b/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/client/gui/hud/InGameHudMixin.java
@@ -1,6 +1,6 @@
 package dev.hugeblank.bouquet.mixin.client.gui.hud;
 
-import dev.hugeblank.bouquet.api.lib.ClientEventsLib;
+import dev.hugeblank.bouquet.api.event.ClientEvents;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.DrawContext;
 import net.minecraft.client.gui.hud.InGameHud;
@@ -24,11 +24,11 @@ public class InGameHudMixin {
 
     @Inject(at = @At("HEAD"), method = "render")
     private void renderHead(DrawContext context, RenderTickCounter tickCounter, CallbackInfo ci) {
-        ClientEventsLib.GUI_RENDER_HEAD.invoker().onGuiRender(client, context, thiz.getTextRenderer());
+        ClientEvents.GUI_RENDER_HEAD.invoker().onGuiRender(client, context, thiz);
     }
 
     @Inject(at = @At("TAIL"), method = "render")
     private void renderTail(DrawContext context, RenderTickCounter tickCounter, CallbackInfo ci) {
-        ClientEventsLib.GUI_RENDER_TAIL.invoker().onGuiRender(client, context, thiz.getTextRenderer());
+        ClientEvents.GUI_RENDER_TAIL.invoker().onGuiRender(client, context, thiz);
     }
 }
diff --git a/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/client/network/ClientPlayerEntityMixin.java b/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/client/network/ClientPlayerEntityMixin.java
deleted file mode 100755
index cc9da8a..0000000
--- a/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/client/network/ClientPlayerEntityMixin.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package dev.hugeblank.bouquet.mixin.client.network;
-
-import dev.hugeblank.bouquet.api.lib.ClientEventsLib;
-import net.minecraft.client.network.ClientPlayerEntity;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(ClientPlayerEntity.class)
-public class ClientPlayerEntityMixin {
-
-    @Inject(at = @At("HEAD"), method = "tick()V")
-    private void tick(CallbackInfo ci) {
-        ClientEventsLib.PLAYER_TICK.invoker().onPlayerTick((ClientPlayerEntity)(Object) this);
-    }
-}
diff --git a/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/server/integrated/IntegratedServerMixin.java b/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/server/integrated/IntegratedServerMixin.java
index 4820c9f..06b6b3a 100644
--- a/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/server/integrated/IntegratedServerMixin.java
+++ b/bouquet/src/client/java/dev/hugeblank/bouquet/mixin/server/integrated/IntegratedServerMixin.java
@@ -1,6 +1,7 @@
 package dev.hugeblank.bouquet.mixin.server.integrated;
 
-import dev.hugeblank.bouquet.api.lib.DefaultEventsLib;
+import dev.hugeblank.bouquet.api.event.CommonEvents;
+import dev.hugeblank.bouquet.api.event.ServerEvents;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.integrated.IntegratedServer;
 import org.spongepowered.asm.mixin.Mixin;
@@ -12,6 +13,6 @@
 public class IntegratedServerMixin {
     @Inject(at = @At("TAIL"), method = "setupServer")
     private void init(CallbackInfoReturnable<Boolean> cir) {
-        DefaultEventsLib.SERVER_START.invoker().onServerStart((MinecraftServer) (Object) this);
+        ServerEvents.SERVER_START.invoker().onServerStart((MinecraftServer) (Object) this);
     }
 }
diff --git a/bouquet/src/client/resources/bouquet.client.mixins.json b/bouquet/src/client/resources/bouquet.client.mixins.json
index 04dd3c6..3f61654 100644
--- a/bouquet/src/client/resources/bouquet.client.mixins.json
+++ b/bouquet/src/client/resources/bouquet.client.mixins.json
@@ -4,7 +4,6 @@
 	"compatibilityLevel": "JAVA_21",
 	"client": [
 		"client.gui.hud.InGameHudMixin",
-		"client.network.ClientPlayerEntityMixin",
 		"server.integrated.IntegratedServerMixin"
 	],
 	"injectors": {
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/BouquetAlliumExtension.java b/bouquet/src/main/java/dev/hugeblank/bouquet/BouquetAlliumExtension.java
index 107654f..ef2bc15 100644
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/BouquetAlliumExtension.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/BouquetAlliumExtension.java
@@ -2,15 +2,23 @@
 
 import dev.hugeblank.allium.loader.EnvironmentManager;
 import dev.hugeblank.allium.api.AlliumExtension;
+import dev.hugeblank.bouquet.api.event.CommonEvents;
+import dev.hugeblank.bouquet.api.event.ServerEvents;
 import dev.hugeblank.bouquet.api.lib.*;
 import dev.hugeblank.bouquet.api.lib.commands.CommandLib;
+import dev.hugeblank.bouquet.api.lib.commands.CommandsLib;
 import dev.hugeblank.bouquet.api.lib.fs.FsLib;
 import dev.hugeblank.bouquet.api.lib.http.HttpLib;
+import me.basiqueevangelist.enhancedreflection.api.EClass;
 
 public class BouquetAlliumExtension implements AlliumExtension {
 
     @Override
     public void onInitialize() {
+        // Register common and server events
+        DefaultEventsLib.registerCategory("common", EClass.fromJava(CommonEvents.class));
+        DefaultEventsLib.registerCategory("server", EClass.fromJava(ServerEvents.class));
+
         EnvironmentManager.registerLibrary(AlliumLib::new);
         EnvironmentManager.registerLibrary(new DefaultEventsLib());
         EnvironmentManager.registerLibrary(new FabricLib());
@@ -19,7 +27,9 @@ public void onInitialize() {
         EnvironmentManager.registerLibrary(new JsonLib());
         EnvironmentManager.registerLibrary(new NbtLib());
         EnvironmentManager.registerLibrary(new TextLib());
+        EnvironmentManager.registerLibrary(new CommandsLib());
         EnvironmentManager.registerLibrary(CommandLib::new);
+
         EnvironmentManager.registerLibrary(FsLib::new);
         EnvironmentManager.registerLibrary(new HttpLib());
     }
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/CommonEventHandlers.java b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/CommonEventHandlers.java
index fca3b59..42e7f23 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/CommonEventHandlers.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/CommonEventHandlers.java
@@ -2,51 +2,26 @@
 
 import net.minecraft.block.BlockState;
 import net.minecraft.entity.damage.DamageSource;
+import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.Hand;
 import net.minecraft.util.hit.BlockHitResult;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
 
 public class CommonEventHandlers {
-    public interface ChatMessage {
-        void onChatMessage(ServerPlayerEntity player, String message);
-    }
-
     public interface PlayerTick {
-        void onPlayerTick(ServerPlayerEntity player);
-    }
-
-    public interface PlayerJoin {
-        void onPlayerJoin(ServerPlayerEntity player);
-    }
-
-    public interface PlayerQuit {
-        void onPlayerQuit(ServerPlayerEntity player);
-    }
-
-    public interface PlayerBlockCollision {
-        void onPlayerBlockCollision(ServerPlayerEntity player, BlockState state);
-    }
-
-    public interface PlayerDeath {
-        void onPlayerDeath(ServerPlayerEntity player, DamageSource damageSource);
+        void onPlayerTick(PlayerEntity player);
     }
 
     public interface PlayerBlockInteract {
-        void onPlayerBlockInteraction(BlockState state, ServerWorld world, BlockPos pos, ServerPlayerEntity player, Hand hand, BlockHitResult hitResult);
+        void onPlayerBlockInteraction(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hitResult);
     }
 
-    public interface ServerTick {
-        void onServerTick(MinecraftServer server);
-    }
-
-    public interface ServerStart {
-        void onServerStart(MinecraftServer server);
+    public interface PlayerDeath {
+        void onPlayerDeath(PlayerEntity player, DamageSource damageSource);
     }
 
-    public interface CommandRegistration {
-        void onCommandRegistration(String scriptId, String commandName, boolean successful);
-    }
 }
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/CommonEvents.java b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/CommonEvents.java
new file mode 100644
index 0000000..ff0cd3c
--- /dev/null
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/CommonEvents.java
@@ -0,0 +1,23 @@
+package dev.hugeblank.bouquet.api.event;
+
+import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
+import net.minecraft.util.Identifier;
+
+@LuaWrapped
+public class CommonEvents implements Events {
+
+    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerTick> PLAYER_TICK;
+    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerDeath> PLAYER_DEATH;
+    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerBlockInteract> BLOCK_INTERACT;
+
+    static {
+        // player gets ticked
+        PLAYER_TICK = new SimpleEventType<>(Identifier.of("allium:common/player_tick"));
+        // player dies
+        PLAYER_DEATH = new SimpleEventType<>(Identifier.of("allium:common/player_death"));
+        // player interacts (right clicks) with a block
+        BLOCK_INTERACT = new SimpleEventType<>(Identifier.of("allium:common/block_interact"));
+
+
+    }
+}
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/Events.java b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/Events.java
new file mode 100644
index 0000000..6c7f910
--- /dev/null
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/Events.java
@@ -0,0 +1,4 @@
+package dev.hugeblank.bouquet.api.event;
+
+public interface Events {
+}
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/ServerEventHandlers.java b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/ServerEventHandlers.java
index 2872753..f10b30b 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/ServerEventHandlers.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/ServerEventHandlers.java
@@ -4,6 +4,37 @@
 // Make sure to provide a dummy method with no parameters for it.
 // We do this so registration goes without a hitch, the dummy method MUST never get called.
 
+import net.minecraft.block.BlockState;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.network.ServerPlayerEntity;
+
 public class ServerEventHandlers {
-    // TODO: Actually have events that are truly server-sided that would break the client...
+
+    public interface ChatMessage {
+        void onChatMessage(ServerPlayerEntity player, String message);
+    }
+
+    public interface PlayerJoin {
+        void onPlayerJoin(ServerPlayerEntity player);
+    }
+
+    public interface PlayerQuit {
+        void onPlayerQuit(ServerPlayerEntity player);
+    }
+
+    public interface PlayerBlockCollision {
+        void onPlayerBlockCollision(ServerPlayerEntity player, BlockState state);
+    }
+
+    public interface ServerTick {
+        void onServerTick(MinecraftServer server);
+    }
+
+    public interface ServerStart {
+        void onServerStart(MinecraftServer server);
+    }
+
+    public interface CommandRegistration {
+        void onCommandRegistration(String scriptId, String commandName, boolean successful);
+    }
 }
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/ServerEvents.java b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/ServerEvents.java
new file mode 100644
index 0000000..7e60d0c
--- /dev/null
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/api/event/ServerEvents.java
@@ -0,0 +1,32 @@
+package dev.hugeblank.bouquet.api.event;
+
+import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
+import net.minecraft.util.Identifier;
+
+public class ServerEvents implements Events {
+
+    @LuaWrapped public static final SimpleEventType<ServerEventHandlers.ChatMessage> CHAT_MESSAGE;
+    @LuaWrapped public static final SimpleEventType<ServerEventHandlers.PlayerJoin> PLAYER_JOIN;
+    @LuaWrapped public static final SimpleEventType<ServerEventHandlers.PlayerQuit> PLAYER_QUIT;
+    @LuaWrapped public static final SimpleEventType<ServerEventHandlers.PlayerBlockCollision> PLAYER_BLOCK_COLLISION;
+    @LuaWrapped public static final SimpleEventType<ServerEventHandlers.ServerTick> SERVER_TICK;
+    @LuaWrapped public static final SimpleEventType<ServerEventHandlers.CommandRegistration> COMMAND_REGISTER;
+    @LuaWrapped public static final SimpleEventType<ServerEventHandlers.ServerStart> SERVER_START;
+
+    static {
+        // server gets a chat message
+        CHAT_MESSAGE = new SimpleEventType<>(Identifier.of("allium:server/chat_message"));
+        // player joins the game
+        PLAYER_JOIN = new SimpleEventType<>(Identifier.of("allium:server/player_join"));
+        // player leaves the game
+        PLAYER_QUIT = new SimpleEventType<>(Identifier.of("allium:server/player_quit"));
+        // player collides with a block
+        PLAYER_BLOCK_COLLISION = new SimpleEventType<>(Identifier.of("allium:server/player_block_collision"));
+        // server gets ticked
+        SERVER_TICK = new SimpleEventType<>(Identifier.of("allium:server/tick"));
+        // the result of a registered command
+        COMMAND_REGISTER = new SimpleEventType<>(Identifier.of("allium:server/command_register"));
+        // server finishes loading
+        SERVER_START = new SimpleEventType<>(Identifier.of("allium:server/start"));
+    }
+}
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/DefaultEventsLib.java b/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/DefaultEventsLib.java
index a71cb0b..4ff4922 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/DefaultEventsLib.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/DefaultEventsLib.java
@@ -1,36 +1,33 @@
 package dev.hugeblank.bouquet.api.lib;
 
 import dev.hugeblank.allium.api.WrappedLuaLibrary;
-import dev.hugeblank.bouquet.api.event.CommonEventHandlers;
+import dev.hugeblank.allium.loader.type.StaticBinder;
+import dev.hugeblank.allium.loader.type.UserdataFactory;
+import dev.hugeblank.allium.loader.type.annotation.LuaIndex;
+import dev.hugeblank.bouquet.api.event.Events;
 import dev.hugeblank.bouquet.api.event.SimpleEventType;
 import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
-import net.minecraft.util.Identifier;
+import me.basiqueevangelist.enhancedreflection.api.EClass;
+import net.minecraft.registry.Registries;
+import org.squiddev.cobalt.LuaUserdata;
+
+import java.util.HashMap;
+import java.util.Map;
 
 @LuaWrapped(name = "events")
 public class DefaultEventsLib implements WrappedLuaLibrary {
-    // TODO: Consider a better naming scheme for events.
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.ChatMessage> CHAT_MESSAGE; // player sends a chat message
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerTick> PLAYER_TICK; // player gets ticked on the server
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerJoin> PLAYER_JOIN; // player joins the game
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerQuit> PLAYER_QUIT; // player leaves the game
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerBlockCollision> PLAYER_BLOCK_COLLISION; // player collides with a block
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerDeath> PLAYER_DEATH; // player dies
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.PlayerBlockInteract> BLOCK_INTERACT; // player interacts (right clicks) with a block
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.ServerTick> SERVER_TICK; // server gets ticked
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.CommandRegistration> COMMAND_REGISTER; // the result of a registered command
-    @LuaWrapped public static final SimpleEventType<CommonEventHandlers.ServerStart> SERVER_START; // server has started
+    private static final Map<String, EClass<? extends Events>> MAP;
+
+    @LuaIndex
+    public LuaUserdata index(String key) {
+        return StaticBinder.bindClass(MAP.get(key));
+    }
 
+    public static void registerCategory(String key, EClass<? extends Events> events) {
+        MAP.put(key, events);
+    }
     static {
-        CHAT_MESSAGE = new SimpleEventType<>(Identifier.of("allium:chat_message"));
-        PLAYER_TICK = new SimpleEventType<>(Identifier.of("allium:server_player_tick"));
-        PLAYER_JOIN = new SimpleEventType<>(Identifier.of("allium:player_join"));
-        PLAYER_QUIT = new SimpleEventType<>(Identifier.of("allium:player_quit"));
-        PLAYER_BLOCK_COLLISION = new SimpleEventType<>(Identifier.of("allium:player_block_collision"));
-        PLAYER_DEATH = new SimpleEventType<>(Identifier.of("allium:player_death"));
-        BLOCK_INTERACT = new SimpleEventType<>(Identifier.of("allium:block_interact"));
-        SERVER_TICK = new SimpleEventType<>(Identifier.of("allium:server_tick"));
-        COMMAND_REGISTER = new SimpleEventType<>(Identifier.of("allium:command_register"));
-        SERVER_START = new SimpleEventType<>(Identifier.of("allium:server_start"));
+        MAP = new HashMap<>();
     }
 
 }
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/JsonLib.java b/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/JsonLib.java
index 99209c0..3e1be04 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/JsonLib.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/JsonLib.java
@@ -2,6 +2,7 @@
 
 import com.google.gson.*;
 import dev.hugeblank.allium.api.WrappedLuaLibrary;
+import dev.hugeblank.allium.loader.type.AlliumUserdata;
 import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
 import dev.hugeblank.allium.loader.type.annotation.OptionalArg;
 import dev.hugeblank.bouquet.util.TableHelpers;
@@ -66,8 +67,8 @@ public static JsonElement toJsonElement(LuaValue value) throws LuaError {
     private static JsonElement toJsonElementInternal(LuaValue value, Set<LuaValue> seenValues) throws LuaError {
         if (seenValues.contains(value)) return JsonNull.INSTANCE;
 
-        if (value instanceof LuaUserdata && value.optUserdata(JsonElement.class, null) != null) {
-            return value.checkUserdata(JsonElement.class);
+        if (value instanceof AlliumUserdata<?> userdata && userdata.instanceOf(JsonElement.class)) {
+            return userdata.toUserdata(JsonElement.class);
         } else if (value instanceof LuaTable table) {
             if (TableHelpers.isArray(table)) {
                 JsonArray out = new JsonArray();
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/commands/CommandsLib.java b/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/commands/CommandsLib.java
index 4f0cb89..5cd3c81 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/commands/CommandsLib.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/api/lib/commands/CommandsLib.java
@@ -2,6 +2,7 @@
 
 import com.mojang.brigadier.CommandDispatcher;
 import com.mojang.brigadier.tree.CommandNode;
+import dev.hugeblank.allium.api.WrappedLuaLibrary;
 import dev.hugeblank.allium.loader.type.annotation.LuaIndex;
 import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
 import net.minecraft.server.MinecraftServer;
@@ -13,10 +14,7 @@
 // Functionally similar to ComputerCraft's commands API
 // See: https://github.com/cc-tweaked/CC-Tweaked/blob/mc-1.16.x/src/main/java/dan200/computercraft/shared/computer/apis/CommandAPI.java
 @LuaWrapped(name = "commands")
-public class CommandsLib {
-
-    public CommandsLib() {
-    }
+public class CommandsLib implements WrappedLuaLibrary {
 
     @LuaWrapped
     public void exec(MinecraftServer server, String... args) {
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/block/AbstractBlockMixin.java b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/block/AbstractBlockMixin.java
index b0b71e6..3bf638a 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/block/AbstractBlockMixin.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/block/AbstractBlockMixin.java
@@ -1,12 +1,10 @@
 package dev.hugeblank.bouquet.mixin.block;
 
-import dev.hugeblank.bouquet.api.lib.DefaultEventsLib;
+import dev.hugeblank.bouquet.api.event.CommonEvents;
 import net.minecraft.block.AbstractBlock;
 import net.minecraft.block.BlockState;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemStack;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
 import net.minecraft.util.ItemActionResult;
@@ -23,11 +21,11 @@ public class AbstractBlockMixin {
 
     @Inject(at = @At("TAIL"), method = "onUse")
     private void onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit, CallbackInfoReturnable<ActionResult> cir) {
-        if (!world.isClient()) DefaultEventsLib.BLOCK_INTERACT.invoker().onPlayerBlockInteraction(state, (ServerWorld) world, pos, (ServerPlayerEntity) player, null, hit);
+        CommonEvents.BLOCK_INTERACT.invoker().onPlayerBlockInteraction(state, world, pos,  player, null, hit);
     }
 
     @Inject(at = @At("TAIL"), method = "onUseWithItem")
     private void onUseWithItem(ItemStack stack, BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit, CallbackInfoReturnable<ItemActionResult> cir) {
-        if (!world.isClient()) DefaultEventsLib.BLOCK_INTERACT.invoker().onPlayerBlockInteraction(state, (ServerWorld) world, pos, (ServerPlayerEntity) player, hand, hit);
+        CommonEvents.BLOCK_INTERACT.invoker().onPlayerBlockInteraction(state, world, pos, player, hand, hit);
     }
 }
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/command/CommandManagerMixin.java b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/command/CommandManagerMixin.java
index a1a9df4..7e74910 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/command/CommandManagerMixin.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/command/CommandManagerMixin.java
@@ -1,6 +1,8 @@
 package dev.hugeblank.bouquet.mixin.command;
 
 import com.mojang.brigadier.CommandDispatcher;
+import dev.hugeblank.bouquet.api.event.CommonEvents;
+import dev.hugeblank.bouquet.api.event.ServerEvents;
 import dev.hugeblank.bouquet.api.lib.AlliumLib;
 import dev.hugeblank.bouquet.api.lib.DefaultEventsLib;
 import dev.hugeblank.bouquet.api.lib.commands.CommandRegisterEntry;
@@ -17,11 +19,6 @@
 @Mixin(CommandManager.class)
 public class CommandManagerMixin {
 
-    @Mutable
-    @Final
-    @Shadow
-    private static Logger LOGGER;
-
     @Mutable
     @Final
     @Shadow
@@ -44,14 +41,9 @@ private void init(CommandManager.RegistrationEnvironment environment, CommandReg
         });
     }
 
-    @Inject(at = @At("TAIL"), method = "<clinit>")
-    private static void clinit(CallbackInfo ci) {
-        LOGGER = new DebugLoggerWrapper(LOGGER);
-    }
-
     @Unique
     private static void queueEvent(CommandRegisterEntry entry, boolean result) {
-        DefaultEventsLib.COMMAND_REGISTER.invoker().onCommandRegistration(
+        ServerEvents.COMMAND_REGISTER.invoker().onCommandRegistration(
                 entry.script().getId(),
                 entry.builder().getLiteral(),
                 result
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/entity/PlayerEntityMixin.java b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/entity/PlayerEntityMixin.java
new file mode 100644
index 0000000..bef0b5c
--- /dev/null
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/entity/PlayerEntityMixin.java
@@ -0,0 +1,22 @@
+package dev.hugeblank.bouquet.mixin.entity;
+
+import dev.hugeblank.bouquet.api.event.CommonEvents;
+import net.minecraft.entity.damage.DamageSource;
+import net.minecraft.entity.player.PlayerEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(PlayerEntity.class)
+public class PlayerEntityMixin {
+    @Inject(at = @At("TAIL"), method = "tick")
+    private void tick(CallbackInfo ci) {
+        CommonEvents.PLAYER_TICK.invoker().onPlayerTick((PlayerEntity)(Object) this);
+    }
+
+    @Inject(at = @At("TAIL"), method = "onDeath")
+    private void onDeath(DamageSource source, CallbackInfo ci) {
+        CommonEvents.PLAYER_DEATH.invoker().onPlayerDeath((PlayerEntity) (Object) this, source);
+    }
+}
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/MinecraftServerMixin.java b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/MinecraftServerMixin.java
index 02fe135..0f2afc3 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/MinecraftServerMixin.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/MinecraftServerMixin.java
@@ -1,6 +1,7 @@
 package dev.hugeblank.bouquet.mixin.server;
 
-import dev.hugeblank.bouquet.api.lib.DefaultEventsLib;
+import dev.hugeblank.bouquet.api.event.CommonEvents;
+import dev.hugeblank.bouquet.api.event.ServerEvents;
 import net.minecraft.server.MinecraftServer;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -14,6 +15,6 @@ public abstract class MinecraftServerMixin {
     
     @Inject(at = @At("TAIL"), method = "tick")
     private void tick(BooleanSupplier shouldKeepTicking, CallbackInfo ci) {
-        DefaultEventsLib.SERVER_TICK.invoker().onServerTick((MinecraftServer) (Object) this);
+        ServerEvents.SERVER_TICK.invoker().onServerTick((MinecraftServer) (Object) this);
     }
 }
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/MinecraftServerSubclassMixin.java b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/MinecraftServerSubclassMixin.java
index 9696701..4c4e60f 100644
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/MinecraftServerSubclassMixin.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/MinecraftServerSubclassMixin.java
@@ -1,6 +1,7 @@
 package dev.hugeblank.bouquet.mixin.server;
 
-import dev.hugeblank.bouquet.api.lib.DefaultEventsLib;
+import dev.hugeblank.bouquet.api.event.CommonEvents;
+import dev.hugeblank.bouquet.api.event.ServerEvents;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.dedicated.MinecraftDedicatedServer;
 import net.minecraft.test.TestServer;
@@ -13,6 +14,6 @@
 public class MinecraftServerSubclassMixin {
     @Inject(at = @At("TAIL"), method = "setupServer")
     private void init(CallbackInfoReturnable<Boolean> cir) {
-        DefaultEventsLib.SERVER_START.invoker().onServerStart((MinecraftServer) (Object) this);
+        ServerEvents.SERVER_START.invoker().onServerStart((MinecraftServer) (Object) this);
     }
 }
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/PlayerManagerMixin.java b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/PlayerManagerMixin.java
index f7d9b65..72a17ba 100644
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/PlayerManagerMixin.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/PlayerManagerMixin.java
@@ -1,6 +1,6 @@
 package dev.hugeblank.bouquet.mixin.server;
 
-import dev.hugeblank.bouquet.api.lib.DefaultEventsLib;
+import dev.hugeblank.bouquet.api.event.ServerEvents;
 import net.minecraft.network.ClientConnection;
 import net.minecraft.network.message.MessageType;
 import net.minecraft.network.message.SignedMessage;
@@ -20,11 +20,7 @@ public class PlayerManagerMixin {
     @Inject(at = @At("HEAD"), method = "broadcast(Lnet/minecraft/network/message/SignedMessage;Ljava/util/function/Predicate;Lnet/minecraft/server/network/ServerPlayerEntity;Lnet/minecraft/network/message/MessageType$Parameters;)V")
     private void onChatMessage(SignedMessage message, Predicate<ServerPlayerEntity> shouldSendFiltered, ServerPlayerEntity sender, MessageType.Parameters params, CallbackInfo ci) {
         var msg = message.signedBody().content();
-        DefaultEventsLib.CHAT_MESSAGE.invoker().onChatMessage(sender, msg);
+        ServerEvents.CHAT_MESSAGE.invoker().onChatMessage(sender, msg);
     }
 
-    @Inject(at = @At("TAIL"), method = "onPlayerConnect")
-    private void onPlayerConnect(ClientConnection connection, ServerPlayerEntity player, ConnectedClientData clientData, CallbackInfo ci) {
-        if (player.getWorld().isClient()) DefaultEventsLib.PLAYER_JOIN.invoker().onPlayerJoin(player);
-    }
 }
diff --git a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/network/ServerPlayerEntityMixin.java b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/network/ServerPlayerEntityMixin.java
index 52df6d8..ae9d2b4 100755
--- a/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/network/ServerPlayerEntityMixin.java
+++ b/bouquet/src/main/java/dev/hugeblank/bouquet/mixin/server/network/ServerPlayerEntityMixin.java
@@ -1,9 +1,8 @@
 package dev.hugeblank.bouquet.mixin.server.network;
 
-import dev.hugeblank.bouquet.api.lib.DefaultEventsLib;
+import dev.hugeblank.bouquet.api.event.ServerEvents;
 import dev.hugeblank.bouquet.util.EntityDataHolder;
 import net.minecraft.block.BlockState;
-import net.minecraft.entity.damage.DamageSource;
 import net.minecraft.server.network.ServerPlayerEntity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
@@ -13,24 +12,19 @@
 @Mixin(ServerPlayerEntity.class)
 public class ServerPlayerEntityMixin{
 
-    @Inject(at = @At("HEAD"), method = "playerTick()V")
-    private void tick(CallbackInfo ci) {
-        DefaultEventsLib.PLAYER_TICK.invoker().onPlayerTick((ServerPlayerEntity)(Object) this);
+    @Inject(at = @At("HEAD"), method = "onSpawn")
+    private void onPlayerConnect(CallbackInfo ci) {
+        ServerEvents.PLAYER_JOIN.invoker().onPlayerJoin((ServerPlayerEntity)(Object) this);
     }
 
     @Inject(at = @At("HEAD"), method = "onDisconnect")
     private void onDisconnect(CallbackInfo ci) {
-        DefaultEventsLib.PLAYER_QUIT.invoker().onPlayerQuit((ServerPlayerEntity)(Object) this);
+        ServerEvents.PLAYER_QUIT.invoker().onPlayerQuit((ServerPlayerEntity)(Object) this);
     }
 
     @Inject(at = @At("HEAD"), method = "onBlockCollision")
     private void onBlockCollision(BlockState state, CallbackInfo ci) {
-        DefaultEventsLib.PLAYER_BLOCK_COLLISION.invoker().onPlayerBlockCollision((ServerPlayerEntity)(Object) this, state);
-    }
-
-    @Inject(at = @At("TAIL"), method = "onDeath")
-    private void onDeath(DamageSource source, CallbackInfo ci) {
-        DefaultEventsLib.PLAYER_DEATH.invoker().onPlayerDeath((ServerPlayerEntity)(Object) this, source);
+        ServerEvents.PLAYER_BLOCK_COLLISION.invoker().onPlayerBlockCollision((ServerPlayerEntity)(Object) this, state);
     }
 
     @Inject(at = @At("RETURN"), method = "copyFrom")
diff --git a/bouquet/src/main/resources/bouquet.mixins.json b/bouquet/src/main/resources/bouquet.mixins.json
index 3ee90f4..b88c5eb 100644
--- a/bouquet/src/main/resources/bouquet.mixins.json
+++ b/bouquet/src/main/resources/bouquet.mixins.json
@@ -9,6 +9,7 @@
     "command.ReloadCommandMixin",
     "command.argument.ArgumentTypesMixin",
     "entity.EntityMixin",
+    "entity.PlayerEntityMixin",
     "resource.ResourcePackManagerMixin",
     "server.MinecraftServerMixin",
     "server.MinecraftServerSubclassMixin",
diff --git a/bouquet/src/main/resources/fabric.mod.json b/bouquet/src/main/resources/fabric.mod.json
index a6787e9..e17af47 100644
--- a/bouquet/src/main/resources/fabric.mod.json
+++ b/bouquet/src/main/resources/fabric.mod.json
@@ -23,6 +23,9 @@
 		],
 		"allium": [
 			"dev.hugeblank.bouquet.BouquetAlliumExtension"
+		],
+		"allium-client": [
+			"dev.hugeblank.bouquet.BouquetAlliumExtensionClient"
 		]
 	},
 	"mixins": [