From b852764be0dca153491be9ece77f59e6b6e6e7e2 Mon Sep 17 00:00:00 2001
From: mworzala <mattheworzala@gmail.com>
Date: Thu, 29 Sep 2022 19:50:50 -0400
Subject: [PATCH 1/3] attach common project locally, move test lib

---
 .idea/gradle.xml                              |   2 +-
 modules/build.gradle.kts                      |   2 +-
 modules/test/README.md                        |   5 +
 modules/test/build.gradle.kts                 |  28 +++++
 .../net/hollowcube/test/ComponentUtil.java    |  15 +++
 .../java/net/hollowcube/test/TestUtil.java    |  40 +++++++
 .../net/minestom/server/test/Collector.java   |  40 +++++++
 .../java/net/minestom/server/test/Env.java    |  57 +++++++++
 .../net/minestom/server/test/EnvBefore.java   |  11 ++
 .../net/minestom/server/test/EnvCleaner.java  |  16 +++
 .../net/minestom/server/test/EnvImpl.java     | 111 ++++++++++++++++++
 .../server/test/EnvParameterResolver.java     |  15 +++
 .../net/minestom/server/test/EnvTest.java     |  17 +++
 .../server/test/FlexibleListener.java         |  24 ++++
 .../minestom/server/test/TestConnection.java  |  20 ++++
 .../server/test/TestConnectionImpl.java       |  87 ++++++++++++++
 .../net/minestom/server/test/TestUtils.java   |  55 +++++++++
 .../test/truth/AbstractInventorySubject.java  |  60 ++++++++++
 .../server/test/truth/EntitySubject.java      |  39 ++++++
 .../server/test/truth/ItemStackSubject.java   |  31 +++++
 .../server/test/truth/MinestomTruth.java      |  24 ++++
 21 files changed, 697 insertions(+), 2 deletions(-)
 create mode 100644 modules/test/README.md
 create mode 100644 modules/test/src/main/java/net/hollowcube/test/ComponentUtil.java
 create mode 100644 modules/test/src/main/java/net/hollowcube/test/TestUtil.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/Collector.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/Env.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/EnvBefore.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/EnvCleaner.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/EnvImpl.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/EnvParameterResolver.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/EnvTest.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/FlexibleListener.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/TestConnection.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/TestConnectionImpl.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/TestUtils.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/truth/AbstractInventorySubject.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/truth/EntitySubject.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/truth/ItemStackSubject.java
 create mode 100644 modules/test/src/main/java/net/minestom/server/test/truth/MinestomTruth.java

diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 3a39f61..c135e4b 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -8,7 +8,7 @@
         <option name="testRunner" value="GRADLE" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="openjdk-17" />
+        <option name="gradleJvm" value="17 (3)" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
diff --git a/modules/build.gradle.kts b/modules/build.gradle.kts
index 76de787..41ccdfe 100644
--- a/modules/build.gradle.kts
+++ b/modules/build.gradle.kts
@@ -5,7 +5,7 @@ subprojects {
     apply(plugin = "java")
     apply(plugin = "net.ltgt.errorprone")
 
-    group = "net.hollowcube.libmmo"
+    group = "net.hollowcube.common"
 
     repositories {
         mavenCentral()
diff --git a/modules/test/README.md b/modules/test/README.md
new file mode 100644
index 0000000..e9d902f
--- /dev/null
+++ b/modules/test/README.md
@@ -0,0 +1,5 @@
+## test
+
+A module for test utilities used by the others. Only ever included for tests.
+
+Contains a copy of the Minestom internal test framework until that has been extracted to its own module.
diff --git a/modules/test/build.gradle.kts b/modules/test/build.gradle.kts
index e69de29..69ec69a 100644
--- a/modules/test/build.gradle.kts
+++ b/modules/test/build.gradle.kts
@@ -0,0 +1,28 @@
+plugins {
+    `java-library`
+}
+
+dependencies {
+
+    // JUnit
+    api("org.junit.jupiter:junit-jupiter-api:5.9.0")
+    api("org.junit.jupiter:junit-jupiter-params:5.9.0")
+    runtimeOnly("org.junit.jupiter:junit-jupiter-engine:5.9.0")
+
+    // Truth
+    api("com.google.truth:truth:1.1.3")
+
+
+    // TestContainers
+    fun testContainersApi(name: String) {
+        api("org.testcontainers:$name:1.17.3") {
+            exclude(group = "junit", module = "junit")
+        }
+    }
+
+    testContainersApi("testcontainers")
+    testContainersApi("junit-jupiter")
+    testContainersApi("mongodb")
+
+
+}
diff --git a/modules/test/src/main/java/net/hollowcube/test/ComponentUtil.java b/modules/test/src/main/java/net/hollowcube/test/ComponentUtil.java
new file mode 100644
index 0000000..4e7684d
--- /dev/null
+++ b/modules/test/src/main/java/net/hollowcube/test/ComponentUtil.java
@@ -0,0 +1,15 @@
+package net.hollowcube.test;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TranslatableComponent;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
+import org.jetbrains.annotations.NotNull;
+
+public class ComponentUtil {
+
+    public static @NotNull String toString(@NotNull Component component) {
+        if (component instanceof TranslatableComponent comp)
+            return comp.key();
+        return PlainTextComponentSerializer.plainText().serialize(component);
+    }
+}
diff --git a/modules/test/src/main/java/net/hollowcube/test/TestUtil.java b/modules/test/src/main/java/net/hollowcube/test/TestUtil.java
new file mode 100644
index 0000000..9c7911b
--- /dev/null
+++ b/modules/test/src/main/java/net/hollowcube/test/TestUtil.java
@@ -0,0 +1,40 @@
+package net.hollowcube.test;
+
+import net.minestom.server.entity.Player;
+import net.minestom.server.network.packet.server.SendablePacket;
+import net.minestom.server.network.player.PlayerConnection;
+import org.jetbrains.annotations.NotNull;
+
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.time.Instant;
+import java.util.UUID;
+
+//todo Moved straight from chat module, needs some refactoring
+public class TestUtil {
+
+    public static Instant instantNow() {
+        return Instant.ofEpochMilli(1659127729952L);
+    }
+
+    public static @NotNull Player headlessPlayer(@NotNull String name) {
+        return new Player(UUID.randomUUID(), name, EMPTY_PLAYER_CONNECTION);
+    }
+
+    public static @NotNull Player headlessPlayer() {
+        return headlessPlayer("test0");
+    }
+
+    private static final PlayerConnection EMPTY_PLAYER_CONNECTION = new PlayerConnection() {
+        @Override
+        public void sendPacket(@NotNull SendablePacket packet) {
+
+        }
+
+        @Override
+        public @NotNull SocketAddress getRemoteAddress() {
+            return new InetSocketAddress(0);
+        }
+    };
+
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/Collector.java b/modules/test/src/main/java/net/minestom/server/test/Collector.java
new file mode 100644
index 0000000..813529b
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/Collector.java
@@ -0,0 +1,40 @@
+package net.minestom.server.test;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
+public interface Collector<T> {
+    @NotNull List<@NotNull T> collect();
+
+    default <P extends T> void assertSingle(@NotNull Class<P> type, @NotNull Consumer<P> consumer) {
+        List<T> elements = collect();
+        assertEquals(1, elements.size(), "Expected 1 element, got " + elements);
+        var element = elements.get(0);
+        assertInstanceOf(type, element, "Expected type " + type.getSimpleName() + ", got " + element.getClass().getSimpleName());
+        consumer.accept((P) element);
+    }
+
+    default void assertSingle(@NotNull Consumer<T> consumer) {
+        List<T> elements = collect();
+        assertEquals(1, elements.size(), "Expected 1 element, got " + elements);
+        consumer.accept(elements.get(0));
+    }
+
+    default void assertCount(int count) {
+        List<T> elements = collect();
+        assertEquals(count, elements.size(), "Expected " + count + " element(s), got " + elements.size() + ": " + elements);
+    }
+
+    default void assertSingle() {
+        assertCount(1);
+    }
+
+    default void assertEmpty() {
+        assertCount(0);
+    }
+}
\ No newline at end of file
diff --git a/modules/test/src/main/java/net/minestom/server/test/Env.java b/modules/test/src/main/java/net/minestom/server/test/Env.java
new file mode 100644
index 0000000..91f5c44
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/Env.java
@@ -0,0 +1,57 @@
+package net.minestom.server.test;
+
+import net.minestom.server.ServerProcess;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Player;
+import net.minestom.server.event.Event;
+import net.minestom.server.event.EventFilter;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.network.PlayerProvider;
+import org.jetbrains.annotations.NotNull;
+
+import java.time.Duration;
+import java.util.function.BooleanSupplier;
+
+public interface Env {
+
+    @NotNull ServerProcess process();
+
+    @NotNull TestConnection createConnection();
+
+    <E extends Event, H> @NotNull Collector<E> trackEvent(@NotNull Class<E> eventType, @NotNull EventFilter<? super E, H> filter, @NotNull H actor);
+
+    <E extends Event> @NotNull FlexibleListener<E> listen(@NotNull Class<E> eventType);
+
+    default void tick() {
+        process().ticker().tick(System.nanoTime());
+    }
+
+    default boolean tickWhile(BooleanSupplier condition, Duration timeout) {
+        var ticker = process().ticker();
+        final long start = System.nanoTime();
+        while (condition.getAsBoolean()) {
+            final long tick = System.nanoTime();
+            ticker.tick(tick);
+            if (timeout != null && System.nanoTime() - start > timeout.toNanos()) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    default @NotNull Player createPlayer(@NotNull Instance instance, @NotNull Pos pos) {
+        return createConnection().connect(Player::new, instance, pos).join();
+    }
+
+    default @NotNull Player createPlayer(@NotNull PlayerProvider playerProvider, @NotNull Instance instance, @NotNull Pos pos) {
+        return createConnection().connect(playerProvider, instance, pos).join();
+    }
+
+    default @NotNull Instance createFlatInstance() {
+        var instance = process().instance().createInstanceContainer();
+        instance.setGenerator(unit -> unit.modifier().fillHeight(0, 40, Block.STONE));
+//        instance.loadChunk(0, 0).join(); //todo this line breaks tests that need a player... somehow...
+        return instance;
+    }
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/EnvBefore.java b/modules/test/src/main/java/net/minestom/server/test/EnvBefore.java
new file mode 100644
index 0000000..b59dc24
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/EnvBefore.java
@@ -0,0 +1,11 @@
+package net.minestom.server.test;
+
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+final class EnvBefore implements BeforeEachCallback {
+    @Override
+    public void beforeEach(ExtensionContext context) {
+        System.setProperty("minestom.viewable-packet", "false");
+    }
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/EnvCleaner.java b/modules/test/src/main/java/net/minestom/server/test/EnvCleaner.java
new file mode 100644
index 0000000..c194013
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/EnvCleaner.java
@@ -0,0 +1,16 @@
+package net.minestom.server.test;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.InvocationInterceptor;
+import org.junit.jupiter.api.extension.ReflectiveInvocationContext;
+
+import java.lang.reflect.Method;
+
+final class EnvCleaner implements InvocationInterceptor {
+    @Override
+    public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
+        invocation.proceed();
+        EnvImpl env = (EnvImpl) invocationContext.getArguments().get(0);
+        env.cleanup();
+    }
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/EnvImpl.java b/modules/test/src/main/java/net/minestom/server/test/EnvImpl.java
new file mode 100644
index 0000000..73f848d
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/EnvImpl.java
@@ -0,0 +1,111 @@
+package net.minestom.server.test;
+
+import net.minestom.server.ServerProcess;
+import net.minestom.server.event.Event;
+import net.minestom.server.event.EventFilter;
+import net.minestom.server.event.EventListener;
+import net.minestom.server.utils.debug.DebugUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.Consumer;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+final class EnvImpl implements Env {
+
+    static {
+        DebugUtils.INSIDE_TEST = true;
+    }
+
+    private final ServerProcess process;
+    private final List<FlexibleListenerImpl<?>> listeners = new CopyOnWriteArrayList<>();
+
+    public EnvImpl(ServerProcess process) {
+        this.process = process;
+    }
+
+    @Override
+    public @NotNull ServerProcess process() {
+        return process;
+    }
+
+    @Override
+    public @NotNull TestConnection createConnection() {
+        return new TestConnectionImpl(this);
+    }
+
+    @Override
+    public @NotNull <E extends Event, H> Collector<E> trackEvent(@NotNull Class<E> eventType, @NotNull EventFilter<? super E, H> filter, @NotNull H actor) {
+        var tracker = new EventCollector<E>(actor);
+        this.process.eventHandler().map(actor, filter).addListener(eventType, tracker.events::add);
+        return tracker;
+    }
+
+    @Override
+    public @NotNull <E extends Event> FlexibleListener<E> listen(@NotNull Class<E> eventType) {
+        var handler = process.eventHandler();
+        var flexible = new FlexibleListenerImpl<>(eventType);
+        var listener = EventListener.of(eventType, e -> flexible.handler.accept(e));
+        handler.addListener(listener);
+        this.listeners.add(flexible);
+        return flexible;
+    }
+
+    void cleanup() {
+        this.listeners.forEach(FlexibleListenerImpl::check);
+    }
+
+    final class EventCollector<E extends Event> implements Collector<E> {
+        private final Object handler;
+        private final List<E> events = new CopyOnWriteArrayList<>();
+
+        public EventCollector(Object handler) {
+            this.handler = handler;
+        }
+
+        @Override
+        public @NotNull List<E> collect() {
+            process.eventHandler().unmap(handler);
+            return List.copyOf(events);
+        }
+    }
+
+    static final class FlexibleListenerImpl<E extends Event> implements FlexibleListener<E> {
+        private final Class<E> eventType;
+        private Consumer<E> handler = e -> {
+        };
+        private boolean initialized;
+        private boolean called;
+
+        FlexibleListenerImpl(Class<E> eventType) {
+            this.eventType = eventType;
+        }
+
+        @Override
+        public void followup(@NotNull Consumer<E> handler) {
+            updateHandler(handler);
+        }
+
+        @Override
+        public void failFollowup() {
+            updateHandler(e -> fail("Event " + e.getClass().getSimpleName() + " was not expected"));
+        }
+
+        void updateHandler(@NotNull Consumer<E> handler) {
+            check();
+            this.initialized = true;
+            this.called = false;
+            this.handler = e -> {
+                handler.accept(e);
+                this.called = true;
+            };
+        }
+
+        void check() {
+            assertTrue(!initialized || called, "Last listener has not been called: " + eventType.getSimpleName());
+        }
+    }
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/EnvParameterResolver.java b/modules/test/src/main/java/net/minestom/server/test/EnvParameterResolver.java
new file mode 100644
index 0000000..5b960ae
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/EnvParameterResolver.java
@@ -0,0 +1,15 @@
+package net.minestom.server.test;
+
+import net.minestom.server.MinecraftServer;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.support.TypeBasedParameterResolver;
+
+final class EnvParameterResolver extends TypeBasedParameterResolver<Env> {
+    @Override
+    public Env resolveParameter(ParameterContext parameterContext, ExtensionContext extensionContext)
+            throws ParameterResolutionException {
+        return new EnvImpl(MinecraftServer.updateProcess());
+    }
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/EnvTest.java b/modules/test/src/main/java/net/minestom/server/test/EnvTest.java
new file mode 100644
index 0000000..fe0230f
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/EnvTest.java
@@ -0,0 +1,17 @@
+package net.minestom.server.test;
+
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@ExtendWith(EnvParameterResolver.class)
+@ExtendWith(EnvBefore.class)
+@ExtendWith(EnvCleaner.class)
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface EnvTest {
+
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/FlexibleListener.java b/modules/test/src/main/java/net/minestom/server/test/FlexibleListener.java
new file mode 100644
index 0000000..446a3c8
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/FlexibleListener.java
@@ -0,0 +1,24 @@
+package net.minestom.server.test;
+
+import net.minestom.server.event.Event;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Consumer;
+
+public interface FlexibleListener<E extends Event> {
+    /**
+     * Updates the handler. Fails if the previous followup has not been called.
+     */
+    void followup(@NotNull Consumer<E> handler);
+
+    default void followup() {
+        followup(event -> {
+            // Empty
+        });
+    }
+
+    /**
+     * Fails if an event is received. Valid until the next followup call.
+     */
+    void failFollowup();
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/TestConnection.java b/modules/test/src/main/java/net/minestom/server/test/TestConnection.java
new file mode 100644
index 0000000..f71ff8c
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/TestConnection.java
@@ -0,0 +1,20 @@
+package net.minestom.server.test;
+
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Player;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.network.PlayerProvider;
+import net.minestom.server.network.packet.server.ServerPacket;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.CompletableFuture;
+
+public interface TestConnection {
+    @NotNull CompletableFuture<@NotNull Player> connect(@NotNull PlayerProvider playerProvider, @NotNull Instance instance, @NotNull Pos pos);
+
+    <T extends ServerPacket> @NotNull Collector<T> trackIncoming(@NotNull Class<T> type);
+
+    default @NotNull Collector<ServerPacket> trackIncoming() {
+        return trackIncoming(ServerPacket.class);
+    }
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/TestConnectionImpl.java b/modules/test/src/main/java/net/minestom/server/test/TestConnectionImpl.java
new file mode 100644
index 0000000..db04b61
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/TestConnectionImpl.java
@@ -0,0 +1,87 @@
+package net.minestom.server.test;
+
+import net.minestom.server.ServerProcess;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Player;
+import net.minestom.server.event.player.PlayerLoginEvent;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.network.PlayerProvider;
+import net.minestom.server.network.packet.server.SendablePacket;
+import net.minestom.server.network.packet.server.ServerPacket;
+import net.minestom.server.network.player.PlayerConnection;
+import org.jetbrains.annotations.NotNull;
+
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+final class TestConnectionImpl implements TestConnection {
+    private final ServerProcess process;
+    private final PlayerConnectionImpl playerConnection = new PlayerConnectionImpl();
+
+    private final List<IncomingCollector<ServerPacket>> incomingTrackers = new CopyOnWriteArrayList<>();
+
+    TestConnectionImpl(Env env) {
+        this.process = env.process();
+    }
+
+    @Override
+    public @NotNull CompletableFuture<Player> connect(@NotNull PlayerProvider playerProvider, @NotNull Instance instance, @NotNull Pos pos) {
+        Player player = playerProvider.createPlayer(UUID.randomUUID(), "RandName", playerConnection);
+        player.eventNode().addListener(PlayerLoginEvent.class, event -> {
+            event.setSpawningInstance(instance);
+            event.getPlayer().setRespawnPoint(pos);
+        });
+
+        return process.connection().startPlayState(player, true)
+                .thenApply(unused -> {
+                    process.connection().updateWaitingPlayers();
+                    return player;
+                });
+    }
+
+    @Override
+    public @NotNull <T extends ServerPacket> Collector<T> trackIncoming(@NotNull Class<T> type) {
+        var tracker = new IncomingCollector<>(type);
+        this.incomingTrackers.add((IncomingCollector) tracker);
+        return tracker;
+    }
+
+    final class PlayerConnectionImpl extends PlayerConnection {
+        @Override
+        public void sendPacket(@NotNull SendablePacket packet) {
+            for (var tracker : incomingTrackers) {
+                final var serverPacket = SendablePacket.extractServerPacket(packet);
+                if (tracker.type.isAssignableFrom(serverPacket.getClass())) tracker.packets.add(serverPacket);
+            }
+        }
+
+        @Override
+        public @NotNull SocketAddress getRemoteAddress() {
+            return new InetSocketAddress("localhost", 25565);
+        }
+
+        @Override
+        public void disconnect() {
+
+        }
+    }
+
+    final class IncomingCollector<T extends ServerPacket> implements Collector<T> {
+        private final Class<T> type;
+        private final List<T> packets = new CopyOnWriteArrayList<>();
+
+        public IncomingCollector(Class<T> type) {
+            this.type = type;
+        }
+
+        @Override
+        public @NotNull List<T> collect() {
+            incomingTrackers.remove(this);
+            return List.copyOf(packets);
+        }
+    }
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/TestUtils.java b/modules/test/src/main/java/net/minestom/server/test/TestUtils.java
new file mode 100644
index 0000000..7f50e04
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/TestUtils.java
@@ -0,0 +1,55 @@
+package net.minestom.server.test;
+
+import org.jglrxavpok.hephaistos.nbt.NBTCompound;
+import org.jglrxavpok.hephaistos.nbt.NBTException;
+import org.jglrxavpok.hephaistos.parser.SNBTParser;
+
+import java.io.StringReader;
+import java.lang.ref.WeakReference;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestUtils {
+    public static void waitUntilCleared(WeakReference<?> ref) {
+        while (ref.get() != null) {
+            System.gc();
+            try {
+                Thread.sleep(50);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    public static void assertEqualsSNBT(String snbt, NBTCompound compound) {
+        try {
+            final var converted = (NBTCompound) new SNBTParser(new StringReader(snbt)).parse();
+            assertEquals(converted, compound);
+        } catch (NBTException e) {
+            fail(e);
+        }
+    }
+
+    public static void assertEqualsIgnoreSpace(String s1, String s2, boolean matchCase) {
+        final String val1 = stripExtraSpaces(s1);
+        final String val2 = stripExtraSpaces(s2);
+        if (matchCase) {
+            assertEquals(val1, val2);
+        } else {
+            assertTrue(val1.equalsIgnoreCase(val2));
+        }
+    }
+
+    public static void assertEqualsIgnoreSpace(String s1, String s2) {
+        assertEqualsIgnoreSpace(s1, s2, true);
+    }
+
+    private static String stripExtraSpaces(String s) {
+        StringBuilder formattedString = new StringBuilder();
+        java.util.StringTokenizer st = new java.util.StringTokenizer(s);
+        while (st.hasMoreTokens()) {
+            formattedString.append(st.nextToken());
+        }
+        return formattedString.toString().trim();
+    }
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/truth/AbstractInventorySubject.java b/modules/test/src/main/java/net/minestom/server/test/truth/AbstractInventorySubject.java
new file mode 100644
index 0000000..0f04b12
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/truth/AbstractInventorySubject.java
@@ -0,0 +1,60 @@
+package net.minestom.server.test.truth;
+
+import com.google.common.truth.Fact;
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import com.google.common.truth.Truth;
+import net.minestom.server.inventory.AbstractInventory;
+import net.minestom.server.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+
+import static com.google.common.truth.Truth.assertAbout;
+
+public class AbstractInventorySubject extends Subject {
+    private final AbstractInventory actual;
+
+    public static AbstractInventorySubject assertThat(AbstractInventory actual) {
+        return assertAbout(abstractInventories()).that(actual);
+    }
+
+    protected AbstractInventorySubject(FailureMetadata metadata, @Nullable AbstractInventory actual) {
+        super(metadata, actual);
+        this.actual = actual;
+    }
+
+    public void isEmpty() {
+        if (!itemStacks().isEmpty()) {
+            failWithActual(Fact.simpleFact("expected to be empty"));
+        }
+    }
+
+    public void isNotEmpty() {
+        if (itemStacks().isEmpty()) {
+            failWithActual(Fact.simpleFact("expected not to be empty"));
+        }
+    }
+
+    public void containsExactly(@NotNull ItemStack... itemStacks) {
+        Truth.assertThat(itemStacks()).containsExactly((Object[]) itemStacks);
+    }
+
+    public void doesNotContain(@NotNull ItemStack itemStack) {
+        Truth.assertThat(itemStacks()).doesNotContain(itemStack);
+    }
+
+    private List<ItemStack> itemStacks() {
+        return Arrays.stream(actual.getItemStacks())
+                .filter(Predicate.not(ItemStack::isAir))
+                .toList();
+    }
+
+    private static Factory<AbstractInventorySubject, AbstractInventory> abstractInventories() {
+        return AbstractInventorySubject::new;
+    }
+
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/truth/EntitySubject.java b/modules/test/src/main/java/net/minestom/server/test/truth/EntitySubject.java
new file mode 100644
index 0000000..6aae0b5
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/truth/EntitySubject.java
@@ -0,0 +1,39 @@
+package net.minestom.server.test.truth;
+
+import com.google.common.truth.Fact;
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import com.google.common.truth.Truth;
+import net.minestom.server.entity.Entity;
+import org.jetbrains.annotations.Nullable;
+
+@SuppressWarnings("ConstantConditions")
+public class EntitySubject extends Subject {
+    private final Entity actual;
+
+    public static EntitySubject assertThat(@Nullable Entity entity) {
+        return Truth.assertAbout(entities()).that(entity);
+    }
+
+    protected EntitySubject(FailureMetadata metadata, @Nullable Entity actual) {
+        super(metadata, actual);
+        this.actual = actual;
+    }
+
+    public void isRemoved() {
+        if (!actual.isRemoved()) {
+            failWithActual(Fact.simpleFact("expected to be removed"));
+        }
+    }
+
+    public void isNotRemoved() {
+        if (actual.isRemoved()) {
+            failWithActual(Fact.simpleFact("expected not to be removed"));
+        }
+    }
+
+    public static Factory<EntitySubject, Entity> entities() {
+        return EntitySubject::new;
+    }
+
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/truth/ItemStackSubject.java b/modules/test/src/main/java/net/minestom/server/test/truth/ItemStackSubject.java
new file mode 100644
index 0000000..c06cb8c
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/truth/ItemStackSubject.java
@@ -0,0 +1,31 @@
+package net.minestom.server.test.truth;
+
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import com.google.common.truth.Truth;
+import net.minestom.server.item.ItemStack;
+import org.jetbrains.annotations.Nullable;
+
+@SuppressWarnings("ConstantConditions")
+public class ItemStackSubject extends Subject {
+    private final ItemStack actual;
+
+    public static ItemStackSubject assertThat(@Nullable ItemStack actual) {
+        return Truth.assertAbout(itemStacks()).that(actual);
+    }
+
+    protected ItemStackSubject(FailureMetadata metadata, @Nullable ItemStack actual) {
+        super(metadata, actual);
+        this.actual = actual;
+    }
+
+    public void hasAmount(int expectedAmount) {
+        check("amount()").that(actual.amount()).isEqualTo(expectedAmount);
+    }
+
+
+    public static Factory<ItemStackSubject, ItemStack> itemStacks() {
+        return ItemStackSubject::new;
+    }
+
+}
diff --git a/modules/test/src/main/java/net/minestom/server/test/truth/MinestomTruth.java b/modules/test/src/main/java/net/minestom/server/test/truth/MinestomTruth.java
new file mode 100644
index 0000000..4974adf
--- /dev/null
+++ b/modules/test/src/main/java/net/minestom/server/test/truth/MinestomTruth.java
@@ -0,0 +1,24 @@
+package net.minestom.server.test.truth;
+
+import net.minestom.server.entity.Entity;
+import net.minestom.server.inventory.AbstractInventory;
+import net.minestom.server.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class MinestomTruth {
+    private MinestomTruth() {}
+
+    public static @NotNull EntitySubject assertThat(@Nullable Entity actual) {
+        return EntitySubject.assertThat(actual);
+    }
+
+    public static @NotNull AbstractInventorySubject assertThat(@Nullable AbstractInventory actual) {
+        return AbstractInventorySubject.assertThat(actual);
+    }
+
+    public static @NotNull ItemStackSubject assertThat(@Nullable ItemStack actual) {
+        return ItemStackSubject.assertThat(actual);
+    }
+
+}

From e969a8f1505e773ef97901c0520b420cb17493cc Mon Sep 17 00:00:00 2001
From: mworzala <mattheworzala@gmail.com>
Date: Thu, 29 Sep 2022 19:56:05 -0400
Subject: [PATCH 2/3] move common module to common project

---
 modules/common/README.md                      |  11 +
 modules/common/build.gradle.kts               |  17 +
 .../src/main/java/net/hollowcube/Env.java     |  28 ++
 .../net/hollowcube/config/ConfigProvider.java |  20 ++
 .../net/hollowcube/data/NumberSource.java     |  24 ++
 .../data/number/ConstantNumberProvider.java   |  42 +++
 .../data/number/NumberProvider.java           |  79 +++++
 .../main/java/net/hollowcube/dfu/DFUUtil.java |  25 ++
 .../java/net/hollowcube/dfu/EnvVarOps.java    | 224 +++++++++++++
 .../java/net/hollowcube/dfu/ExtraCodecs.java  |  77 +++++
 .../net/hollowcube/lang/LanguageProvider.java |  72 +++++
 .../hollowcube/logging/CustomJsonWriter.java  | 155 +++++++++
 .../java/net/hollowcube/logging/Logger.java   |  33 ++
 .../net/hollowcube/logging/LoggerFactory.java |  12 +
 .../net/hollowcube/logging/LoggerImpl.java    |  98 ++++++
 .../java/net/hollowcube/mongo/BsonOps.java    | 294 ++++++++++++++++++
 .../net/hollowcube/mongo/MongoConfig.java     |  17 +
 .../net/hollowcube/mongo/package-info.java    |   7 +
 .../net/hollowcube/registry/MapRegistry.java  |  53 ++++
 .../registry/MissingEntryException.java       |  22 ++
 .../net/hollowcube/registry/Registry.java     | 200 ++++++++++++
 .../net/hollowcube/registry/Resource.java     |  95 ++++++
 .../hollowcube/registry/ResourceFactory.java  |  30 ++
 .../java/net/hollowcube/server/Facet.java     |  23 ++
 .../server/IsolatedServerWrapper.java         |  34 ++
 .../net/hollowcube/server/ServerWrapper.java  |  44 +++
 .../server/instance/TickTrackingInstance.java |  34 ++
 .../java/net/hollowcube/util/BlockUtil.java   |  12 +
 .../net/hollowcube/util/ComponentUtil.java    |  15 +
 .../java/net/hollowcube/util/EventUtil.java   |  46 +++
 .../java/net/hollowcube/util/FutureUtil.java  |  15 +
 .../java/net/hollowcube/util/JsonUtil.java    | 103 ++++++
 .../net/hollowcube/util/ParticleUtils.java    |  19 ++
 .../number/TestConstantNumberProvider.java    |  33 ++
 .../net/hollowcube/dfu/TestEnvVarOps.java     | 172 ++++++++++
 .../hollowcube/registry/TestMissingEntry.java |  17 +
 .../net/hollowcube/registry/TestResource.java |  26 ++
 .../net/hollowcube/util/TestJsonUtil.java     | 136 ++++++++
 .../src/test/resources/lang/en_US.properties  |   0
 modules/common/src/test/resources/test.json   |   5 +
 settings.gradle.kts                           |   1 +
 41 files changed, 2370 insertions(+)
 create mode 100644 modules/common/README.md
 create mode 100644 modules/common/build.gradle.kts
 create mode 100644 modules/common/src/main/java/net/hollowcube/Env.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/config/ConfigProvider.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/data/NumberSource.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/data/number/ConstantNumberProvider.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/data/number/NumberProvider.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/dfu/DFUUtil.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/dfu/EnvVarOps.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/dfu/ExtraCodecs.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/lang/LanguageProvider.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/logging/CustomJsonWriter.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/logging/Logger.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/logging/LoggerFactory.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/logging/LoggerImpl.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/mongo/BsonOps.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/mongo/MongoConfig.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/mongo/package-info.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/registry/MapRegistry.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/registry/MissingEntryException.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/registry/Registry.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/registry/Resource.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/registry/ResourceFactory.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/server/Facet.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/server/IsolatedServerWrapper.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/server/ServerWrapper.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/server/instance/TickTrackingInstance.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/util/BlockUtil.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/util/ComponentUtil.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/util/EventUtil.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/util/FutureUtil.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/util/JsonUtil.java
 create mode 100644 modules/common/src/main/java/net/hollowcube/util/ParticleUtils.java
 create mode 100644 modules/common/src/test/java/net/hollowcube/data/number/TestConstantNumberProvider.java
 create mode 100644 modules/common/src/test/java/net/hollowcube/dfu/TestEnvVarOps.java
 create mode 100644 modules/common/src/test/java/net/hollowcube/registry/TestMissingEntry.java
 create mode 100644 modules/common/src/test/java/net/hollowcube/registry/TestResource.java
 create mode 100644 modules/common/src/test/java/net/hollowcube/util/TestJsonUtil.java
 create mode 100644 modules/common/src/test/resources/lang/en_US.properties
 create mode 100644 modules/common/src/test/resources/test.json

diff --git a/modules/common/README.md b/modules/common/README.md
new file mode 100644
index 0000000..df8b896
--- /dev/null
+++ b/modules/common/README.md
@@ -0,0 +1,11 @@
+## common
+
+Common libraries for other modules in the project.
+
+Included by all other projects, so this must be kept small with minimal dependencies.
+
+```
+data: Data parsing abstraction
+registry: Resource registry for various data driven modules
+util: Common utilities
+```
diff --git a/modules/common/build.gradle.kts b/modules/common/build.gradle.kts
new file mode 100644
index 0000000..1473429
--- /dev/null
+++ b/modules/common/build.gradle.kts
@@ -0,0 +1,17 @@
+plugins {
+    `java-library`
+}
+
+dependencies {
+    api("com.github.minestommmo:DataFixerUpper:cf58e926a6")
+    api("net.kyori:adventure-text-minimessage:4.11.0")
+
+    implementation("org.tinylog:tinylog-impl:2.4.1")
+
+    implementation("io.github.cdimascio:dotenv-java:2.2.4")
+
+    // Optional components
+    compileOnly("org.mongodb:mongodb-driver-sync:4.7.0")
+
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/Env.java b/modules/common/src/main/java/net/hollowcube/Env.java
new file mode 100644
index 0000000..cd9bf1f
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/Env.java
@@ -0,0 +1,28 @@
+package net.hollowcube;
+
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.function.Supplier;
+
+public class Env {
+    /**
+     * Strict mode is enabled in production, but may be disabled during tests.
+     * <p>
+     * It should be used to check cases which are fine during development but are a fatal problem in production. For
+     * example, if a registry is empty for any reason in production the server should not be allowed to start.
+     */
+    public static final Boolean STRICT_MODE = Boolean.valueOf(System.getProperty("starlight.strict", "false"));
+
+
+    private static final Logger STRICT_LOGGER = LoggerFactory.getLogger("STRICT");
+
+    public static void strictValidation(@NotNull String message, @NotNull Supplier<Boolean> predicate) {
+        if (STRICT_MODE && predicate.get()) {
+            STRICT_LOGGER.error(message);
+            System.exit(1);
+        }
+    }
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/config/ConfigProvider.java b/modules/common/src/main/java/net/hollowcube/config/ConfigProvider.java
new file mode 100644
index 0000000..cd363eb
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/config/ConfigProvider.java
@@ -0,0 +1,20 @@
+package net.hollowcube.config;
+
+import com.mojang.serialization.Codec;
+import net.minestom.server.utils.validate.Check;
+import org.jetbrains.annotations.NotNull;
+import net.hollowcube.dfu.EnvVarOps;
+
+import java.util.Locale;
+
+public final class ConfigProvider {
+
+    public static <T> @NotNull T load(@NotNull String prefix, @NotNull Codec<T> codec) {
+        var result = EnvVarOps.DOTENV.withDecoder(codec)
+                .apply(prefix.toUpperCase(Locale.ROOT))
+                .result()
+                .orElse(null);
+        Check.notNull(result, "Config unable to load");
+        return result.getFirst();
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/data/NumberSource.java b/modules/common/src/main/java/net/hollowcube/data/NumberSource.java
new file mode 100644
index 0000000..4a125af
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/data/NumberSource.java
@@ -0,0 +1,24 @@
+package net.hollowcube.data;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * A source of numbers, implementations decide where the numbers come from
+ */
+@FunctionalInterface
+public interface NumberSource {
+
+    static @NotNull NumberSource constant(double value) {
+        return () -> value;
+    }
+
+    static @NotNull NumberSource threadLocalRandom() {
+        return () -> ThreadLocalRandom.current().nextDouble();
+    }
+
+
+    double random();
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/data/number/ConstantNumberProvider.java b/modules/common/src/main/java/net/hollowcube/data/number/ConstantNumberProvider.java
new file mode 100644
index 0000000..398321f
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/data/number/ConstantNumberProvider.java
@@ -0,0 +1,42 @@
+package net.hollowcube.data.number;
+
+import com.google.auto.service.AutoService;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.hollowcube.data.NumberSource;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+import net.hollowcube.dfu.ExtraCodecs;
+
+record ConstantNumberProvider(
+        @NotNull Number value
+) implements NumberProvider {
+
+    public static Codec<ConstantNumberProvider> CODEC = RecordCodecBuilder.create(i -> i.group(
+            ExtraCodecs.NUMBER.fieldOf("value").forGetter(ConstantNumberProvider::value)
+    ).apply(i, ConstantNumberProvider::new));
+
+
+    @Override
+    public long nextLong(@NotNull NumberSource numbers) {
+        return value().longValue();
+    }
+
+    @Override
+    public double nextDouble(@NotNull NumberSource numbers) {
+        return value().doubleValue();
+    }
+
+
+    @AutoService(NumberProvider.Factory.class)
+    public static final class Factory extends NumberProvider.Factory {
+        public Factory() {
+            super(
+                    NamespaceID.from("starlight:constant"),
+                    ConstantNumberProvider.class,
+                    ConstantNumberProvider.CODEC
+            );
+        }
+    }
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/data/number/NumberProvider.java b/modules/common/src/main/java/net/hollowcube/data/number/NumberProvider.java
new file mode 100644
index 0000000..294e09c
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/data/number/NumberProvider.java
@@ -0,0 +1,79 @@
+package net.hollowcube.data.number;
+
+import com.mojang.datafixers.util.Either;
+import com.mojang.serialization.Codec;
+import net.hollowcube.registry.Registry;
+import net.hollowcube.registry.ResourceFactory;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+import net.hollowcube.data.NumberSource;
+import net.hollowcube.dfu.DFUUtil;
+import net.hollowcube.dfu.ExtraCodecs;
+
+/**
+ * A source of numbers, see <a href="https://minecraft.fandom.com/wiki/Loot_table#Number_Providers">Number
+ * Providers</a>.
+ * <p>
+ * Implementing a new number source requires a few steps:
+ * <ol>
+ *     <li>Create a class inheriting from {@link NumberProvider}</li>
+ *     <li>Write a {@link Codec} for the class</li>
+ *     <li>Create an inner factory class inheriting from {@link NumberProvider.Factory}, filling in the required constructor params</li>
+ *     <li>Annotate the factory class with {@link com.google.auto.service.AutoService} for {@link NumberProvider.Factory}</li>
+ * </ol>
+ * <p>
+ * Would like to look into a simplification of this process & removal of the Factory class. I would prefer if it was something like the following
+ * <pre>{@code
+ *     // This, where the annotation generates an entry for the superclass
+ *     @BasicRegistryItem("minecraft:constant")
+ *     public record ConstantNumberProvider(
+ *         Number value
+ *     ) implements NumberProvider {
+ *
+ *         Codec<ConstantNumberProvider> CODEC = ...;
+ *
+ *         // Or alternatively something like this, where it finds the descriptor element
+ *         Descriptor DESCRIPTOR = new Descriptor("minecraft:constant", CODEC){}
+ *
+ *     }
+ * }</pre>
+ *
+ * @see ConstantNumberProvider
+ */
+public interface NumberProvider {
+
+    static @NotNull NumberProvider constant(@NotNull Number value) {
+        return new ConstantNumberProvider(value);
+    }
+
+    Codec<NumberProvider> CODEC = Codec.either(
+            Factory.CODEC.<NumberProvider>dispatch(Factory::from, Factory::codec),
+            // Handle the case of providing a single value value. If serialized back it will
+            // come out as a full {"type": "constant", "value": ...}
+            ExtraCodecs.NUMBER.xmap(ConstantNumberProvider::new, ConstantNumberProvider::value)
+    ).xmap(DFUUtil::value, Either::left);
+
+
+    // Impl
+
+    long nextLong(@NotNull NumberSource numbers);
+
+    double nextDouble(@NotNull NumberSource numbers);
+
+
+    abstract class Factory extends ResourceFactory<NumberProvider> {
+        static Registry<Factory> REGISTRY = Registry.service("number_providers", NumberProvider.Factory.class);
+        static Registry.Index<Class<?>, NumberProvider.Factory> TYPE_REGISTRY = REGISTRY.index(NumberProvider.Factory::type);
+
+        public static final Codec<Factory> CODEC = Codec.STRING.xmap(ns -> REGISTRY.get(ns), Factory::name);
+
+        public Factory(NamespaceID namespace, Class<? extends NumberProvider> type, Codec<? extends NumberProvider> codec) {
+            super(namespace, type, codec);
+        }
+
+        static @NotNull Factory from(@NotNull NumberProvider provider) {
+            return TYPE_REGISTRY.get(provider.getClass());
+        }
+    }
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/dfu/DFUUtil.java b/modules/common/src/main/java/net/hollowcube/dfu/DFUUtil.java
new file mode 100644
index 0000000..424f8d3
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/dfu/DFUUtil.java
@@ -0,0 +1,25 @@
+package net.hollowcube.dfu;
+
+import com.mojang.datafixers.util.Either;
+import com.mojang.datafixers.util.Pair;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public final class DFUUtil {
+
+    public static <T, S> Map<T, S> pairListToMap(List<Pair<T, S>> pairList) {
+        return pairList.stream().collect(Collectors.toMap(Pair::getFirst, Pair::getSecond));
+    }
+
+    public static <T, S> List<Pair<T, S>> mapToPairList(Map<T, S> map) {
+        return map.entrySet().stream().map(entry -> new Pair<>(entry.getKey(), entry.getValue())).toList();
+    }
+
+    public static <T> @NotNull T value(@NotNull Either<? extends T, ? extends T> either) {
+        return either.map(Function.identity(), Function.identity());
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/dfu/EnvVarOps.java b/modules/common/src/main/java/net/hollowcube/dfu/EnvVarOps.java
new file mode 100644
index 0000000..c74221b
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/dfu/EnvVarOps.java
@@ -0,0 +1,224 @@
+package net.hollowcube.dfu;
+
+import com.mojang.datafixers.util.Pair;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.DynamicOps;
+import com.mojang.serialization.MapLike;
+import io.github.cdimascio.dotenv.Dotenv;
+import io.github.cdimascio.dotenv.DotenvEntry;
+import kotlin.NotImplementedError;
+import net.minestom.server.utils.validate.Check;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+public abstract class EnvVarOps implements DynamicOps<String> {
+    public static final EnvVarOps DOTENV = new EnvVarOps() {
+        private final Dotenv dotenv = Dotenv.configure().ignoreIfMissing().load();
+
+        @Override
+        protected Collection<String> envKeys() {
+            return dotenv.entries().stream().map(DotenvEntry::getKey).toList();
+        }
+
+        @Override
+        protected String get(String path) {
+            if (path.isEmpty())
+                return "";
+            return dotenv.get(path);
+        }
+    };
+
+    @Override
+    public String empty() {
+        return "";
+    }
+
+    @Override
+    public DataResult<Number> getNumberValue(String input) {
+        String value = get(input);
+
+        // This is really primitive number parsing, but I guess it will work.
+        try {
+            if (value.contains(".")) {
+                return DataResult.success(Double.parseDouble(value));
+            } else {
+                return DataResult.success(Long.parseLong(value));
+            }
+        } catch (NumberFormatException e) {
+            return DataResult.error(e.getMessage());
+        }
+    }
+
+    @Override
+    public DataResult<Boolean> getBooleanValue(String input) {
+        String value = get(input).toLowerCase(Locale.ROOT);
+        // Do not use Boolean.parseBoolean because it treats invalid as false.
+        if (value.equals("true"))
+            return DataResult.success(true);
+        if (value.equals("false"))
+            return DataResult.success(false);
+        return DataResult.error("Not a boolean: " + input);
+    }
+
+    @Override
+    public DataResult<String> getStringValue(String input) {
+        return DataResult.success(get(input));
+    }
+
+    @Override
+    public DataResult<MapLike<String>> getMap(String input) {
+        // All the available keys starting with the input prefix
+        Set<String> possibleKeys = new HashSet<>();
+        for (String path : envKeys()) {
+            if (path.toUpperCase(Locale.ROOT).startsWith(input)) {
+                possibleKeys.add(path);
+            }
+        }
+
+        return DataResult.success(new MapLike<>() {
+            @Override
+            public String get(String key) {
+                // Create the new path by appending to the original query path
+                String newPath = key.toUpperCase(Locale.ROOT);
+                if (!input.isEmpty()) {
+                    newPath = input + "_" + newPath;
+                }
+
+                // The map contains any path starting with this one, so we need to iterate over it.
+                for (var entryKey : possibleKeys) {
+                    if (entryKey.startsWith(newPath)) {
+                        // Return the new path. entryKey contains the entire path
+                        return newPath;
+                    }
+                }
+
+                return null;
+            }
+
+            @Override
+            public Stream<Pair<String, String>> entries() {
+                return notImplemented("getMap -> entries");
+            }
+        });
+    }
+
+    @Override
+    public DataResult<Consumer<Consumer<String>>> getList(String input) {
+        // Children contains every path which starts with input and is followed by a single number segment
+        Map<Integer, String> children = new HashMap<>(); // (map to ignore duplicate keys)
+        for (String path : envKeys()) {
+            if (!path.toUpperCase(Locale.ROOT).startsWith(input))
+                continue;
+            String[] rest = path.substring(input.length()).split("_", -1);
+            // First entry must be "" because we split on _00_REST
+            if (rest.length < 2 || !rest[0].isEmpty())
+                continue;
+            // Try to parse number segment
+            int index = Integer.parseInt(rest[1]);
+            children.put(index, input + "_" + index);
+        }
+
+        // Sort on index
+        String[] sortedChildren = new String[children.size()];
+        for (var child : children.entrySet()) {
+            // If the child is not within the sorted range then there was an order problem in the original (eg skipping a number)
+            if (child.getKey() < 0 || child.getKey() >= children.size())
+                return DataResult.error(String.format("invalid index of %s: %s", input, child));
+            sortedChildren[child.getKey()] = child.getValue();
+        }
+
+        return DataResult.success(c -> {
+            for (var child : sortedChildren) {
+                Check.notNull(child, "missing list element");
+                c.accept(child);
+            }
+        });
+    }
+
+    @Override
+    public String createList(Stream<String> input) {
+        return "ERR@createList";
+    }
+
+    // NOT IMPLEMENTED BELOW
+    // The rest of DynamicOps is not implemented. The reasons are:
+    // - Serialization is not supported by EnvVarOps.
+    // - I have not found a use for the function. If we find one it will be implemented.
+
+    @Override
+    public <U> U convertTo(DynamicOps<U> outOps, String input) {
+        //todo
+        throw new NotImplementedError("convertTo");
+    }
+
+    @Override
+    public String createNumeric(Number i) {
+        return notImplemented("createNumeric");
+    }
+
+    @Override
+    public String createBoolean(boolean value) {
+        return notImplemented("createBoolean");
+    }
+
+    @Override
+    public String createString(String value) {
+        return notImplemented("createString");
+    }
+
+    @Override
+    public DataResult<String> mergeToList(String list, String value) {
+        throw new NotImplementedError("mergeToList");
+    }
+
+    @Override
+    public DataResult<String> mergeToMap(String map, String key, String value) {
+        return notImplemented("mergeToMap@3");
+    }
+
+    @Override
+    public DataResult<String> mergeToMap(String map, MapLike<String> values) {
+        throw new NotImplementedError("mergeToMap@2");
+    }
+
+    @Override
+    public DataResult<Stream<Pair<String, String>>> getMapValues(String input) {
+        throw new NotImplementedError("getMapValues");
+    }
+
+    @Override
+    public DataResult<Consumer<BiConsumer<String, String>>> getMapEntries(String input) {
+        throw new NotImplementedError("getMapEntries");
+    }
+
+    @Override
+    public String createMap(Stream<Pair<String, String>> map) {
+        return notImplemented("createMap");
+    }
+
+    @Override
+    public DataResult<Stream<String>> getStream(String input) {
+        return notImplemented("getStream");
+    }
+
+    @Override
+    public String remove(String input, String key) {
+        return notImplemented("remove");
+    }
+
+
+    protected abstract Collection<String> envKeys();
+
+    protected abstract String get(String path);
+
+    @Contract("_ -> fail")
+    @SuppressWarnings("TypeParameterUnusedInFormals")
+    private <T> T notImplemented(@NotNull String name) {
+        throw new NotImplementedError("EnvVarOps#" + name);
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/dfu/ExtraCodecs.java b/modules/common/src/main/java/net/hollowcube/dfu/ExtraCodecs.java
new file mode 100644
index 0000000..1e42a46
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/dfu/ExtraCodecs.java
@@ -0,0 +1,77 @@
+package net.hollowcube.dfu;
+
+import com.mojang.datafixers.util.Pair;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.DynamicOps;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.PrimitiveCodec;
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.item.Material;
+import net.minestom.server.potion.PotionEffect;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Locale;
+import java.util.function.Supplier;
+
+public final class ExtraCodecs {
+    private ExtraCodecs() {}
+
+    public static final PrimitiveCodec<Number> NUMBER = new PrimitiveCodec<>() {
+        @Override
+        public <T> DataResult<Number> read(DynamicOps<T> ops, T input) {
+            return ops.getNumberValue(input);
+        }
+
+        @Override
+        public <T> T write(DynamicOps<T> ops, Number value) {
+            return ops.createNumeric(value);
+        }
+    };
+
+    public static final Codec<NamespaceID> NAMESPACE_ID = Codec.STRING.xmap(NamespaceID::from, NamespaceID::asString);
+
+    public static final Codec<Material> MATERIAL = Codec.STRING.xmap(Material::fromNamespaceId, Material::name);
+
+    public static final Codec<PotionEffect> POTION_EFFECT = Codec.STRING.xmap(PotionEffect::fromNamespaceId, PotionEffect::name);
+
+    public static final Codec<Block> BLOCK = Codec.STRING.xmap(Block::fromNamespaceId, Block::name);
+
+    public static @NotNull MapCodec<String> string(@NotNull String name, @Nullable String defaultValue) {
+        return Codec.STRING.optionalFieldOf(name, defaultValue);
+    }
+
+    public static <T extends Enum<T>> @NotNull Codec<T> forEnum(Class<T> type) {
+        return Codec.STRING.xmap(s -> Enum.valueOf(type, s.toUpperCase(Locale.ROOT)), e -> e.name().toLowerCase(Locale.ROOT));
+    }
+
+    public static <T> @NotNull Codec<T> lazy(Supplier<Codec<T>> init) {
+        return new LazyCodec<>(init);
+    }
+
+
+    public static class LazyCodec<T> implements Codec<T> {
+        private final Supplier<Codec<T>> init;
+        private Codec<T> value = null;
+
+        LazyCodec(Supplier<Codec<T>> init) {
+            this.init = init;
+        }
+
+        @Override
+        public <T1> DataResult<Pair<T, T1>> decode(DynamicOps<T1> ops, T1 input) {
+            if (value == null) value = init.get();
+            return value.decode(ops, input);
+        }
+
+        @Override
+        public <T1> DataResult<T1> encode(T input, DynamicOps<T1> ops, T1 prefix) {
+            if (value == null) value = init.get();
+            return value.encode(input, ops, prefix);
+        }
+    }
+
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/lang/LanguageProvider.java b/modules/common/src/main/java/net/hollowcube/lang/LanguageProvider.java
new file mode 100644
index 0000000..11c39f8
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/lang/LanguageProvider.java
@@ -0,0 +1,72 @@
+package net.hollowcube.lang;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextReplacementConfig;
+import net.kyori.adventure.text.TranslatableComponent;
+import org.jetbrains.annotations.NotNull;
+import net.hollowcube.util.ComponentUtil;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Properties;
+import java.util.regex.Pattern;
+
+/**
+ * Naive component translation system.
+ * <p>
+ * Should be replaced with adventure translation or something else in the future.
+ */
+public class LanguageProvider {
+    private static final Properties properties = new Properties();
+
+    static {
+        try (InputStream is = LanguageProvider.class.getResourceAsStream("/lang/en_US.properties")) {
+            if (is != null) {
+                properties.load(is);
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static final Pattern ARG_PATTERN = Pattern.compile("\\{[0-9]+}");
+
+    /**
+     * Translates a component (if possible, see below).
+     * <p>
+     * If the component is a {@link TranslatableComponent}, it will attempt to be translated. Any arguments in the
+     * component will also be templated into the translation using the {@link java.text.MessageFormat} syntax of `{0}`,
+     * `{1}`, etc. Translations are parsed using MiniMessage, and may contain styling as such.
+     * <p>
+     * Translations are always (for now) loaded from `/lang/en_US.properties` within the classpath. This system is
+     * temporary, and will be replaced with either a proxy translation system or using the Adventure translation system.
+     * The problem with the adventure translation system is that it does not support MiniMessage in translation strings
+     * as far as I can tell.
+     *
+     * @param component The component to translate
+     * @return The component, or a component holding just the translation key if not found
+     */
+    public static @NotNull Component get(@NotNull Component component) {
+        if (!(component instanceof TranslatableComponent translatable)) {
+            return component;
+        }
+        String value = properties.getProperty(translatable.key());
+        if (value == null) return Component.text(translatable.key());
+        Component translated = ComponentUtil.fromStringSafe(value);
+        List<Component> args = translatable.args();
+        if (args.size() != 0) {
+            //todo this seems like it could be wildly slow...
+            translated = translated.replaceText(TextReplacementConfig.builder()
+                    .match(ARG_PATTERN)
+                    .replacement((result, builder) -> {
+                        var group = result.group();
+                        int index = Integer.parseInt(group.substring(1, group.length() - 1));
+                        return index < args.size() ?
+                                args.get(index) :
+                                Component.text("$$" + index);
+                    }).build());
+        }
+        return translated;
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/logging/CustomJsonWriter.java b/modules/common/src/main/java/net/hollowcube/logging/CustomJsonWriter.java
new file mode 100644
index 0000000..209bccf
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/logging/CustomJsonWriter.java
@@ -0,0 +1,155 @@
+package net.hollowcube.logging;
+
+import com.google.auto.service.AutoService;
+import org.tinylog.core.LogEntry;
+import org.tinylog.core.LogEntryValue;
+import org.tinylog.pattern.FormatPatternParser;
+import org.tinylog.pattern.Token;
+import org.tinylog.writers.AbstractFileBasedWriter;
+import org.tinylog.writers.Writer;
+import org.tinylog.writers.raw.ByteArrayWriter;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.*;
+import java.util.Map.Entry;
+
+/**
+ * Copy of {@link org.tinylog.writers.JsonWriter} with some modifications to join the config with the log
+ */
+@AutoService(Writer.class)
+public final class CustomJsonWriter extends AbstractFileBasedWriter {
+
+    private static final String NEW_LINE = System.getProperty("line.separator");
+    private static final String FIELD_PREFIX = "field.";
+
+    private final Charset charset;
+    private final ByteArrayWriter writer;
+
+    private StringBuilder builder;
+    private final Map<String, Token> jsonProperties;
+
+    public CustomJsonWriter() throws IOException {
+        this(Collections.emptyMap());
+    }
+
+    public CustomJsonWriter(final Map<String, String> properties) throws IOException {
+        super(properties);
+
+        String fileName = getFileName();
+        boolean append = getBooleanValue("append");
+        boolean buffered = getBooleanValue("buffered");
+        boolean writingThread = getBooleanValue("writingthread");
+
+        charset = getCharset();
+        writer = createByteArrayWriter(fileName, append, buffered, !writingThread, false, charset);
+
+        jsonProperties = createTokens(properties);
+
+        if (writingThread) {
+            builder = new StringBuilder();
+        }
+    }
+
+    @Override
+    public void write(final LogEntry logEntry) throws IOException {
+        StringBuilder builder;
+        if (this.builder == null) {
+            builder = new StringBuilder();
+        } else {
+            builder = this.builder;
+            builder.setLength(0);
+        }
+
+        addJsonObject(logEntry, builder);
+
+        byte[] data = builder.toString().getBytes(charset);
+        writer.write(data, 0, data.length);
+    }
+
+    @Override
+    public void flush() throws IOException {
+        writer.flush();
+    }
+
+    @Override
+    public void close() throws IOException {
+        writer.flush();
+        writer.close();
+    }
+
+    @Override
+    public Collection<LogEntryValue> getRequiredLogEntryValues() {
+        Collection<LogEntryValue> values = EnumSet.noneOf(LogEntryValue.class);
+        values.add(LogEntryValue.CONTEXT);
+        for (Token token : jsonProperties.values()) {
+            values.addAll(token.getRequiredLogEntryValues());
+        }
+        return values;
+    }
+
+    private void addJsonObject(final LogEntry logEntry, final StringBuilder builder) {
+        builder.append("{");
+
+        Map<String, Object> entries = new HashMap<>();
+        if (logEntry.getContext() != null)
+            entries.putAll(logEntry.getContext());
+        entries.putAll(jsonProperties);
+
+        Object[] tokenEntries = entries.values().toArray(new Object[0]);
+        String[] fields = entries.keySet().toArray(new String[0]);
+
+        for (int i = 0; i < tokenEntries.length; i++) {
+            builder.append("\"").append(fields[i]).append("\":\"");
+            int start = builder.length();
+
+            Object entry = tokenEntries[i];
+            if (entry instanceof Token token) {
+                token.render(logEntry, builder);
+            } else {
+                builder.append(entry.toString());
+            }
+
+            escapeCharacter("\\", "\\\\", builder, start);
+            escapeCharacter("\"", "\\\"", builder, start);
+            escapeCharacter(NEW_LINE, "\\n", builder, start);
+            escapeCharacter("\t", "\\t", builder, start);
+            escapeCharacter("\b", "\\b", builder, start);
+            escapeCharacter("\f", "\\f", builder, start);
+            escapeCharacter("\n", "\\n", builder, start);
+            escapeCharacter("\r", "\\r", builder, start);
+
+            builder.append("\"");
+
+            if (i + 1 < entries.size()) {
+                builder.append(",");
+            }
+        }
+        builder.append("}").append(NEW_LINE);
+    }
+
+    private void escapeCharacter(final String character, final String escapeWith, final StringBuilder stringBuilder,
+                                 final int startIndex) {
+        for (
+                int index = stringBuilder.indexOf(character, startIndex);
+                index != -1;
+                index = stringBuilder.indexOf(character, index + escapeWith.length())
+        ) {
+            stringBuilder.replace(index, index + character.length(), escapeWith);
+        }
+    }
+
+    private static Map<String, Token> createTokens(final Map<String, String> properties) {
+        FormatPatternParser parser = new FormatPatternParser(properties.get("exception"));
+
+        Map<String, Token> tokens = new HashMap<>();
+        for (Entry<String, String> entry : properties.entrySet()) {
+            if (entry.getKey().toLowerCase(Locale.ROOT).startsWith(FIELD_PREFIX)) {
+                tokens.put(entry.getKey().substring(FIELD_PREFIX.length()), parser.parse(entry.getValue()));
+            }
+        }
+        return tokens;
+    }
+
+}
+
diff --git a/modules/common/src/main/java/net/hollowcube/logging/Logger.java b/modules/common/src/main/java/net/hollowcube/logging/Logger.java
new file mode 100644
index 0000000..692bd32
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/logging/Logger.java
@@ -0,0 +1,33 @@
+package net.hollowcube.logging;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+/**
+ * SLF4J wrapper with a sane API for MDC.
+ * <p>
+ * Context variables are important for searching within log tools such as Loki (grafana) and the default usage of MDC is
+ * extremely verbose and error-prone.
+ * <p>
+ * Create using {@link LoggerFactory}.
+ */
+public interface Logger {
+
+    void debug(@NotNull String message);
+
+    void debug(@NotNull String message, @NotNull Map<String, Object> context);
+
+    void info(@NotNull String message);
+
+    void info(@NotNull String message, @NotNull Map<String, Object> context);
+
+    void warn(@NotNull String message);
+
+    void warn(@NotNull String message, @NotNull Map<String, Object> context);
+
+    void error(@NotNull String message);
+
+    void error(@NotNull String message, @NotNull Map<String, Object> context);
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/logging/LoggerFactory.java b/modules/common/src/main/java/net/hollowcube/logging/LoggerFactory.java
new file mode 100644
index 0000000..53d3683
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/logging/LoggerFactory.java
@@ -0,0 +1,12 @@
+package net.hollowcube.logging;
+
+import org.jetbrains.annotations.NotNull;
+
+public final class LoggerFactory {
+    private LoggerFactory() {}
+
+    public static @NotNull Logger getLogger(@NotNull Class<?> clazz) {
+        return new LoggerImpl(org.slf4j.LoggerFactory.getLogger(clazz));
+    }
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/logging/LoggerImpl.java b/modules/common/src/main/java/net/hollowcube/logging/LoggerImpl.java
new file mode 100644
index 0000000..d75d987
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/logging/LoggerImpl.java
@@ -0,0 +1,98 @@
+package net.hollowcube.logging;
+
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.MDC;
+
+import java.util.Map;
+
+record LoggerImpl(org.slf4j.Logger delegate) implements Logger {
+
+    @Override
+    public void debug(@NotNull String message) {
+        debug(message, Map.of());
+    }
+
+    @Override
+    public void debug(@NotNull String message, @NotNull Map<String, Object> context) {
+        if (!delegate.isDebugEnabled()) return;
+
+        for (var entry : context.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+
+        delegate.debug(message);
+
+        for (var key : context.keySet()) {
+            remove(key);
+        }
+    }
+
+
+    @Override
+    public void info(@NotNull String message) {
+        info(message, Map.of());
+    }
+
+    @Override
+    public void info(@NotNull String message, @NotNull Map<String, Object> context) {
+        if (!delegate.isInfoEnabled()) return;
+
+        for (var entry : context.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+
+        delegate.info(message);
+
+        for (var key : context.keySet()) {
+            remove(key);
+        }
+    }
+
+    @Override
+    public void warn(@NotNull String message) {
+        warn(message, Map.of());
+    }
+
+    @Override
+    public void warn(@NotNull String message, @NotNull Map<String, Object> context) {
+        if (!delegate.isWarnEnabled()) return;
+
+        for (var entry : context.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+
+        delegate.warn(message);
+
+        for (var key : context.keySet()) {
+            remove(key);
+        }
+    }
+
+    @Override
+    public void error(@NotNull String message) {
+        error(message, Map.of());
+    }
+
+    @Override
+    public void error(@NotNull String message, @NotNull Map<String, Object> context) {
+        if (!delegate.isErrorEnabled()) return;
+
+        for (var entry : context.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+
+        delegate.error(message);
+
+        for (var key : context.keySet()) {
+            remove(key);
+        }
+    }
+
+    private void put(String key, Object value) {
+        MDC.put(key, value == null ? null : value.toString());
+    }
+
+    private void remove(String key) {
+        MDC.remove(key);
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/mongo/BsonOps.java b/modules/common/src/main/java/net/hollowcube/mongo/BsonOps.java
new file mode 100644
index 0000000..0a53a46
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/mongo/BsonOps.java
@@ -0,0 +1,294 @@
+package net.hollowcube.mongo;
+
+import com.mojang.datafixers.util.Pair;
+import com.mojang.serialization.DataResult;
+import com.mojang.serialization.DynamicOps;
+import com.mojang.serialization.MapLike;
+import org.bson.*;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+/**
+ * DFU {@link DynamicOps} implementation for BSON values.
+ * <p>
+ * The official BSON library _does_ support direct reflection based object mapping, however, since codecs are being used
+ * in many other places, it makes some sense to use them here too. It generalizes storage implementations to simply use
+ * the codec for a type.
+ * <p>
+ * todo its possible this will be problematic because it is not using the real bson types (eg bson date),
+ *      but I dont expect this to be a huge issue.
+ */
+public class BsonOps implements DynamicOps<BsonValue> {
+
+    public static final BsonOps INSTANCE = new BsonOps();
+
+    private BsonOps() {}
+
+    @Override
+    public BsonValue empty() {
+        return BsonNull.VALUE;
+    }
+
+    @Override
+    public <U> U convertTo(DynamicOps<U> outOps, BsonValue input) {
+        if (input instanceof BsonDocument) {
+            return convertMap(outOps, input);
+        }
+        if (input instanceof BsonArray) {
+            return convertList(outOps, input);
+        }
+        if (input instanceof BsonNull) {
+            return outOps.empty();
+        }
+        //todo other bson types
+        return null;
+    }
+
+    @Override
+    public DataResult<Number> getNumberValue(BsonValue input) {
+        if (input instanceof BsonNumber number) {
+            return DataResult.success(new BsonNumberWrapper(number));
+        }
+        if (input instanceof BsonBoolean bool) {
+            return DataResult.success(bool.getValue() ? 1 : 0);
+        }
+        return DataResult.error("Not a number: " + input);
+    }
+
+    @Override
+    public BsonValue createNumeric(Number i) {
+        if (i instanceof Byte || i instanceof Short || i instanceof Integer) {
+            return new BsonInt32(i.intValue());
+        }
+        if (i instanceof Long) {
+            return new BsonInt64(i.longValue());
+        }
+        if (i instanceof Float || i instanceof Double) {
+            return new BsonDouble(i.doubleValue());
+        }
+        throw new IllegalArgumentException("Unknown number type: " + i.getClass().getSimpleName() + " (" + i + ")");
+    }
+
+    @Override
+    public DataResult<String> getStringValue(BsonValue input) {
+        if (input instanceof BsonString string) {
+            return DataResult.success(string.getValue());
+        }
+        return DataResult.error("Not a string: " + input);
+    }
+
+    @Override
+    public BsonValue createString(String value) {
+        return new BsonString(value);
+    }
+
+    @Override
+    public DataResult<BsonValue> mergeToList(BsonValue list, BsonValue value) {
+        if (!(list instanceof BsonArray) && list != empty()) {
+            return DataResult.error("mergeToList called with not a list: " + list, list);
+        }
+
+        final BsonArray result = new BsonArray();
+        if (list != empty()) {
+            result.addAll(list.asArray());
+        }
+        result.add(value);
+        return DataResult.success(result);
+    }
+
+    @Override
+    public DataResult<BsonValue> mergeToList(BsonValue list, List<BsonValue> values) {
+        if (!(list instanceof BsonArray) && list != empty()) {
+            return DataResult.error("mergeToList called with not a list: " + list, list);
+        }
+
+        final BsonArray result = new BsonArray();
+        if (list != empty()) {
+            result.addAll(list.asArray());
+        }
+        result.addAll(values);
+        return DataResult.success(result);
+    }
+
+    @Override
+    public DataResult<BsonValue> mergeToMap(BsonValue map, BsonValue key, BsonValue value) {
+        if (!(map instanceof BsonDocument) && map != empty()) {
+            return DataResult.error("mergeToMap called with not a map: " + map, map);
+        }
+        if (!(key instanceof BsonString keyString)) {
+            return DataResult.error("key is not a string: " + key, map);
+        }
+
+        final BsonDocument output = new BsonDocument();
+        if (map != empty()) {
+            output.putAll(map.asDocument());
+        }
+        output.put(keyString.getValue(), value);
+
+        return DataResult.success(output);
+    }
+
+    @Override
+    public DataResult<BsonValue> mergeToMap(BsonValue map, MapLike<BsonValue> values) {
+        if (!(map instanceof BsonDocument) && map != empty()) {
+            return DataResult.error("mergeToMap called with not a map: " + map, map);
+        }
+
+        final BsonDocument output = new BsonDocument();
+        if (map != empty()) {
+            output.putAll(map.asDocument());
+        }
+
+        final List<BsonValue> missed = new ArrayList<>();
+
+        values.entries().forEach(entry -> {
+            final BsonValue key = entry.getFirst();
+            if (!(key instanceof BsonString keyString)) {
+                missed.add(key);
+                return;
+            }
+            output.put(keyString.getValue(), entry.getSecond());
+        });
+
+        if (!missed.isEmpty()) {
+            return DataResult.error("some keys are not strings: " + missed, output);
+        }
+
+        return DataResult.success(output);
+    }
+
+    @Override
+    public DataResult<Stream<Pair<BsonValue, BsonValue>>> getMapValues(BsonValue input) {
+        if (!(input instanceof BsonDocument document)) {
+            return DataResult.error("Not a bson document: " + input);
+        }
+        return DataResult.success(document.entrySet().stream().map(entry -> Pair.of(
+                new BsonString(entry.getKey()),
+                entry.getValue() instanceof BsonNull ? null : entry.getValue())
+        ));
+    }
+
+    @Override
+    public DataResult<Consumer<BiConsumer<BsonValue, BsonValue>>> getMapEntries(BsonValue input) {
+        if (!(input instanceof BsonDocument document)) {
+            return DataResult.error("Not a bson document: " + input);
+        }
+        return DataResult.success(c -> {
+            for (final Map.Entry<String, BsonValue> entry : document.entrySet()) {
+                c.accept(createString(entry.getKey()), entry.getValue() instanceof BsonNull ? null : entry.getValue());
+            }
+        });
+    }
+
+    @Override
+    public DataResult<MapLike<BsonValue>> getMap(BsonValue input) {
+        if (!(input instanceof BsonDocument document)) {
+            return DataResult.error("Not a bson document: " + input);
+        }
+        return DataResult.success(new MapLike<>() {
+            @Override
+            public @Nullable BsonValue get(final BsonValue key) {
+                final BsonValue value = document.get(key.asString().getValue());
+                return value instanceof BsonNull ? null : value;
+            }
+
+            @Override
+            public @Nullable BsonValue get(final String key) {
+                final BsonValue value = document.get(key);
+                return value instanceof BsonNull ? null : value;
+            }
+
+            @Override
+            public Stream<Pair<BsonValue, BsonValue>> entries() {
+                return document.entrySet().stream().map(e -> Pair.of(new BsonString(e.getKey()), e.getValue()));
+            }
+
+            @Override
+            public String toString() {
+                return "MapLike[" + document + "]";
+            }
+        });
+    }
+
+    @Override
+    public BsonValue createMap(Stream<Pair<BsonValue, BsonValue>> map) {
+        final BsonDocument result = new BsonDocument();
+        map.forEach(p -> result.put(p.getFirst().asString().getValue(), p.getSecond()));
+        return result;
+    }
+
+    @Override
+    public DataResult<Stream<BsonValue>> getStream(BsonValue input) {
+        if (input instanceof BsonArray array) {
+            return DataResult.success(array.stream().map(e -> e instanceof BsonNull ? null : e));
+        }
+        return DataResult.error("Not a bson array: " + input);
+    }
+
+    @Override
+    public DataResult<Consumer<Consumer<BsonValue>>> getList(BsonValue input) {
+        if (input instanceof BsonArray array) {
+            return DataResult.success(c -> {
+                for (final BsonValue value : array) {
+                    c.accept(value);
+                }
+            });
+        }
+        return DataResult.error("Not a bson array: " + input);
+    }
+
+    @Override
+    public BsonValue createList(Stream<BsonValue> input) {
+        final BsonArray result = new BsonArray();
+        input.forEach(result::add);
+        return result;
+    }
+
+    @Override
+    public BsonValue remove(BsonValue input, String key) {
+        if (input instanceof BsonDocument document) {
+            final BsonDocument result = new BsonDocument();
+            document.entrySet().stream()
+                    .filter(entry -> !Objects.equals(entry.getKey(), key))
+                    .forEach(entry -> result.put(entry.getKey(), entry.getValue()));
+            return result;
+        }
+        return input;
+    }
+
+
+    private static final class BsonNumberWrapper extends Number {
+        private final BsonNumber delegate;
+
+        public BsonNumberWrapper(BsonNumber delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public int intValue() {
+            return delegate.intValue();
+        }
+
+        @Override
+        public long longValue() {
+            return delegate.longValue();
+        }
+
+        @Override
+        public float floatValue() {
+            return (float) delegate.doubleValue();
+        }
+
+        @Override
+        public double doubleValue() {
+            return delegate.doubleValue();
+        }
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/mongo/MongoConfig.java b/modules/common/src/main/java/net/hollowcube/mongo/MongoConfig.java
new file mode 100644
index 0000000..abf2a40
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/mongo/MongoConfig.java
@@ -0,0 +1,17 @@
+package net.hollowcube.mongo;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import org.jetbrains.annotations.NotNull;
+
+public record MongoConfig(
+        @NotNull String uri,
+        boolean useTransactions
+) {
+
+    public static final Codec<MongoConfig> CODEC = RecordCodecBuilder.create(i -> i.group(
+            Codec.STRING.fieldOf("uri").forGetter(MongoConfig::uri),
+            Codec.BOOL.optionalFieldOf("use_transactions", false).forGetter(MongoConfig::useTransactions)
+    ).apply(i, MongoConfig::new));
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/mongo/package-info.java b/modules/common/src/main/java/net/hollowcube/mongo/package-info.java
new file mode 100644
index 0000000..f359a09
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/mongo/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * MongoDB utilities to work with the other systems present.
+ * <p>
+ * `common` does not have a runtime dependency on mongodb, so this package will not bring along any extra baggage.
+ * However, any package using this module must bring along mongodb-driver-sync.
+ */
+package net.hollowcube.mongo;
\ No newline at end of file
diff --git a/modules/common/src/main/java/net/hollowcube/registry/MapRegistry.java b/modules/common/src/main/java/net/hollowcube/registry/MapRegistry.java
new file mode 100644
index 0000000..c28c2ee
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/registry/MapRegistry.java
@@ -0,0 +1,53 @@
+package net.hollowcube.registry;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnknownNullability;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+class MapRegistry<T extends Resource> implements Registry<T> {
+    private final Map<String, T> delegate;
+
+    public MapRegistry(Map<String, T> resources) {
+        this.delegate = resources;
+    }
+
+    @Override
+    public @Nullable T getRaw(String namespace) {
+        return delegate.get(namespace);
+    }
+
+    @Override
+    public @NotNull Collection<T> values() {
+        return delegate.values();
+    }
+
+    @Override
+    public int size() {
+        return delegate.size();
+    }
+
+    @Override
+    public @NotNull <K> Index<K, T> index(Function<T, K> mapper) {
+        Map<K, T> index = values().stream().collect(Collectors.toMap(mapper, i -> i));
+        return new MapIndex<>(index);
+    }
+
+
+    static class MapIndex<K, T extends Resource> implements Index<K, T> {
+        private final Map<K, T> delegate;
+
+        MapIndex(Map<K, T> delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public @UnknownNullability T get(K key) {
+            return delegate.get(key);
+        }
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/registry/MissingEntryException.java b/modules/common/src/main/java/net/hollowcube/registry/MissingEntryException.java
new file mode 100644
index 0000000..d8ac537
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/registry/MissingEntryException.java
@@ -0,0 +1,22 @@
+package net.hollowcube.registry;
+
+import org.jetbrains.annotations.NotNull;
+
+public class MissingEntryException extends RuntimeException{
+    private final @NotNull Registry<?> registry;
+    private final @NotNull String key;
+
+    public MissingEntryException(@NotNull Registry<?> registry, @NotNull String key) {
+        super("Missing registry entry: " + key + " in " + registry + "!");
+        this.registry = registry;
+        this.key = key;
+    }
+
+    public @NotNull Registry<?> registry() {
+        return registry;
+    }
+
+    public @NotNull String key() {
+        return key;
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/registry/Registry.java b/modules/common/src/main/java/net/hollowcube/registry/Registry.java
new file mode 100644
index 0000000..20a28e9
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/registry/Registry.java
@@ -0,0 +1,200 @@
+package net.hollowcube.registry;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.JsonOps;
+import net.hollowcube.Env;
+import net.minestom.server.utils.NamespaceID;
+import net.minestom.server.utils.collection.ObjectArray;
+import net.minestom.server.utils.validate.Check;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnknownNullability;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import net.hollowcube.dfu.DFUUtil;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.ServiceLoader;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/**
+ * A (publically) immutable list of {@link Resource}s, indexed by {@link NamespaceID}.
+ * <p>
+ * Registries can be created in a variety of ways with varying degrees of comlepexity. Ores, item components and item
+ * entries serve as examples with varying complexity and should be used as an example.
+ * <p>
+ * The most simple option is {@link #codec(String, Codec)}. This will create a registry from a single data file with the
+ * name {@code ${name}.json} which must contain an array of objects, each conforming to the given {@link Codec}. Ores
+ * are an example using this pattern.
+ * <p>
+ * Another very common pattern is used in NumberProviders. This case can be used when a field may contain a variety of
+ * implementations, identified by their key. First, an interface should be created for the resource, as well as a
+ * Factory inner abstract class which implements ResourceFactory. A {@link #service(String, java.lang.Class)} registry
+ * can be created to load all implementations of the factory. From there, registry dispatch may be used on the codec to
+ * create a codec for all implementations of the interface. Finally, each implementation must implement a Factory class
+ * and register it with {@link com.google.auto.service.AutoService}. See NumberProvider for more detail.
+ * <p>
+ * Finally, if some complexity is needed during the loading process of static resources,
+ * {@link #manual(String, Function)} can be used to individually process each resource. The loading mechanism is the
+ * same as {@link #codec(String, Codec)}. Item registry entries (ItemRegistry.Entry) are an example using this pattern.
+ *
+ * @param <T> The type of resource stored in the registry.
+ */
+public interface Registry<T extends Resource> {
+    //todo registry should implement Codec i think
+
+    // Factory
+
+    static <T extends Resource> Registry<T> manual(@NotNull String name, Supplier<Collection<T>> supplier) {
+        Map<String, T> registry = new HashMap<>();
+        for (T element : supplier.get()) {
+            registry.put(element.name(), element);
+        }
+
+        // Registries may not be empty in strict mode
+        Env.strictValidation(
+                "Empty registry for manual resource: " + name,
+                registry::isEmpty
+        );
+
+        return new MapRegistry<>(registry);
+    }
+
+    static <T extends Resource> Registry<T> service(@NotNull String name, Class<T> type) {
+        Map<String, T> registry = new HashMap<>();
+        for (T elem : ServiceLoader.load(type)) {
+            registry.put(elem.name(), elem);
+        }
+
+        // Registries may not be empty in strict mode
+        Env.strictValidation(
+                "Empty registry for manual resource: " + name,
+                registry::isEmpty
+        );
+
+        return new MapRegistry<>(registry);
+    }
+
+    static <T extends Resource> Registry<T> manual(@NotNull String name, @NotNull Function<JsonObject, T> mapper) {
+        Map<String, T> registry = new HashMap<>();
+
+        JsonArray content = Resource.loadJsonArray(name + ".json");
+        for (JsonElement elem : content) {
+            Check.stateCondition(!elem.isJsonObject(), "Registry items must be json objects");
+
+            try {
+                T element = mapper.apply(elem.getAsJsonObject());
+                registry.put(element.name(), element);
+            } catch (Throwable e) {
+                Logger logger = LoggerFactory.getLogger(Registry.class);
+                logger.error("Failed to load registry item in {}: {}", name, elem, e);
+
+                Env.strictValidation("Registry item failure", () -> true);
+            }
+        }
+
+        // Registries may not be empty in strict mode
+        Env.strictValidation(
+                "Empty registry for resource: " + name,
+                registry::isEmpty
+        );
+
+        return new MapRegistry<>(registry);
+    }
+
+    /**
+     * Create a registry from a codec directly. The registry item must have a "namespace" field for the ID.
+     *
+     * @param codec The codec to deserialize with
+     * @param name  The name of the data file to load from (.json is appended)
+     */
+    static <T extends Resource> Registry<T> codec(@NotNull String name, @NotNull Codec<T> codec) {
+        JsonArray content = Resource.loadJsonArray(name + ".json");
+
+        // Create a modified encoder that converts to a map. See the description of ItemRegistry.Entry.CODEC
+        // for more notes on the technique used here.
+        Codec<Map<String, T>> mapCodec = Codec.pair(Codec.STRING.fieldOf("namespace").codec(), codec)
+                .listOf()
+                .xmap(DFUUtil::pairListToMap, DFUUtil::mapToPairList);
+
+        Map<String, T> registry = null; // null is just to make javac happy, it can never happen.
+        try {
+            registry = JsonOps.INSTANCE
+                    .withDecoder(mapCodec)
+                    .apply(content)
+                    .getOrThrow(false, ignored -> {})
+                    .getFirst();
+        } catch (RuntimeException e) {
+            Logger logger = LoggerFactory.getLogger(Registry.class);
+            logger.error("Failed to create registry {}", name, e);
+
+            // This is a fatal error. We should never allow a server to start up with a broken registry.
+            System.exit(1);
+        }
+
+        // Registries may not be empty in strict mode
+        Env.strictValidation(
+                "Empty registry for resource: " + name,
+                registry::isEmpty
+        );
+
+        return new MapRegistry<>(registry);
+    }
+
+
+    // Impl
+
+    @Nullable T getRaw(String namespace);
+
+    default @UnknownNullability T get(String namespace) {
+        if (namespace == null) return null;
+        return getRaw(namespace.contains(":") ? namespace : "minecraft:" + namespace);
+    }
+
+    default @UnknownNullability T get(NamespaceID namespace) {
+        if (namespace == null) return null;
+        return getRaw(namespace.asString());
+    }
+
+    default @NotNull T required(String namespace) {
+        T result = get(namespace);
+        if (result == null) throw new MissingEntryException(this, namespace);
+        return result;
+    }
+
+
+    @NotNull Collection<T> values();
+
+    int size();
+
+
+    // Derivatives
+
+    interface Index<K, T extends Resource> {
+
+        @UnknownNullability T get(K key);
+
+    }
+
+    @NotNull <K> Index<K, T> index(Function<T, K> mapper);
+
+
+    // Below here is kinda cursed, will fix eventually but works for now.
+
+    default @NotNull ObjectArray<T> unsafeIntegerIndex(Function<T, Integer> getter) {
+        Collection<T> values = values();
+
+        ObjectArray<T> index = ObjectArray.singleThread(values.size());
+        for (T elem : values)
+            index.set(getter.apply(elem), elem);
+
+        index.trim();
+        return index;
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/registry/Resource.java b/modules/common/src/main/java/net/hollowcube/registry/Resource.java
new file mode 100644
index 0000000..0bf4173
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/registry/Resource.java
@@ -0,0 +1,95 @@
+package net.hollowcube.registry;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonParser;
+import net.kyori.adventure.key.Key;
+import net.kyori.adventure.key.Keyed;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Collectors;
+
+public interface Resource extends Keyed {
+
+    @Contract(pure = true)
+    @NotNull NamespaceID namespace();
+
+    @Override
+    default @NotNull Key key() {
+        return namespace();
+    }
+
+    @Contract(pure = true)
+    default @NotNull String name() {
+        return namespace().asString();
+    }
+
+
+    interface Id extends Resource {
+
+        @Contract(pure = true)
+        int id();
+
+    }
+
+
+    Path DATA_PATH = Path.of(System.getProperty("starlight.data.dir", "data"));
+
+    /**
+     * Attempts to load a resource file with the following priorities
+     * <ol>
+     *     <li>Read from `jar://data/{name}`</li>
+     *     <li>Read from `{DATA_PATH}/{name}`</li>
+     *     <li>null</li>
+     * </ol>
+     *
+     * @param name The resource name and extension to load
+     * @return The resource file content, or null if missing.
+     */
+    static @Nullable String load(@NotNull String name) {
+        InputStream packaged = Resource.class.getClassLoader().getResourceAsStream("data/" + name);
+        if (packaged != null) {
+            try (BufferedReader reader = new BufferedReader(new InputStreamReader(packaged, Charset.defaultCharset()))) {
+                return reader.lines().collect(Collectors.joining("\n"));
+            } catch (IOException e) {
+                Logger logger = LoggerFactory.getLogger(Resource.class);
+                logger.warn("Found resource {} in classpath, but failed to load it", name, e);
+            }
+        }
+
+        Path external = DATA_PATH.resolve(name);
+        if (Files.exists(external) && Files.isRegularFile(external)) {
+            try (BufferedReader reader = Files.newBufferedReader(external)) {
+                return reader.lines().collect(Collectors.joining("\n"));
+            } catch (IOException e) {
+                Logger logger = LoggerFactory.getLogger(Resource.class);
+                logger.warn("Found resource {} in external data, but failed to load it", name, e);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Loads a resource using the semantics of {@link #load(String)}, but the resource must be a json file with an array
+     * at the root. If the file cannot be found, an empty array will be returned.
+     */
+    static @NotNull JsonArray loadJsonArray(@NotNull String resource) {
+        String content = load(resource);
+        if (content == null)
+            return new JsonArray();
+
+        return JsonParser.parseString(content).getAsJsonArray();
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/registry/ResourceFactory.java b/modules/common/src/main/java/net/hollowcube/registry/ResourceFactory.java
new file mode 100644
index 0000000..a1eb570
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/registry/ResourceFactory.java
@@ -0,0 +1,30 @@
+package net.hollowcube.registry;
+
+import com.mojang.serialization.Codec;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+
+public abstract class ResourceFactory<T> implements Resource {
+    private final NamespaceID namespace;
+    private final Class<? extends T> type;
+    private final Codec<? extends T> codec;
+
+    public ResourceFactory(NamespaceID namespace, Class<? extends T> type, Codec<? extends T> codec) {
+        this.namespace = namespace;
+        this.type = type;
+        this.codec = codec;
+    }
+
+    @Override
+    public @NotNull NamespaceID namespace() {
+        return this.namespace;
+    }
+
+    public @NotNull Class<? extends T> type() {
+        return this.type;
+    }
+
+    public @NotNull Codec<? extends T> codec() {
+        return this.codec;
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/server/Facet.java b/modules/common/src/main/java/net/hollowcube/server/Facet.java
new file mode 100644
index 0000000..de02857
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/server/Facet.java
@@ -0,0 +1,23 @@
+package net.hollowcube.server;
+
+import net.minestom.server.ServerProcess;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A concept for loading modules of the server, similar-ish to extensions.
+ * <p>
+ * Facets are defined, then loaded using the service provider interface by the controlling server (development,
+ * production, etc).
+ * <p>
+ * All facets <i>must</i> have a public no-args constructor. There may be other constructors present (eg for use in
+ * tests).
+ * <p>
+ * Common registration functions are provided on {@link ServerWrapper}. These should be used over accessing the
+ * {@link ServerProcess} directly, because they can be transparently extended to support unloading facets if this ever
+ * becomes a desired behavior (and they have some utilities).
+ */
+public interface Facet {
+
+    void hook(@NotNull ServerWrapper server);
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/server/IsolatedServerWrapper.java b/modules/common/src/main/java/net/hollowcube/server/IsolatedServerWrapper.java
new file mode 100644
index 0000000..6c5267e
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/server/IsolatedServerWrapper.java
@@ -0,0 +1,34 @@
+package net.hollowcube.server;
+
+import net.minestom.server.ServerProcess;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.event.EventNode;
+import net.minestom.server.instance.block.BlockHandler;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Supplier;
+
+@SuppressWarnings("UnstableApiUsage")
+record IsolatedServerWrapper(@NotNull ServerProcess process) implements ServerWrapper {
+
+    @Override
+    public <F extends Facet> @Nullable F getFacet(@NotNull Class<F> type) {
+        return null;
+    }
+
+    @Override
+    public void addEventNode(@NotNull EventNode<?> node) {
+        process.eventHandler().addChild(node);
+    }
+
+    @Override
+    public void registerCommand(@NotNull Command command) {
+        process.command().register(command);
+    }
+
+    @Override
+    public void registerBlockHandler(@NotNull Supplier<BlockHandler> handlerSupplier) {
+        process.block().registerHandler(handlerSupplier.get().getNamespaceId(), handlerSupplier);
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/server/ServerWrapper.java b/modules/common/src/main/java/net/hollowcube/server/ServerWrapper.java
new file mode 100644
index 0000000..bb5a361
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/server/ServerWrapper.java
@@ -0,0 +1,44 @@
+package net.hollowcube.server;
+
+import net.minestom.server.ServerProcess;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.event.EventNode;
+import net.minestom.server.instance.block.BlockHandler;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Supplier;
+
+@SuppressWarnings("UnstableApiUsage")
+public interface ServerWrapper {
+
+    static @NotNull ServerWrapper isolated(@NotNull ServerProcess process) {
+        return new IsolatedServerWrapper(process);
+    }
+
+    /**
+     * Access to the underlying server process. Should not be used if there is an alternative api present in this
+     * class.
+     */
+    @NotNull ServerProcess process();
+
+    /**
+     * Fetches a {@link Facet} loaded on the server.
+     * <p>
+     * Note: Load order is _not_ guaranteed. If this method is accessed during the facet loading phase of server start,
+     * the target may not have been loaded yet. It will still be returned in this case.
+     *
+     * @return The facet if it is present on the server, otherwise null
+     */
+    <F extends Facet> @Nullable F getFacet(@NotNull Class<F> type);
+
+
+    // Utility functions
+
+    void addEventNode(@NotNull EventNode<?> node);
+
+    void registerCommand(@NotNull Command command);
+
+    void registerBlockHandler(@NotNull Supplier<BlockHandler> handlerSupplier);
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/server/instance/TickTrackingInstance.java b/modules/common/src/main/java/net/hollowcube/server/instance/TickTrackingInstance.java
new file mode 100644
index 0000000..df2deee
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/server/instance/TickTrackingInstance.java
@@ -0,0 +1,34 @@
+package net.hollowcube.server.instance;
+
+import net.minestom.server.instance.IChunkLoader;
+import net.minestom.server.instance.InstanceContainer;
+import net.minestom.server.world.DimensionType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+public class TickTrackingInstance extends InstanceContainer {
+    //todo i (matt) really dont think this should be in common, but not sure where
+
+    private long tick = 0;
+
+    public TickTrackingInstance(@NotNull UUID uniqueId, @NotNull DimensionType dimensionType, @Nullable IChunkLoader loader) {
+        super(uniqueId, dimensionType, loader);
+    }
+
+    public TickTrackingInstance(@NotNull UUID uniqueId, @NotNull DimensionType dimensionType) {
+        super(uniqueId, dimensionType);
+    }
+
+    @Override
+    public void tick(long time) {
+        tick++;
+
+        super.tick(time);
+    }
+
+    public long getTick() {
+        return tick;
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/util/BlockUtil.java b/modules/common/src/main/java/net/hollowcube/util/BlockUtil.java
new file mode 100644
index 0000000..34bb1f1
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/util/BlockUtil.java
@@ -0,0 +1,12 @@
+package net.hollowcube.util;
+
+import net.minestom.server.instance.block.Block;
+import org.jetbrains.annotations.NotNull;
+
+public final class BlockUtil {
+
+    public static @NotNull Block withType(@NotNull Block block, @NotNull Block type) {
+        return type.withHandler(block.handler()).withNbt(block.nbt());
+    }
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/util/ComponentUtil.java b/modules/common/src/main/java/net/hollowcube/util/ComponentUtil.java
new file mode 100644
index 0000000..37fbcc7
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/util/ComponentUtil.java
@@ -0,0 +1,15 @@
+package net.hollowcube.util;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.TextDecoration;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.jetbrains.annotations.NotNull;
+
+public class ComponentUtil {
+
+    public static @NotNull Component fromStringSafe(@NotNull String content) {
+        Component mm = MiniMessage.miniMessage().deserialize(content);
+        return Component.text().decoration(TextDecoration.ITALIC, false).append(mm).asComponent();
+    }
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/util/EventUtil.java b/modules/common/src/main/java/net/hollowcube/util/EventUtil.java
new file mode 100644
index 0000000..e5dd8f3
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/util/EventUtil.java
@@ -0,0 +1,46 @@
+package net.hollowcube.util;
+
+import net.hollowcube.Env;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.ServerProcess;
+import net.minestom.server.event.Event;
+import net.minestom.server.event.EventFilter;
+import net.minestom.server.event.EventNode;
+import net.minestom.server.event.trait.CancellableEvent;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Predicate;
+
+public class EventUtil {
+
+    /**
+     * Creates an event node with the given name for any event which has not yet been cancelled.
+     */
+    public static EventNode<Event> notCancelledNode(@NotNull String name) {
+        return EventNode.event(name, EventFilter.ALL, Predicate.not(EventUtil::isCancelled));
+    }
+
+    public static boolean isCancelled(Event event) {
+        return event instanceof CancellableEvent c && c.isCancelled();
+    }
+
+    /**
+     * Call an event in a test-safe manner.
+     */
+    public static void safeDispatch(@NotNull Event event) {
+        ServerProcess process = MinecraftServer.process();
+        if (process == null && !Env.STRICT_MODE)
+            return;
+        process.eventHandler().call(event);
+    }
+
+    /**
+     * Call an event in a test-safe manner.
+     */
+    public static void safeDispatchCancellable(@NotNull Event event, @NotNull Runnable onSuccess) {
+        ServerProcess process = MinecraftServer.process();
+        if (process == null && !Env.STRICT_MODE)
+            return;
+        process.eventHandler().callCancellable(event, onSuccess);
+    }
+}
diff --git a/modules/common/src/main/java/net/hollowcube/util/FutureUtil.java b/modules/common/src/main/java/net/hollowcube/util/FutureUtil.java
new file mode 100644
index 0000000..6b1e8e9
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/util/FutureUtil.java
@@ -0,0 +1,15 @@
+package net.hollowcube.util;
+
+import org.jetbrains.annotations.Contract;
+
+public class FutureUtil {
+
+    @Contract("_ -> null")
+    @SuppressWarnings("TypeParameterUnusedInFormals")
+    public static <T> T handleException(Throwable throwable) {
+        //todo log to sentry or something
+        throwable.printStackTrace();
+        return null;
+    }
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/util/JsonUtil.java b/modules/common/src/main/java/net/hollowcube/util/JsonUtil.java
new file mode 100644
index 0000000..446e1f4
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/util/JsonUtil.java
@@ -0,0 +1,103 @@
+package net.hollowcube.util;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnknownNullability;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class JsonUtil {
+
+    /**
+     * Merge two {@link JsonElement}s recursively, combining arrays based on the "type" field.
+     * <p>
+     * The resulting json element is not necessarily a deep copy if the returned item has not been modified.
+     */
+    @Contract("_, _ -> new")
+    public static @UnknownNullability JsonElement merge(@Nullable JsonElement left, @Nullable JsonElement right) {
+        if (left == null) return right;
+        if (right == null) return left;
+
+        if (left.isJsonObject() && right.isJsonObject())
+            return merge(left.getAsJsonObject(), right.getAsJsonObject());
+        if (left.isJsonArray() && right.isJsonArray())
+            return merge(left.getAsJsonArray(), right.getAsJsonArray());
+
+        return right;
+    }
+
+    public static @NotNull JsonObject merge(@NotNull JsonObject left, @NotNull JsonObject right) {
+        JsonObject merged = new JsonObject();
+        for (var entry : left.entrySet()) {
+            merged.add(entry.getKey(), entry.getValue());
+        }
+        for (var entry : right.entrySet()) {
+            final String name = entry.getKey();
+            // If left had the value, merge the two. Otherwise, just add the new entry.
+            if (merged.has(entry.getKey())) {
+                merged.add(name, merge(merged.get(name), entry.getValue()));
+            } else {
+                merged.add(entry.getKey(), entry.getValue());
+            }
+        }
+        return merged;
+    }
+
+    public static @NotNull JsonArray merge(@NotNull JsonArray left, @NotNull JsonArray right) {
+        JsonArray merged = new JsonArray();
+
+        //todo lots of duplication, very yikes
+        Map<String, JsonElement> temp = new HashMap<>();
+        for (JsonElement elem : left) {
+            // If it isnt an object, we cannot merge. Move on
+            if (!elem.isJsonObject()) {
+                merged.add(elem);
+                continue;
+            }
+            JsonObject obj = elem.getAsJsonObject();
+            // If it has a type field, we can merge. Otherwise, just add it.
+            if (obj.has("type")) {
+                temp.put(obj.get("type").getAsString(), elem);
+            } else {
+                merged.add(elem);
+            }
+        }
+
+        for (JsonElement elem : right) {
+            // If it isnt an object, we cannot merge. Move on
+            if (!elem.isJsonObject()) {
+                merged.add(elem);
+                continue;
+            }
+            JsonObject obj = elem.getAsJsonObject();
+
+            // If there is not a string type, we cannot merge. Move on
+            JsonElement type = obj.get("type");
+            if (!type.isJsonPrimitive()) {
+                merged.add(elem);
+                continue;
+            }
+
+            // If there is already an element of the same type, merge them.
+            // Otherwise just add the element to temp map
+            if (temp.containsKey(type.getAsString())) {
+                temp.put(type.getAsString(), merge(temp.get(type.getAsString()), elem));
+            } else {
+                temp.put(type.getAsString(), elem);
+            }
+        }
+
+        // Copy all entries from temp map into temp
+        for (var entry : temp.entrySet()) {
+            merged.add(entry.getValue());
+        }
+
+        return merged;
+    }
+
+}
diff --git a/modules/common/src/main/java/net/hollowcube/util/ParticleUtils.java b/modules/common/src/main/java/net/hollowcube/util/ParticleUtils.java
new file mode 100644
index 0000000..7214ef8
--- /dev/null
+++ b/modules/common/src/main/java/net/hollowcube/util/ParticleUtils.java
@@ -0,0 +1,19 @@
+package net.hollowcube.util;
+
+import net.minestom.server.coordinate.Point;
+import net.minestom.server.entity.Player;
+import net.minestom.server.item.Material;
+import net.minestom.server.network.packet.server.ServerPacket;
+import net.minestom.server.particle.Particle;
+import net.minestom.server.particle.ParticleCreator;
+import org.jetbrains.annotations.NotNull;
+
+public class ParticleUtils {
+
+    public static void spawnBlockBreakParticles(@NotNull Player player, @NotNull Point point, @NotNull Material material) {
+        ServerPacket packet = ParticleCreator.createParticlePacket(
+                Particle.BLOCK, false, point.x(), point.y(), point.z(), 0.01f, 0.01f, 0.01f,
+                0.05f, 12, binaryWriter -> binaryWriter.writeVarInt(material.id()));
+        player.sendPacketToViewersAndSelf(packet);
+    }
+}
diff --git a/modules/common/src/test/java/net/hollowcube/data/number/TestConstantNumberProvider.java b/modules/common/src/test/java/net/hollowcube/data/number/TestConstantNumberProvider.java
new file mode 100644
index 0000000..0a54452
--- /dev/null
+++ b/modules/common/src/test/java/net/hollowcube/data/number/TestConstantNumberProvider.java
@@ -0,0 +1,33 @@
+package net.hollowcube.data.number;
+
+import net.hollowcube.data.NumberSource;
+import org.junit.jupiter.api.Test;
+import org.opentest4j.AssertionFailedError;
+
+import static com.google.common.truth.Truth.assertThat;
+
+public class TestConstantNumberProvider {
+
+    @Test
+    public void testHappyCase() {
+        var source = NumberSource.constant(0);
+        var provider = new ConstantNumberProvider(1.0);
+
+        assertThat(provider.nextLong(source)).isEqualTo(1);
+    }
+
+    @Test
+    public void testIgnoresSource() {
+        var source = new NumberSource() {
+            @Override
+            public double random() {
+                throw new AssertionFailedError("Should not be called.");
+            }
+        };
+        var provider = new ConstantNumberProvider(1.0);
+
+        provider.nextLong(source);
+        provider.nextDouble(source);
+    }
+
+}
diff --git a/modules/common/src/test/java/net/hollowcube/dfu/TestEnvVarOps.java b/modules/common/src/test/java/net/hollowcube/dfu/TestEnvVarOps.java
new file mode 100644
index 0000000..b57e062
--- /dev/null
+++ b/modules/common/src/test/java/net/hollowcube/dfu/TestEnvVarOps.java
@@ -0,0 +1,172 @@
+package net.hollowcube.dfu;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import static com.google.common.truth.Truth.assertThat;
+
+public class TestEnvVarOps {
+
+    @Test
+    public void testBasicString() {
+        record Config(String value) {}
+        Codec<Config> codec = RecordCodecBuilder.create(i -> i.group(
+                Codec.STRING.fieldOf("value").forGetter(Config::value)
+        ).apply(i, Config::new));
+
+        var ops = new MockEnvVarOps(Map.of(
+                "VALUE", "foo"
+        ));
+        var result = ops.withDecoder(codec)
+                .apply("")
+                .result()
+                .orElse(null);
+
+        assertThat(result).isNotNull();
+        assertThat(result.getFirst().value).isEqualTo("foo");
+    }
+
+    @Test
+    public void testBasicInt() {
+        record Config(int value) {}
+        Codec<Config> codec = RecordCodecBuilder.create(i -> i.group(
+                Codec.INT.fieldOf("value").forGetter(Config::value)
+        ).apply(i, Config::new));
+
+        var ops = new MockEnvVarOps(Map.of(
+                "VALUE", "1"
+        ));
+        var result = ops.withDecoder(codec)
+                .apply("")
+                .result()
+                .orElse(null);
+
+        assertThat(result).isNotNull();
+        assertThat(result.getFirst().value).isEqualTo(1);
+    }
+
+    @Test
+    public void testNestedValue() {
+        record InnerConfig(String value) {}
+        Codec<InnerConfig> innerCodec = RecordCodecBuilder.create(i -> i.group(
+                Codec.STRING.fieldOf("value").forGetter(InnerConfig::value)
+        ).apply(i, InnerConfig::new));
+        record Config(InnerConfig inner) {}
+        Codec<Config> codec = RecordCodecBuilder.create(i -> i.group(
+                innerCodec.fieldOf("inner").forGetter(Config::inner)
+        ).apply(i, Config::new));
+
+        var ops = new MockEnvVarOps(Map.of(
+                "INNER_VALUE", "foo"
+        ));
+        var result = ops.withDecoder(codec)
+                .apply("")
+                .result()
+                .orElse(null);
+
+        assertThat(result).isNotNull();
+        assertThat(result.getFirst().inner.value).isEqualTo("foo");
+    }
+
+    @Test
+    public void test2xNestedValue() {
+        record InnerInnerConfig(String value) {}
+        Codec<InnerInnerConfig> innerInnerCodec = RecordCodecBuilder.create(i -> i.group(
+                Codec.STRING.fieldOf("value").forGetter(InnerInnerConfig::value)
+        ).apply(i, InnerInnerConfig::new));
+        record InnerConfig(InnerInnerConfig inner) {}
+        Codec<InnerConfig> innerCodec = RecordCodecBuilder.create(i -> i.group(
+                innerInnerCodec.fieldOf("inner").forGetter(InnerConfig::inner)
+        ).apply(i, InnerConfig::new));
+        record Config(InnerConfig inner) {}
+        Codec<Config> codec = RecordCodecBuilder.create(i -> i.group(
+                innerCodec.fieldOf("inner").forGetter(Config::inner)
+        ).apply(i, Config::new));
+
+        var ops = new MockEnvVarOps(Map.of(
+                "INNER_INNER_VALUE", "foo"
+        ));
+        var result = ops.withDecoder(codec)
+                .apply("")
+                .result()
+                .orElse(null);
+
+        assertThat(result).isNotNull();
+        assertThat(result.getFirst().inner.inner.value).isEqualTo("foo");
+    }
+
+    @Test
+    public void testList() {
+        record Config(List<String> value) {}
+        Codec<Config> codec = RecordCodecBuilder.create(i -> i.group(
+                Codec.STRING.listOf().fieldOf("value").forGetter(Config::value)
+        ).apply(i, Config::new));
+
+        var ops = new MockEnvVarOps(Map.of(
+                "VALUE_0", "A",
+                "VALUE_1", "B",
+                "VALUE_2", "C"
+        ));
+        var result = ops.withDecoder(codec)
+                .apply("")
+                .result()
+                .orElse(null);
+
+        assertThat(result).isNotNull();
+        assertThat(result.getFirst().value).containsExactly("A", "B", "C");
+    }
+
+    @Test
+    public void testListOfObject() {
+        record InnerConfig(String a, String b) {}
+        Codec<InnerConfig> innerCodec = RecordCodecBuilder.create(i -> i.group(
+                Codec.STRING.fieldOf("a").forGetter(InnerConfig::a),
+                Codec.STRING.fieldOf("b").forGetter(InnerConfig::b)
+        ).apply(i, InnerConfig::new));
+        record Config(List<InnerConfig> value) {}
+        Codec<Config> codec = RecordCodecBuilder.create(i -> i.group(
+                innerCodec.listOf().fieldOf("value").forGetter(Config::value)
+        ).apply(i, Config::new));
+
+        var ops = new MockEnvVarOps(Map.of(
+                "VALUE_0_A", "0 a",
+                "VALUE_0_B", "0 b",
+                "VALUE_1_A", "1 a",
+                "VALUE_1_B", "1 b"
+        ));
+        var result = ops.withDecoder(codec)
+                .apply("")
+                .result()
+                .orElse(null);
+
+        assertThat(result).isNotNull();
+        assertThat(result.getFirst().value).containsExactly(
+                new InnerConfig("0 a", "0 b"),
+                new InnerConfig("1 a", "1 b")
+        );
+    }
+
+
+    private static class MockEnvVarOps extends EnvVarOps {
+        private final Map<String, String> env;
+
+        private MockEnvVarOps(Map<String, String> env) {this.env = env;}
+
+        @Override
+        protected String get(String path) {
+            var value = env.get(path.toUpperCase(Locale.ROOT));
+            return value == null ? "" : value;
+        }
+
+        @Override
+        protected Collection<String> envKeys() {
+            return env.keySet();
+        }
+    }
+}
diff --git a/modules/common/src/test/java/net/hollowcube/registry/TestMissingEntry.java b/modules/common/src/test/java/net/hollowcube/registry/TestMissingEntry.java
new file mode 100644
index 0000000..3aa57cc
--- /dev/null
+++ b/modules/common/src/test/java/net/hollowcube/registry/TestMissingEntry.java
@@ -0,0 +1,17 @@
+package net.hollowcube.registry;
+
+import com.google.gson.JsonParser;
+import com.mojang.serialization.JsonOps;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class TestMissingEntry {
+
+    @Test
+    public void testMissingRegistryEntry() {
+        var json = JsonParser.parseString("{\"type\": \"missing\"}");
+        assertThrows(MissingEntryException.class, () -> JsonOps.INSTANCE.withDecoder(TestResource.CODEC).apply(json));
+    }
+
+}
diff --git a/modules/common/src/test/java/net/hollowcube/registry/TestResource.java b/modules/common/src/test/java/net/hollowcube/registry/TestResource.java
new file mode 100644
index 0000000..630224b
--- /dev/null
+++ b/modules/common/src/test/java/net/hollowcube/registry/TestResource.java
@@ -0,0 +1,26 @@
+package net.hollowcube.registry;
+
+import com.mojang.serialization.Codec;
+import net.minestom.server.utils.NamespaceID;
+import org.jetbrains.annotations.NotNull;
+
+public interface TestResource extends Resource {
+
+    Codec<TestResource> CODEC = Factory.CODEC.dispatch(Factory::from, Factory::codec);
+
+    abstract class Factory extends ResourceFactory<TestResource> {
+        static Registry<Factory> REGISTRY = Registry.service("test_resource", Factory.class);
+        static Registry.Index<Class<?>, Factory> TYPE_REGISTRY = REGISTRY.index(Factory::type);
+
+        static Codec<Factory> CODEC = Codec.STRING.xmap(ns -> REGISTRY.required(ns), Factory::name);
+
+        public Factory(NamespaceID namespace, Class<? extends TestResource> type, Codec<? extends TestResource> codec) {
+            super(namespace, type, codec);
+        }
+
+        public static @NotNull Factory from(@NotNull TestResource resource) {
+            return TYPE_REGISTRY.get(resource.getClass());
+        }
+    }
+
+}
diff --git a/modules/common/src/test/java/net/hollowcube/util/TestJsonUtil.java b/modules/common/src/test/java/net/hollowcube/util/TestJsonUtil.java
new file mode 100644
index 0000000..6d0daad
--- /dev/null
+++ b/modules/common/src/test/java/net/hollowcube/util/TestJsonUtil.java
@@ -0,0 +1,136 @@
+package net.hollowcube.util;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParser;
+import org.intellij.lang.annotations.Language;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static com.google.common.truth.Truth.assertThat;
+
+public class TestJsonUtil {
+    private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
+
+    private static Stream<Arguments> mergeTestData() {
+        return Stream.of(
+                test("null right", """
+                        {
+                            "a": 1
+                        }""", null, """
+                        {
+                            "a": 1
+                        }"""),
+                test("null left", null, """
+                        {
+                            "a": 1
+                        }""", """
+                        {
+                            "a": 1
+                        }"""),
+                test("merge top level objects", """
+                        {
+                            "a": 1,
+                            "b": 1
+                        }""", """
+                        {
+                            "a": 2,
+                            "c": 1
+                        }""", """
+                        {
+                            "a": 2,
+                            "b": 1,
+                            "c": 1
+                        }"""),
+                test("merge sub objects", """
+                        {
+                            "obj": {
+                                "a": 1,
+                                "b": 1
+                            }
+                        }""", """
+                        {
+                            "obj": {
+                                "a": 2,
+                                "c": 1
+                            }
+                        }""", """
+                        {
+                            "obj": {
+                                "a": 2,
+                                "b": 1,
+                                "c": 1
+                            }
+                        }"""),
+                // Note the extra "a" in the result because there is no type field to merge on
+                test("merge array simple", """
+                        [
+                            "a",
+                            "b"
+                        ]""", """
+                        [
+                            "a",
+                            "c"
+                        ]""", """
+                        [
+                            "a",
+                            "b",
+                            "a",
+                            "c"
+                        ]"""),
+                test("merge array complex", """
+                        [
+                            {
+                                "type": "a",
+                                "a": 1
+                            },
+                            {
+                                "type": "b",
+                                "a": 1
+                            }
+                        ]""", """
+                        [
+                            {
+                                "type": "a",
+                                "a": 2,
+                                "b": 1
+                            }
+                        ]""", """
+                        [
+                            {
+                                "type": "a",
+                                "a": 2,
+                                "b": 1
+                            },
+                            {
+                                "type": "b",
+                                "a": 1
+                            }
+                        ]""")
+        );
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("mergeTestData")
+    public void testMergeNullRight(String name, String leftStr, String rightStr, String mergedStr) {
+        // Parse and re stringify result to ensure formatting is the same. We just want to compare content with a readable error.
+        JsonElement left = null, right = null, merged = JsonParser.parseString(mergedStr);
+        if (leftStr != null) left = JsonParser.parseString(leftStr);
+        if (rightStr != null) right = JsonParser.parseString(rightStr);
+
+        JsonElement result = JsonUtil.merge(left, right);
+        String resultStr = gson.toJson(result);
+
+        assertThat(resultStr).isEqualTo(gson.toJson(merged));
+    }
+
+    private static Arguments test(String name, @Language("JSON") String left, @Language("JSON") String right, @Language("JSON") String merged) {
+        return Arguments.of(name, left, right, merged);
+    }
+
+
+}
diff --git a/modules/common/src/test/resources/lang/en_US.properties b/modules/common/src/test/resources/lang/en_US.properties
new file mode 100644
index 0000000..e69de29
diff --git a/modules/common/src/test/resources/test.json b/modules/common/src/test/resources/test.json
new file mode 100644
index 0000000..914e095
--- /dev/null
+++ b/modules/common/src/test/resources/test.json
@@ -0,0 +1,5 @@
+{
+  "test:one": {
+    "string": "hello"
+  }
+}
\ No newline at end of file
diff --git a/settings.gradle.kts b/settings.gradle.kts
index a02015c..a5bfef7 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,5 +1,6 @@
 rootProject.name = "common"
 
 include(":modules")
+include(":modules:common")
 include(":modules:dev")
 include(":modules:test")
\ No newline at end of file

From 35511bbdd0fb2f2dec47f0c1755ca34a87ea7b2f Mon Sep 17 00:00:00 2001
From: mworzala <mattheworzala@gmail.com>
Date: Thu, 29 Sep 2022 20:02:31 -0400
Subject: [PATCH 3/3] Copy over test and doc actions

---
 .github/workflows/build_test.yml | 35 ++++++++++++++++++++++++++++++++
 .github/workflows/sync_docs.yml  | 21 +++++++++++++++++++
 docs/Home.md                     |  2 ++
 3 files changed, 58 insertions(+)
 create mode 100644 .github/workflows/build_test.yml
 create mode 100644 .github/workflows/sync_docs.yml
 create mode 100644 docs/Home.md

diff --git a/.github/workflows/build_test.yml b/.github/workflows/build_test.yml
new file mode 100644
index 0000000..376095a
--- /dev/null
+++ b/.github/workflows/build_test.yml
@@ -0,0 +1,35 @@
+name: Build and test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 17
+        uses: actions/setup-java@v2
+        with:
+          distribution: 'zulu'
+          java-version: 17
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+      - name: Setup gradle cache
+        uses: burrunan/gradle-cache-action@v1
+        with:
+          save-generated-gradle-jars: false
+          save-local-build-cache: false
+          save-gradle-dependencies-cache: true
+          save-maven-dependencies-cache: true
+          # Ignore some of the paths when caching Maven Local repository
+          maven-local-ignore-paths: |
+            starlight/mmo/
+      - name: Build
+        run: ./gradlew classes testClasses
+      - name: Run tests
+        run: ./gradlew test
diff --git a/.github/workflows/sync_docs.yml b/.github/workflows/sync_docs.yml
new file mode 100644
index 0000000..b6a8e3b
--- /dev/null
+++ b/.github/workflows/sync_docs.yml
@@ -0,0 +1,21 @@
+name: Sync Docs
+
+on:
+  push:
+    paths:
+      - docs/**
+    branches:
+      - master
+
+jobs:
+  deploy-wiki:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Sync Wiki Changes
+        uses: Andrew-Chen-Wang/github-wiki-action@v2
+        env:
+          WIKI_DIR: docs/
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_MAIL: ${{ github.triggering_actor }}
+          GH_NAME: ${{ github.repository_owner }}
\ No newline at end of file
diff --git a/docs/Home.md b/docs/Home.md
new file mode 100644
index 0000000..bea7634
--- /dev/null
+++ b/docs/Home.md
@@ -0,0 +1,2 @@
+# HollowCube Common
+