diff --git a/build.gradle b/build.gradle
index 2506f18..66cdd45 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,5 +1,5 @@
 plugins {
-    id "fabric-loom" version "1.11.+"
+    id "fabric-loom" version "1.14-SNAPSHOT"
 }
 
 version = project.mod_version
@@ -20,7 +20,7 @@ repositories {
 dependencies {
     //to change the versions see the gradle.properties file
     minecraft("com.mojang:minecraft:${project.minecraft_version}")
-    mappings("net.fabricmc:yarn:${project.yarn_mappings}:v2")
+    mappings(loom.officialMojangMappings())
     modImplementation("net.fabricmc:fabric-loader:${project.loader_version}")
 
     modImplementation("net.fabricmc.fabric-api:fabric-api:${project.fabric_version}")
diff --git a/gradle.properties b/gradle.properties
index 4b8140e..9003c93 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,17 +1,19 @@
 # Done to increase the memory available to gradle.
 org.gradle.jvmargs=-Xmx1G
+
 # Fabric Properties
 # check these on https://modmuss50.me/fabric.html
-minecraft_version=1.21.9
-yarn_mappings=1.21.9+build.1
-loader_version=0.17.2
+minecraft_version=1.21.11
+loader_version=0.18.2
+
 # Mod Properties
-mod_version=1.2.0
+mod_version=1.2.1
 maven_group=us.potatoboy
 archives_base_name=htm
+
 # Dependencies
 # check this on https://modmuss50.me/fabric.html
-fabric_version=0.133.14+1.21.9
+fabric_version=0.139.4+1.21.11
 translation_version=2.5.2+1.21.9-pre3
-permissions_api_version=0.4.1
+permissions_api_version=0.6.1
 protection_api_version=1.0.0
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 2e11132..23449a2 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.1.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/src/main/java/com/github/fabricservertools/htm/HTM.java b/src/main/java/com/github/fabricservertools/htm/HTM.java
index d412013..d29b4cc 100644
--- a/src/main/java/com/github/fabricservertools/htm/HTM.java
+++ b/src/main/java/com/github/fabricservertools/htm/HTM.java
@@ -1,17 +1,18 @@
 package com.github.fabricservertools.htm;
 
+import com.github.fabricservertools.htm.api.Lock;
 import com.github.fabricservertools.htm.command.HTMCommand;
 import com.github.fabricservertools.htm.command.subcommands.*;
 import com.github.fabricservertools.htm.config.HTMConfig;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
 import com.github.fabricservertools.htm.listeners.PlayerEventListener;
-import com.github.fabricservertools.htm.listeners.WorldEventListener;
+import com.github.fabricservertools.htm.listeners.LevelEventListener;
 import com.mojang.brigadier.CommandDispatcher;
 import eu.pb4.common.protection.api.CommonProtection;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.util.Identifier;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.resources.Identifier;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -20,25 +21,28 @@ public class HTM implements ModInitializer {
 
 	@Override
 	public void onInitialize() {
+        // For some reason, the Lock class has to be loaded before the HTMConfig class for the codecs to be initialised properly
+        // Calling a method of the class loads it. Removing the line below results in an NPE when launching Minecraft
+        Lock.bootstrap();
         HTMConfig.load();
 
 		CommandRegistrationCallback.EVENT.register(((dispatcher, environment, registryAccess) -> registerCommands(dispatcher)));
-		CommonProtection.register(Identifier.of("htm", "containers"), new InteractionManager());
+		CommonProtection.register(Identifier.fromNamespaceAndPath("htm", "containers"), new InteractionManager());
 
 		PlayerEventListener.init();
-		WorldEventListener.init();
+		LevelEventListener.init();
 	}
 
-	private void registerCommands(CommandDispatcher<ServerCommandSource> dispatcher) {
-		HTMCommand.register(dispatcher);
-		HTMCommand.registerSubCommand(new SetCommand().build());
-		HTMCommand.registerSubCommand(new RemoveCommand().build());
-		HTMCommand.registerSubCommand(new TrustCommand().build());
-		HTMCommand.registerSubCommand(new UntrustCommand().build());
-		HTMCommand.registerSubCommand(new InfoCommand().build());
-		HTMCommand.registerSubCommand(new TransferCommand().build());
-		HTMCommand.registerSubCommand(new FlagCommand().build());
-		HTMCommand.registerSubCommand(new PersistCommand().build());
-		HTMCommand.registerSubCommand(new QuietCommand().build());
-	}
+	private void registerCommands(CommandDispatcher<CommandSourceStack> dispatcher) {
+		HTMCommand.registerSubCommand(new SetCommand());
+        HTMCommand.registerSubCommand(new RemoveCommand());
+        HTMCommand.registerSubCommand(new TrustCommand());
+        HTMCommand.registerSubCommand(new UntrustCommand());
+        HTMCommand.registerSubCommand(new InfoCommand());
+        HTMCommand.registerSubCommand(new TransferCommand());
+        HTMCommand.registerSubCommand(new FlagCommand());
+        HTMCommand.registerSubCommand(new PersistCommand());
+        HTMCommand.registerSubCommand(new QuietCommand());
+        HTMCommand.register(dispatcher);
+    }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/HTMComponents.java b/src/main/java/com/github/fabricservertools/htm/HTMComponents.java
new file mode 100644
index 0000000..5eb6711
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/HTMComponents.java
@@ -0,0 +1,87 @@
+package com.github.fabricservertools.htm;
+
+import java.util.function.UnaryOperator;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.CommonComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
+import net.minecraft.network.chat.Style;
+
+public final class HTMComponents {
+    private static final String PREFIX = "text.htm.";
+
+    public static final Component NOT_LOCKABLE = error("error.unlockable");
+    public static final Component NOT_LOCKED = error("error.no_lock");
+    public static final Component NOT_OWNER = error("error.not_owner");
+    public static final Component ALREADY_LOCKED = error("error.already_locked");
+    public static final Component INVALID_LOCK_TYPE = error("error.lock_type");
+    public static final Component INVALID_FLAG_TYPE = error("error.flag_type");
+    public static final Component CANNOT_TRUST_SELF = error("error.trust_self");
+    public static final TranslatableComponentBuilder ALREADY_TRUSTED = errorBuilder("error.already_trusted");
+    public static final TranslatableComponentBuilder PLAYER_NOT_TRUSTED = errorBuilder("error.not_trusted");
+    public static final Component CONTAINER_LOCKED = error("locked");
+    public static final Component OVERRIDING = error("overriding");
+
+    public static final Component CLICK_TO_SELECT = info("select");
+    public static final Component DIVIDER = info("divider");
+    public static final TranslatableComponentBuilder CONTAINER_LOCK_TYPE = infoBuilder("type");
+    public static final TranslatableComponentBuilder CONTAINER_OWNER = infoBuilder("owner");
+    public static final TranslatableComponentBuilder CONTAINER_TRUSTED = infoBuilder("trusted");
+    public static final TranslatableComponentBuilder TRUSTED_GLOBALLY = infoBuilder("trusted.global");
+    public static final TranslatableComponentBuilder TRUST = infoBuilder("trust");
+    public static final TranslatableComponentBuilder UNTRUST = infoBuilder("untrust");
+    public static final Component GLOBAL = info("global").withStyle(ChatFormatting.BOLD);
+    public static final TranslatableComponentBuilder CONTAINER_TRANSFER = infoBuilder("transfer");
+    public static final Component CONTAINER_UNLOCKED = info("unlocked");
+    public static final TranslatableComponentBuilder CONTAINER_KEY = infoBuilder("key");
+    public static final TranslatableComponentBuilder CONTAINER_SET = infoBuilder("set");
+    public static final TranslatableComponentBuilder CONTAINER_KEY_SET = infoBuilder("key_set");
+    public static final TranslatableComponentBuilder CONTAINER_OVERRIDE = infoBuilder("override").andThen(text -> text.append(CommonComponents.space()).append(OVERRIDING));
+    public static final TranslatableComponentBuilder CONTAINER_FLAG_SET = infoBuilder("set_flag");
+    public static final TranslatableComponentBuilder CONTAINER_FLAG_RESET = infoBuilder("reset_flag");
+    public static final TranslatableComponentBuilder CONTAINER_FLAG = infoBuilder("flag");
+    public static final Component ON = translatable("on")
+            .withStyle(ChatFormatting.GREEN, ChatFormatting.BOLD);
+    public static final Component OFF = translatable("off")
+            .withStyle(ChatFormatting.RED, ChatFormatting.BOLD);
+    public static final Component TOGGLE_PERSIST_ON = info("persist").append(CommonComponents.SPACE).append(ON);
+    public static final Component TOGGLE_PERSIST_OFF = info("persist").append(CommonComponents.SPACE).append(OFF);
+    public static final Component TOGGLE_NO_MSG_ON = info("no_msg").append(CommonComponents.SPACE).append(ON);
+    public static final Component TOGGLE_NO_MSG_OFF = info("no_msg").append(CommonComponents.SPACE).append(OFF);
+
+    private static MutableComponent error(String key) {
+        return errorBuilder(key).apply();
+    }
+
+    private static TranslatableComponentBuilder errorBuilder(String key) {
+        return builder(key, style -> style.withColor(ChatFormatting.RED));
+    }
+    
+    private static MutableComponent info(String key) {
+        return infoBuilder(key).apply();
+    }
+
+    private static TranslatableComponentBuilder infoBuilder(String key) {
+        return builder(key, style -> style.withColor(ChatFormatting.AQUA));
+    }
+
+    private static TranslatableComponentBuilder builder(String key, UnaryOperator<Style> style) {
+        return args -> translatable(key, args).withStyle(style);
+    }
+
+    private static MutableComponent translatable(String translation, Object... args) {
+        return Component.translatable(PREFIX + translation, args);
+    }
+
+    @FunctionalInterface
+    public interface TranslatableComponentBuilder {
+
+        MutableComponent apply(Object... arg);
+
+        default TranslatableComponentBuilder andThen(UnaryOperator<MutableComponent> operator) {
+            return args -> operator.apply(apply(args));
+        }
+    }
+
+    private HTMComponents() {}
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/HTMTexts.java b/src/main/java/com/github/fabricservertools/htm/HTMTexts.java
deleted file mode 100644
index cd724fe..0000000
--- a/src/main/java/com/github/fabricservertools/htm/HTMTexts.java
+++ /dev/null
@@ -1,88 +0,0 @@
-package com.github.fabricservertools.htm;
-
-import net.minecraft.screen.ScreenTexts;
-import net.minecraft.text.MutableText;
-import net.minecraft.text.Style;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-
-import java.util.function.UnaryOperator;
-
-public final class HTMTexts {
-    private static final String PREFIX = "text.htm.";
-
-    public static final Text NOT_LOCKABLE = error("error.unlockable");
-    public static final Text NOT_LOCKED = error("error.no_lock");
-    public static final Text NOT_OWNER = error("error.not_owner");
-    public static final Text ALREADY_LOCKED = error("error.already_locked");
-    public static final Text INVALID_LOCK_TYPE = error("error.lock_type");
-    public static final Text INVALID_FLAG_TYPE = error("error.flag_type");
-    public static final Text CANNOT_TRUST_SELF = error("error.trust_self");
-    public static final TranslatableTextBuilder ALREADY_TRUSTED = errorBuilder("error.already_trusted");
-    public static final TranslatableTextBuilder PLAYER_NOT_TRUSTED = errorBuilder("error.not_trusted");
-    public static final Text CONTAINER_LOCKED = error("locked");
-    public static final Text OVERRIDING = error("overriding");
-
-    public static final Text CLICK_TO_SELECT = info("select");
-    public static final Text DIVIDER = info("divider");
-    public static final TranslatableTextBuilder CONTAINER_LOCK_TYPE = infoBuilder("type");
-    public static final TranslatableTextBuilder CONTAINER_OWNER = infoBuilder("owner");
-    public static final TranslatableTextBuilder CONTAINER_TRUSTED = infoBuilder("trusted");
-    public static final TranslatableTextBuilder TRUSTED_GLOBALLY = infoBuilder("trusted.global");
-    public static final TranslatableTextBuilder TRUST = infoBuilder("trust");
-    public static final TranslatableTextBuilder UNTRUST = infoBuilder("untrust");
-    public static final Text GLOBAL = info("global").formatted(Formatting.BOLD);
-    public static final TranslatableTextBuilder CONTAINER_TRANSFER = infoBuilder("transfer");
-    public static final Text CONTAINER_UNLOCKED = info("unlocked");
-    public static final TranslatableTextBuilder CONTAINER_KEY = infoBuilder("key");
-    public static final TranslatableTextBuilder CONTAINER_SET = infoBuilder("set");
-    public static final TranslatableTextBuilder CONTAINER_KEY_SET = infoBuilder("key_set");
-    public static final TranslatableTextBuilder CONTAINER_OVERRIDE = infoBuilder("override").andThen(text -> text.append(ScreenTexts.space()).append(OVERRIDING));
-    public static final TranslatableTextBuilder CONTAINER_FLAG_SET = infoBuilder("set_flag");
-    public static final TranslatableTextBuilder CONTAINER_FLAG_RESET = infoBuilder("reset_flag");
-    public static final TranslatableTextBuilder CONTAINER_FLAG = infoBuilder("flag");
-    public static final Text ON = translatable("on")
-            .formatted(Formatting.GREEN, Formatting.BOLD);
-    public static final Text OFF = translatable("off")
-            .formatted(Formatting.RED, Formatting.BOLD);
-    public static final Text TOGGLE_PERSIST_ON = info("persist").append(ScreenTexts.SPACE).append(ON);
-    public static final Text TOGGLE_PERSIST_OFF = info("persist").append(ScreenTexts.SPACE).append(OFF);
-    public static final Text TOGGLE_NO_MSG_ON = info("no_msg").append(ScreenTexts.SPACE).append(ON);
-    public static final Text TOGGLE_NO_MSG_OFF = info("no_msg").append(ScreenTexts.SPACE).append(OFF);
-
-    private static MutableText error(String key) {
-        return errorBuilder(key).apply();
-    }
-
-    private static TranslatableTextBuilder errorBuilder(String key) {
-        return builder(key, style -> style.withColor(Formatting.RED));
-    }
-    
-    private static MutableText info(String key) {
-        return infoBuilder(key).apply();
-    }
-
-    private static TranslatableTextBuilder infoBuilder(String key) {
-        return builder(key, style -> style.withColor(Formatting.AQUA));
-    }
-
-    private static TranslatableTextBuilder builder(String key, UnaryOperator<Style> style) {
-        return args -> translatable(key, args).styled(style);
-    }
-
-    private static MutableText translatable(String translation, Object... args) {
-        return Text.translatable(PREFIX + translation, args);
-    }
-
-    @FunctionalInterface
-    public interface TranslatableTextBuilder {
-
-        MutableText apply(Object... arg);
-
-        default TranslatableTextBuilder andThen(UnaryOperator<MutableText> operator) {
-            return args -> operator.apply(apply(args));
-        }
-    }
-
-    private HTMTexts() {}
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/Utility.java b/src/main/java/com/github/fabricservertools/htm/Utility.java
index b7c5b12..09b1ea4 100644
--- a/src/main/java/com/github/fabricservertools/htm/Utility.java
+++ b/src/main/java/com/github/fabricservertools/htm/Utility.java
@@ -1,38 +1,37 @@
 package com.github.fabricservertools.htm;
 
 import com.github.fabricservertools.htm.interactions.InteractionManager;
-import com.github.fabricservertools.htm.world.data.GlobalTrustState;
-import net.minecraft.entity.player.PlayerEntity;
+import com.github.fabricservertools.htm.world.data.GlobalTrustData;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.PlayerConfigEntry;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-
+import net.minecraft.server.players.NameAndId;
+import net.minecraft.world.entity.player.Player;
 import java.util.UUID;
 
 public class Utility {
 
     public static String getNameFromUUID(UUID uuid, MinecraftServer server) {
-        return server.getApiServices().nameToIdCache().getByUuid(uuid)
-                .map(PlayerConfigEntry::name)
+        return server.services().nameToIdCache().get(uuid)
+                .map(NameAndId::name)
                 .orElse("unknown");
     }
 
-	public static Text getFormattedNameFromUUID(UUID uuid, MinecraftServer server) {
-        return Text.literal(getNameFromUUID(uuid, server)).formatted(Formatting.WHITE);
+	public static Component getFormattedNameFromUUID(UUID uuid, MinecraftServer server) {
+        return Component.literal(getNameFromUUID(uuid, server)).withStyle(ChatFormatting.WHITE);
 	}
 
-	public static GlobalTrustState getGlobalTrustState(MinecraftServer server) {
-		return server.getOverworld().getPersistentStateManager().getOrCreate(GlobalTrustState.TYPE);
+	public static GlobalTrustData getGlobalTrustData(MinecraftServer server) {
+		return server.overworld().getDataStorage().computeIfAbsent(GlobalTrustData.TYPE);
 	}
 
-	public static void sendMessage(PlayerEntity player, Text message) {
+	public static void sendMessage(Player player, Component message) {
 		sendMessage(player, message, false);
 	}
 
-	public static void sendMessage(PlayerEntity player, Text message, boolean actionBar) {
-		if (!InteractionManager.noMessage.contains(player.getUuid())) {
-			player.sendMessage(message, actionBar);
+	public static void sendMessage(Player player, Component message, boolean actionBar) {
+		if (!InteractionManager.noMessage.contains(player.getUUID())) {
+			player.displayClientMessage(message, actionBar);
 		}
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/api/FlagType.java b/src/main/java/com/github/fabricservertools/htm/api/FlagType.java
index 0a9c040..67e728e 100644
--- a/src/main/java/com/github/fabricservertools/htm/api/FlagType.java
+++ b/src/main/java/com/github/fabricservertools/htm/api/FlagType.java
@@ -1,15 +1,16 @@
 package com.github.fabricservertools.htm.api;
 
 import com.mojang.serialization.Codec;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-import net.minecraft.util.StringIdentifiable;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.StringRepresentable;
+import org.jspecify.annotations.Nullable;
 
-public enum FlagType implements StringIdentifiable {
+public enum FlagType implements StringRepresentable {
     HOPPERS("hoppers", true),
     COPPER_GOLEMS("copper_golems", true);
 
-    public static final Codec<FlagType> CODEC = StringIdentifiable.createCodec(FlagType::values);
+    public static final Codec<FlagType> CODEC = StringRepresentable.fromEnum(FlagType::values);
 
     private final String id;
     private final boolean defaultValue;
@@ -20,7 +21,7 @@ public enum FlagType implements StringIdentifiable {
     }
 
     @Override
-    public String asString() {
+    public String getSerializedName() {
         return id;
     }
 
@@ -28,11 +29,11 @@ public boolean defaultValue() {
         return defaultValue;
     }
 
-    public Text displayName() {
-        return Text.literal(id.toUpperCase()).formatted(Formatting.WHITE);
+    public Component displayName() {
+        return Component.literal(id.toUpperCase()).withStyle(ChatFormatting.WHITE);
     }
 
-    public static FlagType fromString(String flag) {
+    public static @Nullable FlagType fromString(String flag) {
         for (FlagType type : values()) {
             if (type.id.equals(flag.toLowerCase())) {
                 return type;
diff --git a/src/main/java/com/github/fabricservertools/htm/api/Lock.java b/src/main/java/com/github/fabricservertools/htm/api/Lock.java
index 92e1eee..9fac8ff 100644
--- a/src/main/java/com/github/fabricservertools/htm/api/Lock.java
+++ b/src/main/java/com/github/fabricservertools/htm/api/Lock.java
@@ -6,40 +6,44 @@
 import com.github.fabricservertools.htm.lock.type.PublicLock;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.MapCodec;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-import net.minecraft.util.StringIdentifiable;
-
 import java.util.Locale;
 import java.util.function.Function;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.StringRepresentable;
+import org.jspecify.annotations.Nullable;
 
 public interface Lock {
     // A codec that dispatches a lock type (Type) from the "Type" key, and then uses the lock type's codec to create a map codec that has a "TypeData" key as field
     MapCodec<Lock> CODEC = Type.CODEC.dispatchMap("Type", Lock::type, type -> type.codec.fieldOf("TypeData"));
 
-	boolean canOpen(ServerPlayerEntity player, HTMContainerLock lock);
+	boolean canOpen(ServerPlayer player, HTMContainerLock lock);
 
-	default void onInfo(ServerPlayerEntity player, HTMContainerLock lock) {}
+	default void onInfo(ServerPlayer player, HTMContainerLock lock) {}
 
-    default Text displayName() {
+    default Component displayName() {
         return type().displayName();
     }
 
 	Type type();
 
-    enum Type implements StringIdentifiable {
+    static void bootstrap() {
+        // noop
+    }
+
+    enum Type implements StringRepresentable {
         PRIVATE("private", PrivateLock.CODEC, PrivateLock.INSTANCE),
         PUBLIC("public", PublicLock.CODEC, PublicLock.INSTANCE),
         KEY("key", KeyLock.CODEC, KeyLock::fromMainHandItem);
 
-        public static final Codec<Type> CODEC = StringIdentifiable.createCodec(Type::values);
+        public static final Codec<Type> CODEC = StringRepresentable.fromEnum(Type::values);
 
         private final String name;
         private final Codec<? extends Lock> codec;
-        private final Function<ServerPlayerEntity, ? extends Lock> factory;
+        private final Function<ServerPlayer, ? extends Lock> factory;
 
-        Type(String name, Codec<? extends Lock> codec, Function<ServerPlayerEntity, Lock> factory) {
+        Type(String name, Codec<? extends Lock> codec, Function<ServerPlayer, Lock> factory) {
             this.name = name;
             this.codec = codec;
             this.factory = factory;
@@ -49,19 +53,19 @@ enum Type implements StringIdentifiable {
             this(name, codec, player -> instance);
         }
 
-        public Text displayName() {
-            return Text.literal(uiName()).formatted(Formatting.WHITE);
+        public Component displayName() {
+            return Component.literal(uiName()).withStyle(ChatFormatting.WHITE);
         }
 
         public String uiName() {
             return name.toUpperCase(Locale.ROOT);
         }
 
-        public Lock create(ServerPlayerEntity player) {
+        public Lock create(ServerPlayer player) {
             return factory.apply(player);
         }
 
-        public static Type fromUiName(String name) {
+        public static @Nullable Type fromUiName(String name) {
             String lowercase = name.toLowerCase(Locale.ROOT);
             for (Type type : values()) {
                 if (type.name.equals(lowercase)) {
@@ -72,7 +76,7 @@ public static Type fromUiName(String name) {
         }
 
         @Override
-        public String asString() {
+        public String getSerializedName() {
             return name;
         }
     }
diff --git a/src/main/java/com/github/fabricservertools/htm/api/LockInteraction.java b/src/main/java/com/github/fabricservertools/htm/api/LockInteraction.java
index 1234d55..de34055 100644
--- a/src/main/java/com/github/fabricservertools/htm/api/LockInteraction.java
+++ b/src/main/java/com/github/fabricservertools/htm/api/LockInteraction.java
@@ -1,13 +1,13 @@
 package com.github.fabricservertools.htm.api;
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
+import net.minecraft.core.BlockPos;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
 
 public interface LockInteraction {
 
-	void execute(MinecraftServer server, ServerPlayerEntity player, BlockPos pos, LockableObject object, HTMContainerLock lock);
+	void execute(MinecraftServer server, ServerPlayer player, BlockPos pos, LockableObject object, HTMContainerLock lock);
 
 	default boolean requiresLock() {
 		return true;
diff --git a/src/main/java/com/github/fabricservertools/htm/api/LockableObject.java b/src/main/java/com/github/fabricservertools/htm/api/LockableObject.java
index dc98929..7ff8eb2 100644
--- a/src/main/java/com/github/fabricservertools/htm/api/LockableObject.java
+++ b/src/main/java/com/github/fabricservertools/htm/api/LockableObject.java
@@ -2,26 +2,26 @@
 
 import com.github.fabricservertools.htm.HTM;
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.storage.ReadView;
-import net.minecraft.storage.WriteView;
-
 import java.util.Optional;
 import java.util.function.Consumer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.storage.ValueInput;
+import net.minecraft.world.level.storage.ValueOutput;
+import org.jspecify.annotations.Nullable;
 
 public interface LockableObject {
 
-	default void writeLock(WriteView view) {
-		getLock().ifPresent(lock -> view.put("container_lock", HTMContainerLock.CODEC, lock));
+	default void writeLock(ValueOutput output) {
+		getLock().ifPresent(lock -> output.store("container_lock", HTMContainerLock.CODEC, lock));
 	}
 
-	default void readLock(ReadView view, Consumer<HTMContainerLock> consumer) {
-		view.getOptionalString("Type").ifPresentOrElse(
+	default void readLock(ValueInput input, Consumer<@Nullable HTMContainerLock> consumer) {
+		input.getString("Type").ifPresentOrElse(
 				legacy -> {
 					// Legacy, lock data was stored in the root NBT object before 1.21.5
 					// Even Mojang thinks this shouldn't be done anymore and marked the method as deprecated, will probably end up removing this functionality
 					// once this method is removed too
-					view.read(HTMContainerLock.MAP_CODEC).ifPresentOrElse(
+					input.read(HTMContainerLock.MAP_CODEC).ifPresentOrElse(
 							consumer,
 							() -> {
 								HTM.LOGGER.warn("Failed to read legacy container lock data!"); // Can't really do much here
@@ -29,19 +29,19 @@ default void readLock(ReadView view, Consumer<HTMContainerLock> consumer) {
 							}
 					);
 				},
-				() -> view.read("container_lock", HTMContainerLock.CODEC).ifPresentOrElse(consumer, () -> consumer.accept(null))
+				() -> input.read("container_lock", HTMContainerLock.CODEC).ifPresentOrElse(consumer, () -> consumer.accept(null))
 		);
 	}
 
-	default boolean canOpenUnchecked(ServerPlayerEntity player) {
+	default boolean canOpenUnchecked(ServerPlayer player) {
 		return canOpen(player).orElse(true);
 	}
 
-	default Optional<Boolean> canOpen(ServerPlayerEntity player) {
+	default Optional<Boolean> canOpen(ServerPlayer player) {
 		return getLock().map(lock -> lock.canOpen(player));
 	}
 
 	Optional<HTMContainerLock> getLock();
 
-	void setLock(HTMContainerLock lock);
+	void setLock(@Nullable HTMContainerLock lock);
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/api/package-info.java b/src/main/java/com/github/fabricservertools/htm/api/package-info.java
new file mode 100644
index 0000000..cf398ae
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/api/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.api;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/command/HTMCommand.java b/src/main/java/com/github/fabricservertools/htm/command/HTMCommand.java
index 0016526..2bd16c4 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/HTMCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/HTMCommand.java
@@ -1,26 +1,32 @@
 package com.github.fabricservertools.htm.command;
 
 import com.mojang.brigadier.CommandDispatcher;
-import com.mojang.brigadier.tree.LiteralCommandNode;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.commands.CommandSourceStack;
 
-import static net.minecraft.server.command.CommandManager.literal;
+import java.util.ArrayList;
+import java.util.List;
+
+import static net.minecraft.commands.Commands.literal;
 
 public class HTMCommand {
-	private static LiteralCommandNode<ServerCommandSource> rootNode;
+    private static final List<SubCommand> SUB_COMMANDS = new ArrayList<>();
+    private static boolean registeredCommand = false;
 
-	public static void register(CommandDispatcher<ServerCommandSource> dispatcher) {
-		LiteralCommandNode<ServerCommandSource> htmNode =
-				literal("htm")
-						.requires(Permissions.require("htm.command.root", true))
-						.build();
+	public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {
+		LiteralArgumentBuilder<CommandSourceStack> htmNode = literal("htm")
+                .requires(Permissions.require("htm.command.root", true));
+        SUB_COMMANDS.forEach(command -> command.register(htmNode));
+        dispatcher.register(htmNode);
 
-		dispatcher.getRoot().addChild(htmNode);
-		rootNode = htmNode;
+        registeredCommand = true;
 	}
 
-	public static void registerSubCommand(LiteralCommandNode<ServerCommandSource> subCommand) {
-		rootNode.addChild(subCommand);
+	public static void registerSubCommand(SubCommand subCommand) {
+        if (registeredCommand) {
+            throw new IllegalStateException("Tried to register a sub-command after /htm was registered!");
+        }
+        SUB_COMMANDS.add(subCommand);
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/SubCommand.java b/src/main/java/com/github/fabricservertools/htm/command/SubCommand.java
index 8777345..fe25543 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/SubCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/SubCommand.java
@@ -1,8 +1,10 @@
 package com.github.fabricservertools.htm.command;
 
-import com.mojang.brigadier.tree.LiteralCommandNode;
-import net.minecraft.server.command.ServerCommandSource;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import net.minecraft.commands.CommandSourceStack;
 
+@FunctionalInterface
 public interface SubCommand {
-	LiteralCommandNode<ServerCommandSource> build();
+
+    void register(LiteralArgumentBuilder<CommandSourceStack> root);
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/package-info.java b/src/main/java/com/github/fabricservertools/htm/command/package-info.java
new file mode 100644
index 0000000..101b67d
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/command/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.command;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/FlagCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/FlagCommand.java
index 03fdaae..4d4e276 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/FlagCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/FlagCommand.java
@@ -1,62 +1,61 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.api.FlagType;
 import com.github.fabricservertools.htm.command.SubCommand;
-import com.github.fabricservertools.htm.command.suggestors.FlagTypeSuggestionProvider;
+import com.github.fabricservertools.htm.command.suggestion.FlagTypeSuggestionProvider;
 import com.github.fabricservertools.htm.interactions.FlagAction;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
 import com.mojang.brigadier.arguments.BoolArgumentType;
 import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
-import com.mojang.brigadier.tree.LiteralCommandNode;
+import com.mojang.datafixers.util.Pair;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.Pair;
-
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.server.level.ServerPlayer;
 import java.util.Optional;
 
-import static net.minecraft.server.command.CommandManager.argument;
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.argument;
+import static net.minecraft.commands.Commands.literal;
 
 public class FlagCommand implements SubCommand {
 
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("flag")
-				.requires(Permissions.require("htm.command.flag", true))
-				.executes(this::flagInfo)
-				.then(argument("type", StringArgumentType.word())
-						.suggests(new FlagTypeSuggestionProvider())
-						.then(argument("value", BoolArgumentType.bool())
-								.executes(context -> flag(context, false)))
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("flag")
+                .requires(Permissions.require("htm.command.flag", true))
+                .executes(this::flagInfo)
+                .then(argument("type", StringArgumentType.word())
+                        .suggests(new FlagTypeSuggestionProvider())
+                        .then(argument("value", BoolArgumentType.bool())
+                                .executes(context -> flag(context, false)))
                         .executes(context -> flag(context, true)))
-				.build();
-	}
+        );
+    }
 
-	private int flagInfo(CommandContext<ServerCommandSource> context) {
-		ServerPlayerEntity player = context.getSource().getPlayer();
+    private int flagInfo(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+		ServerPlayer player = context.getSource().getPlayerOrException();
 
 		InteractionManager.pendingActions.put(player, new FlagAction(Optional.empty()));
-		context.getSource().sendFeedback(() -> HTMTexts.CLICK_TO_SELECT, false);
+		context.getSource().sendSuccess(() -> HTMComponents.CLICK_TO_SELECT, false);
 
-		return 1;
+		return 0;
 	}
 
-	private int flag(CommandContext<ServerCommandSource> context, boolean unset) throws CommandSyntaxException {
-		ServerPlayerEntity player = context.getSource().getPlayer();
+	private int flag(CommandContext<CommandSourceStack> context, boolean unset) throws CommandSyntaxException {
+		ServerPlayer player = context.getSource().getPlayerOrException();
 		FlagType type = FlagType.fromString(StringArgumentType.getString(context, "type"));
 		Boolean value = unset ? null : BoolArgumentType.getBool(context, "value");
 
 		if (type == null) {
-			throw new SimpleCommandExceptionType(HTMTexts.INVALID_FLAG_TYPE).create();
+			throw new SimpleCommandExceptionType(HTMComponents.INVALID_FLAG_TYPE).create();
 		}
 
 		InteractionManager.pendingActions.put(player, new FlagAction(Optional.of(new Pair<>(type, value))));
-		context.getSource().sendFeedback(() -> HTMTexts.CLICK_TO_SELECT, false);
+		context.getSource().sendSuccess(() -> HTMComponents.CLICK_TO_SELECT, false);
 		return 1;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/InfoCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/InfoCommand.java
index 41f3efe..e11bd16 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/InfoCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/InfoCommand.java
@@ -1,33 +1,33 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.command.SubCommand;
 import com.github.fabricservertools.htm.interactions.InfoAction;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.brigadier.tree.LiteralCommandNode;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.server.level.ServerPlayer;
 
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.literal;
 
 public class InfoCommand implements SubCommand {
 
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("info")
-				.requires(Permissions.require("htm.command.info", true))
-				.executes(this::info)
-				.build();
-	}
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("info")
+                .requires(Permissions.require("htm.command.info", true))
+                .executes(this::info)
+        );
+    }
 
-	private int info(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
-		ServerPlayerEntity player = context.getSource().getPlayer();
+    private int info(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+		ServerPlayer player = context.getSource().getPlayerOrException();
 
 		InteractionManager.pendingActions.put(player, new InfoAction());
-		context.getSource().sendFeedback(() -> HTMTexts.CLICK_TO_SELECT, false);
+		context.getSource().sendSuccess(() -> HTMComponents.CLICK_TO_SELECT, false);
 		return 1;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/PersistCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/PersistCommand.java
index bcc624b..a2f92a2 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/PersistCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/PersistCommand.java
@@ -1,36 +1,37 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.command.SubCommand;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.brigadier.tree.LiteralCommandNode;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.server.level.ServerPlayer;
 
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.literal;
 
 public class PersistCommand implements SubCommand {
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("persist")
-				.requires(Permissions.require("htm.command.persist", true))
-				.executes(this::persist)
-				.build();
-	}
 
-	@SuppressWarnings("SameReturnValue")
-	private int persist(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
-		ServerPlayerEntity player = context.getSource().getPlayerOrThrow();
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("persist")
+                .requires(Permissions.require("htm.command.persist", true))
+                .executes(this::persist)
+        );
+    }
+
+    private int persist(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+		ServerPlayer player = context.getSource().getPlayerOrException();
 
 		InteractionManager.togglePersist(player);
-		if (InteractionManager.persisting.contains(player.getUuid())) {
-			context.getSource().sendFeedback(() -> HTMTexts.TOGGLE_PERSIST_ON, false);
+		if (InteractionManager.persisting.contains(player.getUUID())) {
+			context.getSource().sendSuccess(() -> HTMComponents.TOGGLE_PERSIST_ON, false);
+            return 1;
 		} else {
-			context.getSource().sendFeedback(() -> HTMTexts.TOGGLE_PERSIST_OFF, false);
+			context.getSource().sendSuccess(() -> HTMComponents.TOGGLE_PERSIST_OFF, false);
+            return 0;
 		}
-		return 1;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/QuietCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/QuietCommand.java
index 814ee24..01fb004 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/QuietCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/QuietCommand.java
@@ -1,35 +1,37 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.command.SubCommand;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.brigadier.tree.LiteralCommandNode;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.server.level.ServerPlayer;
 
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.literal;
 
 public class QuietCommand implements SubCommand {
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("quiet")
-				.requires(Permissions.require("htm.command.quiet", true))
-				.executes(this::quiet)
-				.build();
-	}
 
-	private int quiet(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
-		ServerPlayerEntity player = context.getSource().getPlayer();
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("quiet")
+                .requires(Permissions.require("htm.command.quiet", true))
+                .executes(this::quiet)
+        );
+    }
+
+    private int quiet(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+		ServerPlayer player = context.getSource().getPlayerOrException();
 
 		InteractionManager.toggleNoMessage(player);
-		if (InteractionManager.noMessage.contains(player.getUuid())) {
-			context.getSource().sendFeedback(() -> HTMTexts.TOGGLE_NO_MSG_ON, false);
+		if (InteractionManager.noMessage.contains(player.getUUID())) {
+			context.getSource().sendSuccess(() -> HTMComponents.TOGGLE_NO_MSG_ON, false);
+            return 1;
 		} else {
-			context.getSource().sendFeedback(() -> HTMTexts.TOGGLE_NO_MSG_OFF, false);
+			context.getSource().sendSuccess(() -> HTMComponents.TOGGLE_NO_MSG_OFF, false);
+            return 0;
 		}
-		return 1;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/RemoveCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/RemoveCommand.java
index 3479fc4..139fb3c 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/RemoveCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/RemoveCommand.java
@@ -1,33 +1,34 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.command.SubCommand;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
 import com.github.fabricservertools.htm.interactions.RemoveAction;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.brigadier.tree.LiteralCommandNode;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.server.level.ServerPlayer;
 
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.literal;
 
 public class RemoveCommand implements SubCommand {
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("remove")
-				.requires(Permissions.require("htm.command.remove", true))
-				.executes(this::remove)
-				.build();
-	}
 
-	@SuppressWarnings("SameReturnValue")
-	private int remove(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
-		ServerPlayerEntity player = context.getSource().getPlayer();
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("remove")
+                .requires(Permissions.require("htm.command.remove", true))
+                .executes(this::remove)
+        );
+    }
+
+    @SuppressWarnings("SameReturnValue")
+	private int remove(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+		ServerPlayer player = context.getSource().getPlayerOrException();
 
 		InteractionManager.pendingActions.put(player, new RemoveAction());
-		context.getSource().sendFeedback(() -> HTMTexts.CLICK_TO_SELECT, false);
-		return 1;
+		context.getSource().sendSuccess(() -> HTMComponents.CLICK_TO_SELECT, false);
+		return 0;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/SetCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/SetCommand.java
index a5e1651..31ab2f7 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/SetCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/SetCommand.java
@@ -1,43 +1,45 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.api.Lock;
 import com.github.fabricservertools.htm.command.SubCommand;
-import com.github.fabricservertools.htm.command.suggestors.LockTypeSuggestionProvider;
+import com.github.fabricservertools.htm.command.suggestion.LockTypeSuggestionProvider;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
 import com.github.fabricservertools.htm.interactions.SetAction;
 import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
-import com.mojang.brigadier.tree.LiteralCommandNode;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.server.level.ServerPlayer;
 
-import static net.minecraft.server.command.CommandManager.argument;
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.argument;
+import static net.minecraft.commands.Commands.literal;
 
 public class SetCommand implements SubCommand {
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("set")
-				.requires(Permissions.require("htm.command.set", true))
-				.then(argument("type", StringArgumentType.word())
-						.suggests(new LockTypeSuggestionProvider())
-						.executes(this::set))
-				.build();
-	}
 
-	private int set(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("set")
+                .requires(Permissions.require("htm.command.set", true))
+                .then(argument("type", StringArgumentType.word())
+                        .suggests(new LockTypeSuggestionProvider())
+                        .executes(this::set)
+                )
+        );
+    }
+
+    private int set(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
 		Lock.Type type = Lock.Type.fromUiName(StringArgumentType.getString(context, "type"));
 		if (type == null) {
-			throw new SimpleCommandExceptionType(HTMTexts.INVALID_LOCK_TYPE).create();
+			throw new SimpleCommandExceptionType(HTMComponents.INVALID_LOCK_TYPE).create();
 		}
 
-        ServerPlayerEntity player = context.getSource().getPlayer();
+        ServerPlayer player = context.getSource().getPlayerOrException();
 		InteractionManager.pendingActions.put(player, new SetAction(type.create(player)));
-		context.getSource().sendFeedback(() -> HTMTexts.CLICK_TO_SELECT, false);
-		return 1;
+		context.getSource().sendSuccess(() -> HTMComponents.CLICK_TO_SELECT, false);
+		return 0;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/TransferCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/TransferCommand.java
index fb422f3..9952069 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/TransferCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/TransferCommand.java
@@ -1,46 +1,45 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.command.SubCommand;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
 import com.github.fabricservertools.htm.interactions.TransferAction;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.brigadier.tree.LiteralCommandNode;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.command.argument.EntityArgumentType;
-import net.minecraft.command.argument.GameProfileArgumentType;
-import net.minecraft.server.PlayerConfigEntry;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
-
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.arguments.EntityArgument;
+import net.minecraft.commands.arguments.GameProfileArgument;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.players.NameAndId;
 import java.util.Collection;
 
-import static net.minecraft.server.command.CommandManager.argument;
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.argument;
+import static net.minecraft.commands.Commands.literal;
 
 public class TransferCommand implements SubCommand {
 
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("transfer")
-				.requires(Permissions.require("htm.command.transfer", true))
-				.then(argument("target", GameProfileArgumentType.gameProfile())
-						.executes(this::transfer))
-				.build();
-	}
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("transfer")
+                .requires(Permissions.require("htm.command.transfer", true))
+                .then(argument("target", GameProfileArgument.gameProfile())
+                        .executes(this::transfer))
+        );
+    }
 
-	@SuppressWarnings("SameReturnValue")
-	private int transfer(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
-		ServerPlayerEntity player = context.getSource().getPlayer();
-        Collection<PlayerConfigEntry> targets = GameProfileArgumentType.getProfileArgument(context, "target");
+    @SuppressWarnings("SameReturnValue")
+	private int transfer(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+		ServerPlayer player = context.getSource().getPlayerOrException();
+        Collection<NameAndId> targets = GameProfileArgument.getGameProfiles(context, "target");
 
         if (targets.size() > 1) {
-            throw EntityArgumentType.TOO_MANY_PLAYERS_EXCEPTION.create();
+            throw EntityArgument.ERROR_NOT_SINGLE_PLAYER.create();
         }
 
 		InteractionManager.pendingActions.put(player, new TransferAction(targets.iterator().next()));
-		context.getSource().sendFeedback(() -> HTMTexts.CLICK_TO_SELECT, false);
-		return 1;
+		context.getSource().sendSuccess(() -> HTMComponents.CLICK_TO_SELECT, false);
+		return 0;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/TrustCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/TrustCommand.java
index 910e42d..9ec4373 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/TrustCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/TrustCommand.java
@@ -1,85 +1,84 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.Utility;
 import com.github.fabricservertools.htm.command.SubCommand;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
 import com.github.fabricservertools.htm.interactions.TrustAction;
-import com.github.fabricservertools.htm.world.data.GlobalTrustState;
+import com.github.fabricservertools.htm.world.data.GlobalTrustData;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.brigadier.tree.LiteralCommandNode;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.command.argument.GameProfileArgumentType;
-import net.minecraft.screen.ScreenTexts;
-import net.minecraft.server.PlayerConfigEntry;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-
+import net.minecraft.ChatFormatting;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.arguments.GameProfileArgument;
+import net.minecraft.network.chat.CommonComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.players.NameAndId;
 import java.util.Collection;
 import java.util.stream.Collectors;
 
-import static net.minecraft.server.command.CommandManager.argument;
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.argument;
+import static net.minecraft.commands.Commands.literal;
 
 public class TrustCommand implements SubCommand {
 
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("trust")
-				.requires(Permissions.require("htm.command.trust", true))
-				.executes(this::trustList)
-				.then(argument("target", GameProfileArgumentType.gameProfile())
-						.executes(ctx -> trust(ctx.getSource(), GameProfileArgumentType.getProfileArgument(ctx, "target"), false))
-						.then(literal("global")
-								.executes(ctx -> trust(
-										ctx.getSource(), GameProfileArgumentType.getProfileArgument(ctx, "target"), true)
-								)
-						))
-				.build();
-	}
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("trust")
+                .requires(Permissions.require("htm.command.trust", true))
+                .executes(this::trustList)
+                .then(argument("target", GameProfileArgument.gameProfile())
+                        .executes(ctx -> trust(ctx.getSource(), GameProfileArgument.getGameProfiles(ctx, "target"), false))
+                        .then(literal("global")
+                                .executes(ctx -> trust(ctx.getSource(), GameProfileArgument.getGameProfiles(ctx, "target"), true))
+                        )
+                )
+        );
+    }
 
-	@SuppressWarnings("SameReturnValue")
-	private int trustList(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
-		ServerPlayerEntity player = context.getSource().getPlayerOrThrow();
-		GlobalTrustState globalTrustState = Utility.getGlobalTrustState(context.getSource().getServer());
+    @SuppressWarnings("SameReturnValue")
+	private int trustList(CommandContext<CommandSourceStack> context) throws CommandSyntaxException {
+		ServerPlayer player = context.getSource().getPlayerOrException();
+		GlobalTrustData globalTrustData = Utility.getGlobalTrustData(context.getSource().getServer());
 
-		String trustedList = globalTrustState.getTrusted().get(player.getUuid())
+		String trustedList = globalTrustData.getTrusted().get(player.getUUID())
 				.stream()
 				.map(uuid -> Utility.getNameFromUUID(uuid, context.getSource().getServer()))
 				.collect(Collectors.joining(", "));
 
-		player.sendMessage(HTMTexts.TRUSTED_GLOBALLY.apply(Text.literal(trustedList).formatted(Formatting.WHITE)), false);
+		player.displayClientMessage(HTMComponents.TRUSTED_GLOBALLY.apply(Component.literal(trustedList).withStyle(ChatFormatting.WHITE)), false);
 
-		return 1;
+		return 0;
 	}
 
-	private static int trust(ServerCommandSource source, Collection<PlayerConfigEntry> players, boolean global) throws CommandSyntaxException {
-		ServerPlayerEntity player = source.getPlayerOrThrow();
+	private static int trust(CommandSourceStack source, Collection<NameAndId> players, boolean global) throws CommandSyntaxException {
+		ServerPlayer player = source.getPlayerOrException();
 
 		if (global) {
-			for (PlayerConfigEntry target : players) {
-				GlobalTrustState globalTrustState = Utility.getGlobalTrustState(source.getServer());
-				if (player.getUuid().equals(target.id())) {
-                    source.sendError(HTMTexts.CANNOT_TRUST_SELF);
-					return -1;
+			for (NameAndId target : players) {
+				GlobalTrustData globalTrustData = Utility.getGlobalTrustData(source.getServer());
+				if (player.getUUID().equals(target.id())) {
+                    source.sendFailure(HTMComponents.CANNOT_TRUST_SELF);
+					return 1;
 				}
 
-                Text playerName = Text.literal(target.name()).formatted(Formatting.WHITE);
-				if (globalTrustState.addTrust(player.getUuid(), target.id())) {
-                    source.sendFeedback(() -> HTMTexts.TRUST.apply(playerName).append(ScreenTexts.SPACE).append(HTMTexts.GLOBAL), false);
+                Component playerName = Component.literal(target.name()).withStyle(ChatFormatting.WHITE);
+				if (globalTrustData.addTrust(player.getUUID(), target.id())) {
+                    source.sendSuccess(() -> HTMComponents.TRUST.apply(playerName).append(CommonComponents.SPACE).append(HTMComponents.GLOBAL), false);
+                    return 2;
 				} else {
-					source.sendFeedback(() -> HTMTexts.ALREADY_TRUSTED.apply(playerName), false);
+					source.sendSuccess(() -> HTMComponents.ALREADY_TRUSTED.apply(playerName), false);
+                    return 3;
 				}
 			}
 		} else {
 			InteractionManager.pendingActions.put(player, new TrustAction(players, false));
-			source.sendFeedback(() -> HTMTexts.CLICK_TO_SELECT, false);
+			source.sendSuccess(() -> HTMComponents.CLICK_TO_SELECT, false);
 		}
 
-
-		return 1;
+		return 4;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/UntrustCommand.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/UntrustCommand.java
index 697c951..af327ad 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/subcommands/UntrustCommand.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/UntrustCommand.java
@@ -1,66 +1,66 @@
 package com.github.fabricservertools.htm.command.subcommands;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.Utility;
 import com.github.fabricservertools.htm.command.SubCommand;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
 import com.github.fabricservertools.htm.interactions.TrustAction;
-import com.github.fabricservertools.htm.world.data.GlobalTrustState;
+import com.github.fabricservertools.htm.world.data.GlobalTrustData;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.brigadier.tree.LiteralCommandNode;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.command.argument.GameProfileArgumentType;
-import net.minecraft.screen.ScreenTexts;
-import net.minecraft.server.PlayerConfigEntry;
-import net.minecraft.server.command.ServerCommandSource;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.text.Text;
-
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.arguments.GameProfileArgument;
+import net.minecraft.network.chat.CommonComponents;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.players.NameAndId;
 import java.util.Collection;
 
-import static net.minecraft.server.command.CommandManager.argument;
-import static net.minecraft.server.command.CommandManager.literal;
+import static net.minecraft.commands.Commands.argument;
+import static net.minecraft.commands.Commands.literal;
 
 public class UntrustCommand implements SubCommand {
 
-	@Override
-	public LiteralCommandNode<ServerCommandSource> build() {
-		return literal("untrust")
-				.requires(Permissions.require("htm.command.trust", true))
-				.then(argument("target", GameProfileArgumentType.gameProfile())
-						.executes(ctx -> untrust(
-								ctx.getSource(),
-								GameProfileArgumentType.getProfileArgument(ctx, "target"),
-								false
-						))
-						.then(literal("global")
-								.executes(ctx -> untrust(
-										ctx.getSource(),
-										GameProfileArgumentType.getProfileArgument(ctx, "target"),
-										true
-								))
-						))
-				.build();
-	}
+    @Override
+    public void register(LiteralArgumentBuilder<CommandSourceStack> root) {
+        root.then(literal("untrust")
+                .requires(Permissions.require("htm.command.trust", true))
+                .then(argument("target", GameProfileArgument.gameProfile())
+                        .executes(ctx -> untrust(
+                                ctx.getSource(),
+                                GameProfileArgument.getGameProfiles(ctx, "target"),
+                                false
+                        ))
+                        .then(literal("global")
+                                .executes(ctx -> untrust(
+                                        ctx.getSource(),
+                                        GameProfileArgument.getGameProfiles(ctx, "target"),
+                                        true
+                                ))
+                        )
+                )
+        );
+    }
 
-	@SuppressWarnings("SameReturnValue")
-	private int untrust(ServerCommandSource source, Collection<PlayerConfigEntry> players, boolean global) throws CommandSyntaxException {
-		ServerPlayerEntity player = source.getPlayerOrThrow();
+    private int untrust(CommandSourceStack source, Collection<NameAndId> players, boolean global) throws CommandSyntaxException {
+		ServerPlayer player = source.getPlayerOrException();
 
 		if (global) {
-			for (PlayerConfigEntry target : players) {
-				GlobalTrustState globalTrustState = Utility.getGlobalTrustState(source.getServer());
-				if (globalTrustState.removeTrust(player.getUuid(), target.id())) {
-                    source.sendFeedback(() -> HTMTexts.UNTRUST.apply(target.name()).append(ScreenTexts.SPACE).append(HTMTexts.GLOBAL), false);
+			for (NameAndId target : players) {
+				GlobalTrustData globalTrustData = Utility.getGlobalTrustData(source.getServer());
+				if (globalTrustData.removeTrust(player.getUUID(), target.id())) {
+                    source.sendSuccess(() -> HTMComponents.UNTRUST.apply(target.name()).append(CommonComponents.SPACE).append(HTMComponents.GLOBAL), false);
+                    return 2;
 				} else {
-                    source.sendFeedback(() -> HTMTexts.PLAYER_NOT_TRUSTED.apply(target.name()).append(ScreenTexts.SPACE).append(HTMTexts.GLOBAL), false);
+                    source.sendSuccess(() -> HTMComponents.PLAYER_NOT_TRUSTED.apply(target.name()).append(CommonComponents.SPACE).append(HTMComponents.GLOBAL), false);
+                    return 3;
 				}
 			}
 		} else {
 			InteractionManager.pendingActions.put(player, new TrustAction(players, true));
-			source.sendFeedback(() -> HTMTexts.CLICK_TO_SELECT, false);
+			source.sendSuccess(() -> HTMComponents.CLICK_TO_SELECT, false);
 		}
 
-		return 1;
+		return 0;
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/subcommands/package-info.java b/src/main/java/com/github/fabricservertools/htm/command/subcommands/package-info.java
new file mode 100644
index 0000000..c3afdc4
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/command/subcommands/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.command.subcommands;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/command/suggestors/FlagTypeSuggestionProvider.java b/src/main/java/com/github/fabricservertools/htm/command/suggestion/FlagTypeSuggestionProvider.java
similarity index 64%
rename from src/main/java/com/github/fabricservertools/htm/command/suggestors/FlagTypeSuggestionProvider.java
rename to src/main/java/com/github/fabricservertools/htm/command/suggestion/FlagTypeSuggestionProvider.java
index 990822e..6ec8599 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/suggestors/FlagTypeSuggestionProvider.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/suggestion/FlagTypeSuggestionProvider.java
@@ -1,22 +1,22 @@
-package com.github.fabricservertools.htm.command.suggestors;
+package com.github.fabricservertools.htm.command.suggestion;
 
 import com.github.fabricservertools.htm.api.FlagType;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.suggestion.SuggestionProvider;
 import com.mojang.brigadier.suggestion.Suggestions;
 import com.mojang.brigadier.suggestion.SuggestionsBuilder;
-import net.minecraft.server.command.ServerCommandSource;
-
 import java.util.concurrent.CompletableFuture;
+import net.minecraft.commands.CommandSourceStack;
+
+public class FlagTypeSuggestionProvider implements SuggestionProvider<CommandSourceStack> {
 
-public class FlagTypeSuggestionProvider implements SuggestionProvider<ServerCommandSource> {
 	@Override
-	public CompletableFuture<Suggestions> getSuggestions(CommandContext<ServerCommandSource> context, SuggestionsBuilder builder) {
+	public CompletableFuture<Suggestions> getSuggestions(CommandContext<CommandSourceStack> context, SuggestionsBuilder builder) {
 		String current = builder.getRemaining().toUpperCase();
 
 		for (FlagType flag : FlagType.values()) {
-			if (flag.asString().contains(current.toLowerCase())) {
-				builder.suggest(flag.asString().toUpperCase());
+			if (flag.getSerializedName().contains(current.toLowerCase())) {
+				builder.suggest(flag.getSerializedName().toUpperCase());
 			}
 		}
 
diff --git a/src/main/java/com/github/fabricservertools/htm/command/suggestors/LockTypeSuggestionProvider.java b/src/main/java/com/github/fabricservertools/htm/command/suggestion/LockTypeSuggestionProvider.java
similarity index 56%
rename from src/main/java/com/github/fabricservertools/htm/command/suggestors/LockTypeSuggestionProvider.java
rename to src/main/java/com/github/fabricservertools/htm/command/suggestion/LockTypeSuggestionProvider.java
index 1ea8cb2..5fa9977 100644
--- a/src/main/java/com/github/fabricservertools/htm/command/suggestors/LockTypeSuggestionProvider.java
+++ b/src/main/java/com/github/fabricservertools/htm/command/suggestion/LockTypeSuggestionProvider.java
@@ -1,20 +1,19 @@
-package com.github.fabricservertools.htm.command.suggestors;
+package com.github.fabricservertools.htm.command.suggestion;
 
 import com.github.fabricservertools.htm.api.Lock;
 import com.mojang.brigadier.context.CommandContext;
 import com.mojang.brigadier.suggestion.SuggestionProvider;
 import com.mojang.brigadier.suggestion.Suggestions;
 import com.mojang.brigadier.suggestion.SuggestionsBuilder;
-import net.minecraft.command.CommandSource;
-import net.minecraft.server.command.ServerCommandSource;
-
 import java.util.Arrays;
 import java.util.concurrent.CompletableFuture;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.SharedSuggestionProvider;
 
-public class LockTypeSuggestionProvider implements SuggestionProvider<ServerCommandSource> {
+public class LockTypeSuggestionProvider implements SuggestionProvider<CommandSourceStack> {
 
 	@Override
-	public CompletableFuture<Suggestions> getSuggestions(CommandContext<ServerCommandSource> context, SuggestionsBuilder builder) {
-        return CommandSource.suggestMatching(Arrays.stream(Lock.Type.values()).map(Lock.Type::uiName), builder);
+	public CompletableFuture<Suggestions> getSuggestions(CommandContext<CommandSourceStack> context, SuggestionsBuilder builder) {
+        return SharedSuggestionProvider.suggest(Arrays.stream(Lock.Type.values()).map(Lock.Type::uiName), builder);
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/command/suggestion/package-info.java b/src/main/java/com/github/fabricservertools/htm/command/suggestion/package-info.java
new file mode 100644
index 0000000..d8215a5
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/command/suggestion/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.command.suggestion;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/config/HTMConfig.java b/src/main/java/com/github/fabricservertools/htm/config/HTMConfig.java
index 309744c..9f91b95 100644
--- a/src/main/java/com/github/fabricservertools/htm/config/HTMConfig.java
+++ b/src/main/java/com/github/fabricservertools/htm/config/HTMConfig.java
@@ -1,6 +1,7 @@
 package com.github.fabricservertools.htm.config;
 
 import com.github.fabricservertools.htm.HTM;
+import com.github.fabricservertools.htm.api.Lock;
 import com.github.fabricservertools.htm.lock.BlockFlagSet;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
@@ -9,57 +10,68 @@
 import com.mojang.serialization.JsonOps;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import net.fabricmc.loader.api.FabricLoader;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.Blocks;
-import net.minecraft.registry.tag.BlockTags;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import org.jspecify.annotations.Nullable;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
-public record HTMConfig(boolean canTrustedPlayersBreakChests, BlockFlagSet defaultFlags, List<SingleBlockSelector> autoLockingContainers) {
+public record HTMConfig(boolean canTrustedPlayersBreakChests, BlockFlagSet defaultFlags, Map<SingleBlockSelector, Lock.Type> autoLockingContainers) {
     private static final Gson GSON = new GsonBuilder()
             .setPrettyPrinting()
             .create();
     private static final Path CONFIG_PATH = Path.of("htm_config.json");
 
+    private static final Codec<Map<SingleBlockSelector, Lock.Type>> AUTO_LOCKING_CONTAINERS_LEGACY_CODEC = SingleBlockSelector.CODEC.listOf()
+            .xmap(list -> list.stream().collect(Collectors.toMap(Function.identity(), selector -> Lock.Type.PRIVATE)),
+                    map -> List.copyOf(map.keySet()));
+    private static final Codec<Map<SingleBlockSelector, Lock.Type>> AUTO_LOCKING_CONTAINERS_MODERN_CODEC = Codec.unboundedMap(SingleBlockSelector.CODEC, Lock.Type.CODEC);
+    private static final Codec<Map<SingleBlockSelector, Lock.Type>> AUTO_LOCKING_CONTAINERS_CODEC = Codec.withAlternative(AUTO_LOCKING_CONTAINERS_MODERN_CODEC, AUTO_LOCKING_CONTAINERS_LEGACY_CODEC);
+
     public static final Codec<HTMConfig> CODEC = RecordCodecBuilder.create(instance ->
             instance.group(
                     Codec.BOOL.fieldOf("can_trusted_players_break_chests").forGetter(HTMConfig::canTrustedPlayersBreakChests),
                     BlockFlagSet.SAFE_CODEC.fieldOf("default_flags").forGetter(HTMConfig::defaultFlags),
-                    SingleBlockSelector.CODEC.listOf().fieldOf("auto_locking_containers").forGetter(HTMConfig::autoLockingContainers)
+                    AUTO_LOCKING_CONTAINERS_CODEC.fieldOf("auto_locking_containers").forGetter(HTMConfig::autoLockingContainers)
             ).apply(instance, HTMConfig::new)
     );
     public static final Codec<HTMConfig> LEGACY_CODEC = RecordCodecBuilder.create(instance ->
             instance.group(
                     Codec.BOOL.fieldOf("canTrustedPlayersBreakChests").forGetter(HTMConfig::canTrustedPlayersBreakChests),
                     BlockFlagSet.SAFE_CODEC.fieldOf("defaultFlags").forGetter(HTMConfig::defaultFlags),
-                    SingleBlockSelector.CODEC.listOf().fieldOf("autolockingContainers").forGetter(HTMConfig::autoLockingContainers)
+                    AUTO_LOCKING_CONTAINERS_CODEC.fieldOf("autolockingContainers").forGetter(HTMConfig::autoLockingContainers)
             ).apply(instance, HTMConfig::new)
     );
     public static final Codec<HTMConfig> SAFE_CODEC = Codec.withAlternative(CODEC, LEGACY_CODEC);
 
-    private static final List<SingleBlockSelector> DEFAULT_AUTO_LOCKING_CONTAINERS = List.of(
-            new SingleBlockSelector(Blocks.CHEST),
-            new SingleBlockSelector(Blocks.TRAPPED_CHEST),
-            new SingleBlockSelector(Blocks.BARREL),
-            new SingleBlockSelector(Blocks.FURNACE),
-            new SingleBlockSelector(Blocks.BLAST_FURNACE),
-            new SingleBlockSelector(Blocks.SMOKER),
-            new SingleBlockSelector(BlockTags.SHULKER_BOXES),
-            new SingleBlockSelector(BlockTags.COPPER_CHESTS));
+    private static final Map<SingleBlockSelector, Lock.Type> DEFAULT_AUTO_LOCKING_CONTAINERS = Map.of(
+            new SingleBlockSelector(Blocks.CHEST), Lock.Type.PRIVATE,
+            new SingleBlockSelector(Blocks.TRAPPED_CHEST), Lock.Type.PRIVATE,
+            new SingleBlockSelector(Blocks.BARREL), Lock.Type.PRIVATE,
+            new SingleBlockSelector(Blocks.FURNACE), Lock.Type.PRIVATE,
+            new SingleBlockSelector(Blocks.BLAST_FURNACE), Lock.Type.PRIVATE,
+            new SingleBlockSelector(Blocks.SMOKER), Lock.Type.PRIVATE,
+            new SingleBlockSelector(BlockTags.SHULKER_BOXES), Lock.Type.PRIVATE,
+            new SingleBlockSelector(BlockTags.COPPER_CHESTS), Lock.Type.PRIVATE);
     private static final HTMConfig DEFAULT_CONFIG = new HTMConfig(false, BlockFlagSet.DEFAULT, DEFAULT_AUTO_LOCKING_CONTAINERS);
 
-    private static HTMConfig loaded = null;
+    private static @Nullable HTMConfig loaded = null;
 
-    public boolean isAutoLocking(BlockState block) {
-        for (SingleBlockSelector container : autoLockingContainers) {
-            if (container.is(block)) {
-                return true;
+    public Optional<Lock.Type> getAutoLockingType(BlockState block) {
+        for (Map.Entry<SingleBlockSelector, Lock.Type> container : autoLockingContainers.entrySet()) {
+            if (container.getKey().is(block)) {
+                return Optional.of(container.getValue());
             }
         }
-        return false;
+        return Optional.empty();
     }
 
     private void save() {
diff --git a/src/main/java/com/github/fabricservertools/htm/config/SingleBlockSelector.java b/src/main/java/com/github/fabricservertools/htm/config/SingleBlockSelector.java
index 80dacc0..6372ec7 100644
--- a/src/main/java/com/github/fabricservertools/htm/config/SingleBlockSelector.java
+++ b/src/main/java/com/github/fabricservertools/htm/config/SingleBlockSelector.java
@@ -2,20 +2,20 @@
 
 import com.mojang.datafixers.util.Either;
 import com.mojang.serialization.Codec;
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockState;
-import net.minecraft.registry.Registries;
-import net.minecraft.registry.RegistryKey;
-import net.minecraft.registry.RegistryKeys;
-import net.minecraft.registry.entry.RegistryEntry;
-import net.minecraft.registry.tag.TagKey;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
 
-public record SingleBlockSelector(Either<RegistryKey<Block>, TagKey<Block>> key) {
-    public static final Codec<SingleBlockSelector> CODEC = Codec.either(RegistryKey.createCodec(RegistryKeys.BLOCK), TagKey.codec(RegistryKeys.BLOCK))
+public record SingleBlockSelector(Either<ResourceKey<Block>, TagKey<Block>> key) {
+    public static final Codec<SingleBlockSelector> CODEC = Codec.either(ResourceKey.codec(Registries.BLOCK), TagKey.hashedCodec(Registries.BLOCK))
             .xmap(SingleBlockSelector::new, SingleBlockSelector::key);
 
     public SingleBlockSelector(Block block) {
-        this(Either.left(block.getRegistryEntry().registryKey()));
+        this(Either.left(block.builtInRegistryHolder().key()));
     }
 
     public SingleBlockSelector(TagKey<Block> tag) {
@@ -23,11 +23,11 @@ public SingleBlockSelector(TagKey<Block> tag) {
     }
 
     public boolean is(BlockState block) {
-        return is(Registries.BLOCK.getEntry(block.getBlock()));
+        return is(BuiltInRegistries.BLOCK.wrapAsHolder(block.getBlock()));
     }
 
-    public boolean is(RegistryEntry<Block> block) {
-        RegistryKey<Block> registryKey = block.getKey().orElseThrow();
-        return key.map(registryKey::equals, block::isIn);
+    public boolean is(Holder<Block> block) {
+        ResourceKey<Block> registryKey = block.unwrapKey().orElseThrow();
+        return key.map(registryKey::equals, block::is);
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/config/package-info.java b/src/main/java/com/github/fabricservertools/htm/config/package-info.java
new file mode 100644
index 0000000..e126e6a
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/config/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.config;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/events/BlockExplodeCallback.java b/src/main/java/com/github/fabricservertools/htm/events/BlockExplodeCallback.java
index 959afc0..7a48072 100644
--- a/src/main/java/com/github/fabricservertools/htm/events/BlockExplodeCallback.java
+++ b/src/main/java/com/github/fabricservertools/htm/events/BlockExplodeCallback.java
@@ -2,25 +2,25 @@
 
 import net.fabricmc.fabric.api.event.Event;
 import net.fabricmc.fabric.api.event.EventFactory;
-import net.minecraft.block.BlockState;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.explosion.Explosion;
-import net.minecraft.world.explosion.ExplosionBehavior;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.level.Explosion;
+import net.minecraft.world.level.ExplosionDamageCalculator;
+import net.minecraft.world.level.block.state.BlockState;
 
 public interface BlockExplodeCallback {
 	Event<BlockExplodeCallback> EVENT = EventFactory.createArrayBacked(BlockExplodeCallback.class,
 			(listeners) -> (explosionBehavior, explosion, pos, state) -> {
 				for (BlockExplodeCallback listener : listeners) {
-					ActionResult result = listener.explode(explosionBehavior, explosion, pos, state);
+					InteractionResult result = listener.explode(explosionBehavior, explosion, pos, state);
 
-					if (result != ActionResult.PASS) {
+					if (result != InteractionResult.PASS) {
 						return result;
 					}
 				}
 
-				return ActionResult.PASS;
+				return InteractionResult.PASS;
 			});
 
-	ActionResult explode(ExplosionBehavior explosionBehavior, Explosion explosion, BlockPos pos, BlockState state);
+	InteractionResult explode(ExplosionDamageCalculator damageCalculator, Explosion explosion, BlockPos pos, BlockState state);
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/events/EnderDragonBreakBlockCallback.java b/src/main/java/com/github/fabricservertools/htm/events/EnderDragonBreakBlockCallback.java
index 9340a9f..25155d0 100644
--- a/src/main/java/com/github/fabricservertools/htm/events/EnderDragonBreakBlockCallback.java
+++ b/src/main/java/com/github/fabricservertools/htm/events/EnderDragonBreakBlockCallback.java
@@ -2,23 +2,23 @@
 
 import net.fabricmc.fabric.api.event.Event;
 import net.fabricmc.fabric.api.event.EventFactory;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.InteractionResult;
 
 public interface EnderDragonBreakBlockCallback {
 	Event<EnderDragonBreakBlockCallback> EVENT = EventFactory.createArrayBacked(EnderDragonBreakBlockCallback.class,
 			(listeners) -> (world, pos, move) -> {
 				for (EnderDragonBreakBlockCallback listener : listeners) {
-					ActionResult result = listener.blockBreak(world, pos, move);
+					InteractionResult result = listener.blockBreak(world, pos, move);
 
-					if (result != ActionResult.PASS) {
+					if (result != InteractionResult.PASS) {
 						return result;
 					}
 				}
 
-				return ActionResult.PASS;
+				return InteractionResult.PASS;
 			});
 
-	ActionResult blockBreak(ServerWorld world, BlockPos pos, boolean move);
+	InteractionResult blockBreak(ServerLevel level, BlockPos pos, boolean move);
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/events/LevelBreakBlockCallback.java b/src/main/java/com/github/fabricservertools/htm/events/LevelBreakBlockCallback.java
new file mode 100644
index 0000000..dcd2a80
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/events/LevelBreakBlockCallback.java
@@ -0,0 +1,26 @@
+package com.github.fabricservertools.htm.events;
+
+import net.fabricmc.fabric.api.event.Event;
+import net.fabricmc.fabric.api.event.EventFactory;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
+import org.jspecify.annotations.Nullable;
+
+public interface LevelBreakBlockCallback {
+	Event<LevelBreakBlockCallback> EVENT = EventFactory.createArrayBacked(LevelBreakBlockCallback.class,
+			(listeners) -> (world, pos, drop, breakingEntity) -> {
+				for (LevelBreakBlockCallback listener : listeners) {
+					InteractionResult result = listener.blockBreak(world, pos, drop, breakingEntity);
+
+					if (result != InteractionResult.PASS) {
+						return result;
+					}
+				}
+
+				return InteractionResult.PASS;
+			});
+
+	InteractionResult blockBreak(Level level, BlockPos pos, boolean drop, @Nullable Entity breakingEntity);
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/events/PlayerPlaceBlockCallback.java b/src/main/java/com/github/fabricservertools/htm/events/PlayerPlaceBlockCallback.java
index 07f2187..1b14ffd 100644
--- a/src/main/java/com/github/fabricservertools/htm/events/PlayerPlaceBlockCallback.java
+++ b/src/main/java/com/github/fabricservertools/htm/events/PlayerPlaceBlockCallback.java
@@ -2,9 +2,9 @@
 
 import net.fabricmc.fabric.api.event.Event;
 import net.fabricmc.fabric.api.event.EventFactory;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.item.ItemPlacementContext;
-import net.minecraft.util.ActionResult;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.context.BlockPlaceContext;
 
 /**
  * Callback for player placing a block
@@ -14,15 +14,15 @@ public interface PlayerPlaceBlockCallback {
 	Event<PlayerPlaceBlockCallback> EVENT = EventFactory.createArrayBacked(PlayerPlaceBlockCallback.class,
 			(listeners) -> (player, context) -> {
 				for (PlayerPlaceBlockCallback listener : listeners) {
-					ActionResult result = listener.place(player, context);
+					InteractionResult result = listener.place(player, context);
 
-					if (result != ActionResult.PASS) {
+					if (result != InteractionResult.PASS) {
 						return result;
 					}
 				}
 
-				return ActionResult.PASS;
+				return InteractionResult.PASS;
 			});
 
-	ActionResult place(PlayerEntity player, ItemPlacementContext context);
+	InteractionResult place(Player player, BlockPlaceContext context);
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/events/WorldBreakBlockCallback.java b/src/main/java/com/github/fabricservertools/htm/events/WorldBreakBlockCallback.java
deleted file mode 100644
index 0d8ccf0..0000000
--- a/src/main/java/com/github/fabricservertools/htm/events/WorldBreakBlockCallback.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package com.github.fabricservertools.htm.events;
-
-import net.fabricmc.fabric.api.event.Event;
-import net.fabricmc.fabric.api.event.EventFactory;
-import net.minecraft.entity.Entity;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import org.jetbrains.annotations.Nullable;
-
-public interface WorldBreakBlockCallback {
-	Event<WorldBreakBlockCallback> EVENT = EventFactory.createArrayBacked(WorldBreakBlockCallback.class,
-			(listeners) -> (world, pos, drop, breakingEntity) -> {
-				for (WorldBreakBlockCallback listener : listeners) {
-					ActionResult result = listener.blockBreak(world, pos, drop, breakingEntity);
-
-					if (result != ActionResult.PASS) {
-						return result;
-					}
-				}
-
-				return ActionResult.PASS;
-			});
-
-	ActionResult blockBreak(World world, BlockPos pos, boolean drop, @Nullable Entity breakingEntity);
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/events/package-info.java b/src/main/java/com/github/fabricservertools/htm/events/package-info.java
new file mode 100644
index 0000000..75ff1fd
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/events/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.events;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/interactions/FlagAction.java b/src/main/java/com/github/fabricservertools/htm/interactions/FlagAction.java
index 57f9983..b2282e2 100644
--- a/src/main/java/com/github/fabricservertools/htm/interactions/FlagAction.java
+++ b/src/main/java/com/github/fabricservertools/htm/interactions/FlagAction.java
@@ -2,17 +2,18 @@
 
 import com.github.fabricservertools.htm.config.HTMConfig;
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.api.FlagType;
 import com.github.fabricservertools.htm.api.LockInteraction;
 import com.github.fabricservertools.htm.api.LockableObject;
-import net.minecraft.block.BlockState;
+import com.mojang.datafixers.util.Pair;
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-import net.minecraft.util.Pair;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.block.state.BlockState;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Optional;
 
@@ -23,7 +24,7 @@ public class FlagAction implements LockInteraction {
 	 * Optional flag type and value to set it to.
 	 * If empty, get flag info instead
 	 */
-	private final Optional<Pair<FlagType, Boolean>> flagSet;
+	private final Optional<Pair<FlagType, @Nullable Boolean>> flagSet;
 
 	/**
 	 * Creates a flag action
@@ -31,47 +32,47 @@ public class FlagAction implements LockInteraction {
 	 * @param flagSet Optional flag type and value to set it to.
 	 *                If empty, get flag info instead
 	 */
-	public FlagAction(Optional<Pair<FlagType, Boolean>> flagSet) {
+	public FlagAction(Optional<Pair<FlagType, @Nullable Boolean>> flagSet) {
 		this.flagSet = flagSet;
 	}
 
 	@Override
-	public void execute(MinecraftServer server, ServerPlayerEntity player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
+	public void execute(MinecraftServer server, ServerPlayer player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
 		if (!lock.isOwner(player)) {
-			player.sendMessage(HTMTexts.NOT_OWNER, false);
+			player.displayClientMessage(HTMComponents.NOT_OWNER, false);
 			return;
 		}
 
-        BlockState state = player.getEntityWorld().getBlockState(pos);
+        BlockState state = player.level().getBlockState(pos);
 		if (flagSet.isEmpty()) {
 			//flag info
-			player.sendMessage(HTMTexts.DIVIDER, false);
+			player.displayClientMessage(HTMComponents.DIVIDER, false);
             lock.flags().forEach(state, (flag, value) -> {
-                player.sendMessage(HTMTexts.CONTAINER_FLAG.apply(
+                player.displayClientMessage(HTMComponents.CONTAINER_FLAG.apply(
                                 flag.displayName(),
-                                Text.literal(value.toString().toUpperCase()).formatted(value ? Formatting.GREEN : Formatting.RED, Formatting.BOLD)),
+                                Component.literal(value.toString().toUpperCase()).withStyle(value ? ChatFormatting.GREEN : ChatFormatting.RED, ChatFormatting.BOLD)),
                         false);
             });
-			player.sendMessage(HTMTexts.DIVIDER, false);
+			player.displayClientMessage(HTMComponents.DIVIDER, false);
 		} else {
 			//flag set
-			FlagType flagType = flagSet.get().getLeft();
-			Boolean value = flagSet.get().getRight();
+			FlagType flagType = flagSet.get().getFirst();
+			Boolean value = flagSet.get().getSecond();
 
-            HTMTexts.TranslatableTextBuilder feedback;
+            HTMComponents.TranslatableComponentBuilder feedback;
             boolean feedbackValue;
             if (value == null) {
                 object.setLock(lock.withoutFlag(flagType));
-                feedback = HTMTexts.CONTAINER_FLAG_RESET;
+                feedback = HTMComponents.CONTAINER_FLAG_RESET;
                 feedbackValue = HTMConfig.get().defaultFlags().get(flagType, state);
             } else {
                 object.setLock(lock.withFlag(flagType, value));
-                feedback = HTMTexts.CONTAINER_FLAG_SET;
+                feedback = HTMComponents.CONTAINER_FLAG_SET;
                 feedbackValue = value;
             }
-            player.sendMessage(feedback.apply(
+            player.displayClientMessage(feedback.apply(
                             flagType.displayName(),
-                            Text.literal(String.valueOf(feedbackValue).toUpperCase()).formatted(feedbackValue ? Formatting.GREEN : Formatting.RED, Formatting.BOLD)),
+                            Component.literal(String.valueOf(feedbackValue).toUpperCase()).withStyle(feedbackValue ? ChatFormatting.GREEN : ChatFormatting.RED, ChatFormatting.BOLD)),
                     false);
         }
 	}
diff --git a/src/main/java/com/github/fabricservertools/htm/interactions/InfoAction.java b/src/main/java/com/github/fabricservertools/htm/interactions/InfoAction.java
index 76dc2b0..e1d0ac9 100644
--- a/src/main/java/com/github/fabricservertools/htm/interactions/InfoAction.java
+++ b/src/main/java/com/github/fabricservertools/htm/interactions/InfoAction.java
@@ -2,16 +2,16 @@
 
 import com.github.fabricservertools.htm.HTM;
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.Utility;
 import com.github.fabricservertools.htm.api.LockInteraction;
 import com.github.fabricservertools.htm.api.LockableObject;
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.PlayerConfigEntry;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.players.NameAndId;
 
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -19,26 +19,26 @@
 public class InfoAction implements LockInteraction {
 
 	@Override
-	public void execute(MinecraftServer server, ServerPlayerEntity player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
-		Optional<PlayerConfigEntry> owner = server.getApiServices().nameToIdCache().getByUuid(lock.owner());
+	public void execute(MinecraftServer server, ServerPlayer player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
+		Optional<NameAndId> owner = server.services().nameToIdCache().get(lock.owner());
 
 		if (owner.isEmpty()) {
             HTM.LOGGER.error("Can't find lock owner: {}", lock.owner());
 			return;
 		}
 
-		player.sendMessage(HTMTexts.DIVIDER, false);
-		player.sendMessage(HTMTexts.CONTAINER_LOCK_TYPE.apply(lock.lockData().displayName()), false);
-		player.sendMessage(HTMTexts.CONTAINER_OWNER.apply(Text.literal(owner.get().name()).formatted(Formatting.WHITE)), false);
+		player.displayClientMessage(HTMComponents.DIVIDER, false);
+		player.displayClientMessage(HTMComponents.CONTAINER_LOCK_TYPE.apply(lock.lockData().displayName()), false);
+		player.displayClientMessage(HTMComponents.CONTAINER_OWNER.apply(Component.literal(owner.get().name()).withStyle(ChatFormatting.WHITE)), false);
 		if (lock.isOwner(player)) {
 			String trustedList = lock.trusted()
 					.stream()
 					.map(uuid -> Utility.getNameFromUUID(uuid, server))
 					.collect(Collectors.joining(", "));
 
-			player.sendMessage(HTMTexts.CONTAINER_TRUSTED.apply(Text.literal(trustedList).formatted(Formatting.WHITE)), false);
+			player.displayClientMessage(HTMComponents.CONTAINER_TRUSTED.apply(Component.literal(trustedList).withStyle(ChatFormatting.WHITE)), false);
 			lock.lockData().onInfo(player, lock);
 		}
-		player.sendMessage(HTMTexts.DIVIDER, false);
+		player.displayClientMessage(HTMComponents.DIVIDER, false);
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/interactions/InteractionManager.java b/src/main/java/com/github/fabricservertools/htm/interactions/InteractionManager.java
index 8a7a519..b0ee1c0 100644
--- a/src/main/java/com/github/fabricservertools/htm/interactions/InteractionManager.java
+++ b/src/main/java/com/github/fabricservertools/htm/interactions/InteractionManager.java
@@ -1,7 +1,7 @@
 package com.github.fabricservertools.htm.interactions;
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.api.LockInteraction;
 import com.github.fabricservertools.htm.api.LockableObject;
 import com.mojang.authlib.GameProfile;
@@ -10,30 +10,31 @@
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
 import it.unimi.dsi.fastutil.objects.ObjectSet;
-import net.minecraft.block.ChestBlock;
-import net.minecraft.block.DoubleBlockProperties;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.block.entity.ChestBlockEntity;
-import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.core.BlockPos;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Box;
-import net.minecraft.world.World;
-import org.jetbrains.annotations.Nullable;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.level.block.DoubleBlockCombiner;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.ChestBlockEntity;
+import net.minecraft.world.phys.AABB;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Optional;
 import java.util.UUID;
 
 public class InteractionManager implements ProtectionProvider {
-    public static final Object2ObjectMap<ServerPlayerEntity, LockInteraction> pendingActions = new Object2ObjectOpenHashMap<>();
+    public static final Object2ObjectMap<ServerPlayer, LockInteraction> pendingActions = new Object2ObjectOpenHashMap<>();
     public static final ObjectSet<UUID> persisting = new ObjectOpenHashSet<>();
     public static final ObjectSet<UUID> noMessage = new ObjectOpenHashSet<>();
 
-    private static final DoubleBlockProperties.PropertyRetriever<BlockEntity, LockableObject> LOCKABLE_RETRIEVER = new DoubleBlockProperties.PropertyRetriever<>() {
+    private static final DoubleBlockCombiner.Combiner<BlockEntity, LockableObject> LOCKABLE_RETRIEVER = new DoubleBlockCombiner.Combiner<>() {
+
         @Override
-        public LockableObject getFromBoth(BlockEntity first, BlockEntity second) {
+        public @Nullable LockableObject acceptDouble(BlockEntity first, BlockEntity second) {
             if (first instanceof LockableObject lockable) {
                 if (lockable.getLock().isPresent()) {
                   return lockable;
@@ -46,7 +47,7 @@ public LockableObject getFromBoth(BlockEntity first, BlockEntity second) {
         }
 
         @Override
-        public LockableObject getFrom(BlockEntity single) {
+        public @Nullable LockableObject acceptSingle(BlockEntity single) {
             if (single instanceof LockableObject lockable) {
                 return lockable;
             }
@@ -54,14 +55,14 @@ public LockableObject getFrom(BlockEntity single) {
         }
 
         @Override
-        public LockableObject getFallback() {
+        public @Nullable LockableObject acceptNone() {
             return null;
         }
     };
 
-    private static final DoubleBlockProperties.PropertyRetriever<BlockEntity, LockableObject> UNLOCKED_LOCKABLE_RETRIEVER = new DoubleBlockProperties.PropertyRetriever<>() {
+    private static final DoubleBlockCombiner.Combiner<BlockEntity, LockableObject> UNLOCKED_LOCKABLE_RETRIEVER = new DoubleBlockCombiner.Combiner<>() {
         @Override
-        public LockableObject getFromBoth(BlockEntity first, BlockEntity second) {
+        public @Nullable LockableObject acceptDouble(BlockEntity first, BlockEntity second) {
             if (first instanceof LockableObject lockable) {
                 if (lockable.getLock().isEmpty()) {
                     return lockable;
@@ -73,7 +74,7 @@ public LockableObject getFromBoth(BlockEntity first, BlockEntity second) {
         }
 
         @Override
-        public LockableObject getFrom(BlockEntity single) {
+        public @Nullable LockableObject acceptSingle(BlockEntity single) {
             if (single instanceof LockableObject lockable && lockable.getLock().isEmpty()) {
                 return lockable;
             }
@@ -81,12 +82,12 @@ public LockableObject getFrom(BlockEntity single) {
         }
 
         @Override
-        public LockableObject getFallback() {
+        public @Nullable LockableObject acceptNone() {
             return null;
         }
     };
 
-    public static void execute(MinecraftServer server, ServerPlayerEntity player, BlockPos pos) {
+    public static void execute(MinecraftServer server, ServerPlayer player, BlockPos pos) {
         LockInteraction action = pendingActions.get(player);
 
         Optional<LockableObject> lockableObject = getLockable(player, pos);
@@ -95,34 +96,35 @@ public static void execute(MinecraftServer server, ServerPlayerEntity player, Bl
             if (action.requiresLock()) {
                 containerLock.ifPresentOrElse(
                         lock -> action.execute(server, player, pos, object, lock),
-                        () -> player.sendMessage(HTMTexts.NOT_LOCKED, false));
+                        () -> player.displayClientMessage(HTMComponents.NOT_LOCKED, false));
             } else {
+                //noinspection DataFlowIssue - if requiresLock is false then action should be able to accept null lock
                 action.execute(server, player, pos, object, containerLock.orElse(null));
             }
-        }, () -> player.sendMessage(HTMTexts.NOT_LOCKABLE, false));
+        }, () -> player.displayClientMessage(HTMComponents.NOT_LOCKABLE, false));
 
-        if (!persisting.contains(player.getUuid())) {
+        if (!persisting.contains(player.getUUID())) {
             pendingActions.remove(player);
         }
     }
 
-    public static boolean canOpen(ServerPlayerEntity player, BlockPos pos) {
+    public static boolean canOpen(ServerPlayer player, BlockPos pos) {
         return getLock(player, pos).map(lock -> lock.canOpen(player)).orElse(true);
     }
 
-    public static Optional<HTMContainerLock> getLock(ServerPlayerEntity player, BlockPos pos) {
+    public static Optional<HTMContainerLock> getLock(ServerPlayer player, BlockPos pos) {
         return getLockable(player, pos).flatMap(LockableObject::getLock);
     }
 
-    public static Optional<LockableObject> getLockable(ServerPlayerEntity player, BlockPos pos) {
-        return getLockable(player.getEntityWorld(), pos);
+    public static Optional<LockableObject> getLockable(ServerPlayer player, BlockPos pos) {
+        return getLockable(player.level(), pos);
     }
 
-    public static Optional<HTMContainerLock> getLock(ServerWorld world, BlockPos pos) {
+    public static Optional<HTMContainerLock> getLock(ServerLevel world, BlockPos pos) {
         return getLockable(world, pos).flatMap(LockableObject::getLock);
     }
 
-    public static Optional<LockableObject> getLockable(ServerWorld world, BlockPos pos) {
+    public static Optional<LockableObject> getLockable(ServerLevel world, BlockPos pos) {
         BlockEntity blockEntity = world.getBlockEntity(pos);
         if (blockEntity == null) {
             return Optional.empty();
@@ -131,14 +133,15 @@ public static Optional<LockableObject> getLockable(ServerWorld world, BlockPos p
         return getLockable(world, pos, blockEntity);
     }
 
-    public static Optional<HTMContainerLock> getLock(ServerWorld world, BlockPos pos, BlockEntity blockEntity) {
+    public static Optional<HTMContainerLock> getLock(ServerLevel world, BlockPos pos, BlockEntity blockEntity) {
         return getLockable(world, pos, blockEntity).flatMap(LockableObject::getLock);
     }
 
-    public static Optional<LockableObject> getLockable(ServerWorld world, BlockPos pos, BlockEntity blockEntity) {
+    public static Optional<LockableObject> getLockable(ServerLevel world, BlockPos pos, BlockEntity blockEntity) {
         if (blockEntity instanceof ChestBlockEntity chest) {
-            DoubleBlockProperties.PropertySource<? extends BlockEntity> propertySource = DoubleBlockProperties.toPropertySource(chest.getType(), ChestBlock::getDoubleBlockType,
-                    ChestBlock::getFacing, ChestBlock.FACING, world.getBlockState(pos), world, pos, (access, blockPos) -> false);
+            DoubleBlockCombiner.NeighborCombineResult<? extends BlockEntity> propertySource = DoubleBlockCombiner.combineWithNeigbour(chest.getType(), ChestBlock::getBlockType,
+                    ChestBlock::getConnectedDirection, ChestBlock.FACING, world.getBlockState(pos), world, pos, (access, blockPos) -> false);
+            //noinspection OptionalOfNullableMisuse - LOCKABLE_RETRIEVER may return null
             return Optional.ofNullable(propertySource.apply(LOCKABLE_RETRIEVER));
         } else if (blockEntity instanceof LockableObject lockable) {
             return Optional.of(lockable);
@@ -146,10 +149,11 @@ public static Optional<LockableObject> getLockable(ServerWorld world, BlockPos p
         return Optional.empty();
     }
 
-    public static Optional<LockableObject> getUnlockedLockable(ServerWorld world, BlockPos pos, BlockEntity blockEntity) {
+    public static Optional<LockableObject> getUnlockedLockable(ServerLevel world, BlockPos pos, BlockEntity blockEntity) {
         if (blockEntity instanceof ChestBlockEntity chest) {
-            DoubleBlockProperties.PropertySource<? extends BlockEntity> propertySource = DoubleBlockProperties.toPropertySource(chest.getType(), ChestBlock::getDoubleBlockType,
-                    ChestBlock::getFacing, ChestBlock.FACING, world.getBlockState(pos), world, pos, (access, blockPos) -> false);
+            DoubleBlockCombiner.NeighborCombineResult<? extends BlockEntity> propertySource = DoubleBlockCombiner.combineWithNeigbour(chest.getType(), ChestBlock::getBlockType,
+                    ChestBlock::getConnectedDirection, ChestBlock.FACING, world.getBlockState(pos), world, pos, (access, blockPos) -> false);
+            //noinspection OptionalOfNullableMisuse - UNLOCKED_LOCKABLE_RETRIEVER may return null
             return Optional.ofNullable(propertySource.apply(UNLOCKED_LOCKABLE_RETRIEVER));
         } else if (blockEntity instanceof LockableObject lockable && lockable.getLock().isEmpty()) {
             return Optional.of(lockable);
@@ -157,36 +161,36 @@ public static Optional<LockableObject> getUnlockedLockable(ServerWorld world, Bl
         return Optional.empty();
     }
 
-    public static void togglePersist(ServerPlayerEntity player) {
-        if (persisting.contains(player.getUuid())) {
-            persisting.remove(player.getUuid());
+    public static void togglePersist(ServerPlayer player) {
+        if (persisting.contains(player.getUUID())) {
+            persisting.remove(player.getUUID());
         } else {
-            persisting.add(player.getUuid());
+            persisting.add(player.getUUID());
         }
     }
 
-    public static void toggleNoMessage(ServerPlayerEntity player) {
-        if (noMessage.contains(player.getUuid())) {
-            noMessage.remove(player.getUuid());
+    public static void toggleNoMessage(ServerPlayer player) {
+        if (noMessage.contains(player.getUUID())) {
+            noMessage.remove(player.getUUID());
         } else {
-            noMessage.add(player.getUuid());
+            noMessage.add(player.getUUID());
         }
     }
 
     @Override
-    public boolean isProtected(World world, BlockPos pos) {
-        var lock = InteractionManager.getLockable((ServerWorld) world, pos);
+    public boolean isProtected(Level world, BlockPos pos) {
+        var lock = InteractionManager.getLockable((ServerLevel) world, pos);
         return lock.isPresent();
     }
 
     @Override
-    public boolean canBreakBlock(World world, BlockPos pos, GameProfile profile, @Nullable PlayerEntity player) {
-        var lockable = InteractionManager.getLockable((ServerWorld) world, pos);
+    public boolean canBreakBlock(Level world, BlockPos pos, GameProfile profile, @Nullable Player player) {
+        var lockable = InteractionManager.getLockable((ServerLevel) world, pos);
         return lockable.flatMap(LockableObject::getLock).map(lock -> lock.owner().equals(profile.id())).orElse(true);
     }
 
     @Override
-    public boolean isAreaProtected(World world, Box area) {
+    public boolean isAreaProtected(Level world, AABB area) {
         return false;
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/interactions/RemoveAction.java b/src/main/java/com/github/fabricservertools/htm/interactions/RemoveAction.java
index 7afb46f..e776fc6 100644
--- a/src/main/java/com/github/fabricservertools/htm/interactions/RemoveAction.java
+++ b/src/main/java/com/github/fabricservertools/htm/interactions/RemoveAction.java
@@ -1,22 +1,23 @@
 package com.github.fabricservertools.htm.interactions;
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.api.LockInteraction;
 import com.github.fabricservertools.htm.api.LockableObject;
+import net.minecraft.core.BlockPos;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
 
 public class RemoveAction implements LockInteraction {
+
 	@Override
-	public void execute(MinecraftServer server, ServerPlayerEntity player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
+	public void execute(MinecraftServer server, ServerPlayer player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
 		if (!lock.isOwner(player)) {
-			player.sendMessage(HTMTexts.NOT_OWNER, false);
+			player.displayClientMessage(HTMComponents.NOT_OWNER, false);
 			return;
 		}
 
 		object.setLock(null);
-		player.sendMessage(HTMTexts.CONTAINER_UNLOCKED, false);
+		player.displayClientMessage(HTMComponents.CONTAINER_UNLOCKED, false);
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/interactions/SetAction.java b/src/main/java/com/github/fabricservertools/htm/interactions/SetAction.java
index 7fe8602..4bf7920 100644
--- a/src/main/java/com/github/fabricservertools/htm/interactions/SetAction.java
+++ b/src/main/java/com/github/fabricservertools/htm/interactions/SetAction.java
@@ -1,13 +1,14 @@
 package com.github.fabricservertools.htm.interactions;
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.api.Lock;
 import com.github.fabricservertools.htm.api.LockInteraction;
 import com.github.fabricservertools.htm.api.LockableObject;
+import net.minecraft.core.BlockPos;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import org.jspecify.annotations.Nullable;
 
 public class SetAction implements LockInteraction {
 	private final Lock setType;
@@ -17,15 +18,15 @@ public SetAction(Lock setType) {
 	}
 
 	@Override
-	public void execute(MinecraftServer server, ServerPlayerEntity player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
+	public void execute(MinecraftServer server, ServerPlayer player, BlockPos pos, LockableObject object, @Nullable HTMContainerLock lock) {
 		if (lock != null && !lock.isOwner(player)) {
-			player.sendMessage(HTMTexts.NOT_OWNER, false);
+			player.displayClientMessage(HTMComponents.NOT_OWNER, false);
 			return;
 		}
 
-		HTMContainerLock newLock = lock != null ? lock.withType(setType) : new HTMContainerLock(setType, player);
+		HTMContainerLock newLock = lock != null ? lock.withData(setType) : new HTMContainerLock(setType, player);
 		object.setLock(newLock);
-		player.sendMessage(HTMTexts.CONTAINER_SET.apply(setType.displayName()), false);
+		player.displayClientMessage(HTMComponents.CONTAINER_SET.apply(setType.displayName()), false);
 	}
 
 	@Override
diff --git a/src/main/java/com/github/fabricservertools/htm/interactions/TransferAction.java b/src/main/java/com/github/fabricservertools/htm/interactions/TransferAction.java
index 99c552f..f83e498 100644
--- a/src/main/java/com/github/fabricservertools/htm/interactions/TransferAction.java
+++ b/src/main/java/com/github/fabricservertools/htm/interactions/TransferAction.java
@@ -1,36 +1,36 @@
 package com.github.fabricservertools.htm.interactions;
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.api.LockInteraction;
 import com.github.fabricservertools.htm.api.LockableObject;
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.PlayerConfigEntry;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.players.NameAndId;
 
 public class TransferAction implements LockInteraction {
-	private final PlayerConfigEntry transferPlayer;
+	private final NameAndId transferPlayer;
 
-	public TransferAction(PlayerConfigEntry transferPlayer) {
+	public TransferAction(NameAndId transferPlayer) {
 		this.transferPlayer = transferPlayer;
 	}
 
 	@Override
-	public void execute(MinecraftServer server, ServerPlayerEntity player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
+	public void execute(MinecraftServer server, ServerPlayer player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
 		if (!lock.isOwner(player)) {
-			player.sendMessage(HTMTexts.NOT_OWNER, false);
+			player.displayClientMessage(HTMComponents.NOT_OWNER, false);
 			return;
 		}
 
 		if (lock.owner().equals(transferPlayer.id())) {
-			player.sendMessage(HTMTexts.CANNOT_TRUST_SELF, false);
+			player.displayClientMessage(HTMComponents.CANNOT_TRUST_SELF, false);
 			return;
 		}
 
 		object.setLock(lock.transfer(transferPlayer.id()));
-		player.sendMessage(HTMTexts.CONTAINER_TRANSFER.apply(Text.literal(transferPlayer.name()).formatted(Formatting.WHITE)), false);
+		player.displayClientMessage(HTMComponents.CONTAINER_TRANSFER.apply(Component.literal(transferPlayer.name()).withStyle(ChatFormatting.WHITE)), false);
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/interactions/TrustAction.java b/src/main/java/com/github/fabricservertools/htm/interactions/TrustAction.java
index cb7d475..c8a7032 100644
--- a/src/main/java/com/github/fabricservertools/htm/interactions/TrustAction.java
+++ b/src/main/java/com/github/fabricservertools/htm/interactions/TrustAction.java
@@ -1,51 +1,51 @@
 package com.github.fabricservertools.htm.interactions;
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.api.LockInteraction;
 import com.github.fabricservertools.htm.api.LockableObject;
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.PlayerConfigEntry;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.text.Text;
-import net.minecraft.util.Formatting;
-import net.minecraft.util.math.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.players.NameAndId;
 
 import java.util.Collection;
 
 public class TrustAction implements LockInteraction {
-	private final Collection<PlayerConfigEntry> trustPlayers;
+	private final Collection<NameAndId> trustPlayers;
 	private final boolean untrust;
 
-	public TrustAction(Collection<PlayerConfigEntry> trustPlayers, boolean untrust) {
+	public TrustAction(Collection<NameAndId> trustPlayers, boolean untrust) {
 		this.trustPlayers = trustPlayers;
 		this.untrust = untrust;
 	}
 
 	@Override
-	public void execute(MinecraftServer server, ServerPlayerEntity player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
+	public void execute(MinecraftServer server, ServerPlayer player, BlockPos pos, LockableObject object, HTMContainerLock lock) {
 		if (!lock.isOwner(player)) {
-			player.sendMessage(HTMTexts.NOT_OWNER, false);
+			player.displayClientMessage(HTMComponents.NOT_OWNER, false);
 			return;
 		}
 
-		for (PlayerConfigEntry trustPlayer : trustPlayers) {
+		for (NameAndId trustPlayer : trustPlayers) {
 			if (lock.owner().equals(trustPlayer.id())) {
-				player.sendMessage(HTMTexts.CANNOT_TRUST_SELF, false);
+				player.displayClientMessage(HTMComponents.CANNOT_TRUST_SELF, false);
 				continue;
 			}
 
-            Text playerName = Text.literal(trustPlayer.name()).formatted(Formatting.WHITE);
+            Component playerName = Component.literal(trustPlayer.name()).withStyle(ChatFormatting.WHITE);
 			if (untrust) {
 				lock.withoutTrusted(trustPlayer.id()).ifPresentOrElse(newLock -> {
-					player.sendMessage(HTMTexts.UNTRUST.apply(playerName), false);
+					player.displayClientMessage(HTMComponents.UNTRUST.apply(playerName), false);
 					object.setLock(newLock);
-				}, () -> player.sendMessage(HTMTexts.PLAYER_NOT_TRUSTED.apply(playerName), false));
+				}, () -> player.displayClientMessage(HTMComponents.PLAYER_NOT_TRUSTED.apply(playerName), false));
 			} else {
 				lock.withTrusted(trustPlayer.id()).ifPresentOrElse(newLock -> {
-					player.sendMessage(HTMTexts.TRUST.apply(playerName), false);
+					player.displayClientMessage(HTMComponents.TRUST.apply(playerName), false);
 					object.setLock(newLock);
-				}, () -> player.sendMessage(HTMTexts.ALREADY_TRUSTED.apply(playerName), false));
+				}, () -> player.displayClientMessage(HTMComponents.ALREADY_TRUSTED.apply(playerName), false));
 			}
 		}
 	}
diff --git a/src/main/java/com/github/fabricservertools/htm/interactions/package-info.java b/src/main/java/com/github/fabricservertools/htm/interactions/package-info.java
new file mode 100644
index 0000000..f71f7f8
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/interactions/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.interactions;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/listeners/LevelEventListener.java b/src/main/java/com/github/fabricservertools/htm/listeners/LevelEventListener.java
new file mode 100644
index 0000000..52ca452
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/listeners/LevelEventListener.java
@@ -0,0 +1,63 @@
+package com.github.fabricservertools.htm.listeners;
+
+import com.github.fabricservertools.htm.lock.HTMContainerLock;
+import com.github.fabricservertools.htm.events.BlockExplodeCallback;
+import com.github.fabricservertools.htm.events.EnderDragonBreakBlockCallback;
+import com.github.fabricservertools.htm.events.LevelBreakBlockCallback;
+import com.github.fabricservertools.htm.interactions.InteractionManager;
+
+import java.util.Optional;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Explosion;
+import net.minecraft.world.level.ExplosionDamageCalculator;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+import org.jspecify.annotations.Nullable;
+
+public class LevelEventListener {
+	public static void init() {
+		BlockExplodeCallback.EVENT.register(LevelEventListener::onBlockExplode);
+		LevelBreakBlockCallback.EVENT.register(LevelEventListener::onBlockBreak);
+		EnderDragonBreakBlockCallback.EVENT.register(LevelEventListener::enderDragonBreakBlock);
+	}
+
+	private static InteractionResult enderDragonBreakBlock(ServerLevel level, BlockPos pos, boolean b) {
+		BlockState state = level.getBlockState(pos);
+		if (!state.hasBlockEntity()) return InteractionResult.PASS;
+
+		if (InteractionManager.getLock(level, pos).isPresent()) return InteractionResult.FAIL;
+
+		return InteractionResult.PASS;
+	}
+
+	private static InteractionResult onBlockBreak(Level level, BlockPos pos, boolean drop, @Nullable Entity entity) {
+		if (level.isClientSide()) {
+            return InteractionResult.PASS;
+        }
+
+		Optional<HTMContainerLock> lock = InteractionManager.getLock((ServerLevel) level, pos);
+		if (lock.isEmpty()) {
+            return InteractionResult.PASS;
+        }
+
+		if (entity instanceof ServerPlayer) {
+			if (lock.get().isOwner((ServerPlayer) entity)) {
+                return InteractionResult.PASS;
+            }
+		}
+
+		return InteractionResult.FAIL;
+	}
+
+	private static InteractionResult onBlockExplode(ExplosionDamageCalculator damageCalculator, Explosion explosion, BlockPos pos, BlockState state) {
+		if (!state.hasBlockEntity()) return InteractionResult.PASS;
+
+		if (InteractionManager.getLock(explosion.level(), pos).isPresent()) return InteractionResult.FAIL;
+
+		return InteractionResult.PASS;
+	}
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/listeners/PlayerEventListener.java b/src/main/java/com/github/fabricservertools/htm/listeners/PlayerEventListener.java
index 477d86f..fdec746 100644
--- a/src/main/java/com/github/fabricservertools/htm/listeners/PlayerEventListener.java
+++ b/src/main/java/com/github/fabricservertools/htm/listeners/PlayerEventListener.java
@@ -1,28 +1,29 @@
 package com.github.fabricservertools.htm.listeners;
 
 import com.github.fabricservertools.htm.HTM;
+import com.github.fabricservertools.htm.api.Lock;
 import com.github.fabricservertools.htm.config.HTMConfig;
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.Utility;
 import com.github.fabricservertools.htm.api.LockableObject;
 import com.github.fabricservertools.htm.events.PlayerPlaceBlockCallback;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
-import com.github.fabricservertools.htm.lock.type.PrivateLock;
 import net.fabricmc.fabric.api.event.player.AttackBlockCallback;
 import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.ChestBlock;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.item.ItemPlacementContext;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.Hand;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
-import net.minecraft.world.World;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Optional;
 
@@ -33,25 +34,25 @@ public static void init() {
         AttackBlockCallback.EVENT.register(PlayerEventListener::onAttackBlock);
     }
 
-    private static ActionResult onAttackBlock(PlayerEntity player, World world, Hand hand, BlockPos pos, Direction direction) {
-        if (player instanceof ServerPlayerEntity serverPlayer) {
+    private static InteractionResult onAttackBlock(Player player, Level level, InteractionHand hand, BlockPos pos, Direction direction) {
+        if (player instanceof ServerPlayer serverPlayer) {
             if (InteractionManager.pendingActions.containsKey(serverPlayer)) {
-                InteractionManager.execute(serverPlayer.getEntityWorld().getServer(), serverPlayer, pos);
+                InteractionManager.execute(serverPlayer.level().getServer(), serverPlayer, pos);
 
-                world.updateNeighborsAlways(pos, world.getBlockState(pos).getBlock(), null);
-                return ActionResult.SUCCESS;
+                level.updateNeighborsAt(pos, level.getBlockState(pos).getBlock(), null);
+                return InteractionResult.SUCCESS;
             }
         }
 
-        return ActionResult.PASS;
+        return InteractionResult.PASS;
     }
 
-    private static boolean onBeforeBreak(World world, PlayerEntity player, BlockPos pos, BlockState state, BlockEntity blockEntity) {
-        if (world.isClient()) {
+    private static boolean onBeforeBreak(Level level, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity) {
+        if (level.isClientSide()) {
             return true;
         }
 
-        ServerPlayerEntity playerEntity = (ServerPlayerEntity) player;
+        ServerPlayer playerEntity = (ServerPlayer) player;
         if (blockEntity instanceof LockableObject) {
             Optional<HTMContainerLock> lock = InteractionManager.getLock(playerEntity, pos);
             if (lock.isEmpty()) {
@@ -60,18 +61,18 @@ private static boolean onBeforeBreak(World world, PlayerEntity player, BlockPos
 
             if (lock.get().isOwner(playerEntity) || (HTMConfig.get().canTrustedPlayersBreakChests() && lock.get().canOpen(playerEntity))) {
                 if (state.getBlock() instanceof ChestBlock) {
-                    Optional<LockableObject> unlocked = InteractionManager.getUnlockedLockable((ServerWorld) world, pos, blockEntity);
+                    Optional<LockableObject> unlocked = InteractionManager.getUnlockedLockable((ServerLevel) level, pos, blockEntity);
                     if (unlocked.isPresent()) {
                         unlocked.get().setLock(lock.get());
                         return true;
                     }
                 }
 
-                Utility.sendMessage(playerEntity, HTMTexts.CONTAINER_UNLOCKED);
+                Utility.sendMessage(playerEntity, HTMComponents.CONTAINER_UNLOCKED);
                 return true;
             }
 
-            Utility.sendMessage(playerEntity, HTMTexts.NOT_OWNER);
+            Utility.sendMessage(playerEntity, HTMComponents.NOT_OWNER);
             return false;
         }
 
@@ -79,31 +80,32 @@ private static boolean onBeforeBreak(World world, PlayerEntity player, BlockPos
     }
 
     @SuppressWarnings({"ConstantConditions", "SameReturnValue"})
-    private static ActionResult onPlace(PlayerEntity playerEntity, ItemPlacementContext context) {
+    private static InteractionResult onPlace(Player player, BlockPlaceContext context) {
         try {
-            BlockPos pos = context.getBlockPos();
-            World world = context.getWorld();
+            BlockPos pos = context.getClickedPos();
+            Level world = context.getLevel();
             BlockState state = world.getBlockState(pos);
 
-            if (world.isClient() || !state.hasBlockEntity()) {
-                return ActionResult.PASS;
+            if (!(player instanceof ServerPlayer serverPlayer) || !state.hasBlockEntity()) {
+                return InteractionResult.PASS;
             }
 
             BlockEntity blockEntity = world.getBlockEntity(pos);
             if (blockEntity instanceof LockableObject) {
-                if (HTMConfig.get().isAutoLocking(state)) {
-                    if (InteractionManager.getLock((ServerWorld) world, pos, blockEntity).isPresent()) {
-                        return ActionResult.PASS;
+                Optional<Lock.Type> autoLockingType = HTMConfig.get().getAutoLockingType(state);
+                if (autoLockingType.isPresent()) {
+                    if (InteractionManager.getLock((ServerLevel) world, pos, blockEntity).isPresent()) {
+                        return InteractionResult.PASS;
                     }
 
-                    ((LockableObject) blockEntity).setLock(new HTMContainerLock(PrivateLock.INSTANCE, (ServerPlayerEntity) playerEntity));
-                    Utility.sendMessage(playerEntity, HTMTexts.CONTAINER_SET.apply(PrivateLock.INSTANCE.displayName()));
+                    ((LockableObject) blockEntity).setLock(new HTMContainerLock(autoLockingType.get().create(serverPlayer), serverPlayer));
+                    Utility.sendMessage(player, HTMComponents.CONTAINER_SET.apply(autoLockingType.get().displayName()));
                 }
             }
         } catch (Exception e) {
             HTM.LOGGER.warn("Something went wrong auto locking", e);
         }
 
-        return ActionResult.PASS;
+        return InteractionResult.PASS;
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/listeners/WorldEventListener.java b/src/main/java/com/github/fabricservertools/htm/listeners/WorldEventListener.java
deleted file mode 100644
index 733eb37..0000000
--- a/src/main/java/com/github/fabricservertools/htm/listeners/WorldEventListener.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package com.github.fabricservertools.htm.listeners;
-
-import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.events.BlockExplodeCallback;
-import com.github.fabricservertools.htm.events.EnderDragonBreakBlockCallback;
-import com.github.fabricservertools.htm.events.WorldBreakBlockCallback;
-import com.github.fabricservertools.htm.interactions.InteractionManager;
-import net.minecraft.block.BlockState;
-import net.minecraft.entity.Entity;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import net.minecraft.world.explosion.Explosion;
-import net.minecraft.world.explosion.ExplosionBehavior;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Optional;
-
-public class WorldEventListener {
-	public static void init() {
-		BlockExplodeCallback.EVENT.register(WorldEventListener::onBlockExplode);
-		WorldBreakBlockCallback.EVENT.register(WorldEventListener::onBlockBreak);
-		EnderDragonBreakBlockCallback.EVENT.register(WorldEventListener::enderDragonBreakBlock);
-	}
-
-	private static ActionResult enderDragonBreakBlock(ServerWorld world, BlockPos pos, boolean b) {
-		BlockState state = world.getBlockState(pos);
-		if (!state.hasBlockEntity()) return ActionResult.PASS;
-
-		if (InteractionManager.getLock(world, pos).isPresent()) return ActionResult.FAIL;
-
-		return ActionResult.PASS;
-	}
-
-	private static ActionResult onBlockBreak(World world, BlockPos pos, boolean drop, @Nullable Entity entity) {
-		if (world.isClient()) {
-            return ActionResult.PASS;
-        }
-
-		Optional<HTMContainerLock> lock = InteractionManager.getLock((ServerWorld) world, pos);
-		if (lock.isEmpty()) {
-            return ActionResult.PASS;
-        }
-
-		if (entity instanceof ServerPlayerEntity) {
-			if (lock.get().isOwner((ServerPlayerEntity) entity)) {
-                return ActionResult.PASS;
-            }
-		}
-
-		return ActionResult.FAIL;
-	}
-
-	private static ActionResult onBlockExplode(ExplosionBehavior explosionBehavior, Explosion explosion, BlockPos pos, BlockState state) {
-		if (!state.hasBlockEntity()) return ActionResult.PASS;
-
-		if (InteractionManager.getLock(explosion.getWorld(), pos).isPresent()) return ActionResult.FAIL;
-
-		return ActionResult.PASS;
-	}
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/listeners/package-info.java b/src/main/java/com/github/fabricservertools/htm/listeners/package-info.java
new file mode 100644
index 0000000..c4eb181
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/listeners/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.listeners;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/lock/BlockFlagSet.java b/src/main/java/com/github/fabricservertools/htm/lock/BlockFlagSet.java
index 56c83e2..faa1382 100644
--- a/src/main/java/com/github/fabricservertools/htm/lock/BlockFlagSet.java
+++ b/src/main/java/com/github/fabricservertools/htm/lock/BlockFlagSet.java
@@ -4,15 +4,16 @@
 import com.github.fabricservertools.htm.config.SingleBlockSelector;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockState;
-import net.minecraft.registry.Registries;
-import net.minecraft.registry.entry.RegistryEntry;
-
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Objects;
 import java.util.function.BiFunction;
 import java.util.function.BiPredicate;
+import net.minecraft.core.Holder;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import org.jspecify.annotations.Nullable;
 
 public record BlockFlagSet(Map<SingleBlockSelector, FlagSet> overrides, FlagSet fallback, BlockFlagPredicate flagPredicate) {
     private static final Codec<Map<SingleBlockSelector, FlagSet>> OVERRIDES_CODEC = Codec.unboundedMap(SingleBlockSelector.CODEC, FlagSet.CONFIG_CODEC);
@@ -32,7 +33,7 @@ public BlockFlagSet(Map<SingleBlockSelector, FlagSet> overrides, FlagSet fallbac
     }
 
     public boolean get(FlagType flag, BlockState state) {
-        return flagPredicate.test(flag, Registries.BLOCK.getEntry(state.getBlock()));
+        return flagPredicate.test(flag, BuiltInRegistries.BLOCK.wrapAsHolder(state.getBlock()));
     }
 
     private static BlockFlagPredicate createFlagPredicate(Map<SingleBlockSelector, FlagSet> overrides, FlagSet fallback) {
@@ -44,8 +45,8 @@ private static BlockFlagPredicate createFlagPredicate(Map<SingleBlockSelector, F
         return builder;
     }
 
-    private record BlockFlagPredicate(BiFunction<FlagType, RegistryEntry<Block>, Boolean> predicate,
-                                      BlockFlagPredicate fallback) implements BiPredicate<FlagType, RegistryEntry<Block>> {
+    private record BlockFlagPredicate(BiFunction<FlagType, Holder<Block>, @Nullable Boolean> predicate,
+                                      @Nullable BlockFlagPredicate fallback) implements BiPredicate<FlagType, Holder<Block>> {
 
         private BlockFlagPredicate(Map.Entry<SingleBlockSelector, FlagSet> entry, BlockFlagPredicate fallback) {
             this((flag, block) -> {
@@ -56,17 +57,17 @@ private BlockFlagPredicate(Map.Entry<SingleBlockSelector, FlagSet> entry, BlockF
             }, fallback);
         }
 
-        private BlockFlagPredicate(BiPredicate<FlagType, RegistryEntry<Block>> fallback) {
+        private BlockFlagPredicate(BiPredicate<FlagType, Holder<Block>> fallback) {
             this(fallback::test, null);
         }
 
         @Override
-        public boolean test(FlagType flag, RegistryEntry<Block> block) {
+        public boolean test(FlagType flag, Holder<Block> block) {
             Boolean override = predicate.apply(flag, block);
             if (override != null) {
                 return override;
             }
-            return fallback.test(flag, block);
+            return Objects.requireNonNull(fallback, "fallback of BlockFlagPredicate may not be null when the predicate itself returns null").test(flag, block);
         }
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/lock/FlagSet.java b/src/main/java/com/github/fabricservertools/htm/lock/FlagSet.java
index e427605..d05d043 100644
--- a/src/main/java/com/github/fabricservertools/htm/lock/FlagSet.java
+++ b/src/main/java/com/github/fabricservertools/htm/lock/FlagSet.java
@@ -5,14 +5,13 @@
 import com.mojang.datafixers.util.Pair;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
-import net.minecraft.block.BlockState;
-
 import java.util.Arrays;
 import java.util.EnumMap;
 import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import net.minecraft.world.level.block.state.BlockState;
 
 public final class FlagSet {
     public static final FlagSet DEFAULT_FLAGS = new FlagSet(Arrays.stream(FlagType.values())
diff --git a/src/main/java/com/github/fabricservertools/htm/lock/HTMContainerLock.java b/src/main/java/com/github/fabricservertools/htm/lock/HTMContainerLock.java
index 50565b1..3f3230b 100644
--- a/src/main/java/com/github/fabricservertools/htm/lock/HTMContainerLock.java
+++ b/src/main/java/com/github/fabricservertools/htm/lock/HTMContainerLock.java
@@ -1,6 +1,6 @@
 package com.github.fabricservertools.htm.lock;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.Utility;
 import com.github.fabricservertools.htm.api.FlagType;
 import com.github.fabricservertools.htm.api.Lock;
@@ -8,12 +8,11 @@
 import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import me.lucko.fabric.api.permissions.v0.Permissions;
-import net.minecraft.block.BlockState;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.sound.SoundCategory;
-import net.minecraft.sound.SoundEvents;
-import net.minecraft.util.Uuids;
-
+import net.minecraft.core.UUIDUtil;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.level.block.state.BlockState;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
@@ -24,51 +23,51 @@ public record HTMContainerLock(Lock lockData, UUID owner, Set<UUID> trusted, Fla
 	public static final MapCodec<HTMContainerLock> MAP_CODEC = RecordCodecBuilder.mapCodec(instance ->
 			instance.group(
 					Lock.CODEC.forGetter(HTMContainerLock::lockData),
-					Uuids.INT_STREAM_CODEC.fieldOf("Owner").forGetter(HTMContainerLock::owner),
-					setOf(Uuids.INT_STREAM_CODEC.listOf()).fieldOf("Trusted").forGetter(HTMContainerLock::trusted),
+					UUIDUtil.CODEC.fieldOf("Owner").forGetter(HTMContainerLock::owner),
+					setOf(UUIDUtil.CODEC.listOf()).fieldOf("Trusted").forGetter(HTMContainerLock::trusted),
 					FlagSet.CODEC.fieldOf("Flags").forGetter(HTMContainerLock::flags)
 			).apply(instance, HTMContainerLock::new)
 	);
 	public static final Codec<HTMContainerLock> CODEC = MAP_CODEC.codec();
 
-	public HTMContainerLock(Lock type, ServerPlayerEntity owner) {
-		this(type, owner.getUuid(), Set.of(), FlagSet.EMPTY);
+	public HTMContainerLock(Lock type, ServerPlayer owner) {
+		this(type, owner.getUUID(), Set.of(), FlagSet.EMPTY);
 	}
 
 	private static <T> Codec<Set<T>> setOf(Codec<List<T>> listCodec) {
 		return listCodec.xmap(Set::copyOf, List::copyOf);
 	}
 
-	public boolean canOpen(ServerPlayerEntity player) {
-		if (lockData.canOpen(player, this)) return true;
-
-		if (isOwner(player)) return true;
+	public boolean canOpen(ServerPlayer player) {
+		if (isOwner(player) || lockData.canOpen(player, this)) {
+            return true;
+        }
 
-		player.sendMessage(HTMTexts.CONTAINER_LOCKED, true);
-		player.playSoundToPlayer(SoundEvents.BLOCK_CHEST_LOCKED, SoundCategory.BLOCKS, 1.0F, 1.0F);
+		player.displayClientMessage(HTMComponents.CONTAINER_LOCKED, true);
+        player.level().playSound(null, player.position().x(), player.position().y(), player.position().z(), SoundEvents.CHEST_LOCKED, SoundSource.BLOCKS, 1.0F, 1.0F);
 		return false;
 	}
 
-	public HTMContainerLock withType(Lock type) {
-		return new HTMContainerLock(type, owner, trusted, flags);
+	public HTMContainerLock withData(Lock newData) {
+		return new HTMContainerLock(newData, owner, trusted, flags);
 	}
 
-	public HTMContainerLock transfer(UUID id) {
-		return new HTMContainerLock(lockData, id, trusted, flags);
+	public HTMContainerLock transfer(UUID newOwner) {
+		return new HTMContainerLock(lockData, newOwner, trusted, flags);
 	}
 
-	public Optional<HTMContainerLock> withTrusted(UUID id) {
+	public Optional<HTMContainerLock> withTrusted(UUID trustedPlayer) {
 		Set<UUID> newTrusted = new HashSet<>(trusted);
-		boolean added = newTrusted.add(id);
+		boolean added = newTrusted.add(trustedPlayer);
 		if (added) {
 			return Optional.of(new HTMContainerLock(lockData, owner, Set.copyOf(newTrusted), flags));
 		}
 		return Optional.empty();
 	}
 
-	public Optional<HTMContainerLock> withoutTrusted(UUID id) {
+	public Optional<HTMContainerLock> withoutTrusted(UUID trustedPlayer) {
 		Set<UUID> newTrusted = new HashSet<>(trusted);
-		boolean removed = newTrusted.remove(id);
+		boolean removed = newTrusted.remove(trustedPlayer);
 		if (removed) {
 			return Optional.of(new HTMContainerLock(lockData, owner, Set.copyOf(newTrusted), flags));
 		}
@@ -83,16 +82,14 @@ public HTMContainerLock withoutFlag(FlagType flag) {
         return new HTMContainerLock(lockData, owner, trusted, flags.without(flag));
     }
 
-	public boolean isOwner(ServerPlayerEntity player) {
-		if (!owner.equals(player.getUuid())) {
+	public boolean isOwner(ServerPlayer player) {
+		if (!owner.equals(player.getUUID())) {
 			if (Permissions.check(player, "htm.admin", 2)) {
-				Utility.sendMessage(player, HTMTexts.CONTAINER_OVERRIDE.apply(Utility.getFormattedNameFromUUID(owner, player.getEntityWorld().getServer())));
+				Utility.sendMessage(player, HTMComponents.CONTAINER_OVERRIDE.apply(Utility.getFormattedNameFromUUID(owner, player.level().getServer())));
 				return true;
 			}
-
 			return false;
 		}
-
 		return true;
 	}
 
diff --git a/src/main/java/com/github/fabricservertools/htm/lock/package-info.java b/src/main/java/com/github/fabricservertools/htm/lock/package-info.java
new file mode 100644
index 0000000..3b2a6d7
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/lock/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.lock;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/lock/type/KeyLock.java b/src/main/java/com/github/fabricservertools/htm/lock/type/KeyLock.java
index f2d3e78..a088e35 100644
--- a/src/main/java/com/github/fabricservertools/htm/lock/type/KeyLock.java
+++ b/src/main/java/com/github/fabricservertools/htm/lock/type/KeyLock.java
@@ -1,6 +1,6 @@
 package com.github.fabricservertools.htm.lock.type;
 
-import com.github.fabricservertools.htm.HTMTexts;
+import com.github.fabricservertools.htm.HTMComponents;
 import com.github.fabricservertools.htm.Utility;
 import com.github.fabricservertools.htm.api.Lock;
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
@@ -12,15 +12,15 @@
 import com.mojang.serialization.DynamicOps;
 import com.mojang.serialization.MapCodec;
 import net.minecraft.SharedConstants;
-import net.minecraft.datafixer.Schemas;
-import net.minecraft.datafixer.TypeReferences;
-import net.minecraft.item.ItemStack;
-import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.datafix.DataFixers;
+import net.minecraft.util.datafix.fixes.References;
+import net.minecraft.world.item.ItemStack;
 
 public record KeyLock(ItemStack key) implements Lock {
 	// You're really not supposed to do it like this... but it works
-	private static final Codec<ItemStack> VERSIONED_ITEM_STACK = Codec.INT.dispatch(SharedConstants.DATA_VERSION_KEY,
-			stack -> SharedConstants.getGameVersion().dataVersion().id(), KeyLock::itemStackCodec);
+	private static final Codec<ItemStack> VERSIONED_ITEM_STACK = Codec.INT.dispatch(SharedConstants.DATA_VERSION_TAG,
+			stack -> SharedConstants.getCurrentVersion().dataVersion().version(), KeyLock::itemStackCodec);
 
 	public static final Codec<KeyLock> CODEC = VERSIONED_ITEM_STACK.xmap(KeyLock::new, KeyLock::key);
 
@@ -30,25 +30,25 @@ private static MapCodec<ItemStack> itemStackCodec(int dataVersion) {
                     @Override
                     public <T> DataResult<Pair<ItemStack, T>> decode(DynamicOps<T> ops, T input) {
                         Dynamic<T> dynamic = new Dynamic<>(ops, input);
-                        return ItemStack.OPTIONAL_CODEC.decode(Schemas.getFixer().update(TypeReferences.ITEM_STACK, dynamic, dataVersion, SharedConstants.getGameVersion().dataVersion().id()));
+                        return ItemStack.OPTIONAL_CODEC.decode(DataFixers.getDataFixer().update(References.ITEM_STACK, dynamic, dataVersion, SharedConstants.getCurrentVersion().dataVersion().version()));
                     }
                 }).fieldOf("Item");
 	}
 
 	@Override
-	public boolean canOpen(ServerPlayerEntity player, HTMContainerLock lock) {
-		if (Utility.getGlobalTrustState(player.getEntityWorld().getServer()).isTrusted(lock.owner(), player.getUuid())
-                || lock.isTrusted(player.getUuid())) {
+	public boolean canOpen(ServerPlayer player, HTMContainerLock lock) {
+		if (Utility.getGlobalTrustData(player.level().getServer()).isTrusted(lock.owner(), player.getUUID())
+                || lock.isTrusted(player.getUUID())) {
             return true;
         }
 
-		ItemStack itemStack = player.getMainHandStack();
-		return ItemStack.areItemsAndComponentsEqual(itemStack, key);
+		ItemStack itemStack = player.getMainHandItem();
+		return ItemStack.isSameItemSameComponents(itemStack, key);
 	}
 
 	@Override
-	public void onInfo(ServerPlayerEntity player, HTMContainerLock lock) {
-		player.sendMessage(HTMTexts.CONTAINER_KEY.apply(key.toHoverableText()), false);
+	public void onInfo(ServerPlayer player, HTMContainerLock lock) {
+		player.displayClientMessage(HTMComponents.CONTAINER_KEY.apply(key.getDisplayName()), false);
 	}
 
 	@Override
@@ -56,9 +56,9 @@ public Type type() {
 		return Type.KEY;
 	}
 
-	public static KeyLock fromMainHandItem(ServerPlayerEntity player) {
-		ItemStack key = player.getMainHandStack().copy();
-		player.sendMessage(HTMTexts.CONTAINER_KEY_SET.apply(key.toHoverableText()), false);
+	public static KeyLock fromMainHandItem(ServerPlayer player) {
+		ItemStack key = player.getMainHandItem().copy();
+		player.displayClientMessage(HTMComponents.CONTAINER_KEY_SET.apply(key.getDisplayName()), false);
 		return new KeyLock(key);
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/lock/type/PrivateLock.java b/src/main/java/com/github/fabricservertools/htm/lock/type/PrivateLock.java
index 8761f78..e9434a1 100644
--- a/src/main/java/com/github/fabricservertools/htm/lock/type/PrivateLock.java
+++ b/src/main/java/com/github/fabricservertools/htm/lock/type/PrivateLock.java
@@ -4,18 +4,22 @@
 import com.github.fabricservertools.htm.api.Lock;
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
 import com.mojang.serialization.Codec;
-import net.minecraft.server.network.ServerPlayerEntity;
+import com.mojang.serialization.MapCodec;
+import net.minecraft.server.level.ServerPlayer;
 
 public class PrivateLock implements Lock {
 	public static final PrivateLock INSTANCE = new PrivateLock();
-	public static final Codec<PrivateLock> CODEC = Codec.unit(INSTANCE);
+	public static final Codec<PrivateLock> CODEC = MapCodec.unitCodec(INSTANCE);
 
 	private PrivateLock() {}
 
 	@Override
-	public boolean canOpen(ServerPlayerEntity player, HTMContainerLock lock) {
-		if (lock.isTrusted(player.getUuid())) return true;
-		return Utility.getGlobalTrustState(player.getEntityWorld().getServer()).isTrusted(lock.owner(), player.getUuid());
+	public boolean canOpen(ServerPlayer player, HTMContainerLock lock) {
+		if (lock.isTrusted(player.getUUID())) {
+            return true;
+        }
+
+		return Utility.getGlobalTrustData(player.level().getServer()).isTrusted(lock.owner(), player.getUUID());
 	}
 
 	@Override
diff --git a/src/main/java/com/github/fabricservertools/htm/lock/type/PublicLock.java b/src/main/java/com/github/fabricservertools/htm/lock/type/PublicLock.java
index ed380c2..3243bd1 100644
--- a/src/main/java/com/github/fabricservertools/htm/lock/type/PublicLock.java
+++ b/src/main/java/com/github/fabricservertools/htm/lock/type/PublicLock.java
@@ -3,16 +3,17 @@
 import com.github.fabricservertools.htm.api.Lock;
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
 import com.mojang.serialization.Codec;
-import net.minecraft.server.network.ServerPlayerEntity;
+import com.mojang.serialization.MapCodec;
+import net.minecraft.server.level.ServerPlayer;
 
 public class PublicLock implements Lock {
 	public static final PublicLock INSTANCE = new PublicLock();
-	public static final Codec<PublicLock> CODEC = Codec.unit(INSTANCE);
+	public static final Codec<PublicLock> CODEC = MapCodec.unitCodec(INSTANCE);
 
 	private PublicLock() {}
 
 	@Override
-	public boolean canOpen(ServerPlayerEntity player, HTMContainerLock lock) {
+	public boolean canOpen(ServerPlayer player, HTMContainerLock lock) {
 		return true;
 	}
 
diff --git a/src/main/java/com/github/fabricservertools/htm/lock/type/package-info.java b/src/main/java/com/github/fabricservertools/htm/lock/type/package-info.java
new file mode 100644
index 0000000..ff77ab6
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/lock/type/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.lock.type;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/HopperBlockEntityMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/HopperBlockEntityMixin.java
index 97393ef..4fda040 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/HopperBlockEntityMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/HopperBlockEntityMixin.java
@@ -3,14 +3,6 @@
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
 import com.github.fabricservertools.htm.api.FlagType;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.block.entity.Hopper;
-import net.minecraft.block.entity.HopperBlockEntity;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
-import net.minecraft.world.World;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
@@ -18,31 +10,41 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 import java.util.Optional;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.Hopper;
+import net.minecraft.world.level.block.entity.HopperBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
 
 @Mixin(HopperBlockEntity.class)
 public abstract class HopperBlockEntityMixin {
-	@Inject(method = "extract(Lnet/minecraft/world/World;Lnet/minecraft/block/entity/Hopper;)Z", at = @At(value = "FIELD", target = "Lnet/minecraft/util/math/Direction;DOWN:Lnet/minecraft/util/math/Direction;", shift = At.Shift.AFTER), cancellable = true)
-    private static void extractHTMCheck(World world, Hopper hopper, CallbackInfoReturnable<Boolean> cir) {
+
+	@Inject(method = "suckInItems(Lnet/minecraft/world/level/Level;Lnet/minecraft/world/level/block/entity/Hopper;)Z", at = @At(value = "FIELD", target = "Lnet/minecraft/core/Direction;DOWN:Lnet/minecraft/core/Direction;", shift = At.Shift.AFTER), cancellable = true)
+    private static void extractHTMCheck(Level level, Hopper hopper, CallbackInfoReturnable<Boolean> cir) {
         // only checks extraction, so only needs to check block above hopper
-        if (!isBlockContainerHopperable(world, BlockPos.ofFloored(hopper.getHopperX(), hopper.getHopperY(), hopper.getHopperZ()).offset(Direction.UP)))
+        if (!isBlockContainerHopperable(level, BlockPos.containing(hopper.getLevelX(), hopper.getLevelY(), hopper.getLevelZ()).relative(Direction.UP))) {
             cir.setReturnValue(true); // if block is not hopperable, cancel the extract method call
+        }
         // otherwise continue the extract method as normal
     }
 
 	//TODO optimize better
     @Unique
-    private static boolean isBlockContainerHopperable(World world, BlockPos pos) {
-        if (world.isClient()) {
+    private static boolean isBlockContainerHopperable(Level level, BlockPos pos) {
+        if (level.isClientSide()) {
             return true;
         }
 
-        BlockEntity blockEntity = world.getBlockEntity(pos);
+        BlockEntity blockEntity = level.getBlockEntity(pos);
         if (blockEntity == null) { // no block entity above
             return true;
         }
 
-        BlockState state = world.getBlockState(pos);
-        Optional<HTMContainerLock> lock = InteractionManager.getLock((ServerWorld) world, pos, blockEntity);
-        return lock.map(l -> l.flag(FlagType.HOPPERS, state)).orElse(true);
+        BlockState state = level.getBlockState(pos);
+        Optional<HTMContainerLock> lock = InteractionManager.getLock((ServerLevel) level, pos, blockEntity);
+        return lock.map(present -> present.flag(FlagType.HOPPERS, state)).orElse(true);
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/MoveItemsTaskMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/MoveItemsTaskMixin.java
deleted file mode 100644
index b16455f..0000000
--- a/src/main/java/com/github/fabricservertools/htm/mixin/MoveItemsTaskMixin.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package com.github.fabricservertools.htm.mixin;
-
-import com.github.fabricservertools.htm.api.FlagType;
-import com.github.fabricservertools.htm.interactions.InteractionManager;
-import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import net.minecraft.entity.ai.brain.MemoryModuleState;
-import net.minecraft.entity.ai.brain.MemoryModuleType;
-import net.minecraft.entity.ai.brain.task.MoveItemsTask;
-import net.minecraft.entity.ai.brain.task.MultiTickTask;
-import net.minecraft.entity.mob.PathAwareEntity;
-import net.minecraft.server.world.ServerWorld;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Map;
-import java.util.Optional;
-
-@Mixin(MoveItemsTask.class)
-public abstract class MoveItemsTaskMixin extends MultiTickTask<PathAwareEntity> {
-
-    public MoveItemsTaskMixin(Map<MemoryModuleType<?>, MemoryModuleState> requiredMemoryState) {
-        super(requiredMemoryState);
-    }
-
-    @Inject(method = "isLocked", at = @At("RETURN"), cancellable = true)
-    private void checkLockedContainerFlags(MoveItemsTask.Storage storage, CallbackInfoReturnable<Boolean> cir) {
-        if (!cir.getReturnValueZ() && storage.blockEntity().getWorld() instanceof ServerWorld world) {
-            Optional<HTMContainerLock> lock = InteractionManager.getLock(world, storage.pos(), storage.blockEntity());
-            cir.setReturnValue(lock.isPresent() && !lock.get().flag(FlagType.COPPER_GOLEMS, storage.state()));
-        }
-    }
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/PistonBlockMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/PistonBlockMixin.java
index e861487..88437a8 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/PistonBlockMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/PistonBlockMixin.java
@@ -3,33 +3,33 @@
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
 import com.github.fabricservertools.htm.interactions.InteractionManager;
 import com.llamalad7.mixinextras.sugar.Local;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.PistonBlock;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Direction;
-import net.minecraft.world.World;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 import java.util.Optional;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.piston.PistonBaseBlock;
+import net.minecraft.world.level.block.state.BlockState;
 
-@Mixin(PistonBlock.class)
+@Mixin(PistonBaseBlock.class)
 public abstract class PistonBlockMixin {
 
 	@Inject(
-			method = "move",
+			method = "moveBlocks",
 			at = @At(value = "INVOKE", target = "Ljava/util/List;add(Ljava/lang/Object;)Z"),
 			cancellable = true)
-	private void HTMPistonMoveCheck(World world, BlockPos pos, Direction dir, boolean extend, CallbackInfoReturnable<Boolean> cir, @Local BlockState state, @Local(ordinal = 2) BlockPos blockPos) {
-		if (world.isClient()) {
+	private void HTMPistonMoveCheck(Level level, BlockPos pos, Direction direction, boolean extend, CallbackInfoReturnable<Boolean> cir, @Local BlockState state, @Local(ordinal = 2) BlockPos blockPos) {
+		if (level.isClientSide()) {
             return;
         }
 
 		if (state.hasBlockEntity()) {
-			Optional<HTMContainerLock> lock = InteractionManager.getLock((ServerWorld) world, blockPos);
+			Optional<HTMContainerLock> lock = InteractionManager.getLock((ServerLevel) level, blockPos);
 			if (lock.isPresent()) {
 				cir.setReturnValue(false);
 			}
@@ -37,17 +37,17 @@ private void HTMPistonMoveCheck(World world, BlockPos pos, Direction dir, boolea
 	}
 
 	@Inject(
-			method = "move",
-			at = @At(value = "INVOKE", target = "Lnet/minecraft/block/BlockState;hasBlockEntity()Z"),
+			method = "moveBlocks",
+			at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/state/BlockState;hasBlockEntity()Z"),
 			cancellable = true)
-	private void HTMPistonDestroyCheck(World world, BlockPos pos, Direction dir, boolean retract, CallbackInfoReturnable<Boolean> cir,
-									   @Local BlockState state, @Local(ordinal = 2) BlockPos blockPos) {
-		if (world.isClient()) {
+	private void HTMPistonDestroyCheck(Level level, BlockPos pos, Direction direction, boolean retract, CallbackInfoReturnable<Boolean> cir,
+                                       @Local BlockState state, @Local(ordinal = 2) BlockPos blockPos) {
+		if (level.isClientSide()) {
             return;
         }
 
 		if (state.hasBlockEntity()) {
-			Optional<HTMContainerLock> lock = InteractionManager.getLock((ServerWorld) world, blockPos);
+			Optional<HTMContainerLock> lock = InteractionManager.getLock((ServerLevel) level, blockPos);
 			if (lock.isPresent()) {
 				cir.setReturnValue(false);
 			}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/TransportItemsBetweenContainersMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/TransportItemsBetweenContainersMixin.java
new file mode 100644
index 0000000..7cb71b9
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/TransportItemsBetweenContainersMixin.java
@@ -0,0 +1,34 @@
+package com.github.fabricservertools.htm.mixin;
+
+import com.github.fabricservertools.htm.api.FlagType;
+import com.github.fabricservertools.htm.interactions.InteractionManager;
+import com.github.fabricservertools.htm.lock.HTMContainerLock;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.Map;
+import java.util.Optional;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.PathfinderMob;
+import net.minecraft.world.entity.ai.behavior.Behavior;
+import net.minecraft.world.entity.ai.behavior.TransportItemsBetweenContainers;
+import net.minecraft.world.entity.ai.memory.MemoryModuleType;
+import net.minecraft.world.entity.ai.memory.MemoryStatus;
+
+@Mixin(TransportItemsBetweenContainers.class)
+public abstract class TransportItemsBetweenContainersMixin extends Behavior<PathfinderMob> {
+
+    public TransportItemsBetweenContainersMixin(Map<MemoryModuleType<?>, MemoryStatus> map) {
+        super(map);
+    }
+
+    @Inject(method = "isContainerLocked", at = @At("RETURN"), cancellable = true)
+    private void checkLockedContainerFlags(TransportItemsBetweenContainers.TransportItemTarget target, CallbackInfoReturnable<Boolean> cir) {
+        if (!cir.getReturnValueZ() && target.blockEntity().getLevel() instanceof ServerLevel world) {
+            Optional<HTMContainerLock> lock = InteractionManager.getLock(world, target.pos(), target.blockEntity());
+            cir.setReturnValue(lock.isPresent() && !lock.get().flag(FlagType.COPPER_GOLEMS, target.state()));
+        }
+    }
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/events/BlockItemMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/events/BlockItemMixin.java
index 813d0f0..ea7c206 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/events/BlockItemMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/events/BlockItemMixin.java
@@ -1,10 +1,10 @@
 package com.github.fabricservertools.htm.mixin.events;
 
 import com.github.fabricservertools.htm.events.PlayerPlaceBlockCallback;
-import net.minecraft.item.BlockItem;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemPlacementContext;
-import net.minecraft.util.ActionResult;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.context.BlockPlaceContext;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -12,8 +12,9 @@
 
 @Mixin(BlockItem.class)
 public abstract class BlockItemMixin extends Item {
-	public BlockItemMixin(Settings settings) {
-		super(settings);
+
+	public BlockItemMixin(Properties properties) {
+		super(properties);
 	}
 
 	/**
@@ -22,18 +23,19 @@ public BlockItemMixin(Settings settings) {
 	@Inject(
 			at = @At(
 					value = "INVOKE",
-					target = "Lnet/minecraft/item/ItemPlacementContext;getBlockPos()Lnet/minecraft/util/math/BlockPos;"
+					target = "Lnet/minecraft/world/item/context/BlockPlaceContext;getClickedPos()Lnet/minecraft/core/BlockPos;"
 			),
-			method = "place(Lnet/minecraft/item/ItemPlacementContext;)Lnet/minecraft/util/ActionResult;",
+			method = "place(Lnet/minecraft/world/item/context/BlockPlaceContext;)Lnet/minecraft/world/InteractionResult;",
 			cancellable = true
 	)
-	public void HTMPlaceEventTrigger(ItemPlacementContext context, CallbackInfoReturnable<ActionResult> info) {
-		if (context.getPlayer() == null) return;
-
-		ActionResult result = PlayerPlaceBlockCallback.EVENT.invoker().place(context.getPlayer(), context);
+	public void HTMPlaceEventTrigger(BlockPlaceContext context, CallbackInfoReturnable<InteractionResult> cir) {
+		if (context.getPlayer() == null) {
+            return;
+        }
 
-		if (result != ActionResult.PASS) {
-			info.setReturnValue(ActionResult.FAIL);
+		InteractionResult result = PlayerPlaceBlockCallback.EVENT.invoker().place(context.getPlayer(), context);
+		if (result != InteractionResult.PASS) {
+			cir.setReturnValue(InteractionResult.FAIL);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/events/EnderDragonEntityMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/events/EnderDragonEntityMixin.java
deleted file mode 100644
index 9a5415d..0000000
--- a/src/main/java/com/github/fabricservertools/htm/mixin/events/EnderDragonEntityMixin.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package com.github.fabricservertools.htm.mixin.events;
-
-import com.github.fabricservertools.htm.events.EnderDragonBreakBlockCallback;
-import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
-import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
-import net.minecraft.entity.boss.dragon.EnderDragonEntity;
-import net.minecraft.server.world.ServerWorld;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.math.BlockPos;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-
-@Mixin(EnderDragonEntity.class)
-public abstract class EnderDragonEntityMixin {
-
-	@WrapOperation(method = "destroyBlocks", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/world/ServerWorld;removeBlock(Lnet/minecraft/util/math/BlockPos;Z)Z"))
-	public boolean checkEvent(ServerWorld world, BlockPos blockPos, boolean move, Operation<Boolean> original) {
-		if (EnderDragonBreakBlockCallback.EVENT.invoker().blockBreak(world, blockPos, move) != ActionResult.PASS) {
-			return false;
-		}
-		return original.call(world, blockPos, move);
-	}
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/events/EnderDragonMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/events/EnderDragonMixin.java
new file mode 100644
index 0000000..808493a
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/events/EnderDragonMixin.java
@@ -0,0 +1,30 @@
+package com.github.fabricservertools.htm.mixin.events;
+
+import com.github.fabricservertools.htm.events.EnderDragonBreakBlockCallback;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.boss.enderdragon.EnderDragon;
+import net.minecraft.world.level.Level;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(EnderDragon.class)
+public abstract class EnderDragonMixin extends Mob {
+
+    protected EnderDragonMixin(EntityType<? extends Mob> entityType, Level level) {
+        super(entityType, level);
+    }
+
+    @WrapOperation(method = "checkWalls", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerLevel;removeBlock(Lnet/minecraft/core/BlockPos;Z)Z"))
+	public boolean checkEvent(ServerLevel level, BlockPos pos, boolean move, Operation<Boolean> original) {
+		if (EnderDragonBreakBlockCallback.EVENT.invoker().blockBreak(level, pos, move) != InteractionResult.PASS) {
+			return false;
+		}
+		return original.call(level, pos, move);
+	}
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/events/ExplosionImplMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/events/ExplosionImplMixin.java
deleted file mode 100644
index 5555741..0000000
--- a/src/main/java/com/github/fabricservertools/htm/mixin/events/ExplosionImplMixin.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package com.github.fabricservertools.htm.mixin.events;
-
-import com.github.fabricservertools.htm.events.BlockExplodeCallback;
-import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
-import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
-import net.minecraft.block.BlockState;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.BlockView;
-import net.minecraft.world.explosion.Explosion;
-import net.minecraft.world.explosion.ExplosionBehavior;
-import net.minecraft.world.explosion.ExplosionImpl;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-
-@Mixin(ExplosionImpl.class)
-public abstract class ExplosionImplMixin implements Explosion{
-
-	@WrapOperation(method = "getBlocksToDestroy", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/explosion/ExplosionBehavior;canDestroyBlock(Lnet/minecraft/world/explosion/Explosion;Lnet/minecraft/world/BlockView;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;F)Z"))
-	private boolean HTMExplosionProtectionCheck(ExplosionBehavior behavior, Explosion explosion, BlockView world, BlockPos pos, BlockState state, float power, Operation<Boolean> original) {
-		return BlockExplodeCallback.EVENT.invoker().explode(behavior, this, pos, state) == ActionResult.PASS
-				&& original.call(behavior, explosion, world, pos, state, power);
-	}
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/events/LevelMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/events/LevelMixin.java
new file mode 100644
index 0000000..04ad766
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/events/LevelMixin.java
@@ -0,0 +1,26 @@
+package com.github.fabricservertools.htm.mixin.events;
+
+import com.github.fabricservertools.htm.events.LevelBreakBlockCallback;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
+import org.jspecify.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(Level.class)
+public abstract class LevelMixin {
+
+    @Inject(method = "destroyBlock", at = @At("HEAD"), cancellable = true)
+	private void checkBlockBreakForLock(BlockPos pos, boolean drop, @Nullable Entity breakingEntity, int maxUpdateDepth, CallbackInfoReturnable<Boolean> cir) {
+		InteractionResult result = LevelBreakBlockCallback.EVENT.invoker().blockBreak((Level) (Object) this, pos, drop, breakingEntity);
+
+		if (result != InteractionResult.PASS) {
+			cir.setReturnValue(false);
+			cir.cancel();
+		}
+	}
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/events/ServerExplosionMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/events/ServerExplosionMixin.java
new file mode 100644
index 0000000..51e05fe
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/events/ServerExplosionMixin.java
@@ -0,0 +1,25 @@
+package com.github.fabricservertools.htm.mixin.events;
+
+import com.github.fabricservertools.htm.events.BlockExplodeCallback;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Explosion;
+import net.minecraft.world.level.ExplosionDamageCalculator;
+import net.minecraft.world.level.ServerExplosion;
+import net.minecraft.world.level.block.state.BlockState;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(ServerExplosion.class)
+public abstract class ServerExplosionMixin implements Explosion {
+
+	@WrapOperation(method = "calculateExplodedPositions", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/ExplosionDamageCalculator;shouldBlockExplode(Lnet/minecraft/world/level/Explosion;Lnet/minecraft/world/level/BlockGetter;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/state/BlockState;F)Z"))
+	private boolean HTMExplosionProtectionCheck(ExplosionDamageCalculator damageCalculator, Explosion explosion, BlockGetter level, BlockPos pos,
+                                                BlockState state, float power, Operation<Boolean> original) {
+		return BlockExplodeCallback.EVENT.invoker().explode(damageCalculator, this, pos, state) == InteractionResult.PASS
+				&& original.call(damageCalculator, explosion, level, pos, state, power);
+	}
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/events/WorldMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/events/WorldMixin.java
deleted file mode 100644
index c364b8a..0000000
--- a/src/main/java/com/github/fabricservertools/htm/mixin/events/WorldMixin.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package com.github.fabricservertools.htm.mixin.events;
-
-import com.github.fabricservertools.htm.events.WorldBreakBlockCallback;
-import net.minecraft.entity.Entity;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import org.jetbrains.annotations.Nullable;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(World.class)
-public abstract class WorldMixin {
-	@Inject(method = "breakBlock", at = @At("HEAD"), cancellable = true)
-	private void checkBlockBreakForLock(BlockPos pos, boolean drop, @Nullable Entity breakingEntity, int maxUpdateDepth, CallbackInfoReturnable<Boolean> cir) {
-		ActionResult result = WorldBreakBlockCallback.EVENT.invoker().blockBreak((World) (Object) this, pos, drop, breakingEntity);
-
-		if (result != ActionResult.PASS) {
-			cir.setReturnValue(false);
-			cir.cancel();
-		}
-	}
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/events/package-info.java b/src/main/java/com/github/fabricservertools/htm/mixin/events/package-info.java
new file mode 100644
index 0000000..829fc24
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/events/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.mixin.events;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookShelfBlockEntityMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookShelfBlockEntityMixin.java
new file mode 100644
index 0000000..c5af8c7
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookShelfBlockEntityMixin.java
@@ -0,0 +1,62 @@
+package com.github.fabricservertools.htm.mixin.lockable;
+
+import com.github.fabricservertools.htm.lock.HTMContainerLock;
+import com.github.fabricservertools.htm.api.LockableObject;
+import org.jspecify.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.Optional;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.Container;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.entity.ChiseledBookShelfBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.storage.ValueInput;
+import net.minecraft.world.level.storage.ValueOutput;
+
+@Mixin(ChiseledBookShelfBlockEntity.class)
+public abstract class ChiseledBookShelfBlockEntityMixin extends BlockEntity implements Container, LockableObject {
+
+    @Unique
+    private @Nullable HTMContainerLock lock = null;
+
+    public ChiseledBookShelfBlockEntityMixin(BlockEntityType<?> type, BlockPos pos, BlockState state) {
+        super(type, pos, state);
+    }
+
+    @Inject(method = "loadAdditional", at = @At("TAIL"))
+    public void readLockData(ValueInput input, CallbackInfo ci) {
+        readLock(input, lock -> this.lock = lock);
+    }
+
+    @Inject(method = "saveAdditional", at = @At("TAIL"))
+    public void writeLockData(ValueOutput output, CallbackInfo ci) {
+        writeLock(output);
+    }
+
+    @Inject(method = "stillValid", at = @At("HEAD"), cancellable = true)
+    public void checkLock(Player player, CallbackInfoReturnable<Boolean> cir) {
+        if (player instanceof ServerPlayer serverPlayer && !canOpenUnchecked(serverPlayer)) {
+            cir.setReturnValue(false);
+        }
+    }
+
+    @Override
+    public Optional<HTMContainerLock> getLock() {
+        return Optional.ofNullable(lock);
+    }
+
+    @Override
+    public void setLock(@Nullable HTMContainerLock lock) {
+        this.lock = lock;
+        setChanged();
+    }
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookShelfBlockMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookShelfBlockMixin.java
new file mode 100644
index 0000000..2b349a4
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookShelfBlockMixin.java
@@ -0,0 +1,44 @@
+package com.github.fabricservertools.htm.mixin.lockable;
+
+import com.github.fabricservertools.htm.interactions.InteractionManager;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.ChiseledBookShelfBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(ChiseledBookShelfBlock.class)
+public abstract class ChiseledBookShelfBlockMixin extends BaseEntityBlock {
+
+    protected ChiseledBookShelfBlockMixin(Properties settings) {
+        super(settings);
+    }
+
+    @Inject(method = "useItemOn",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/ChiseledBookShelfBlock;addBook(Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/entity/player/Player;Lnet/minecraft/world/level/block/entity/ChiseledBookShelfBlockEntity;Lnet/minecraft/world/item/ItemStack;I)V"),
+            cancellable = true)
+    public void checkLock(ItemStack stack, BlockState state, Level level, BlockPos pos, Player player, InteractionHand hand, BlockHitResult hitResult, CallbackInfoReturnable<InteractionResult> cir) {
+        if (player instanceof ServerPlayer serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
+            cir.setReturnValue(InteractionResult.FAIL);
+        }
+    }
+
+    @Inject(method = "useWithoutItem",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/ChiseledBookShelfBlock;removeBook(Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/entity/player/Player;Lnet/minecraft/world/level/block/entity/ChiseledBookShelfBlockEntity;I)V"),
+            cancellable = true)
+    public void checkLock(BlockState state, Level level, BlockPos pos, Player player, BlockHitResult hitResult, CallbackInfoReturnable<InteractionResult> cir) {
+        if (player instanceof ServerPlayer serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
+            cir.setReturnValue(InteractionResult.FAIL);
+        }
+    }
+}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookshelfBlockEntityMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookshelfBlockEntityMixin.java
deleted file mode 100644
index afccbf0..0000000
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookshelfBlockEntityMixin.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package com.github.fabricservertools.htm.mixin.lockable;
-
-import com.github.fabricservertools.htm.lock.HTMContainerLock;
-import com.github.fabricservertools.htm.api.LockableObject;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.block.entity.BlockEntityType;
-import net.minecraft.block.entity.ChiseledBookshelfBlockEntity;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.inventory.Inventory;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.storage.ReadView;
-import net.minecraft.storage.WriteView;
-import net.minecraft.util.math.BlockPos;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Unique;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Optional;
-
-@Mixin(ChiseledBookshelfBlockEntity.class)
-public abstract class ChiseledBookshelfBlockEntityMixin extends BlockEntity implements Inventory, LockableObject {
-
-    @Unique
-    private HTMContainerLock lock = null;
-
-    public ChiseledBookshelfBlockEntityMixin(BlockEntityType<?> type, BlockPos pos, BlockState state) {
-        super(type, pos, state);
-    }
-
-    @Inject(method = "readData", at = @At("TAIL"))
-    public void readLockData(ReadView view, CallbackInfo ci) {
-        readLock(view, lock -> this.lock = lock);
-    }
-
-    @Inject(method = "writeData", at = @At("TAIL"))
-    public void writeLockData(WriteView view, CallbackInfo ci) {
-        writeLock(view);
-    }
-
-    @Inject(method = "canPlayerUse", at = @At("HEAD"), cancellable = true)
-    public void checkLock(PlayerEntity player, CallbackInfoReturnable<Boolean> cir) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !canOpenUnchecked(serverPlayer)) {
-            cir.setReturnValue(false);
-        }
-    }
-
-    @Override
-    public Optional<HTMContainerLock> getLock() {
-        return Optional.ofNullable(lock);
-    }
-
-    @Override
-    public void setLock(HTMContainerLock lock) {
-        this.lock = lock;
-        markDirty();
-    }
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookshelfBlockMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookshelfBlockMixin.java
deleted file mode 100644
index eb28cc7..0000000
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/ChiseledBookshelfBlockMixin.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package com.github.fabricservertools.htm.mixin.lockable;
-
-import com.github.fabricservertools.htm.interactions.InteractionManager;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.BlockWithEntity;
-import net.minecraft.block.ChiseledBookshelfBlock;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.Hand;
-import net.minecraft.util.hit.BlockHitResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(ChiseledBookshelfBlock.class)
-public abstract class ChiseledBookshelfBlockMixin extends BlockWithEntity {
-
-    protected ChiseledBookshelfBlockMixin(Settings settings) {
-        super(settings);
-    }
-
-    @Inject(method = "onUseWithItem",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/block/ChiseledBookshelfBlock;tryAddBook(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/entity/player/PlayerEntity;Lnet/minecraft/block/entity/ChiseledBookshelfBlockEntity;Lnet/minecraft/item/ItemStack;I)V"),
-            cancellable = true)
-    public void checkLock(ItemStack stack, BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit, CallbackInfoReturnable<ActionResult> cir) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
-            cir.setReturnValue(ActionResult.FAIL);
-        }
-    }
-
-    @Inject(method = "onUse",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/block/ChiseledBookshelfBlock;tryRemoveBook(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/entity/player/PlayerEntity;Lnet/minecraft/block/entity/ChiseledBookshelfBlockEntity;I)V"),
-            cancellable = true)
-    public void checkLock(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit, CallbackInfoReturnable<ActionResult> cir) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
-            cir.setReturnValue(ActionResult.FAIL);
-        }
-    }
-}
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/DecoratedPotBlockEntityMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/DecoratedPotBlockEntityMixin.java
index 1c191ce..ed5badb 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/DecoratedPotBlockEntityMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/DecoratedPotBlockEntityMixin.java
@@ -2,17 +2,7 @@
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
 import com.github.fabricservertools.htm.api.LockableObject;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.block.entity.BlockEntityType;
-import net.minecraft.block.entity.DecoratedPotBlockEntity;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.inventory.LootableInventory;
-import net.minecraft.inventory.SingleStackInventory;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.storage.ReadView;
-import net.minecraft.storage.WriteView;
-import net.minecraft.util.math.BlockPos;
+import org.jspecify.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
@@ -20,33 +10,44 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 import java.util.Optional;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.RandomizableContainer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.entity.DecoratedPotBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.storage.ValueInput;
+import net.minecraft.world.level.storage.ValueOutput;
+import net.minecraft.world.ticks.ContainerSingleItem;
 
 @Mixin(DecoratedPotBlockEntity.class)
-public abstract class DecoratedPotBlockEntityMixin extends BlockEntity implements LootableInventory, SingleStackInventory.SingleStackBlockEntityInventory, LockableObject {
+public abstract class DecoratedPotBlockEntityMixin extends BlockEntity implements RandomizableContainer, ContainerSingleItem.BlockContainerSingleItem, LockableObject {
 
     @Unique
-    private HTMContainerLock lock = null;
+    private @Nullable HTMContainerLock lock = null;
 
     public DecoratedPotBlockEntityMixin(BlockEntityType<?> type, BlockPos pos, BlockState state) {
         super(type, pos, state);
     }
 
-    @Inject(method = "readData", at = @At("TAIL"))
-    public void readLockData(ReadView view, CallbackInfo ci) {
-        readLock(view, lock -> this.lock = lock);
+    @Inject(method = "loadAdditional", at = @At("TAIL"))
+    public void readLockData(ValueInput input, CallbackInfo ci) {
+        readLock(input, lock -> this.lock = lock);
     }
 
-    @Inject(method = "writeData", at = @At("TAIL"))
-    public void writeLockData(WriteView view, CallbackInfo ci) {
-        writeLock(view);
+    @Inject(method = "saveAdditional", at = @At("TAIL"))
+    public void writeLockData(ValueOutput output, CallbackInfo ci) {
+        writeLock(output);
     }
 
     @Override
-    public boolean canPlayerUse(PlayerEntity player) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !canOpenUnchecked(serverPlayer)) {
+    public boolean stillValid(Player player) {
+        if (player instanceof ServerPlayer serverPlayer && !canOpenUnchecked(serverPlayer)) {
             return false;
         }
-        return SingleStackBlockEntityInventory.super.canPlayerUse(player);
+        return BlockContainerSingleItem.super.stillValid(player);
     }
 
     @Override
@@ -55,8 +56,8 @@ public Optional<HTMContainerLock> getLock() {
     }
 
     @Override
-    public void setLock(HTMContainerLock lock) {
+    public void setLock(@Nullable HTMContainerLock lock) {
         this.lock = lock;
-        markDirty();
+        setChanged();
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/DecoratedPotBlockMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/DecoratedPotBlockMixin.java
index 57799ae..6172be7 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/DecoratedPotBlockMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/DecoratedPotBlockMixin.java
@@ -1,36 +1,36 @@
 package com.github.fabricservertools.htm.mixin.lockable;
 
 import com.github.fabricservertools.htm.interactions.InteractionManager;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.BlockWithEntity;
-import net.minecraft.block.DecoratedPotBlock;
-import net.minecraft.block.Waterloggable;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.Hand;
-import net.minecraft.util.hit.BlockHitResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.DecoratedPotBlock;
+import net.minecraft.world.level.block.SimpleWaterloggedBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(DecoratedPotBlock.class)
-public abstract class DecoratedPotBlockMixin extends BlockWithEntity implements Waterloggable {
+public abstract class DecoratedPotBlockMixin extends BaseEntityBlock implements SimpleWaterloggedBlock {
 
-    protected DecoratedPotBlockMixin(Settings settings) {
+    protected DecoratedPotBlockMixin(Properties settings) {
         super(settings);
     }
 
-    @Inject(method = "onUseWithItem",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/block/entity/DecoratedPotBlockEntity;getStack()Lnet/minecraft/item/ItemStack;"),
+    @Inject(method = "useItemOn",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/entity/DecoratedPotBlockEntity;getTheItem()Lnet/minecraft/world/item/ItemStack;"),
             cancellable = true)
-    public void checkLock(ItemStack stack, BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit, CallbackInfoReturnable<ActionResult> cir) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
-            cir.setReturnValue(ActionResult.FAIL);
+    public void checkLock(ItemStack stack, BlockState state, Level level, BlockPos pos, Player player, InteractionHand hand, BlockHitResult hitResult, CallbackInfoReturnable<InteractionResult> cir) {
+        if (player instanceof ServerPlayer serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
+            cir.setReturnValue(InteractionResult.FAIL);
         }
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/JukeboxBlockEntityMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/JukeboxBlockEntityMixin.java
index 6c3cdfd..3f0d3f8 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/JukeboxBlockEntityMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/JukeboxBlockEntityMixin.java
@@ -2,16 +2,7 @@
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
 import com.github.fabricservertools.htm.api.LockableObject;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.block.entity.BlockEntityType;
-import net.minecraft.block.entity.JukeboxBlockEntity;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.inventory.SingleStackInventory;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.storage.ReadView;
-import net.minecraft.storage.WriteView;
-import net.minecraft.util.math.BlockPos;
+import org.jspecify.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
@@ -19,33 +10,43 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 import java.util.Optional;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.entity.JukeboxBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.storage.ValueInput;
+import net.minecraft.world.level.storage.ValueOutput;
+import net.minecraft.world.ticks.ContainerSingleItem;
 
 @Mixin(JukeboxBlockEntity.class)
-public abstract class JukeboxBlockEntityMixin extends BlockEntity implements SingleStackInventory.SingleStackBlockEntityInventory, LockableObject {
+public abstract class JukeboxBlockEntityMixin extends BlockEntity implements ContainerSingleItem.BlockContainerSingleItem, LockableObject {
 
     @Unique
-    private HTMContainerLock lock = null;
+    private @Nullable HTMContainerLock lock = null;
 
     public JukeboxBlockEntityMixin(BlockEntityType<?> type, BlockPos pos, BlockState state) {
         super(type, pos, state);
     }
 
-    @Inject(method = "readData", at = @At("TAIL"))
-    public void readLockData(ReadView view, CallbackInfo ci) {
-        readLock(view, lock -> this.lock = lock);
+    @Inject(method = "loadAdditional", at = @At("TAIL"))
+    public void readLockData(ValueInput input, CallbackInfo ci) {
+        readLock(input, lock -> this.lock = lock);
     }
 
-    @Inject(method = "writeData", at = @At("TAIL"))
-    public void writeLockData(WriteView view, CallbackInfo ci) {
-        writeLock(view);
+    @Inject(method = "saveAdditional", at = @At("TAIL"))
+    public void writeLockData(ValueOutput output, CallbackInfo ci) {
+        writeLock(output);
     }
 
     @Override
-    public boolean canPlayerUse(PlayerEntity player) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !canOpenUnchecked(serverPlayer)) {
+    public boolean stillValid(Player player) {
+        if (player instanceof ServerPlayer serverPlayer && !canOpenUnchecked(serverPlayer)) {
             return false;
         }
-        return SingleStackBlockEntityInventory.super.canPlayerUse(player);
+        return BlockContainerSingleItem.super.stillValid(player);
     }
 
     @Override
@@ -54,8 +55,8 @@ public Optional<HTMContainerLock> getLock() {
     }
 
     @Override
-    public void setLock(HTMContainerLock lock) {
+    public void setLock(@Nullable HTMContainerLock lock) {
         this.lock = lock;
-        markDirty();
+        setChanged();
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/JukeboxBlockMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/JukeboxBlockMixin.java
index f7cefcd..48a77d3 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/JukeboxBlockMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/JukeboxBlockMixin.java
@@ -1,44 +1,44 @@
 package com.github.fabricservertools.htm.mixin.lockable;
 
 import com.github.fabricservertools.htm.interactions.InteractionManager;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.BlockWithEntity;
-import net.minecraft.block.JukeboxBlock;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.Hand;
-import net.minecraft.util.hit.BlockHitResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.JukeboxBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(JukeboxBlock.class)
-public abstract class JukeboxBlockMixin extends BlockWithEntity {
+public abstract class JukeboxBlockMixin extends BaseEntityBlock {
 
-    protected JukeboxBlockMixin(Settings settings) {
+    protected JukeboxBlockMixin(Properties settings) {
         super(settings);
     }
 
-    @Inject(method = "onUseWithItem",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/player/PlayerEntity;getStackInHand(Lnet/minecraft/util/Hand;)Lnet/minecraft/item/ItemStack;"),
+    @Inject(method = "useItemOn",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/player/Player;getItemInHand(Lnet/minecraft/world/InteractionHand;)Lnet/minecraft/world/item/ItemStack;"),
             cancellable = true)
-    public void checkLock(ItemStack stack, BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit, CallbackInfoReturnable<ActionResult> cir) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
-            cir.setReturnValue(ActionResult.FAIL);
+    public void checkLock(ItemStack stack, BlockState state, Level level, BlockPos pos, Player player, InteractionHand hand, BlockHitResult hitResult, CallbackInfoReturnable<InteractionResult> cir) {
+        if (player instanceof ServerPlayer serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
+            cir.setReturnValue(InteractionResult.FAIL);
         }
     }
 
-    @Inject(method = "onUse",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/block/entity/JukeboxBlockEntity;dropRecord()V"),
+    @Inject(method = "useWithoutItem",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/entity/JukeboxBlockEntity;popOutTheItem()V"),
             cancellable = true)
-    public void checkLock(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit, CallbackInfoReturnable<ActionResult> cir) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
-            cir.setReturnValue(ActionResult.FAIL);
+    public void checkLock(BlockState state, Level level, BlockPos pos, Player player, BlockHitResult hitResult, CallbackInfoReturnable<InteractionResult> cir) {
+        if (player instanceof ServerPlayer serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
+            cir.setReturnValue(InteractionResult.FAIL);
         }
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LecternBlockEntityMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LecternBlockEntityMixin.java
index b39479e..ff1fa48 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LecternBlockEntityMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LecternBlockEntityMixin.java
@@ -2,15 +2,7 @@
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
 import com.github.fabricservertools.htm.api.LockableObject;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.block.entity.BlockEntityType;
-import net.minecraft.block.entity.LecternBlockEntity;
-import net.minecraft.screen.NamedScreenHandlerFactory;
-import net.minecraft.storage.ReadView;
-import net.minecraft.storage.WriteView;
-import net.minecraft.util.Clearable;
-import net.minecraft.util.math.BlockPos;
+import org.jspecify.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
@@ -18,25 +10,34 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 import java.util.Optional;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.Clearable;
+import net.minecraft.world.MenuProvider;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.entity.LecternBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.storage.ValueInput;
+import net.minecraft.world.level.storage.ValueOutput;
 
 @Mixin(LecternBlockEntity.class)
-public abstract class LecternBlockEntityMixin extends BlockEntity implements Clearable, NamedScreenHandlerFactory, LockableObject {
+public abstract class LecternBlockEntityMixin extends BlockEntity implements Clearable, MenuProvider, LockableObject {
 
     @Unique
-    private HTMContainerLock lock = null;
+    private @Nullable HTMContainerLock lock = null;
 
     public LecternBlockEntityMixin(BlockEntityType<?> type, BlockPos pos, BlockState state) {
         super(type, pos, state);
     }
 
-    @Inject(method = "readData", at = @At("TAIL"))
-    public void readLockData(ReadView view, CallbackInfo ci) {
-        readLock(view, lock -> this.lock = lock);
+    @Inject(method = "loadAdditional", at = @At("TAIL"))
+    public void readLockData(ValueInput input, CallbackInfo ci) {
+        readLock(input, lock -> this.lock = lock);
     }
 
-    @Inject(method = "writeData", at = @At("TAIL"))
-    public void writeLockData(WriteView view, CallbackInfo ci) {
-        writeLock(view);
+    @Inject(method = "saveAdditional", at = @At("TAIL"))
+    public void writeLockData(ValueOutput output, CallbackInfo ci) {
+        writeLock(output);
     }
 
     @Override
@@ -45,8 +46,8 @@ public Optional<HTMContainerLock> getLock() {
     }
 
     @Override
-    public void setLock(HTMContainerLock lock) {
+    public void setLock(@Nullable HTMContainerLock lock) {
         this.lock = lock;
-        markDirty();
+        setChanged();
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LecternBlockMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LecternBlockMixin.java
index 5a7c5d6..35043be 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LecternBlockMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LecternBlockMixin.java
@@ -1,44 +1,44 @@
 package com.github.fabricservertools.htm.mixin.lockable;
 
 import com.github.fabricservertools.htm.interactions.InteractionManager;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.BlockWithEntity;
-import net.minecraft.block.LecternBlock;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.hit.BlockHitResult;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.World;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.LecternBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(LecternBlock.class)
-public abstract class LecternBlockMixin extends BlockWithEntity {
+public abstract class LecternBlockMixin extends BaseEntityBlock {
 
-    protected LecternBlockMixin(Settings settings) {
+    protected LecternBlockMixin(Properties settings) {
         super(settings);
     }
 
-    @Inject(method = "putBookIfAbsent",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/block/LecternBlock;putBook(Lnet/minecraft/entity/LivingEntity;Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;Lnet/minecraft/item/ItemStack;)V"),
+    @Inject(method = "tryPlaceBook",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/LecternBlock;placeBook(Lnet/minecraft/world/entity/LivingEntity;Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/world/item/ItemStack;)V"),
             cancellable = true)
-    private static void checkLock(LivingEntity user, World world, BlockPos pos, BlockState state, ItemStack stack, CallbackInfoReturnable<Boolean> cir) {
-        if (user instanceof ServerPlayerEntity serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
+    private static void checkLock(LivingEntity user, Level level, BlockPos pos, BlockState state, ItemStack stack, CallbackInfoReturnable<Boolean> cir) {
+        if (user instanceof ServerPlayer serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
             cir.setReturnValue(false);
         }
     }
 
-    @Inject(method = "onUse",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/block/LecternBlock;openScreen(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/entity/player/PlayerEntity;)V"),
+    @Inject(method = "useWithoutItem",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/LecternBlock;openScreen(Lnet/minecraft/world/level/Level;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/entity/player/Player;)V"),
             cancellable = true)
-    public void checkLock(BlockState state, World world, BlockPos pos, PlayerEntity player, BlockHitResult hit, CallbackInfoReturnable<ActionResult> cir) {
-        if (player instanceof ServerPlayerEntity serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
-            cir.setReturnValue(ActionResult.FAIL);
+    public void checkLock(BlockState state, Level level, BlockPos pos, Player player, BlockHitResult hit, CallbackInfoReturnable<InteractionResult> cir) {
+        if (player instanceof ServerPlayer serverPlayer && !InteractionManager.canOpen(serverPlayer, pos)) {
+            cir.setReturnValue(InteractionResult.FAIL);
         }
     }
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LockableContainerMixin.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LockableContainerMixin.java
index b43b43d..ed6ab98 100644
--- a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LockableContainerMixin.java
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/LockableContainerMixin.java
@@ -2,15 +2,7 @@
 
 import com.github.fabricservertools.htm.lock.HTMContainerLock;
 import com.github.fabricservertools.htm.api.LockableObject;
-import net.minecraft.block.BlockState;
-import net.minecraft.block.entity.BlockEntity;
-import net.minecraft.block.entity.BlockEntityType;
-import net.minecraft.block.entity.LockableContainerBlockEntity;
-import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.storage.ReadView;
-import net.minecraft.storage.WriteView;
-import net.minecraft.util.math.BlockPos;
+import org.jspecify.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
@@ -19,29 +11,38 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 import java.util.Optional;
-
-@Mixin(LockableContainerBlockEntity.class)
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.entity.BaseContainerBlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.storage.ValueInput;
+import net.minecraft.world.level.storage.ValueOutput;
+
+@Mixin(BaseContainerBlockEntity.class)
 public abstract class LockableContainerMixin extends BlockEntity implements LockableObject {
 	@Unique
-	private HTMContainerLock htmContainerLock = null;
+	private @Nullable HTMContainerLock htmContainerLock = null;
 
 	public LockableContainerMixin(BlockEntityType<?> type, BlockPos pos, BlockState state) {
 		super(type, pos, state);
 	}
 
-	@Inject(method = "writeData", at = @At("HEAD"))
-	private void toTag(WriteView view, CallbackInfo ci) {
-		writeLock(view);
+	@Inject(method = "loadAdditional", at = @At("HEAD"))
+	private void fromTag(ValueInput input, CallbackInfo ci) {
+		readLock(input, lock -> htmContainerLock = lock);
 	}
 
-	@Inject(method = "readData", at = @At("HEAD"))
-	private void fromTag(ReadView view, CallbackInfo ci) {
-		readLock(view, lock -> htmContainerLock = lock);
-	}
+    @Inject(method = "saveAdditional", at = @At("HEAD"))
+    private void toTag(ValueOutput output, CallbackInfo ci) {
+        writeLock(output);
+    }
 
-	@Inject(method = "checkUnlocked(Lnet/minecraft/entity/player/PlayerEntity;)Z", at = @At("HEAD"), cancellable = true)
-	private void checkUnlocked(PlayerEntity player, CallbackInfoReturnable<Boolean> cir) {
-		if (player instanceof ServerPlayerEntity serverPlayer) {
+	@Inject(method = "canOpen(Lnet/minecraft/world/entity/player/Player;)Z", at = @At("HEAD"), cancellable = true)
+	private void checkUnlocked(Player player, CallbackInfoReturnable<Boolean> cir) {
+		if (player instanceof ServerPlayer serverPlayer) {
 			canOpen(serverPlayer).ifPresent(cir::setReturnValue);
 		}
 	}
@@ -52,8 +53,8 @@ public Optional<HTMContainerLock> getLock() {
 	}
 
 	@Override
-	public void setLock(HTMContainerLock lock) {
+	public void setLock(@Nullable HTMContainerLock lock) {
 		htmContainerLock = lock;
-		markDirty();
+		setChanged();
 	}
 }
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/lockable/package-info.java b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/package-info.java
new file mode 100644
index 0000000..b2da59c
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/lockable/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.mixin.lockable;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/mixin/package-info.java b/src/main/java/com/github/fabricservertools/htm/mixin/package-info.java
new file mode 100644
index 0000000..65d09a3
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/mixin/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.mixin;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/package-info.java b/src/main/java/com/github/fabricservertools/htm/package-info.java
new file mode 100644
index 0000000..a2c802f
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/java/com/github/fabricservertools/htm/world/data/GlobalTrustState.java b/src/main/java/com/github/fabricservertools/htm/world/data/GlobalTrustData.java
similarity index 63%
rename from src/main/java/com/github/fabricservertools/htm/world/data/GlobalTrustState.java
rename to src/main/java/com/github/fabricservertools/htm/world/data/GlobalTrustData.java
index 9959aa2..e99159d 100644
--- a/src/main/java/com/github/fabricservertools/htm/world/data/GlobalTrustState.java
+++ b/src/main/java/com/github/fabricservertools/htm/world/data/GlobalTrustData.java
@@ -5,34 +5,33 @@
 import com.mojang.datafixers.util.Pair;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
-import net.minecraft.util.Uuids;
-import net.minecraft.world.PersistentState;
-import net.minecraft.world.PersistentStateType;
-
 import java.util.List;
 import java.util.UUID;
+import net.minecraft.core.UUIDUtil;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
 
-public class GlobalTrustState extends PersistentState {
+public class GlobalTrustData extends SavedData {
 	private static final Codec<Pair<UUID, List<UUID>>> TRUSTER_CODEC = RecordCodecBuilder.create(instance ->
 			instance.group(
-					Uuids.INT_STREAM_CODEC.fieldOf("Truster").forGetter(Pair::getFirst),
-					Uuids.INT_STREAM_CODEC.listOf().fieldOf("Trusted").forGetter(Pair::getSecond)
+					UUIDUtil.CODEC.fieldOf("Truster").forGetter(Pair::getFirst),
+					UUIDUtil.CODEC.listOf().fieldOf("Trusted").forGetter(Pair::getSecond)
 			).apply(instance, Pair::of)
 	);
 
-	public static final Codec<GlobalTrustState> CODEC = RecordCodecBuilder.create(instance ->
+	public static final Codec<GlobalTrustData> CODEC = RecordCodecBuilder.create(instance ->
 			instance.group(
-					TRUSTER_CODEC.listOf().fieldOf("GlobalTrusts").forGetter(GlobalTrustState::globalTrusts)
-			).apply(instance, GlobalTrustState::new)
+					TRUSTER_CODEC.listOf().fieldOf("GlobalTrusts").forGetter(GlobalTrustData::globalTrusts)
+			).apply(instance, GlobalTrustData::new)
 	);
 
-	public static final PersistentStateType<GlobalTrustState> TYPE = new PersistentStateType<>("globalTrust", GlobalTrustState::new, CODEC, null);
+	public static final SavedDataType<GlobalTrustData> TYPE = new SavedDataType<>("globalTrust", GlobalTrustData::new, CODEC, null);
 
 	private final Multimap<UUID, UUID> globalTrust = HashMultimap.create();
 
-	private GlobalTrustState() {}
+	private GlobalTrustData() {}
 
-	private GlobalTrustState(List<Pair<UUID, List<UUID>>> globalTrusts) {
+	private GlobalTrustData(List<Pair<UUID, List<UUID>>> globalTrusts) {
 		for (Pair<UUID, List<UUID>> truster : globalTrusts) {
 			globalTrust.putAll(truster.getFirst(), truster.getSecond());
 		}
@@ -43,12 +42,12 @@ public boolean isTrusted(UUID truster, UUID trusted) {
 	}
 
 	public boolean addTrust(UUID truster, UUID trusted) {
-		markDirty();
+		setDirty();
 		return globalTrust.put(truster, trusted);
 	}
 
 	public boolean removeTrust(UUID truster, UUID trusted) {
-		markDirty();
+		setDirty();
 		return globalTrust.remove(truster, trusted);
 	}
 
diff --git a/src/main/java/com/github/fabricservertools/htm/world/data/package-info.java b/src/main/java/com/github/fabricservertools/htm/world/data/package-info.java
new file mode 100644
index 0000000..2cd1c23
--- /dev/null
+++ b/src/main/java/com/github/fabricservertools/htm/world/data/package-info.java
@@ -0,0 +1,4 @@
+@NullMarked
+package com.github.fabricservertools.htm.world.data;
+
+import org.jspecify.annotations.NullMarked;
diff --git a/src/main/resources/fabric.mod.json b/src/main/resources/fabric.mod.json
index f292491..078a581 100644
--- a/src/main/resources/fabric.mod.json
+++ b/src/main/resources/fabric.mod.json
@@ -8,8 +8,8 @@
     "Potatoboy9999"
   ],
   "contact": {
-    "sources": "https://github.com/fabricservertools/HeyThatsMine",
-    "issues": "https://github.com/fabricservertools/HeyThatsMine/issues"
+    "sources": "https://github.com/QuiltServerTools/HeyThatsMine",
+    "issues": "https://github.com/QuiltServerTools/HeyThatsMine/issues"
   },
   "license": "MIT",
   "icon": "assets/htm/icon.png",
@@ -23,8 +23,8 @@
     "htm.mixins.json"
   ],
   "depends": {
-    "fabricloader": ">=0.17.2",
-    "fabric": "*",
-    "minecraft": ">=1.21.9"
+    "fabricloader": ">=0.18.2",
+    "fabric-api": "*",
+    "minecraft": ">=1.21.11"
   }
 }
diff --git a/src/main/resources/htm.mixins.json b/src/main/resources/htm.mixins.json
index 7b14622..036672e 100644
--- a/src/main/resources/htm.mixins.json
+++ b/src/main/resources/htm.mixins.json
@@ -5,14 +5,14 @@
   "compatibilityLevel": "JAVA_21",
   "mixins": [
     "HopperBlockEntityMixin",
-    "MoveItemsTaskMixin",
+    "TransportItemsBetweenContainersMixin",
     "PistonBlockMixin",
     "events.BlockItemMixin",
-    "events.EnderDragonEntityMixin",
-    "events.ExplosionImplMixin",
-    "events.WorldMixin",
-    "lockable.ChiseledBookshelfBlockEntityMixin",
-    "lockable.ChiseledBookshelfBlockMixin",
+    "events.EnderDragonMixin",
+    "events.ServerExplosionMixin",
+    "events.LevelMixin",
+    "lockable.ChiseledBookShelfBlockEntityMixin",
+    "lockable.ChiseledBookShelfBlockMixin",
     "lockable.DecoratedPotBlockEntityMixin",
     "lockable.DecoratedPotBlockMixin",
     "lockable.JukeboxBlockEntityMixin",