Release 2.1.22 (#434)

* Add full registries to fix compatibility issues

* Fix 1.18.2-1.19.1 registries

* Fix codec nbt loading error

* Optimize 1.20-1.21.4 codecs

* Registries fixes & Fixed some unexpected behavior about mods. (#430)

* Fix 1.20.5 + viafabricplus

* Update registries

* Apply SIMPLE_BIOME filter on 1.18.2-1.21.4 codecs

* Use 1.21-1.21.4 codecs from the previous commit

---------

Co-authored-by: Akkariin <fallencrystal@outlook.com>

.editorconfig

@@ -7,7 +7,7 @@ indent_size = 2
 insert_final_newline = true
 trim_trailing_whitespace = true
 
-[{*.java,*.kt}]
+[*.java]
 ij_java_wrap_long_lines = true
 
 [{*.md,*.yml}]

.github/FUNDING.yml

@@ -0,0 +1 @@
+patreon: jonesdev

.github/README.md

@@ -48,6 +48,11 @@ Sonar also protects against spambot attacks since it queues the incoming connect
 Sonar is unlikely to ever falsely prevent a player from joining the server since Minecraft uses the TCP protocol, which means that packets are always sent in the correct order. Therefore, lag or ping should not affect the bot check.
 If you or one of your players experiences a false positive, make sure to report it by opening a [GitHub issue](https://github.com/jonesdevelopment/sonar/issues/new/choose) or a ticket on the [Discord server](https://jonesdev.xyz/discord/).
 
+## Sponsors
+Massive thanks to the sponsors of Sonar who help keep this project running:
+
+<a href="https://github.com/Hydoxl"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/107579333?v=4&h=50&w=50&fit=cover&mask=circle&maxage=7d" alt="logo" align="center"></a>
+
 ## Building
 If you want to build your own version of Sonar, please take a look at the [Sonar building documentation](https://docs.jonesdev.xyz/development/building).
 <br>

.github/workflows/gradle.yml

@@ -9,9 +9,9 @@ name: Sonar CI
 
 on:
   push:
-    branches: [ "main", "dev" ]
+    branches: [ "main" ]
   pull_request:
-    branches: [ "main", "dev" ]
+    branches: [ "main" ]
 
 permissions:
   contents: read
@@ -21,13 +21,36 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Set up JDK 17
-      uses: actions/setup-java@v3
-      with:
-        java-version: '17'
-        distribution: 'temurin'
-    - name: Build with Gradle
-      uses: gradle/gradle-build-action@bd5760595778326ba7f1441bcf7e88b49de61a25 # v2.6.0
-      with:
-        arguments: build-sonar
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+
+      - name: Build with Gradle
+        uses: gradle/gradle-build-action@v3
+        with:
+          arguments: build-sonar
+
+      - name: Upload Bukkit Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Sonar-Bukkit
+          path: bukkit/build/libs/Sonar-Bukkit.jar
+          if-no-files-found: error
+
+      - name: Upload BungeeCord Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Sonar-Bungee
+          path: bungeecord/build/libs/Sonar-Bungee.jar
+          if-no-files-found: error
+
+      - name: Upload Velocity Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Sonar-Velocity
+          path: velocity/build/libs/Sonar-Velocity.jar
+          if-no-files-found: error

HEADER

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) ${YEAR} Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -14,3 +14,4 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
+

api/build.gradle.kts

@@ -9,5 +9,8 @@ dependencies {
   compileOnly(rootProject.libs.annotations)
 }
 
-java.sourceCompatibility = JavaVersion.VERSION_11
-java.targetCompatibility = JavaVersion.VERSION_11
+tasks {
+  shadowJar {
+    archiveFileName = "sonar-api-${rootProject.version}.jar"
+  }
+}

api/src/main/java/xyz/jonesdev/sonar/api/Sonar.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,17 +21,17 @@ import net.kyori.adventure.audience.Audience;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import xyz.jonesdev.sonar.api.attack.AttackTracker;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandRegistry;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
-import xyz.jonesdev.sonar.api.controller.VerifiedPlayerController;
+import xyz.jonesdev.sonar.api.database.controller.VerifiedPlayerController;
 import xyz.jonesdev.sonar.api.event.SonarEventManager;
 import xyz.jonesdev.sonar.api.fallback.Fallback;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
+import xyz.jonesdev.sonar.api.notification.ActionBarNotificationHandler;
+import xyz.jonesdev.sonar.api.notification.ChatNotificationHandler;
 import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
-import xyz.jonesdev.sonar.api.verbose.Notification;
-import xyz.jonesdev.sonar.api.verbose.Verbose;
+import xyz.jonesdev.sonar.api.tracker.AttackTracker;
 
 import java.text.DecimalFormat;
 import java.util.UUID;
@@ -41,7 +41,7 @@ public interface Sonar {
 
   /**
    * Since we want to use Adventure on every server platform,
-   * we have to use their platform module to support BungeeCord and Bukkit
+   * we have to use their platform module to support BungeeCord and Bukkit.
    */
   @ApiStatus.Internal
   @Nullable Audience audience(final @Nullable UUID uniqueId);
@@ -49,14 +49,8 @@ public interface Sonar {
   @ApiStatus.Internal
   @NotNull Audience sender(final @NotNull Object object);
 
-  /**
-   * @return The platform the plugin is being run on
-   */
   @NotNull SonarPlatform getPlatform();
 
-  /**
-   * @return A small wrapper for the plugin logger so we can use the logger everywhere
-   */
   @NotNull LoggerWrapper getLogger();
 
   @NotNull SonarConfiguration getConfig();
@@ -65,56 +59,39 @@ public interface Sonar {
 
   VerifiedPlayerController getVerifiedPlayerController();
 
-  @NotNull Verbose getVerboseHandler();
+  @NotNull ActionBarNotificationHandler getActionBarNotificationHandler();
 
-  @NotNull Notification getNotificationHandler();
+  @NotNull ChatNotificationHandler getChatNotificationHandler();
 
   @NotNull SystemTimer getLaunchTimer();
 
   @NotNull SonarStatistics getStatistics();
 
-  /**
-   * Set a custom verbose handler
-   */
   @SuppressWarnings("unused")
-  void setVerboseHandler(final @NotNull Verbose verboseHandler);
+  void setActionBarNotificationHandler(final @NotNull ActionBarNotificationHandler notificationHandler);
 
-  /**
-   * Set a custom notification handler
-   */
   @SuppressWarnings("unused")
-  void setNotificationHandler(final @NotNull Notification notificationHandler);
+  void setChatNotificationHandler(final @NotNull ChatNotificationHandler notificationHandler);
 
-  /**
-   * Reloads the entire plugin
-   */
   void reload();
 
-  @NotNull
-  default SonarVersion getVersion() {
+  @NotNull default SonarVersion getVersion() {
     return SonarVersion.INSTANCE;
   }
 
-  @NotNull
-  default SonarEventManager getEventManager() {
-    // We don't want anyone else to create a new instance.
+  @NotNull default SonarEventManager getEventManager() {
     return SonarEventManager.INSTANCE;
   }
 
-  @NotNull
-  default AttackTracker getAttackTracker() {
-    // We don't want anyone else to create a new instance.
+  @NotNull default AttackTracker getAttackTracker() {
     return AttackTracker.INSTANCE;
   }
 
-  @NotNull
-  default Fallback getFallback() {
-    // We don't want anyone else to create a new instance.
+  @NotNull default Fallback getFallback() {
     return Fallback.INSTANCE;
   }
 
-  @NotNull
-  static Sonar get() {
-    return SonarSupplier.get();
+  @NotNull static Sonar get() {
+    return SonarSupplier.sonar;
   }
 }

api/src/main/java/xyz/jonesdev/sonar/api/SonarPlatform.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,21 +26,15 @@ import java.util.function.Function;
 @Getter
 @RequiredArgsConstructor
 public enum SonarPlatform {
-  BUKKIT("Bukkit", 19110,
-    pipeline -> pipeline.context("outbound_config") != null ? "outbound_config" : "encoder",
-    pipeline -> "packet_handler"),
-  BUNGEE("BungeeCord", 19109,
-    pipeline -> "packet-encoder",
-    pipeline -> "inbound-boss"),
-  VELOCITY("Velocity", 19107,
-    pipeline -> "minecraft-encoder",
-    pipeline -> "handler");
+  BUKKIT("Bukkit", 19110, "packet_handler",
+    pipeline -> pipeline.context("outbound_config") != null ? "outbound_config" : "encoder"),
+  BUNGEE("BungeeCord", 19109, "inbound-boss",
+    pipeline -> "packet-encoder"),
+  VELOCITY("Velocity", 19107, "handler",
+    pipeline -> "minecraft-encoder");
 
   private final String displayName;
-  /**
-   * bStats service ID for the respective Sonar platform
-   */
   private final int metricsId;
-  private final Function<ChannelPipeline, String> encoderFunction;
-  private final Function<ChannelPipeline, String> handlerFunction;
+  private final String connectionHandler;
+  private final Function<ChannelPipeline, String> encoder;
 }

api/src/main/java/xyz/jonesdev/sonar/api/SonarSupplier.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,20 +20,14 @@ package xyz.jonesdev.sonar.api;
 import lombok.experimental.UtilityClass;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Objects;
-
 @UtilityClass
 public class SonarSupplier {
-  private Sonar sonar;
+  Sonar sonar;
 
-  public void set(final @NotNull Sonar s) {
+  public void set(final @NotNull Sonar _sonar) {
     if (sonar != null) {
-      throw new AlreadyInitializedException();
+      throw new IllegalStateException("Sonar is already initialized");
     }
-    sonar = Objects.requireNonNull(s);
-  }
-
-  public @NotNull Sonar get() {
-    return sonar;
+    sonar = _sonar;
   }
 }

api/src/main/java/xyz/jonesdev/sonar/api/SonarVersion.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -42,7 +42,6 @@ public final class SonarVersion {
     this.formatted = version + " (" + gitCommit + ")";
   }
 
-  // Taken from
   // https://github.com/PaperMC/Velocity/pull/1336/
   private static @NotNull Manifest getManifest() {
     final String classLocation = "/" + Sonar.class.getName().replace(".", "/") + ".class";

api/src/main/java/xyz/jonesdev/sonar/api/command/InvocationSource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,7 +21,6 @@ import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.minimessage.MiniMessage;
 
 import java.util.UUID;
 import java.util.function.Predicate;
@@ -34,23 +33,12 @@ public final class InvocationSource {
   private final Predicate<String> permissionFunction;
 
   /**
-   * @return True, if {@link InvocationSource#uuid} is not null
-   * @apiNote This indicates a player as a player will always have a UUID
+   * @return true if {@link InvocationSource#uuid} is not null
    */
   public boolean isPlayer() {
     return uuid != null;
   }
 
-  /**
-   * Sends a message to the command executor
-   *
-   * @apiNote We should probably use cached components...
-   * (See {@link InvocationSource#sendMessage(Component)})
-   */
-  public void sendMessage(final String legacy) {
-    sendMessage(MiniMessage.miniMessage().deserialize(legacy));
-  }
-
   /**
    * Sends a message to the command executor
    */

api/src/main/java/xyz/jonesdev/sonar/api/command/SonarCommand.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,20 +26,19 @@ import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
+import xyz.jonesdev.sonar.api.update.UpdateChecker;
 
 import java.util.*;
 
-import static java.util.Collections.emptyList;
-
 public interface SonarCommand {
-  List<String> TAB_SUGGESTIONS = new ArrayList<>();
-
-  Map<String, List<String>> ARG_TAB_SUGGESTIONS = new HashMap<>();
+  Map<Integer, List<String>> TAB_SUGGESTIONS = new LinkedHashMap<>();
 
   default void handle(final @NotNull InvocationSource source, final String @NotNull [] args) {
     // Check if the player actually has the permission to run the command
     if (source.isPlayer() && !source.getPermissionFunction().test("sonar.command")) {
-      source.sendMessage(Sonar.get().getConfig().getNoPermission());
+      if (Sonar.get().getConfig().getNoPermission() != null) {
+        source.sendMessage(Sonar.get().getConfig().getNoPermission());
+      }
       return;
     }
 
@@ -66,11 +65,18 @@ public interface SonarCommand {
       // Invoke subcommand
       command.invoke(source, args);
     }, () -> {
+      final UpdateChecker.CheckResult checkResult = UpdateChecker.getLastCheckResult();
+      Component version = Component.text(Sonar.get().getVersion().getFormatted());
+      if (checkResult.getConfigKey() != null) {
+        version = version.append(MiniMessage.miniMessage().deserialize(
+          Sonar.get().getConfig().getMessagesConfig().getString("commands.main." + checkResult.getConfigKey())));
+      }
+
       // Print standard help message
       source.sendMessage(MiniMessage.miniMessage().deserialize(
         String.join("<newline>",
           Sonar.get().getConfig().getMessagesConfig().getStringList("commands.main.header")),
-        Placeholder.unparsed("version", Sonar.get().getVersion().getFormatted()),
+        Placeholder.component("version", version),
         Placeholder.unparsed("platform", Sonar.get().getPlatform().getDisplayName()),
         Placeholder.unparsed("copyright-year", String.valueOf(Calendar.getInstance().get(Calendar.YEAR)))));
 
@@ -94,30 +100,29 @@ public interface SonarCommand {
     });
   }
 
-  static void prepareCachedMessages() {
-    // Don't re-cache tab suggestions
-    if (!TAB_SUGGESTIONS.isEmpty()) return;
-    // Cache tab suggestions
-    for (final Subcommand subcommand : Sonar.get().getSubcommandRegistry().getSubcommands()) {
-      TAB_SUGGESTIONS.add(subcommand.getInfo().name());
-      if (subcommand.getInfo().aliases().length > 0) {
-        TAB_SUGGESTIONS.addAll(Arrays.asList(subcommand.getInfo().aliases()));
-      }
-      final List<String> arguments = Arrays.asList(subcommand.getInfo().arguments());
-      ARG_TAB_SUGGESTIONS.put(subcommand.getInfo().name(), arguments);
-      for (final String alias : subcommand.getInfo().aliases()) {
-        ARG_TAB_SUGGESTIONS.put(alias, arguments);
+  static void prepareCachedTabSuggestions() {
+    if (TAB_SUGGESTIONS.isEmpty()) {
+      final List<String> subcommandsAndAliases = new ArrayList<>();
+      for (final Subcommand subcommand : Sonar.get().getSubcommandRegistry().getSubcommands()) {
+        subcommandsAndAliases.add(subcommand.getInfo().name());
+
+        final List<String> arguments = Arrays.asList(subcommand.getInfo().arguments());
+        TAB_SUGGESTIONS.put(subcommand.getInfo().name().hashCode(), arguments);
+
+        for (final String alias : subcommand.getInfo().aliases()) {
+          subcommandsAndAliases.add(alias);
+          TAB_SUGGESTIONS.put(alias.hashCode(), arguments);
+        }
       }
+      TAB_SUGGESTIONS.put(-1, subcommandsAndAliases);
     }
   }
 
   default List<String> getCachedTabSuggestions(final String @NotNull [] arguments) {
-    if (arguments.length <= 1) {
-      return TAB_SUGGESTIONS;
-    } else if (arguments.length == 2) {
-      final String subcommandName = arguments[0].toLowerCase();
-      return ARG_TAB_SUGGESTIONS.getOrDefault(subcommandName, emptyList());
+    if (arguments.length <= 2) {
+      final int subcommandHash = arguments.length <= 1 ? -1 : arguments[0].toLowerCase().hashCode();
+      return TAB_SUGGESTIONS.getOrDefault(subcommandHash, Collections.emptyList());
     }
-    return emptyList();
+    return Collections.emptyList();
   }
 }

api/src/main/java/xyz/jonesdev/sonar/api/command/subcommand/Subcommand.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,7 +23,6 @@ import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.command.CommandInvocation;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 
 import java.util.Objects;
@@ -91,7 +90,7 @@ public abstract class Subcommand {
     }
 
     // Execute the sub command from the invocation source with the given arguments
-    execute(new CommandInvocation(invocationSource, arguments));
+    execute(invocationSource, arguments);
   }
 
   public final @NotNull String getDescription() {
@@ -99,5 +98,5 @@ public abstract class Subcommand {
     return Objects.requireNonNull(Sonar.get().getConfig().getMessagesConfig().getString(path));
   }
 
-  protected abstract void execute(final @NotNull CommandInvocation invocation);
+  protected abstract void execute(final @NotNull InvocationSource source, final String @NotNull [] args);
 }

api/src/main/java/xyz/jonesdev/sonar/api/command/subcommand/SubcommandInfo.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,34 +25,15 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 public @interface SubcommandInfo {
-
-  /**
-   * @return Name of the subcommand
-   */
   String name();
 
-  /**
-   * @return Aliases of the subcommand
-   */
   String[] aliases() default {};
 
-  /**
-   * @return Arguments of the subcommand
-   */
   String[] arguments() default {};
 
-  /**
-   * @return Whether the subcommands requires arguments
-   */
   boolean argumentsRequired() default true;
 
-  /**
-   * @return Whether the subcommands can only be executed by a player
-   */
   boolean onlyPlayers() default false;
 
-  /**
-   * @return Whether the subcommands can only be executed by console
-   */
   boolean onlyConsole() default false;
 }

api/src/main/java/xyz/jonesdev/sonar/api/command/subcommand/SubcommandRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

api/src/main/java/xyz/jonesdev/sonar/api/config/Language.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

api/src/main/java/xyz/jonesdev/sonar/api/config/SimpleYamlConfig.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,6 +21,7 @@ import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
 import org.simpleyaml.configuration.MemorySection;
 import org.simpleyaml.configuration.file.YamlFile;
+import xyz.jonesdev.sonar.api.Sonar;
 
 import java.io.File;
 import java.io.InputStream;
@@ -31,8 +32,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
-import static xyz.jonesdev.sonar.api.config.SonarConfiguration.LOGGER;
-
 @Getter
 public final class SimpleYamlConfig {
   private final File file;
@@ -90,7 +89,7 @@ public final class SimpleYamlConfig {
 
   public int getInt(final String path) {
     if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get().getLogger().warn("Could not find {} in {}.", path, file.getName());
       return 0;
     }
     return yaml.getInt(path);
@@ -98,7 +97,7 @@ public final class SimpleYamlConfig {
 
   public boolean getBoolean(final String path) {
     if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get().getLogger().warn("Could not find {} in {}.", path, file.getName());
       return false;
     }
     return yaml.getBoolean(path);
@@ -106,7 +105,7 @@ public final class SimpleYamlConfig {
 
   public @NotNull String getString(final String path) {
     if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get().getLogger().warn("Could not find {} in {}.", path, file.getName());
       return "";
     }
     final Object object = yaml.get(path);
@@ -118,7 +117,7 @@ public final class SimpleYamlConfig {
 
   public List<String> getStringList(final String path) {
     if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get().getLogger().warn("Could not find {} in {}.", path, file.getName());
       return new ArrayList<>(0);
     }
     return yaml.getStringList(path);
@@ -126,7 +125,7 @@ public final class SimpleYamlConfig {
 
   public List<Integer> getIntList(final String path) {
     if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get().getLogger().warn("Could not find {} in {}.", path, file.getName());
       return new ArrayList<>(0);
     }
     return yaml.getIntegerList(path);

api/src/main/java/xyz/jonesdev/sonar/api/config/SonarConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -27,10 +27,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.command.SonarCommand;
-import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
-import xyz.jonesdev.sonar.api.ormlite.H2DatabaseTypeAdapter;
-import xyz.jonesdev.sonar.api.ormlite.MariaDbDatabaseTypeAdapter;
-import xyz.jonesdev.sonar.api.ormlite.MysqlDatabaseTypeAdapter;
+import xyz.jonesdev.sonar.api.database.ormlite.H2DatabaseTypeAdapter;
+import xyz.jonesdev.sonar.api.database.ormlite.MariaDbDatabaseTypeAdapter;
+import xyz.jonesdev.sonar.api.database.ormlite.MysqlDatabaseTypeAdapter;
 import xyz.jonesdev.sonar.api.webhook.DiscordWebhook;
 
 import java.io.File;
@@ -52,24 +51,6 @@ public final class SonarConfiguration {
   @Getter
   private Language language;
 
-  static final LoggerWrapper LOGGER = new LoggerWrapper() {
-
-    @Override
-    public void info(final String message, final Object... args) {
-      Sonar.get().getLogger().info("[config] " + message, args);
-    }
-
-    @Override
-    public void warn(final String message, final Object... args) {
-      Sonar.get().getLogger().warn("[config] " + message, args);
-    }
-
-    @Override
-    public void error(final String message, final Object... args) {
-      Sonar.get().getLogger().error("[config] " + message, args);
-    }
-  };
-
   public SonarConfiguration(final @NotNull File pluginFolder) {
     this.pluginFolder = pluginFolder;
     this.messagesConfig = new SimpleYamlConfig(new File(pluginFolder, "messages.yml"));
@@ -85,14 +66,14 @@ public final class SonarConfiguration {
       final URL defaultLanguageFile = Sonar.class.getResource("/assets/language.properties");
       // Make sure the file actually exists before trying to copy it
       if (defaultLanguageFile == null) {
-        LOGGER.error("Cannot check for custom language (is the file missing?)");
+        Sonar.get().getLogger().error("Cannot check for custom language (is the file missing?)");
         return DEFAULT_FALLBACK_LANGUAGE;
       }
       // Copy the file to the plugin data directory
       try (final InputStream inputStream = defaultLanguageFile.openStream()) {
         Files.copy(inputStream, languageFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
       } catch (IOException exception) {
-        LOGGER.error("Error copying file: {}", exception);
+        Sonar.get().getLogger().error("Error copying file: {}", exception);
         return DEFAULT_FALLBACK_LANGUAGE;
       }
     }
@@ -106,13 +87,13 @@ public final class SonarConfiguration {
         // Try parsing the property as a language
         return Language.fromCode(property);
       } catch (Throwable throwable) {
-        LOGGER.error("Could not find requested language: {}", throwable);
-        LOGGER.error("You can view a full list of valid language codes here:");
-        LOGGER.error("https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes");
-        LOGGER.error("If a translation does not exist yet, Sonar will use English (en).");
+        Sonar.get().getLogger().error("Could not find requested language: {}", throwable);
+        Sonar.get().getLogger().error("You can view a full list of valid language codes here:");
+        Sonar.get().getLogger().error("https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes");
+        Sonar.get().getLogger().error("If a translation does not exist yet, Sonar will use English (en).");
       }
     } catch (IOException exception) {
-      LOGGER.error("Error reading language file: {}", exception);
+      Sonar.get().getLogger().error("Error reading language file: {}", exception);
     }
     return DEFAULT_FALLBACK_LANGUAGE;
   }
@@ -131,13 +112,13 @@ public final class SonarConfiguration {
         final String property = System.getProperty("user.language", "en");
         language = Language.fromCode(property);
         // Make sure the user knows that we're using the system language for translations
-        LOGGER.info("Using system language ({}) for translations.", language);
+        Sonar.get().getLogger().info("Using system language ({}) for translations.", language);
       } catch (Exception exception) {
-        LOGGER.warn("Could not use system language for translations.");
-        LOGGER.warn("Using default language ({}) for translations.", language);
+        Sonar.get().getLogger().warn("Could not use system language for translations.");
+        Sonar.get().getLogger().warn("Using default language ({}) for translations.", language);
       }
     } else {
-      LOGGER.info("Using custom language ({}) for translations.", language);
+      Sonar.get().getLogger().info("Using custom language ({}) for translations.", language);
     }
 
     // Load all configurations
@@ -177,12 +158,12 @@ public final class SonarConfiguration {
     verification.timing = Verification.Timing.valueOf(generalConfig.getString("verification.timing"));
     // Warn the user if the verification timing is set to NEVER
     if (verification.timing == Verification.Timing.NEVER) {
-      LOGGER.warn(" ");
-      LOGGER.warn("You have set the verification timing to 'NEVER'.");
-      LOGGER.warn("Sonar will NOT perform the bot verification at all, therefore making it useless.");
-      LOGGER.warn("It is highly suggested to set this option to either 'DURING_ATTACK' or 'ALWAYS'.");
-      LOGGER.warn("Please only edit this option if you really know what you are doing.");
-      LOGGER.warn(" ");
+      Sonar.get().getLogger().warn(" ");
+      Sonar.get().getLogger().warn("You have set the verification timing to 'NEVER'.");
+      Sonar.get().getLogger().warn("Sonar will NOT perform the bot verification at all, therefore making it useless.");
+      Sonar.get().getLogger().warn("It is highly suggested to set this option to either 'DURING_ATTACK' or 'ALWAYS'.");
+      Sonar.get().getLogger().warn("Please only edit this option if you really know what you are doing.");
+      Sonar.get().getLogger().warn(" ");
     }
 
     verification.gravity.enabled = generalConfig.getBoolean("verification.checks.gravity.enabled");
@@ -202,10 +183,11 @@ public final class SonarConfiguration {
 
     final String backgroundPath = generalConfig.getString("verification.checks.map-captcha.background");
     if (!backgroundPath.isEmpty()) {
-      try (final InputStream inputStream = new FileInputStream(backgroundPath)) {
-        verification.map.backgroundImage = inputStream;
-      } catch (IOException exception) {
-        Sonar.get().getLogger().error("Could not find background image", exception);
+      final File backgroundFile = new File(pluginFolder, backgroundPath);
+      if (backgroundFile.exists()) {
+        verification.map.backgroundImage = backgroundFile;
+      } else {
+        Sonar.get().getLogger().error("Could not find background image {}", backgroundFile.getAbsolutePath());
       }
     }
 
@@ -213,10 +195,10 @@ public final class SonarConfiguration {
     verification.brand.validRegex = Pattern.compile(generalConfig.getString("verification.checks.client-brand.valid-regex"));
     verification.brand.maxLength = generalConfig.getInt("verification.checks.client-brand.max-length");
 
+    verification.timeOfDay = clamp(generalConfig.getInt("verification.time-of-day"), 0, 24000);
     verification.gamemode = Verification.Gamemode.valueOf(generalConfig.getString("verification.gamemode"));
     verification.validNameRegex = Pattern.compile(generalConfig.getString("verification.checks.valid-name-regex"));
     verification.validLocaleRegex = Pattern.compile(generalConfig.getString("verification.checks.valid-locale-regex"));
-    verification.maxLoginPackets = clamp(generalConfig.getInt("verification.checks.max-login-packets"), 128, 8192);
 
     verification.checkGeyser = generalConfig.getBoolean("verification.check-geyser-players");
     verification.logConnections = generalConfig.getBoolean("verification.log-connections");
@@ -238,16 +220,12 @@ public final class SonarConfiguration {
     webhook.content = webhookConfig.getString("webhook.content");
     webhook.footer.text = webhookConfig.getString("webhook.embed.footer.text");
     webhook.footer.iconUrl = webhookConfig.getString("webhook.embed.footer.icon-url");
-
-    final String realEmbedPath = "webhook.embed";
-    final String embedPath = realEmbedPath + ".";
-
-    webhook.embed.title = webhookConfig.getString(embedPath + "title");
-    webhook.embed.titleUrl = webhookConfig.getString(embedPath + "title-url");
-    webhook.embed.description = String.join("\n", webhookConfig.getStringList(embedPath + "description"));
-    webhook.embed.r = webhookConfig.getInt(embedPath + "color.red");
-    webhook.embed.g = webhookConfig.getInt(embedPath + "color.green");
-    webhook.embed.b = webhookConfig.getInt(embedPath + "color.blue");
+    webhook.embed.title = webhookConfig.getString("webhook.embed.title");
+    webhook.embed.titleUrl = webhookConfig.getString("webhook.embed.title-url");
+    webhook.embed.description = String.join("\n", webhookConfig.getStringList("webhook.embed.description"));
+    webhook.embed.r = webhookConfig.getInt("webhook.embed.color.red");
+    webhook.embed.g = webhookConfig.getInt("webhook.embed.color.green");
+    webhook.embed.b = webhookConfig.getInt("webhook.embed.color.blue");
 
     if (!webhook.url.isEmpty()) {
       if (webhook.username.isEmpty()) {
@@ -261,10 +239,16 @@ public final class SonarConfiguration {
 
     // Messages
     prefix = MiniMessage.miniMessage().deserialize(messagesConfig.getString("prefix"));
-    noPermission = MiniMessage.miniMessage().deserialize(messagesConfig.getString("commands.no-permission"),
-      Placeholder.component("prefix", prefix));
 
-    SonarCommand.prepareCachedMessages();
+    final String noPermissionMessage = messagesConfig.getString("commands.no-permission");
+    if (noPermissionMessage.isEmpty()) {
+      noPermission = null;
+    } else {
+      noPermission = MiniMessage.miniMessage().deserialize(noPermissionMessage,
+        Placeholder.component("prefix", prefix));
+    }
+
+    SonarCommand.prepareCachedTabSuggestions();
 
     supportUrl = messagesConfig.getString("support-url");
     header = MiniMessage.miniMessage().deserialize(
@@ -278,6 +262,7 @@ public final class SonarConfiguration {
 
     tooManyOnlinePerIp = deserializeDisconnectMessage("too-many-online-per-ip");
     verification.currentlyPreparing = deserializeDisconnectMessage("verification.currently-preparing");
+    verification.unsupportedVersion = deserializeDisconnectMessage("verification.unsupported-version");
     verification.tooFastReconnect = deserializeDisconnectMessage("verification.too-fast-reconnect");
     verification.alreadyVerifying = deserializeDisconnectMessage("verification.already-verifying");
     verification.alreadyQueued = deserializeDisconnectMessage("verification.already-queued");
@@ -303,7 +288,7 @@ public final class SonarConfiguration {
     final String resourceName = url + "/" + language.getCode() + ".yml";
     URL result = Sonar.class.getResource("/assets/" + resourceName);
     if (result == null) {
-      LOGGER.warn("Could not find " + resourceName + "! Using en.yml!");
+      Sonar.get().getLogger().warn("Could not find " + resourceName + "! Using en.yml!");
       result = Objects.requireNonNull(Sonar.class.getResource("/assets/" + url + "/en.yml"));
     }
     return result;
@@ -317,8 +302,8 @@ public final class SonarConfiguration {
     return output;
   }
 
-  public String formatAddress(final InetAddress inetAddress) {
-    return logPlayerAddresses ? inetAddress.toString() : "/<ip address withheld>";
+  public @NotNull String formatAddress(final @NotNull InetAddress inetAddress) {
+    return logPlayerAddresses ? inetAddress.getHostAddress() : "<ip address withheld>";
   }
 
   @Getter
@@ -386,7 +371,7 @@ public final class SonarConfiguration {
       private int maxDuration;
       private int maxTries;
       private String alphabet;
-      private InputStream backgroundImage;
+      private File backgroundImage;
     }
 
     @Getter
@@ -427,6 +412,7 @@ public final class SonarConfiguration {
       }
     }
 
+    private int timeOfDay;
     private boolean checkGeyser;
     private boolean logConnections;
     private boolean logDuringAttack;
@@ -434,7 +420,6 @@ public final class SonarConfiguration {
     private Pattern validNameRegex;
     private Pattern validLocaleRegex;
 
-    private int maxLoginPackets;
     private int readTimeout;
     private int writeTimeout;
     private int reconnectDelay;
@@ -452,6 +437,7 @@ public final class SonarConfiguration {
     private Component blacklisted;
     private Component protocolBlacklisted;
     private Component currentlyPreparing;
+    private Component unsupportedVersion;
   }
 
   @Getter
@@ -489,7 +475,7 @@ public final class SonarConfiguration {
       private final DatabaseType databaseType;
       private final Library databaseDriver;
       @Setter
-      private boolean downloaded;
+      private boolean loaded;
     }
 
     private Type type;

api/src/main/java/xyz/jonesdev/sonar/api/database/controller/VerifiedPlayerController.java

@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.database.controller;
+
+import com.alessiodp.libby.LibraryManager;
+import com.j256.ormlite.dao.Dao;
+import com.j256.ormlite.dao.DaoManager;
+import com.j256.ormlite.jdbc.JdbcConnectionSource;
+import com.j256.ormlite.stmt.QueryBuilder;
+import com.j256.ormlite.support.ConnectionSource;
+import com.j256.ormlite.table.TableUtils;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Range;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+import xyz.jonesdev.sonar.api.database.model.VerifiedPlayer;
+import xyz.jonesdev.sonar.api.fingerprint.FingerprintingUtil;
+
+import java.io.File;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public final class VerifiedPlayerController {
+  @Getter
+  private final Set<String> cache = Collections.synchronizedSet(new HashSet<>());
+  private @Nullable ConnectionSource connectionSource;
+  private Dao<VerifiedPlayer, Integer> dao;
+  private QueryBuilder<VerifiedPlayer, Integer> queryBuilder;
+  @Getter
+  private final @NotNull SonarConfiguration.Database.Type cachedDatabaseType;
+  private final ExecutorService updateService = Executors.newSingleThreadExecutor();
+
+  public VerifiedPlayerController(final @NotNull LibraryManager libraryManager) {
+    final SonarConfiguration.Database database = Sonar.get().getConfig().getDatabase();
+    cachedDatabaseType = database.getType();
+
+    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
+      Sonar.get().getLogger().warn("Configure a database to save verified players.");
+      return;
+    }
+
+    // Make sure to only load the driver once per database type
+    if (!cachedDatabaseType.isLoaded()) {
+      Sonar.get().getLogger().info("Loading {} driver version {}",
+        cachedDatabaseType.getDatabaseType().getDatabaseName(),
+        cachedDatabaseType.getDatabaseDriver().getVersion());
+      libraryManager.loadLibrary(cachedDatabaseType.getDatabaseDriver());
+      cachedDatabaseType.setLoaded(true);
+    }
+
+    try {
+      final String jdbcURL;
+
+      // H2 has a different JDBC URL layout
+      // https://www.codejava.net/java-se/jdbc/connect-to-h2-database-examples
+      if (cachedDatabaseType == SonarConfiguration.Database.Type.H2) {
+        final File file = new File(Sonar.get().getConfig().getPluginFolder(),
+          Sonar.get().getConfig().getGeneralConfig().getString("database.filename"));
+        jdbcURL = String.format(cachedDatabaseType.getConnectionString(), file.getAbsolutePath());
+      } else {
+        // Normal JDBC URL layout for MySQL/MariaDB/...
+        jdbcURL = String.format(cachedDatabaseType.getConnectionString(),
+          Sonar.get().getConfig().getGeneralConfig().getString("database.host"),
+          Sonar.get().getConfig().getGeneralConfig().getInt("database.port"),
+          Sonar.get().getConfig().getGeneralConfig().getString("database.name"));
+      }
+
+      connectionSource = new JdbcConnectionSource(jdbcURL,
+        Sonar.get().getConfig().getGeneralConfig().getString("database.username"),
+        Sonar.get().getConfig().getGeneralConfig().getString("database.password"),
+        cachedDatabaseType.getDatabaseType());
+
+      try {
+        TableUtils.createTableIfNotExists(connectionSource, VerifiedPlayer.class);
+      } catch (SQLException ignored) {
+        /*
+         * This is caused by a duplicate index;
+         * I know this isn't the best method of handling it,
+         * but I don't know how else I could address this issue.
+         */
+      }
+
+      dao = DaoManager.createDao(connectionSource, VerifiedPlayer.class);
+      queryBuilder = dao.queryBuilder();
+
+      // Make sure to run the clean task and the caching task in the same thread
+      // https://github.com/jonesdevelopment/sonar/issues/150
+      updateService.execute(() -> {
+        if (connectionSource != null) {
+          try {
+            // Make sure to clear all outdated entries first
+            clearOld(database.getMaximumAge());
+            // Add all entries from the database to the cache
+            dao.queryForAll().forEach(verifiedPlayer -> cache.add(verifiedPlayer.getFingerprint()));
+          } catch (SQLException exception) {
+            exception.printStackTrace(System.err);
+          }
+        }
+      });
+    } catch (SQLException exception) {
+      exception.printStackTrace(System.err);
+    }
+  }
+
+  /**
+   * Closes the connection if instantiated
+   */
+  public void close() {
+    // The connection source will always be null if the database type is NONE.
+    if (connectionSource != null) {
+      try {
+        connectionSource.close();
+      } catch (Exception exception) {
+        exception.printStackTrace(System.err);
+      }
+      // Make sure not to reuse a closed connection
+      connectionSource = null;
+      updateService.shutdown();
+    }
+  }
+
+  /**
+   * Clear all old entries using the given timestamp
+   */
+  private void clearOld(final @Range(from = 1, to = 365) int maximumAge) throws SQLException {
+    final long timestamp = Instant.now().minus(maximumAge, ChronoUnit.DAYS).getEpochSecond() * 1000L;
+
+    final List<VerifiedPlayer> oldEntries = queryBuilder.where()
+      .lt("timestamp", new Timestamp(timestamp))
+      .query();
+
+    if (oldEntries != null && !oldEntries.isEmpty()) {
+      for (final VerifiedPlayer player : oldEntries) {
+        dao.delete(player);
+      }
+      Sonar.get().getLogger().info("Removed {} database entries older than {} days.",
+        oldEntries.size(), maximumAge);
+    }
+  }
+
+  /**
+   * First, remove the player from the local cache and then,
+   * secondly, asynchronously add the player to the database.
+   *
+   * @param fingerprint Fingerprint of the verified player
+   */
+  public void remove(final @NotNull String fingerprint) {
+    cache.remove(fingerprint);
+
+    // Don't try to update the column if the database type is NONE
+    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
+      return;
+    }
+
+    updateService.execute(() -> {
+      if (connectionSource != null) {
+        try {
+          final List<VerifiedPlayer> verifiedPlayer = queryBuilder.where()
+            .eq("fingerprint", fingerprint)
+            .query();
+
+          if (verifiedPlayer != null) {
+            for (final VerifiedPlayer player : verifiedPlayer) {
+              dao.delete(player);
+            }
+          }
+        } catch (SQLException exception) {
+          exception.printStackTrace(System.err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Creates a new VerifiedPlayer model from the given username, host address, and timestamp
+   */
+  public void add(final @NotNull String username, final @NotNull String hostAddress, final long timestamp) {
+    final String fingerprint = FingerprintingUtil.getFingerprint(username, hostAddress);
+    // Add a new VerifiedPlayer object from the given parameters to the database
+    add(new VerifiedPlayer(fingerprint, timestamp));
+  }
+
+  /**
+   * Caches the player locally and then adds the player to the database
+   */
+  public void add(final @NotNull VerifiedPlayer player) {
+    cache.add(player.getFingerprint());
+
+    // Don't try to update the column if the database type is NONE
+    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
+      return;
+    }
+
+    updateService.execute(() -> {
+      if (connectionSource != null) {
+        try {
+          dao.createIfNotExists(player);
+        } catch (SQLException exception) {
+          exception.printStackTrace(System.err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Clear the local cache, and, if the database type is set,
+   * remove the table from the database.
+   */
+  public void clearAll() {
+    cache.clear();
+
+    // Delete the entire table from the database, if necessary
+    if (connectionSource != null
+      && cachedDatabaseType != SonarConfiguration.Database.Type.NONE) {
+      try {
+        dao.deleteBuilder().delete();
+      } catch (SQLException exception) {
+        exception.printStackTrace(System.err);
+      }
+    }
+  }
+}

api/src/main/java/xyz/jonesdev/sonar/api/database/model/VerifiedPlayer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.model;
+package xyz.jonesdev.sonar.api.database.model;
 
 import com.j256.ormlite.field.DatabaseField;
 import com.j256.ormlite.table.DatabaseTable;
@@ -25,34 +25,23 @@ import lombok.NoArgsConstructor;
 import lombok.ToString;
 import org.jetbrains.annotations.NotNull;
 
-import java.net.InetAddress;
 import java.sql.Timestamp;
-import java.util.UUID;
 
 @Getter
 @ToString
+@DatabaseTable(tableName = "sonar_fingerprints")
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
-@DatabaseTable(tableName = "sonar_verified_players")
 public final class VerifiedPlayer {
   @SuppressWarnings("unused")
   @DatabaseField(generatedId = true)
   private int id;
 
   @DatabaseField(
-    columnName = "ip_address",
+    columnName = "fingerprint",
     canBeNull = false,
-    uniqueIndexName = "ip_address_player_uuid_idx",
-    width = 16
+    width = 48
   )
-  private String inetAddress;
-
-  @DatabaseField(
-    columnName = "player_uuid",
-    canBeNull = false,
-    uniqueIndexName = "ip_address_player_uuid_idx",
-    width = 36
-  )
-  private UUID playerUuid;
+  private String fingerprint;
 
   @DatabaseField(
     columnName = "timestamp",
@@ -60,17 +49,9 @@ public final class VerifiedPlayer {
   )
   private Timestamp timestamp;
 
-  public VerifiedPlayer(final @NotNull InetAddress inetAddress,
-                        final @NotNull UUID playerUuid,
+  public VerifiedPlayer(final @NotNull String fingerprint,
                         final long timestamp) {
-    this(inetAddress.toString(), playerUuid, timestamp);
-  }
-
-  public VerifiedPlayer(final @NotNull String inetAddress,
-                        final @NotNull UUID playerUuid,
-                        final long timestamp) {
-    this.inetAddress = inetAddress;
-    this.playerUuid = playerUuid;
+    this.fingerprint = fingerprint;
     this.timestamp = new Timestamp(timestamp);
   }
 }

api/src/main/java/xyz/jonesdev/sonar/api/database/ormlite/H2DatabaseTypeAdapter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.ormlite;
+package xyz.jonesdev.sonar.api.database.ormlite;
 
 import com.j256.ormlite.jdbc.db.H2DatabaseType;
 import org.jetbrains.annotations.NotNull;

api/src/main/java/xyz/jonesdev/sonar/api/database/ormlite/MariaDbDatabaseTypeAdapter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.ormlite;
+package xyz.jonesdev.sonar.api.database.ormlite;
 
 import com.j256.ormlite.jdbc.db.MariaDbDatabaseType;
 import org.jetbrains.annotations.NotNull;

api/src/main/java/xyz/jonesdev/sonar/api/database/ormlite/MysqlDatabaseTypeAdapter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.ormlite;
+package xyz.jonesdev.sonar.api.database.ormlite;
 
 import com.j256.ormlite.jdbc.db.MysqlDatabaseType;
 import org.jetbrains.annotations.NotNull;

api/src/main/java/xyz/jonesdev/sonar/api/event/SonarEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

api/src/main/java/xyz/jonesdev/sonar/api/event/SonarEventListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,13 +17,13 @@
 
 package xyz.jonesdev.sonar.api.event;
 
+import org.jetbrains.annotations.NotNull;
+
 @FunctionalInterface
 public interface SonarEventListener {
 
   /**
-   * Handles the publishing of an event
-   *
-   * @param event [Cancellable] Sonar event
+   * Handles the publishing of an event through Sonar's API
    */
-  void handle(final SonarEvent event);
+  void handle(final @NotNull SonarEvent event);
 }

api/src/main/java/xyz/jonesdev/sonar/api/event/SonarEventManager.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -35,12 +35,9 @@ public final class SonarEventManager {
   private static final Collection<SonarEventListener> EVENT_LISTENERS = new Vector<>(0);
   private static final ExecutorService EVENT_SERVICE = Executors.newSingleThreadExecutor();
 
-  /**
-   * Publishes the given event to all listeners
-   */
   @ApiStatus.Internal
   public void publish(final @NotNull SonarEvent event) {
-    // Don't post a task if there are no listeners
+    // Don't post an event if there are no listeners
     if (EVENT_LISTENERS.isEmpty()) {
       return;
     }
@@ -61,11 +58,13 @@ public final class SonarEventManager {
    * Registers one (or more) event listeners
    *
    * @param listeners One (or more) listeners to register
-   * @see #unregisterListener(SonarEventListener...) Unregister an event listener
+   * @see #unregisterListener(SonarEventListener[]) Unregister an event listener
    */
   @SuppressWarnings("unused") // External API usage
-  public synchronized void registerListener(final @NotNull SonarEventListener... listeners) {
-    EVENT_LISTENERS.addAll(Arrays.asList(listeners));
+  public void registerListener(final @NotNull SonarEventListener... listeners) {
+    synchronized (EVENT_LISTENERS) {
+      EVENT_LISTENERS.addAll(Arrays.asList(listeners));
+    }
   }
 
   /**
@@ -73,10 +72,12 @@ public final class SonarEventManager {
    *
    * @param listeners One (or more) listeners to unregister
    * @apiNote This does not have any effect if the given listeners are not registered
-   * @see #registerListener(SonarEventListener...) Register an event listener
+   * @see #registerListener(SonarEventListener[]) Register an event listener
    */
   @SuppressWarnings("unused") // External API usage
-  public synchronized void unregisterListener(final @NotNull SonarEventListener... listeners) {
-    EVENT_LISTENERS.removeAll(Arrays.asList(listeners));
+  public void unregisterListener(final @NotNull SonarEventListener... listeners) {
+    synchronized (EVENT_LISTENERS) {
+      EVENT_LISTENERS.removeAll(Arrays.asList(listeners));
+    }
   }
 }

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/AttackDetectedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/AttackMitigatedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,8 +20,8 @@ package xyz.jonesdev.sonar.api.event.impl;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
-import xyz.jonesdev.sonar.api.attack.AttackTracker;
 import xyz.jonesdev.sonar.api.event.SonarEvent;
+import xyz.jonesdev.sonar.api.tracker.AttackTracker;
 
 @Getter
 @ToString

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/CaptchaGenerationEndEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,16 +15,18 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.command;
+package xyz.jonesdev.sonar.api.event.impl;
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
+import xyz.jonesdev.sonar.api.event.SonarEvent;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
 @Getter
+@ToString
 @RequiredArgsConstructor
-@ToString(of = "rawArguments")
-public final class CommandInvocation {
-  private final InvocationSource source;
-  private final String[] rawArguments;
+public final class CaptchaGenerationEndEvent implements SonarEvent {
+  private final SystemTimer timer;
+  private final int amountGenerated;
 }

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/CaptchaGenerationStartEvent.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.event.impl;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+import xyz.jonesdev.sonar.api.event.SonarEvent;
+import xyz.jonesdev.sonar.api.fallback.captcha.CaptchaGenerator;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public final class CaptchaGenerationStartEvent implements SonarEvent {
+  private CaptchaGenerator captchaGenerator;
+}

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/UserBlacklistedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,7 +20,6 @@ package xyz.jonesdev.sonar.api.event.impl;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
-import org.jetbrains.annotations.ApiStatus;
 import xyz.jonesdev.sonar.api.event.SonarEvent;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 
@@ -28,6 +27,5 @@ import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 @ToString
 @RequiredArgsConstructor
 public final class UserBlacklistedEvent implements SonarEvent {
-  @ApiStatus.Experimental
   private final FallbackUser user;
 }

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/UserVerifyFailedEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/UserVerifyJoinEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -27,6 +27,5 @@ import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 @ToString
 @RequiredArgsConstructor
 public final class UserVerifyJoinEvent implements SonarEvent {
-  private final String username;
   private final FallbackUser user;
 }

api/src/main/java/xyz/jonesdev/sonar/api/event/impl/UserVerifySuccessEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,14 +23,9 @@ import lombok.ToString;
 import xyz.jonesdev.sonar.api.event.SonarEvent;
 import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 
-import java.util.UUID;
-
 @Getter
 @ToString
 @RequiredArgsConstructor
 public final class UserVerifySuccessEvent implements SonarEvent {
-  private final String username;
-  private final UUID offlineUuid;
   private final FallbackUser user;
-  private final long timeTakenToVerify;
 }

api/src/main/java/xyz/jonesdev/sonar/api/fallback/Fallback.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,11 +22,10 @@ import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
-import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
 import xyz.jonesdev.sonar.api.fallback.captcha.CaptchaGenerator;
-import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
+import xyz.jonesdev.sonar.api.fallback.ratelimit.Ratelimiter;
 
 import java.net.InetAddress;
 import java.util.concurrent.ConcurrentHashMap;
@@ -37,38 +36,17 @@ import java.util.concurrent.ConcurrentMap;
 public final class Fallback {
   public static final Fallback INSTANCE = new Fallback();
 
-  // Map of all players connected to the server in general
   private final ConcurrentMap<InetAddress, Integer> online = new ConcurrentHashMap<>(128);
-  // Map of all connected IP addresses (used for fast checking)
-  private final ConcurrentMap<InetAddress, Byte> connected = new ConcurrentHashMap<>(128);
-  // Cache of all blacklisted IP addresses to ensure each entry can expire after the given time
+  private final ConcurrentMap<InetAddress, Boolean> connected = new ConcurrentHashMap<>(256);
+  private final FallbackLoginQueue queue = new FallbackLoginQueue();
   @Setter
-  private Cache<InetAddress, Byte> blacklist;
+  private Cache<String, Integer> blacklist;
   @Setter
   private long blacklistTime;
   @Setter
   private CaptchaGenerator captchaGenerator;
-
-  private final @NotNull FallbackQueue queue = new FallbackQueue();
-  private final @NotNull FallbackRatelimiter ratelimiter = new FallbackRatelimiter();
-
-  private final LoggerWrapper logger = new LoggerWrapper() {
-
-    @Override
-    public void info(final String message, final Object... args) {
-      Sonar.get().getLogger().info("[fallback] " + message, args);
-    }
-
-    @Override
-    public void warn(final String message, final Object... args) {
-      Sonar.get().getLogger().warn("[fallback] " + message, args);
-    }
-
-    @Override
-    public void error(final String message, final Object... args) {
-      Sonar.get().getLogger().error("[fallback] " + message, args);
-    }
-  };
+  @Setter
+  private Ratelimiter<InetAddress> ratelimiter;
 
   public boolean shouldVerifyNewPlayers() {
     return shouldPerform(Sonar.get().getConfig().getVerification().getTiming());

api/src/main/java/xyz/jonesdev/sonar/api/fallback/FallbackLoginQueue.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,8 +23,6 @@ import lombok.RequiredArgsConstructor;
 import xyz.jonesdev.sonar.api.Sonar;
 
 import java.net.InetAddress;
-import java.util.Iterator;
-import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ExecutorService;
@@ -32,27 +30,24 @@ import java.util.concurrent.Executors;
 
 @Getter
 @RequiredArgsConstructor(access = AccessLevel.PROTECTED)
-public final class FallbackQueue {
+public final class FallbackLoginQueue {
   // Fixed thread pool executor for all new verifications
   private static final int THREAD_POOL_SIZE = Math.min(0x7fff, Runtime.getRuntime().availableProcessors() * 2);
   private static final ExecutorService QUEUE_EXECUTOR = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
 
-  private final ConcurrentMap<InetAddress, Runnable> players = new ConcurrentHashMap<>(
-    128, 0.75f, Runtime.getRuntime().availableProcessors());
+  private final ConcurrentMap<InetAddress, Runnable> players = new ConcurrentHashMap<>(512);
 
   public void poll() {
-    final int maxQueuePolls = Sonar.get().getConfig().getQueue().getMaxQueuePolls();
-    int index = 0;
-
-    // Iterate through the map and process up to maxQueuePolls entries
+    final int maxQueuePolls = Math.min(players.size(), Sonar.get().getConfig().getQueue().getMaxQueuePolls());
+    // No need to initiate an executor service task if nobody is currently queued
+    if (maxQueuePolls <= 0) return;
     // We need to be cautious here since we don't want any concurrency issues
-    final Iterator<Map.Entry<InetAddress, Runnable>> iterator = players.entrySet().iterator();
-    while (iterator.hasNext() && index++ < maxQueuePolls) {
-      // Run the cached runnable
-      final Map.Entry<InetAddress, Runnable> entry = iterator.next();
-      QUEUE_EXECUTOR.execute(entry.getValue());
-      // Remove runnable from the map
-      iterator.remove();
-    }
+    QUEUE_EXECUTOR.execute(() -> {
+      final var iterator = players.entrySet().iterator();
+      for (int index = 0; index < maxQueuePolls && iterator.hasNext(); index++) {
+        iterator.next().getValue().run();
+        iterator.remove();
+      }
+    });
   }
 }

api/src/main/java/xyz/jonesdev/sonar/api/fallback/FallbackPipelines.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

api/src/main/java/xyz/jonesdev/sonar/api/fallback/FallbackUser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,7 +18,6 @@
 package xyz.jonesdev.sonar.api.fallback;
 
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelPipeline;
 import io.netty.util.ReferenceCountUtil;
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
@@ -26,34 +25,23 @@ import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
 import java.net.InetAddress;
-import java.util.UUID;
 
 public interface FallbackUser {
-  @NotNull
-  Channel getChannel();
+  @NotNull Channel channel();
 
-  @NotNull
-  ChannelPipeline getPipeline();
+  @NotNull InetAddress getInetAddress();
 
-  @NotNull
-  InetAddress getInetAddress();
+  @NotNull ProtocolVersion getProtocolVersion();
 
-  @NotNull
-  ProtocolVersion getProtocolVersion();
+  @NotNull SystemTimer getLoginTimer();
 
-  @NotNull
-  SystemTimer getLoginTimer();
+  @NotNull String getFingerprint();
 
-  @NotNull
-  UUID getOfflineUuid();
+  @NotNull String getUsername();
 
-  boolean isReceivedClientSettings();
+  boolean isForceCaptcha();
 
-  void setReceivedClientSettings(final boolean receivedClientSettings);
-
-  boolean isReceivedPluginMessage();
-
-  void setReceivedPluginMessage(final boolean receivedPluginMessage);
+  void setForceCaptcha(final boolean isForceCaptcha);
 
   boolean isGeyser();
 
@@ -65,22 +53,14 @@ public interface FallbackUser {
    */
   void disconnect(final @NotNull Component reason);
 
-  /**
-   * Takes over the channel and begins the verification process
-   *
-   * @param username    Username of the player
-   * @param offlineUuid UUID of the player
-   */
-  void hijack(final @NotNull String username, final @NotNull UUID offlineUuid);
-
   /**
    * Sends a packet/message to the player
    *
    * @param msg Message to send to the player
    */
   default void write(final @NotNull Object msg) {
-    if (getChannel().isActive()) {
-      getChannel().writeAndFlush(msg, getChannel().voidPromise());
+    if (channel().isActive()) {
+      channel().writeAndFlush(msg, channel().voidPromise());
     } else {
       ReferenceCountUtil.release(msg);
     }
@@ -91,22 +71,10 @@ public interface FallbackUser {
    * sent once all messages are flushed.
    */
   default void delayedWrite(final @NotNull Object msg) {
-    if (getChannel().isActive()) {
-      getChannel().write(msg, getChannel().voidPromise());
+    if (channel().isActive()) {
+      channel().write(msg, channel().voidPromise());
     } else {
       ReferenceCountUtil.release(msg);
     }
   }
-
-  /**
-   * Disconnects the player who failed the verification
-   * and caches them in FAILED_VERIFICATIONS.
-   * If the player fails the verification twice,
-   * the player will be temporarily denied from verifying.
-   *
-   * @param reason Reason for failing the verification
-   * @apiNote The {@link xyz.jonesdev.sonar.api.event.impl.UserVerifyFailedEvent}
-   * will not be thrown if no reason is given
-   */
-  void fail(final @NotNull String reason);
 }

api/src/main/java/xyz/jonesdev/sonar/api/fallback/captcha/CaptchaGenerator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023-2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,9 +17,15 @@
 
 package xyz.jonesdev.sonar.api.fallback.captcha;
 
+import org.jetbrains.annotations.NotNull;
+
 import java.awt.image.BufferedImage;
 
 @FunctionalInterface
 public interface CaptchaGenerator {
-  BufferedImage createImage(final char[] answer);
+
+  /**
+   * Generates a {@link java.awt.image.BufferedImage} that shows the answer to the CAPTCHA
+   */
+  @NotNull BufferedImage createImage(final char @NotNull [] answer);
 }

api/src/main/java/xyz/jonesdev/sonar/api/fallback/protocol/ProtocolVersion.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.fallback.protocol;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Getter
+@RequiredArgsConstructor
+public enum ProtocolVersion {
+  UNKNOWN(-1, "Unknown"),
+  MINECRAFT_1_7_2(4, "1.7.2"),
+  MINECRAFT_1_7_6(5, "1.7.6"),
+  MINECRAFT_1_8(47, "1.8"),
+  MINECRAFT_1_9(107, "1.9"),
+  MINECRAFT_1_9_1(108, "1.9.1"),
+  MINECRAFT_1_9_2(109, "1.9.2"),
+  MINECRAFT_1_9_4(110, "1.9.3"),
+  MINECRAFT_1_10(210, "1.10"),
+  MINECRAFT_1_11(315, "1.11"),
+  MINECRAFT_1_11_1(316, "1.11.1"),
+  MINECRAFT_1_12(335, "1.12"),
+  MINECRAFT_1_12_1(338, "1.12.1"),
+  MINECRAFT_1_12_2(340, "1.12.2"),
+  MINECRAFT_1_13(393, "1.13"),
+  MINECRAFT_1_13_1(401, "1.13.1"),
+  MINECRAFT_1_13_2(404, "1.13.2"),
+  MINECRAFT_1_14(477, "1.14"),
+  MINECRAFT_1_14_1(480, "1.14.1"),
+  MINECRAFT_1_14_2(485, "1.14.2"),
+  MINECRAFT_1_14_3(490, "1.14.3"),
+  MINECRAFT_1_14_4(498, "1.14.4"),
+  MINECRAFT_1_15(573, "1.15"),
+  MINECRAFT_1_15_1(575, "1.15.1"),
+  MINECRAFT_1_15_2(578, "1.15.2"),
+  MINECRAFT_1_16(735, "1.16"),
+  MINECRAFT_1_16_1(736, "1.16.1"),
+  MINECRAFT_1_16_2(751, "1.16.2"),
+  MINECRAFT_1_16_3(753, "1.16.3"),
+  MINECRAFT_1_16_4(754, "1.16.4"),
+  MINECRAFT_1_17(755, "1.17"),
+  MINECRAFT_1_17_1(756, "1.17.1"),
+  MINECRAFT_1_18(757, "1.18"),
+  MINECRAFT_1_18_2(758, "1.18.2"),
+  MINECRAFT_1_19(759, "1.19"),
+  MINECRAFT_1_19_1(760, "1.19.1"),
+  MINECRAFT_1_19_3(761, "1.19.3"),
+  MINECRAFT_1_19_4(762, "1.19.4"),
+  MINECRAFT_1_20(763, "1.20"),
+  MINECRAFT_1_20_2(764, "1.20.2"),
+  MINECRAFT_1_20_3(765, "1.20.3"),
+  MINECRAFT_1_20_5(766, "1.20.5"),
+  MINECRAFT_1_21(767, "1.21"),
+  MINECRAFT_1_21_2(768, "1.21.2"),
+  MINECRAFT_1_21_4(769, "1.21.4");
+
+  private final int protocol;
+  private final String name;
+
+  public static final ProtocolVersion LATEST_VERSION;
+  public static final Map<Integer, ProtocolVersion> ID_TO_PROTOCOL_CONSTANT;
+
+  static {
+    final Map<Integer, ProtocolVersion> versions = new HashMap<>();
+
+    for (final ProtocolVersion version : values()) {
+      versions.putIfAbsent(version.protocol, version);
+    }
+
+    ID_TO_PROTOCOL_CONSTANT = versions;
+    LATEST_VERSION = values()[values().length - 1];
+  }
+
+  public static ProtocolVersion fromId(final int protocol) {
+    return ID_TO_PROTOCOL_CONSTANT.getOrDefault(protocol, UNKNOWN);
+  }
+
+  public boolean greaterThan(final ProtocolVersion that) {
+    return compareTo(that) > 0;
+  }
+
+  public boolean greaterThanOrEquals(final ProtocolVersion that) {
+    return compareTo(that) >= 0;
+  }
+
+  public boolean lessThan(final ProtocolVersion that) {
+    return compareTo(that) < 0;
+  }
+
+  public boolean lessThanOrEquals(final ProtocolVersion that) {
+    return compareTo(that) <= 0;
+  }
+
+  public boolean inBetween(final ProtocolVersion first, final ProtocolVersion last) {
+    return compareTo(first) >= 0 && compareTo(last) <= 0;
+  }
+
+  public boolean isUnknown() {
+    return this == UNKNOWN;
+  }
+}

api/src/main/java/xyz/jonesdev/sonar/api/fallback/ratelimit/Ratelimiter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,12 +15,11 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.command.subcommand.argument;
+package xyz.jonesdev.sonar.api.fallback.ratelimit;
 
-public @interface Argument {
+import org.jetbrains.annotations.NotNull;
 
-  /**
-   * @return Returns the name of the argument
-   */
-  String value();
+@FunctionalInterface
+public interface Ratelimiter<T> {
+  boolean attempt(final @NotNull T t);
 }

api/src/main/java/xyz/jonesdev/sonar/api/fingerprint/FingerprintingUtil.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.fingerprint;
+
+import lombok.experimental.UtilityClass;
+import org.jetbrains.annotations.NotNull;
+
+@UtilityClass
+public class FingerprintingUtil {
+
+  /**
+   * Returns a hex string representing a hash of the username and IP address
+   */
+  public @NotNull String getFingerprint(final @NotNull String username,
+                                        final @NotNull String hostAddress) {
+    final int hash0 = username.hashCode();
+    final int hash1 = hostAddress.hashCode();
+    final int combined = hash0 + hash1;
+    return Integer.toHexString(hash0 >> 4)
+      + Integer.toHexString(combined << 2)
+      + Integer.toHexString(hash1 >> 4);
+  }
+}

api/src/main/java/xyz/jonesdev/sonar/api/logger/LoggerWrapper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -33,7 +33,6 @@ public interface LoggerWrapper {
 
   void error(final String message, final Object... args);
 
-  // Taken from
   // https://github.com/j256/ormlite-core/blob/master/src/main/java/com/j256/ormlite/logger/Logger.java
   String ARG_STRING = "{}";
   int ARG_STRING_LENGTH = ARG_STRING.length();

api/src/main/java/xyz/jonesdev/sonar/api/notification/ActionBarNotificationHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.verbose;
+package xyz.jonesdev.sonar.api.notification;
 
 import lombok.Getter;
 import net.kyori.adventure.audience.Audience;
@@ -23,21 +23,21 @@ import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.attack.AttackTracker;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.api.tracker.AttackTracker;
 
 import java.util.UUID;
 
 import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
-import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
+import static xyz.jonesdev.sonar.api.profiler.SimpleProcessProfiler.*;
 import static xyz.jonesdev.sonar.api.timer.SystemTimer.DATE_FORMATTER;
 
 @Getter
-public final class Verbose extends Observable {
+public final class ActionBarNotificationHandler extends NotificationHandler {
   private int animationIndex;
 
   @Override
-  public void observe() {
+  public void handleNotification() {
     // Don't prepare component if there are no subscribers
     if (subscribers.isEmpty()) {
       return;
@@ -63,10 +63,10 @@ public final class Verbose extends Observable {
       Placeholder.unparsed("verify-total", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalAttemptedVerifications())),
       Placeholder.unparsed("verify-success", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalSuccessfulVerifications())),
       Placeholder.unparsed("verify-failed", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalFailedVerifications())),
-      Placeholder.unparsed("incoming-traffic", Sonar.get().getStatistics().getCurrentIncomingBandwidthFormatted()),
-      Placeholder.unparsed("outgoing-traffic", Sonar.get().getStatistics().getCurrentOutgoingBandwidthFormatted()),
-      Placeholder.unparsed("incoming-traffic-ttl", Sonar.get().getStatistics().getTotalIncomingBandwidthFormatted()),
-      Placeholder.unparsed("outgoing-traffic-ttl", Sonar.get().getStatistics().getTotalOutgoingBandwidthFormatted()),
+      Placeholder.unparsed("incoming-traffic", Sonar.get().getStatistics().getPerSecondIncomingBandwidthFormatted()),
+      Placeholder.unparsed("outgoing-traffic", Sonar.get().getStatistics().getPerSecondOutgoingBandwidthFormatted()),
+      Placeholder.unparsed("incoming-traffic-ttl", formatMemory(Sonar.get().getStatistics().getTotalIncomingBandwidth())),
+      Placeholder.unparsed("outgoing-traffic-ttl", formatMemory(Sonar.get().getStatistics().getTotalOutgoingBandwidth())),
       Placeholder.unparsed("used-memory", formatMemory(getUsedMemory())),
       Placeholder.unparsed("free-memory", formatMemory(getFreeMemory())),
       Placeholder.unparsed("total-memory", formatMemory(getTotalMemory())),

api/src/main/java/xyz/jonesdev/sonar/api/notification/ChatNotificationHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.verbose;
+package xyz.jonesdev.sonar.api.notification;
 
 import lombok.Getter;
 import net.kyori.adventure.audience.Audience;
@@ -29,13 +29,13 @@ import java.util.List;
 import java.util.UUID;
 
 import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
-import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
+import static xyz.jonesdev.sonar.api.profiler.SimpleProcessProfiler.*;
 
 @Getter
-public final class Notification extends Observable {
+public final class ChatNotificationHandler extends NotificationHandler {
 
   @Override
-  public void observe() {
+  public void handleNotification() {
     // Don't prepare component if there are no subscribers
     if (subscribers.isEmpty()) {
       return;
@@ -63,10 +63,10 @@ public final class Notification extends Observable {
         Placeholder.unparsed("verify-total", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalAttemptedVerifications())),
         Placeholder.unparsed("verify-success", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalSuccessfulVerifications())),
         Placeholder.unparsed("verify-failed", DECIMAL_FORMAT.format(Sonar.get().getStatistics().getTotalFailedVerifications())),
-        Placeholder.unparsed("incoming-traffic", Sonar.get().getStatistics().getCurrentIncomingBandwidthFormatted()),
-        Placeholder.unparsed("outgoing-traffic", Sonar.get().getStatistics().getCurrentOutgoingBandwidthFormatted()),
-        Placeholder.unparsed("incoming-traffic-ttl", Sonar.get().getStatistics().getTotalIncomingBandwidthFormatted()),
-        Placeholder.unparsed("outgoing-traffic-ttl", Sonar.get().getStatistics().getTotalOutgoingBandwidthFormatted()),
+        Placeholder.unparsed("incoming-traffic", Sonar.get().getStatistics().getPerSecondIncomingBandwidthFormatted()),
+        Placeholder.unparsed("outgoing-traffic", Sonar.get().getStatistics().getPerSecondOutgoingBandwidthFormatted()),
+        Placeholder.unparsed("incoming-traffic-ttl", formatMemory(Sonar.get().getStatistics().getTotalIncomingBandwidth())),
+        Placeholder.unparsed("outgoing-traffic-ttl", formatMemory(Sonar.get().getStatistics().getTotalOutgoingBandwidth())),
         Placeholder.unparsed("used-memory", formatMemory(getUsedMemory())),
         Placeholder.unparsed("free-memory", formatMemory(getFreeMemory())),
         Placeholder.unparsed("total-memory", formatMemory(getTotalMemory())),
@@ -74,7 +74,7 @@ public final class Notification extends Observable {
     }
 
     // Send the title and chat messages to all online players
-    for (final UUID subscriber : Sonar.get().getNotificationHandler().getSubscribers()) {
+    for (final UUID subscriber : Sonar.get().getChatNotificationHandler().getSubscribers()) {
       final Audience audience = Sonar.get().audience(subscriber);
       if (audience == null) continue;
 

api/src/main/java/xyz/jonesdev/sonar/api/notification/NotificationHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.verbose;
+package xyz.jonesdev.sonar.api.notification;
 
 import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
@@ -25,10 +25,10 @@ import java.util.UUID;
 import java.util.Vector;
 
 @Getter
-public abstract class Observable {
+public abstract class NotificationHandler {
   protected final @NotNull Collection<UUID> subscribers = new Vector<>(0);
 
-  public abstract void observe();
+  public abstract void handleNotification();
 
   /**
    * @param uuid UUID of the player

api/src/main/java/xyz/jonesdev/sonar/api/profiler/SimpleProcessProfiler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.jvm;
+package xyz.jonesdev.sonar.api.profiler;
 
 import com.sun.management.OperatingSystemMXBean;
 import lombok.experimental.UtilityClass;
@@ -24,7 +24,7 @@ import java.lang.management.ManagementFactory;
 import java.text.DecimalFormat;
 
 @UtilityClass
-public class JVMProcessInformation {
+public class SimpleProcessProfiler {
   private final Runtime RUNTIME = Runtime.getRuntime();
   private final OperatingSystemMXBean MX = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
   private final char[] MEMORY_UNITS = {'K', 'M', 'G', 'T', 'P', 'E'};

api/src/main/java/xyz/jonesdev/sonar/api/statistics/SonarStatistics.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.api.statistics;
+
+@SuppressWarnings("unused")
+public interface SonarStatistics {
+  long getConnectionsPerSecond();
+
+  long getLoginsPerSecond();
+
+  long getCurrentIncomingBandwidth();
+
+  long getCurrentOutgoingBandwidth();
+
+  long getTotalIncomingBandwidth();
+
+  long getTotalOutgoingBandwidth();
+
+  String getPerSecondIncomingBandwidthFormatted();
+
+  String getPerSecondOutgoingBandwidthFormatted();
+
+  int getTotalPlayersJoined();
+
+  int getTotalPlayersVerified();
+
+  int getTotalSuccessfulVerifications();
+
+  int getTotalFailedVerifications();
+
+  long getCurrentAttemptedVerifications();
+
+  int getTotalAttemptedVerifications();
+
+  long getCurrentBlacklistSize();
+
+  long getTotalBlacklistSize();
+}

api/src/main/java/xyz/jonesdev/sonar/api/timer/SystemTimer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

api/src/main/java/xyz/jonesdev/sonar/api/tracker/AttackTracker.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.api.attack;
+package xyz.jonesdev.sonar.api.tracker;
 
 import lombok.*;
 import org.jetbrains.annotations.Nullable;
@@ -27,12 +27,13 @@ import xyz.jonesdev.sonar.api.timer.SystemTimer;
 
 import java.util.Optional;
 
-import static xyz.jonesdev.sonar.api.jvm.JVMProcessInformation.*;
+import static xyz.jonesdev.sonar.api.profiler.SimpleProcessProfiler.*;
 
 @Getter
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
 public final class AttackTracker {
   public static final AttackTracker INSTANCE = new AttackTracker();
+
   private @Nullable AttackStatistics currentAttack;
   private int attackThreshold;
 
@@ -65,10 +66,10 @@ public final class AttackTracker {
       // An attack has been detected
       if (currentAttack == null) {
         currentAttack = new AttackStatistics();
-        currentAttack.successfulVerifications = Sonar.get().getVerifiedPlayerController().estimatedSize();
+        currentAttack.successfulVerifications = Sonar.get().getVerifiedPlayerController().getCache().size();
         currentAttack.failedVerifications = Sonar.get().getStatistics().getTotalFailedVerifications();
         Sonar.get().getEventManager().publish(new AttackDetectedEvent());
-        Sonar.get().getNotificationHandler().observe();
+        Sonar.get().getChatNotificationHandler().handleNotification();
       } else {
         // Reset attack timer if we're still under attack
         currentAttack.timer.reset();
@@ -117,7 +118,7 @@ public final class AttackTracker {
               final String endTimestamp = String.valueOf(System.currentTimeMillis() / 1000L);
               final long blacklisted = Sonar.get().getFallback().getBlacklist().estimatedSize();
               // Calculate during-attack-statistics using their deltas
-              final long totalVerified = Sonar.get().getVerifiedPlayerController().estimatedSize();
+              final long totalVerified = Sonar.get().getVerifiedPlayerController().getCache().size();
               final long verified = Math.max(totalVerified - currentAttack.successfulVerifications, 0);
               final long totalFailed = Sonar.get().getStatistics().getTotalFailedVerifications();
               final long failed = Math.max(totalFailed - currentAttack.failedVerifications, 0);
@@ -143,11 +144,9 @@ public final class AttackTracker {
 
         // Reset the attack status
         currentAttack = null;
-        // Reset threshold
         attackThreshold = 0;
       }
     } else {
-      // Reset threshold
       attackThreshold = 0;
     }
   }

api/src/main/java/xyz/jonesdev/sonar/api/update/UpdateChecker.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,14 +15,15 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.common.update;
+package xyz.jonesdev.sonar.api.update;
 
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import lombok.experimental.UtilityClass;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
 
 import javax.net.ssl.HttpsURLConnection;
 import java.io.BufferedReader;
@@ -36,24 +37,8 @@ import java.util.concurrent.Executors;
 @UtilityClass
 public class UpdateChecker {
   private final ExecutorService ASYNC_EXECUTOR = Executors.newSingleThreadExecutor();
-
-  private final LoggerWrapper LOGGER = new LoggerWrapper() {
-
-    @Override
-    public void info(final String message, final Object... args) {
-      Sonar.get().getLogger().info("[update-checker] " + message, args);
-    }
-
-    @Override
-    public void warn(final String message, final Object... args) {
-      Sonar.get().getLogger().warn("[update-checker] " + message, args);
-    }
-
-    @Override
-    public void error(final String message, final Object... args) {
-      Sonar.get().getLogger().error("[update-checker] " + message, args);
-    }
-  };
+  @Getter
+  private CheckResult lastCheckResult = CheckResult.UNRESOLVED;
 
   public void checkForUpdates() {
     ASYNC_EXECUTOR.execute(() -> {
@@ -66,17 +51,21 @@ public class UpdateChecker {
         final int convertedCurrentVersion = convertVersion(Sonar.get().getVersion().getVersion());
 
         if (convertedCurrentVersion < convertedLatestVersion) {
-          LOGGER.warn("A new version of Sonar is available: {}", latestStableRelease);
-          LOGGER.warn("Please make sure to update to the latest version to ensure stability and security:");
-          LOGGER.warn("https://github.com/jonesdevelopment/sonar/releases/tag/{}", latestStableRelease);
+          Sonar.get().getLogger().warn("A new version of Sonar is available: {}", latestStableRelease);
+          Sonar.get().getLogger().warn("Please make sure to update to the latest version to ensure stability and security:");
+          Sonar.get().getLogger().warn("https://github.com/jonesdevelopment/sonar/releases/latest");
+          lastCheckResult = CheckResult.OUTDATED_VERSION;
         } else if (convertedCurrentVersion > convertedLatestVersion || !Sonar.get().getVersion().getGitBranch().equals("main")) {
-          LOGGER.warn("You are currently using an unreleased version of Sonar!");
-          LOGGER.warn("The contributors of Sonar are not responsible for any damage done by using an unstable version");
-        } else {
-          LOGGER.info("You are currently using the latest stable release of Sonar!");
+          Sonar.get().getLogger().warn("You are currently using an unreleased version of Sonar!");
+          Sonar.get().getLogger().warn("The contributors of Sonar are not responsible for any damage done by using an unstable version");
+          lastCheckResult = CheckResult.UNSTABLE_VERSION;
+        } else if (lastCheckResult != CheckResult.LATEST_VERSION) {
+          Sonar.get().getLogger().info("You are currently using the latest stable release of Sonar!");
+          lastCheckResult = CheckResult.LATEST_VERSION;
         }
       } catch (Throwable throwable) {
-        LOGGER.warn("Unable to retrieve version information: {}", throwable);
+        Sonar.get().getLogger().warn("Unable to retrieve version information: {}", throwable);
+        lastCheckResult = CheckResult.API_ERROR;
       }
     });
   }
@@ -118,4 +107,16 @@ public class UpdateChecker {
     final int patch = Integer.parseInt(convertedParts[2]);
     return convertedMajor + convertedMinor + patch; // sum the converted version parts
   }
+
+  @Getter
+  @RequiredArgsConstructor
+  public enum CheckResult {
+    API_ERROR("api-error"),
+    OUTDATED_VERSION("outdated-version"),
+    UNSTABLE_VERSION("unstable-version"),
+    LATEST_VERSION(null),
+    UNRESOLVED(null);
+
+    private final String configKey;
+  }
 }

api/src/main/java/xyz/jonesdev/sonar/api/webhook/DiscordWebhook.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

build.gradle.kts

@@ -3,7 +3,8 @@ import net.kyori.indra.git.IndraGitExtension
 plugins {
   java
   alias(libs.plugins.shadow)
-  alias(libs.plugins.indra.git) apply true
+  alias(libs.plugins.indra.git)
+  alias(libs.plugins.spotless)
 }
 
 allprojects {
@@ -15,6 +16,7 @@ allprojects {
 
   apply(plugin = "java")
   apply(plugin = "com.gradleup.shadow")
+  apply(plugin = "com.diffplug.spotless")
 
   dependencies {
     compileOnly(rootProject.libs.lombok)
@@ -31,6 +33,16 @@ allprojects {
     compileOnly(rootProject.libs.libby.core)
   }
 
+  spotless {
+    java {
+      endWithNewline()
+      formatAnnotations()
+      removeUnusedImports()
+      trimTrailingWhitespace()
+      indentWithSpaces(2)
+    }
+  }
+
   tasks {
     shadowJar {
       // Set the file name of the shadowed jar
@@ -80,14 +92,17 @@ allprojects {
         attributes["Git-Commit"] = gitCommit
       }
     }
+
+    java.sourceCompatibility = JavaVersion.VERSION_11
+    java.targetCompatibility = JavaVersion.VERSION_11
   }
 }
 
 tasks {
   // This is a small wrapper tasks to simplify the building process
   register("build-sonar") {
-    val subprojects = listOf("api", "common", "bukkit", "bungee", "velocity")
-    val buildTasks = subprojects.flatMap { listOf("$it:clean", "$it:shadowJar") }
+    val subprojects = listOf("api", "captcha", "common", "bukkit", "bungeecord", "velocity")
+    val buildTasks = subprojects.flatMap { listOf("$it:clean", "$it:spotlessApply", "$it:shadowJar") }
     dependsOn(buildTasks)
   }
 }

bukkit/build.gradle.kts

@@ -46,6 +46,3 @@ tasks {
     relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori")
   }
 }
-
-java.sourceCompatibility = JavaVersion.VERSION_11
-java.targetCompatibility = JavaVersion.VERSION_11

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/SonarBukkit.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -120,8 +120,8 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
 
   @Override
   public void disable() {
+    // Make sure to properly stop the metrics
     if (metrics != null) {
-      // Make sure to properly shutdown bStats metrics
       metrics.shutdown();
     }
   }

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/SonarBukkitPlugin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/command/BukkitSonarCommand.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -27,10 +27,9 @@ import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.api.command.SonarCommand;
 
+import java.util.Collections;
 import java.util.List;
 
-import static java.util.Collections.emptyList;
-
 public final class BukkitSonarCommand implements CommandExecutor, TabExecutor, SonarCommand {
 
   @Override
@@ -45,7 +44,7 @@ public final class BukkitSonarCommand implements CommandExecutor, TabExecutor, S
       sender::hasPermission);
     // Pass the invocation source and command arguments to our command handler
     handle(invocationSource, args);
-    return true; // Valid
+    return true;
   }
 
   @Override
@@ -54,9 +53,6 @@ public final class BukkitSonarCommand implements CommandExecutor, TabExecutor, S
                                     final String commandAlias,
                                     final String @NotNull [] args) {
     // Do not allow tab completion if the player does not have the required permission
-    if (!sender.hasPermission("sonar.command")) {
-      return emptyList();
-    }
-    return getCachedTabSuggestions(args);
+    return sender.hasPermission("sonar.command") ? getCachedTabSuggestions(args) : Collections.emptyList();
   }
 }

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/fallback/BukkitServerVersion.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -70,7 +70,11 @@ public enum BukkitServerVersion {
   MINECRAFT_1_20_4,
   MINECRAFT_1_20_5,
   MINECRAFT_1_20_6,
-  MINECRAFT_1_21;
+  MINECRAFT_1_21,
+  MINECRAFT_1_21_1,
+  MINECRAFT_1_21_2,
+  MINECRAFT_1_21_3,
+  MINECRAFT_1_21_4;
 
   static final BukkitServerVersion[] REVERSED_VALUES;
 

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/fallback/ChannelInactiveListener.java

@@ -1,3 +1,20 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
 package xyz.jonesdev.sonar.bukkit.fallback;
 
 import io.netty.buffer.ByteBufAllocator;
@@ -7,6 +24,7 @@ import io.netty.util.AttributeKey;
 import io.netty.util.concurrent.EventExecutor;
 import lombok.AccessLevel;
 import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
 
 import java.net.SocketAddress;
 import java.util.HashSet;
@@ -16,7 +34,7 @@ public final class ChannelInactiveListener extends ChannelInboundHandlerAdapter
   private final Set<ChannelInboundHandler> handlers = new HashSet<>();
 
   @Override
-  public void channelInactive(ChannelHandlerContext ctx) throws Exception {
+  public void channelInactive(final @NotNull ChannelHandlerContext ctx) throws Exception {
     final ProxiedChannelHandlerContext proxy = new ProxiedChannelHandlerContext(ctx);
     for (final ChannelInboundHandler handler : handlers) {
       try {
@@ -28,9 +46,9 @@ public final class ChannelInactiveListener extends ChannelInboundHandlerAdapter
     super.channelInactive(ctx);
   }
 
-  public void add(ChannelHandler handler) {
-    if (handler instanceof ChannelInboundHandler) {
-      handlers.add((ChannelInboundHandler) handler);
+  public void add(final @NotNull ChannelHandler channelHandler) {
+    if (channelHandler instanceof ChannelInboundHandler) {
+      handlers.add((ChannelInboundHandler) channelHandler);
     }
   }
 

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/fallback/FallbackBukkitInboundHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,7 +20,7 @@ package xyz.jonesdev.sonar.bukkit.fallback;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.CorruptedFrameException;
+import io.netty.handler.codec.DecoderException;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.common.fallback.FallbackInboundHandlerAdapter;
@@ -28,23 +28,25 @@ import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.handshake.HandshakePacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginStartPacket;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
+import xyz.jonesdev.sonar.common.util.exception.QuietDecoderException;
 
 import java.net.InetSocketAddress;
 import java.util.Objects;
 
-import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_INACTIVE_LISTENER;
 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_INBOUND_HANDLER;
-import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.Direction.SERVERBOUND;
 import static xyz.jonesdev.sonar.common.fallback.protocol.packets.handshake.HandshakePacket.*;
-import static xyz.jonesdev.sonar.common.util.ProtocolUtil.readVarInt;
 
 final class FallbackBukkitInboundHandler extends FallbackInboundHandlerAdapter {
+  private static final ProtocolVersion DEFAULT_PROTOCOL_VERSION = ProtocolVersion.MINECRAFT_1_7_2;
+
+  private FallbackPacketRegistry.ProtocolRegistry registry;
 
   FallbackBukkitInboundHandler() {
     updateRegistry(FallbackPacketRegistry.HANDSHAKE, DEFAULT_PROTOCOL_VERSION);
 
     channelRemovalListener = (pipeline, name, handler) -> {
-      final var inactiveListener = (ChannelInactiveListener) pipeline.get(FALLBACK_INACTIVE_LISTENER);
+      final ChannelInactiveListener inactiveListener = pipeline.get(ChannelInactiveListener.class);
 
       if (inactiveListener != null) {
         inactiveListener.add(handler);
@@ -52,22 +54,21 @@ final class FallbackBukkitInboundHandler extends FallbackInboundHandlerAdapter {
     };
   }
 
-  private FallbackPacketRegistry.ProtocolRegistry registry;
-
-  private static final ProtocolVersion DEFAULT_PROTOCOL_VERSION = ProtocolVersion.MINECRAFT_1_7_2;
-
   public void updateRegistry(final @NotNull FallbackPacketRegistry registry,
                              final @NotNull ProtocolVersion protocolVersion) {
-    this.registry = registry.getProtocolRegistry(SERVERBOUND, protocolVersion);
+    this.registry = registry.getProtocolRegistry(FallbackPacketRegistry.Direction.SERVERBOUND, protocolVersion);
   }
 
   @Override
-  public void channelRead(final @NotNull ChannelHandlerContext ctx, final @NotNull Object msg) throws Exception {
+  public void channelRead(final @NotNull ChannelHandlerContext ctx, final Object msg) throws Exception {
     if (msg instanceof ByteBuf) {
       final ByteBuf byteBuf = (ByteBuf) msg;
 
-      // Reset the reader index, so we can read the content
-      // Make sure to store the original reader index
+      /*
+       * Reset the reader index, so we can read the content;
+       * We also have to make sure to store the original reader index.
+       * We do this to 'spoof' the packet state - we want to read it without the server knowing.
+       */
       final int originalReaderIndex = byteBuf.readerIndex();
       byteBuf.readerIndex(0);
 
@@ -77,12 +78,11 @@ final class FallbackBukkitInboundHandler extends FallbackInboundHandlerAdapter {
         return;
       }
 
-      final int packetId = readVarInt(byteBuf);
+      final int packetId = ProtocolUtil.readVarInt(byteBuf);
       final FallbackPacket packet = registry.createPacket(packetId);
 
       // Skip the packet if it's not registered within Sonar's packet registry
       if (packet == null) {
-        // Release the ByteBuf to avoid memory leaks
         byteBuf.release();
         return;
       }
@@ -91,53 +91,55 @@ final class FallbackBukkitInboundHandler extends FallbackInboundHandlerAdapter {
         // Try to decode the packet for the given protocol version
         packet.decode(byteBuf, protocolVersion == null ? DEFAULT_PROTOCOL_VERSION : protocolVersion);
       } catch (Throwable throwable) {
-        // Release the ByteBuf to avoid memory leaks
         byteBuf.release();
-        throw new CorruptedFrameException("Failed to decode packet");
+        throw ProtocolUtil.DEBUG ? new DecoderException(throwable) : QuietDecoderException.INSTANCE;
       }
 
       // Check if the packet still has bytes left after we decoded it
       if (byteBuf.isReadable()) {
-        // Release the ByteBuf to avoid memory leaks
         byteBuf.release();
-        throw new CorruptedFrameException("Could not read packet to end");
+        throw ProtocolUtil.DEBUG ? new DecoderException("Could not read packet to end ("
+          + byteBuf.readableBytes() + " bytes left)") : QuietDecoderException.INSTANCE;
       }
 
-      // Useful resources:
-      // https://wiki.vg/Protocol#Handshaking
-      // https://wiki.vg/Protocol#Login
+      /*
+       * Useful resources:
+       * https://wiki.vg/Protocol#Handshaking
+       * https://wiki.vg/Protocol#Login
+       */
       if (packet instanceof HandshakePacket) {
         final HandshakePacket handshake = (HandshakePacket) packet;
         switch (handshake.getIntent()) {
           case STATUS:
             // We don't care about server pings or transfers; remove the handler
-            ctx.channel().pipeline().remove(this);
+            ctx.pipeline().remove(this);
             break;
           case LOGIN:
           case TRANSFER:
             // Let the actual handler know about the handshake packet
-            handleHandshake(ctx.channel(), handshake.getHostname(), handshake.getProtocolVersionId());
+            handleHandshake(ctx, handshake.getHostname(), handshake.getProtocolVersionId());
             // Be ready for the next packet (which is supposed to be a login packet)
             updateRegistry(FallbackPacketRegistry.LOGIN, Objects.requireNonNull(protocolVersion));
             break;
           default:
-            throw new CorruptedFrameException("Unknown handshake intent " + handshake.getIntent());
+            throw ProtocolUtil.DEBUG ? new DecoderException("Bad handshake intent " + handshake.getIntent())
+              : QuietDecoderException.INSTANCE;
         }
       } else if (packet instanceof LoginStartPacket) {
         final LoginStartPacket loginStart = (LoginStartPacket) packet;
         final InetSocketAddress socketAddress = (InetSocketAddress) ctx.channel().remoteAddress();
         // We've done our job - deject this pipeline
-        ctx.channel().pipeline().remove(this);
+        ctx.pipeline().remove(this);
         // Let Sonar process the login packet
-        handleLogin(ctx.channel(), ctx, () -> {
+        handleLogin(ctx, () -> {
           byteBuf.readerIndex(originalReaderIndex);
           ctx.fireChannelRead(byteBuf.retain());
-          final ChannelHandler inboundHandler = ctx.channel().pipeline().remove(FALLBACK_INBOUND_HANDLER);
+          // TODO: recode this?
+          final ChannelHandler inboundHandler = ctx.pipeline().remove(FALLBACK_INBOUND_HANDLER);
           if (inboundHandler != null) {
             channelRemovalListener.accept(ctx.pipeline(), FALLBACK_INBOUND_HANDLER, inboundHandler);
           }
         }, loginStart.getUsername(), socketAddress);
-        // Release the ByteBuf to avoid memory leaks
         byteBuf.release();
         return;
       }

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/fallback/FallbackBukkitInjector.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,18 +25,18 @@ import lombok.Getter;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Bukkit;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.fallback.FallbackPipelines;
-import xyz.jonesdev.sonar.bukkit.SonarBukkit;
 import xyz.jonesdev.sonar.common.fallback.netty.FallbackInjectedChannelInitializer;
+import xyz.jonesdev.sonar.common.util.exception.ReflectiveOperationException;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.List;
 
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_INACTIVE_LISTENER;
 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_PACKET_DECODER;
+import static xyz.jonesdev.sonar.bukkit.SonarBukkit.INITIALIZE_LISTENER;
 
 // Check out these links if you want to see some more magic
 // https://github.com/retrooper/packetevents/blob/2.0/spigot/src/main/java/io/github/retrooper/packetevents/util/SpigotReflectionUtil.java
@@ -196,8 +196,7 @@ public class FallbackBukkitInjector {
       for (int i = 0; i < 2; i++) {
         final Field field = getFieldAt(SERVER_CONNECTION_CLASS, List.class, i);
 
-        // Check if the field has the correct generic type;
-        // We need this field to be List<ChannelFuture>
+        // Check if the field has the correct generic type; We need this field to be List<ChannelFuture>
         if (!field.getGenericType().getTypeName().contains(ChannelFuture.class.getName())) {
           continue;
         }
@@ -235,27 +234,29 @@ public class FallbackBukkitInjector {
           childHandlerField.setAccessible(true);
           final var originalInitializer = (ChannelInitializer<Channel>) childHandlerField.get(bootstrap);
 
-          ChannelHandler finalBootstrap = bootstrap;
+          /*
+           * Inject our own channel initializer into the original field
+           * If the plugin is not fully enabled but executes the injection,
+           * put an initializer to close the new connection automatically.
+           */
+          if (!INITIALIZE_LISTENER.isDone()) {
+            childHandlerField.set(bootstrap, new ChannelInitializer<>() {
 
-          // Inject our own channel initializer into the original field
-          // If the plugin is not fully enabled but executes the injection,
-          // put an initializer to close the new connection automatically.
-          if (!SonarBukkit.INITIALIZE_LISTENER.isDone()) {
-            final ChannelInitializer<Channel> initializer = new ChannelInitializer<>() {
               @Override
-              protected void initChannel(Channel channel) {
+              protected void initChannel(final @NotNull Channel channel) {
                 channel.close();
               }
-            };
-            childHandlerField.set(finalBootstrap, initializer);
+            });
           }
 
-          SonarBukkit.INITIALIZE_LISTENER.thenAccept(v -> {
+          final ChannelHandler _bootstrap = bootstrap;
+
+          INITIALIZE_LISTENER.thenAccept(__ -> {
             try {
-              childHandlerField.set(finalBootstrap, new FallbackInjectedChannelInitializer(originalInitializer,
+              childHandlerField.set(_bootstrap, new FallbackInjectedChannelInitializer(originalInitializer,
                 pipeline -> {
                   pipeline.addAfter("splitter", FALLBACK_PACKET_DECODER, new FallbackBukkitInboundHandler());
-                  pipeline.addFirst(FallbackPipelines.FALLBACK_INACTIVE_LISTENER, new ChannelInactiveListener());
+                  pipeline.addFirst(FALLBACK_INACTIVE_LISTENER, new ChannelInactiveListener());
                 }
               ));
             } catch (IllegalAccessException exception) {

bukkit/src/main/java/xyz/jonesdev/sonar/bukkit/listener/BukkitJoinListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -34,7 +34,6 @@ import java.lang.reflect.Method;
 
 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.FALLBACK_BANDWIDTH;
 
-// Taken from
 // https://github.com/ViaVersion/ViaVersion/blob/master/bukkit/src/main/java/com/viaversion/viaversion/bukkit/listeners/JoinListener.java
 public final class BukkitJoinListener implements Listener {
   private static MethodHandle _handleMethod;
@@ -84,7 +83,7 @@ public final class BukkitJoinListener implements Listener {
       }
 
       // Make sure the player is not a fake player
-      if (FakeChannelUtil.isFakePlayer(channel)) {
+      if (FakeChannelUtil.isFakeChannel(channel)) {
         return;
       }
 

bungeecord/build.gradle.kts

@@ -26,8 +26,7 @@ dependencies {
 tasks {
   shadowJar {
     relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori")
+
+    archiveFileName = "Sonar-Bungee.jar" // Hardcode a shortened version of the name
   }
 }
-
-java.sourceCompatibility = JavaVersion.VERSION_11
-java.targetCompatibility = JavaVersion.VERSION_11

bungeecord/src/main/java/xyz/jonesdev/sonar/bungee/SonarBungee.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -108,8 +108,8 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
 
   @Override
   public void disable() {
+    // Make sure to properly stop the metrics
     if (metrics != null) {
-      // Make sure to properly shutdown bStats metrics
       metrics.shutdown();
     }
   }

bungeecord/src/main/java/xyz/jonesdev/sonar/bungee/SonarBungeePlugin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

bungeecord/src/main/java/xyz/jonesdev/sonar/bungee/command/BungeeSonarCommand.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,7 +26,7 @@ import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.command.InvocationSource;
 import xyz.jonesdev.sonar.api.command.SonarCommand;
 
-import static java.util.Collections.emptyList;
+import java.util.Collections;
 
 public final class BungeeSonarCommand extends Command implements TabExecutor, SonarCommand {
   public BungeeSonarCommand() {
@@ -47,9 +47,6 @@ public final class BungeeSonarCommand extends Command implements TabExecutor, So
   @Override
   public Iterable<String> onTabComplete(final @NotNull CommandSender sender, final String @NotNull [] args) {
     // Do not allow tab completion if the player does not have the required permission
-    if (!sender.hasPermission("sonar.command")) {
-      return emptyList();
-    }
-    return getCachedTabSuggestions(args);
+    return sender.hasPermission("sonar.command") ? getCachedTabSuggestions(args) : Collections.emptyList();
   }
 }

bungeecord/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackBungeeInboundHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,7 +17,6 @@
 
 package xyz.jonesdev.sonar.bungee.fallback;
 
-import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import net.md_5.bungee.netty.ChannelWrapper;
 import net.md_5.bungee.netty.HandlerBoss;
@@ -26,13 +25,15 @@ import net.md_5.bungee.protocol.PacketWrapper;
 import net.md_5.bungee.protocol.packet.Handshake;
 import net.md_5.bungee.protocol.packet.LoginRequest;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
 import xyz.jonesdev.sonar.common.fallback.FallbackInboundHandlerAdapter;
+import xyz.jonesdev.sonar.common.util.exception.ReflectiveOperationException;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.net.InetSocketAddress;
 
+import static xyz.jonesdev.sonar.common.fallback.protocol.packets.handshake.HandshakePacket.STATUS;
+
 final class FallbackBungeeInboundHandler extends FallbackInboundHandlerAdapter {
 
   private static final MethodHandle CHANNEL_WRAPPER_GETTER;
@@ -47,46 +48,45 @@ final class FallbackBungeeInboundHandler extends FallbackInboundHandlerAdapter {
   }
 
   @Override
-  public void channelRead(final @NotNull ChannelHandlerContext ctx, final @NotNull Object msg) throws Exception {
-    // Intercept any packets processed by BungeeCord
+  public void channelRead(final @NotNull ChannelHandlerContext ctx, final Object msg) throws Exception {
     if (msg instanceof PacketWrapper) {
       final PacketWrapper packetWrapper = (PacketWrapper) msg;
       final DefinedPacket wrappedPacket = packetWrapper.packet;
-      // Don't handle any invalid packets
+      // Skip any unknown or invalid packets
       if (wrappedPacket != null) {
-        final Channel channel = ctx.channel();
-        // Intercept any handshake packet by the client
         if (wrappedPacket instanceof Handshake) {
           final Handshake handshake = (Handshake) wrappedPacket;
-          handleHandshake(channel, handshake.getHost(), handshake.getProtocolVersion());
           // We don't care about server pings; remove the handler
-            if (handshake.getRequestedProtocol() == 1) {
-            ctx.channel().pipeline().remove(this);
+          if (handshake.getRequestedProtocol() == STATUS) {
+            ctx.pipeline().remove(this);
+          } else {
+            handleHandshake(ctx, handshake.getHost(), handshake.getProtocolVersion());
           }
-        }
-        // Intercept any server login packet by the client
-        else if (wrappedPacket instanceof LoginRequest) {
+        } else if (wrappedPacket instanceof LoginRequest) {
           // Make sure to use the potentially modified, real IP
           final LoginRequest loginRequest = (LoginRequest) wrappedPacket;
-          final HandlerBoss handlerBoss = channel.pipeline().get(HandlerBoss.class);
-          final ChannelWrapper channelWrapper;
-          try {
-            channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER_GETTER.invokeExact(handlerBoss);
-          } catch (final Throwable throwable) {
-            throw new ReflectiveOperationException(throwable);
+          final HandlerBoss handlerBoss = ctx.pipeline().get(HandlerBoss.class);
+          // This might sometimes happen if the client unexpectedly disconnects
+          if (handlerBoss != null) {
+            // Get the real IP address of the player through the channel wrapper
+            final ChannelWrapper channelWrapper;
+            try {
+              channelWrapper = (ChannelWrapper) CHANNEL_WRAPPER_GETTER.invokeExact(handlerBoss);
+            } catch (final Throwable throwable) {
+              throw new ReflectiveOperationException(throwable);
+            }
+            // We've done our job - deject this pipeline
+            ctx.pipeline().remove(this);
+            // Make sure to mark this packet as released
+            packetWrapper.trySingleRelease();
+            // Let Sonar process the login packet
+            final InetSocketAddress socketAddress = (InetSocketAddress) channelWrapper.getRemoteAddress();
+            handleLogin(ctx, () -> ctx.fireChannelRead(msg), loginRequest.getData(), socketAddress);
+            return;
           }
-          final InetSocketAddress socketAddress = (InetSocketAddress) channelWrapper.getRemoteAddress();
-          // We've done our job - deject this pipeline
-          ctx.channel().pipeline().remove(this);
-          // Make sure to mark this packet as released
-          packetWrapper.trySingleRelease();
-          // Let Sonar process the login packet
-          handleLogin(channel, ctx, () -> ctx.fireChannelRead(msg), loginRequest.getData(), socketAddress);
-          return;
         }
       }
     }
-    // Make sure to let the server handle the rest
     ctx.fireChannelRead(msg);
   }
 }

bungeecord/src/main/java/xyz/jonesdev/sonar/bungee/fallback/FallbackBungeeInjector.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -47,12 +47,10 @@ public class FallbackBungeeInjector {
       unsafeField.setAccessible(true);
       final Unsafe unsafe = (Unsafe) unsafeField.get(null);
 
-      // Get the base object (the object containing the field)
       final Object base = unsafe.staticFieldBase(childField);
-      // Get the offset of the static field within its class
       final long offset = unsafe.staticFieldOffset(childField);
 
-      // Replace the original channel initializer
+      // Replace the original channel initializer with our new injected initializer
       unsafe.putObject(base, offset, injectedInitializer);
     } catch (Exception exception) {
       Sonar.get().getLogger().error("An error occurred while injecting {}", exception);

captcha/build.gradle.kts

@@ -5,6 +5,3 @@ dependencies {
   testCompileOnly(project(":api"))
   testCompileOnly(rootProject.libs.imagefilters)
 }
-
-java.sourceCompatibility = JavaVersion.VERSION_11
-java.targetCompatibility = JavaVersion.VERSION_11

captcha/src/main/java/xyz/jonesdev/sonar/captcha/StandardCaptchaGenerator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -33,15 +33,11 @@ import java.awt.font.FontRenderContext;
 import java.awt.font.GlyphVector;
 import java.awt.geom.AffineTransform;
 import java.awt.image.BufferedImage;
+import java.io.File;
 import java.io.IOException;
-import java.io.InputStream;
 import java.util.Arrays;
 import java.util.Random;
 
-import static java.awt.image.BufferedImage.TYPE_3BYTE_BGR;
-import static xyz.jonesdev.sonar.captcha.StandardTTFFontProvider.FONTS;
-import static xyz.jonesdev.sonar.captcha.StandardTTFFontProvider.STANDARD_FONT_SIZE;
-
 @Getter
 @RequiredArgsConstructor
 public final class StandardCaptchaGenerator implements CaptchaGenerator {
@@ -69,12 +65,12 @@ public final class StandardCaptchaGenerator implements CaptchaGenerator {
     }
   }
 
-  private final int width, height;
-  private final @Nullable InputStream background;
-  private BufferedImage backgroundImage;
+  private final int width = 128, height = 128;
+  private final @Nullable File background;
+  private @Nullable BufferedImage backgroundImage;
 
   @Override
-  public @NotNull BufferedImage createImage(final char[] answer) {
+  public @NotNull BufferedImage createImage(final char @NotNull [] answer) {
     final BufferedImage image = createBackgroundImage();
     final Graphics2D graphics = image.createGraphics();
     graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
@@ -91,16 +87,22 @@ public final class StandardCaptchaGenerator implements CaptchaGenerator {
   }
 
   private @NotNull BufferedImage createBackgroundImage() {
+    // Create a new image buffer with a 3-byte color spectrum
+    final BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
     if (background == null) {
-      final BufferedImage image = new BufferedImage(width, height, TYPE_3BYTE_BGR);
       // Fill the entire image with a noise texture
       return FBM.filter(image, image);
     }
-    try {
-      return backgroundImage == null ? backgroundImage = ImageIO.read(background) : backgroundImage;
-    } catch (IOException exception) {
-      throw new IllegalStateException("Could not read background image", exception);
+    // Try to load the image from a file if it doesn't exist yet
+    if (backgroundImage == null) {
+      try {
+        backgroundImage = ImageIO.read(background);
+      } catch (IOException exception) {
+        throw new IllegalStateException("Could not read background image", exception);
+      }
     }
+    image.createGraphics().drawImage(backgroundImage, 0, 0, Color.WHITE, null);
+    return image;
   }
 
   private void applyRandomColorGradient(final @NotNull Graphics2D graphics) {
@@ -122,7 +124,7 @@ public final class StandardCaptchaGenerator implements CaptchaGenerator {
 
     for (int i = 0; i < answer.length; i++) {
       // Create a glyph vector for the character with a random font
-      final Font font = FONTS[RANDOM.nextInt(FONTS.length)];
+      final Font font = StandardTTFFontProvider.FONTS[RANDOM.nextInt(StandardTTFFontProvider.FONTS.length)];
       glyphs[i] = font.createGlyphVector(ctx, String.valueOf(answer[i]));
     }
 
@@ -133,7 +135,7 @@ public final class StandardCaptchaGenerator implements CaptchaGenerator {
       .mapToDouble(glyph -> glyph.getLogicalBounds().getWidth() * scalingXY - 1)
       .sum();
     double beginX = Math.max(Math.min(width / 2D - totalWidth / 2D, totalWidth), 0);
-    double beginY = (height + STANDARD_FONT_SIZE / 2D) / 2D + scalingXY;
+    double beginY = (height + StandardTTFFontProvider.STANDARD_FONT_SIZE / 2D) / 2D + scalingXY;
 
     // Draw each glyph one by one
     for (final GlyphVector glyph : glyphs) {

captcha/src/main/java/xyz/jonesdev/sonar/captcha/StandardTTFFontProvider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

captcha/src/main/java/xyz/jonesdev/sonar/captcha/filters/CircleInverseFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023-2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

captcha/src/main/java/xyz/jonesdev/sonar/captcha/filters/CurvesOverlayFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

captcha/src/main/java/xyz/jonesdev/sonar/captcha/filters/GridOverlayFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

captcha/src/main/java/xyz/jonesdev/sonar/captcha/filters/NoiseOverlayFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

captcha/src/test/java/Main.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -28,7 +28,7 @@ import java.util.Random;
 public class Main {
   public void main(final String... args) throws IOException {
     final Random random = new Random();
-    final StandardCaptchaGenerator standardCaptchaGenerator = new StandardCaptchaGenerator(128, 128, null);
+    final StandardCaptchaGenerator standardCaptchaGenerator = new StandardCaptchaGenerator(null);
 
     final long start = System.currentTimeMillis();
     final char[] dictionary = {'a', 'b', 'c', 'd', 'e', 'f'/*, 'g'*/, 'h'/*, 'i'*/, 'j',

common/build.gradle.kts

@@ -3,6 +3,3 @@ dependencies {
   implementation(project(":captcha"))
   compileOnly(rootProject.libs.adventure.nbt)
 }
-
-java.sourceCompatibility = JavaVersion.VERSION_11
-java.targetCompatibility = JavaVersion.VERSION_11

common/src/main/java/xyz/jonesdev/sonar/common/boot/LibraryLoader.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -72,19 +72,19 @@ class LibraryLoader {
         Library.builder()
           .groupId("net{}kyori")
           .artifactId("adventure-text-minimessage")
-          .version("4.17.0")
+          .version("4.13.1") // adventure-platforms hasn't updated in years... Please update! :'(
           .relocate("net{}kyori", "xyz{}jonesdev{}sonar{}libs{}kyori")
           .build(),
         Library.builder()
           .groupId("net{}kyori")
           .artifactId("adventure-text-serializer-gson")
-          .version("4.17.0")
+          .version("4.18.0")
           .relocate("net{}kyori", "xyz{}jonesdev{}sonar{}libs{}kyori")
           .build(),
         Library.builder()
           .groupId("net{}kyori")
           .artifactId("adventure-nbt")
-          .version("4.17.0")
+          .version("4.18.0")
           .relocate("net{}kyori", "xyz{}jonesdev{}sonar{}libs{}kyori")
           .build()
       );

common/src/main/java/xyz/jonesdev/sonar/common/boot/SonarBootstrap.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -31,17 +31,17 @@ import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.SonarSupplier;
 import xyz.jonesdev.sonar.api.command.subcommand.SubcommandRegistry;
 import xyz.jonesdev.sonar.api.config.SonarConfiguration;
-import xyz.jonesdev.sonar.api.controller.VerifiedPlayerController;
+import xyz.jonesdev.sonar.api.database.controller.VerifiedPlayerController;
+import xyz.jonesdev.sonar.api.notification.ActionBarNotificationHandler;
+import xyz.jonesdev.sonar.api.notification.ChatNotificationHandler;
 import xyz.jonesdev.sonar.api.statistics.SonarStatistics;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
-import xyz.jonesdev.sonar.api.verbose.Notification;
-import xyz.jonesdev.sonar.api.verbose.Verbose;
-import xyz.jonesdev.sonar.captcha.StandardCaptchaGenerator;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer;
-import xyz.jonesdev.sonar.common.service.SonarServiceManager;
+import xyz.jonesdev.sonar.common.fallback.ratelimit.CaffeineCacheRatelimiter;
+import xyz.jonesdev.sonar.common.fallback.ratelimit.NoopCacheRatelimiter;
+import xyz.jonesdev.sonar.common.service.ScheduledServiceManager;
 import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
-import xyz.jonesdev.sonar.common.subcommands.*;
-import xyz.jonesdev.sonar.common.update.UpdateChecker;
+import xyz.jonesdev.sonar.common.subcommand.*;
 import xyz.jonesdev.sonar.common.util.ProtocolUtil;
 
 import java.io.File;
@@ -52,9 +52,9 @@ import java.time.Duration;
 public abstract class SonarBootstrap<T> implements Sonar {
   private T plugin;
   @Setter
-  private Verbose verboseHandler;
+  private ActionBarNotificationHandler actionBarNotificationHandler;
   @Setter
-  private Notification notificationHandler;
+  private ChatNotificationHandler chatNotificationHandler;
   private SonarConfiguration config;
   private VerifiedPlayerController verifiedPlayerController;
   private final LibraryManager libraryManager;
@@ -79,8 +79,8 @@ public abstract class SonarBootstrap<T> implements Sonar {
     this.platform = platform;
     // Load the rest of the components
     this.statistics = new GlobalSonarStatistics();
-    this.verboseHandler = new Verbose();
-    this.notificationHandler = new Notification();
+    this.actionBarNotificationHandler = new ActionBarNotificationHandler();
+    this.chatNotificationHandler = new ChatNotificationHandler();
     this.config = new SonarConfiguration(dataDirectory);
     // Register all subcommands
     this.subcommandRegistry = new SubcommandRegistry();
@@ -97,13 +97,6 @@ public abstract class SonarBootstrap<T> implements Sonar {
   }
 
   public final void initialize() {
-    // Check if the branch is not the main branch to warn about unstable versions
-    if (!getVersion().getGitBranch().equals("main")) {
-      getLogger().warn("You are currently using an unofficial experimental branch.");
-      getLogger().warn("It is highly recommended to use the latest stable release of Sonar:");
-      getLogger().warn("https://github.com/jonesdevelopment/sonar/releases");
-    }
-
     getLogger().info("Successfully booted in {}s!", launchTimer);
     getLogger().info("Initializing shared components...");
 
@@ -119,7 +112,7 @@ public abstract class SonarBootstrap<T> implements Sonar {
 
       // Start threads
       getLogger().info("Starting all managed threads...");
-      SonarServiceManager.start();
+      ScheduledServiceManager.start();
 
       // Done
       getLogger().info("Done ({}s)!", launchTimer);
@@ -127,12 +120,6 @@ public abstract class SonarBootstrap<T> implements Sonar {
       // An error has occurred
       getLogger().error("An error has occurred while launching Sonar: {}", throwable);
       throwable.printStackTrace(System.err);
-      return; // Do not check for updates if the launch failed
-    }
-
-    // Check if a new version has been released if enabled in the configuration
-    if (Sonar.get().getConfig().getGeneralConfig().getBoolean("general.check-for-updates")) {
-      UpdateChecker.checkForUpdates();
     }
   }
 
@@ -148,30 +135,14 @@ public abstract class SonarBootstrap<T> implements Sonar {
       getLogger().warn("Reloading after changing the database type is not recommended as it may cause data loss.");
     }
 
-    // Update the CAPTCHA generator if necessary
-    if (getConfig().getVerification().getMap().getTiming() == SonarConfiguration.Verification.Timing.NEVER) {
-      getFallback().setCaptchaGenerator(null);
-    } else if (getFallback().getCaptchaGenerator() == null
-      || getFallback().getCaptchaGenerator() instanceof StandardCaptchaGenerator) {
-      getFallback().setCaptchaGenerator(new StandardCaptchaGenerator(128, 128,
-        Sonar.get().getConfig().getVerification().getMap().getBackgroundImage()));
-    } else {
-      getLogger().info("Custom CAPTCHA generator detected, skipping reinitialization.");
-    }
-
     // Prepare cached packets
     getLogger().info("Taking cached snapshots of all packets...");
     FallbackPreparer.prepare();
 
-    // Update ratelimiter caches
-    getFallback().getRatelimiter().setAttemptCache(Caffeine.newBuilder()
-      .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getReconnectDelay()))
-      .ticker(Ticker.systemTicker())
-      .build());
-    getFallback().getRatelimiter().setFailCountCache(Caffeine.newBuilder()
-      .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getRememberTime()))
-      .ticker(Ticker.systemTicker())
-      .build());
+    // Update ratelimiter cache
+    getFallback().setRatelimiter(getConfig().getVerification().getReconnectDelay() > 0L
+      ? new CaffeineCacheRatelimiter(Duration.ofMillis(getConfig().getVerification().getReconnectDelay()))
+      : NoopCacheRatelimiter.INSTANCE);
 
     // Update blacklist cache
     final long blacklistTime = getConfig().getVerification().getBlacklistTime();
@@ -204,7 +175,7 @@ public abstract class SonarBootstrap<T> implements Sonar {
     // Initialize the shutdown process
     getLogger().info("Starting shutdown process...");
     // Interrupt threads
-    SonarServiceManager.stop();
+    ScheduledServiceManager.stop();
     // Close database connection if present
     if (verifiedPlayerController != null) {
       verifiedPlayerController.close();

common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackBandwidthHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,9 +25,7 @@ import io.netty.channel.ChannelPromise;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.jetbrains.annotations.NotNull;
-
-import static xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics.INCOMING;
-import static xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics.OUTGOING;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 
 @ChannelHandler.Sharable
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
@@ -35,27 +33,22 @@ public final class FallbackBandwidthHandler extends ChannelDuplexHandler {
   public static final ChannelHandler INSTANCE = new FallbackBandwidthHandler();
 
   @Override
-  public void channelRead(final @NotNull ChannelHandlerContext ctx,
-                          final @NotNull Object msg) throws Exception {
-    // We can only get the size of a message if it's a ByteBuf
+  public void channelRead(final ChannelHandlerContext ctx, final @NotNull Object msg) throws Exception {
     if (msg instanceof ByteBuf) {
       // Increment the incoming traffic by the number of readable bytes
-      INCOMING.increment(((ByteBuf) msg).readableBytes());
+      final int readableBytes = ((ByteBuf) msg).readableBytes();
+      GlobalSonarStatistics.perSecondIncomingTraffic += readableBytes;
     }
-    // Make sure to let the server handle the rest
     ctx.fireChannelRead(msg);
   }
 
   @Override
-  public void write(final @NotNull ChannelHandlerContext ctx,
-                    final @NotNull Object msg,
-                    final ChannelPromise promise) throws Exception {
-    // We can only get the size of a message if it's a ByteBuf
+  public void write(final ChannelHandlerContext ctx, final Object msg, final ChannelPromise promise) throws Exception {
     if (msg instanceof ByteBuf) {
       // Increment the outgoing traffic by the number of readable bytes
-      OUTGOING.increment(((ByteBuf) msg).readableBytes());
+      final int readableBytes = ((ByteBuf) msg).readableBytes();
+      GlobalSonarStatistics.perSecondOutgoingTraffic += readableBytes;
     }
-    // Make sure to let the server handle the rest
     ctx.write(msg, promise);
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackInboundHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -41,7 +41,7 @@ public final class FallbackInboundHandler extends ChannelInboundHandlerAdapter {
   public void channelActive(final @NotNull ChannelHandlerContext ctx) throws Exception {
     // Increase connections per second for the action bar verbose
     GlobalSonarStatistics.countConnection();
-    // Make sure to let the server handle the rest
+    // Make sure to let the server handle this
     ctx.fireChannelActive();
     // Add the packet handler pipeline
     sonarPipelineInjector.accept(ctx.pipeline());
@@ -49,26 +49,41 @@ public final class FallbackInboundHandler extends ChannelInboundHandlerAdapter {
 
   @Override
   public void channelInactive(final @NotNull ChannelHandlerContext ctx) throws Exception {
+    // Make sure to let the server handle this
+    ctx.fireChannelInactive();
     // The player can disconnect without sending the login packet first
     // Account for this by checking if the inetAddress has been set yet
     if (inetAddress != null) {
-      // Remove the IP address from the connected players
-      Sonar.get().getFallback().getConnected().compute(inetAddress, (k, v) -> null);
       // Remove the IP address from the queue
-      Sonar.get().getFallback().getQueue().getPlayers().compute(inetAddress, (k, v) -> null);
-      // Remove this account from the online players or decrement the number of accounts with the same IP
-      Sonar.get().getFallback().getOnline().compute(inetAddress, (k, v) -> v == null || v <= 1 ? null : v - 1);
+      Sonar.get().getFallback().getQueue().getPlayers().compute(inetAddress, (ignored, action) -> {
+        // The player is not queued, so we need to remove them from other maps as well
+        if (action == null) {
+          // Remove the IP address from the connected players, if needed
+          Sonar.get().getFallback().getConnected().compute(inetAddress, (__, v) -> {
+            /*
+             * Remove this account from the online players or decrement the number of accounts
+             * with the same IP, but only if the player is logging into the backend server.
+             * We don't need to decrement the count if the player was just verified since
+             * we've never actually incremented it in the first place ¯\_(ツ)_/¯
+             */
+            if (v == null) {
+              Sonar.get().getFallback().getOnline().compute(inetAddress,
+                (ignored1, count) -> count == null || count <= 1 ? null : count - 1);
+            }
+            return null;
+          });
+        }
+        return null;
+      });
     }
-    // Make sure to let the server handle the rest
-    ctx.fireChannelInactive();
   }
 
-  // We can override the default exceptionCaught method since this handler
-  // will run before the connection knows that there has been an error.
+  /*
+   * We can override the default exceptionCaught method since this handler
+   * will run before the connection knows that there has been an error.
+   */
   @Override
-  public void exceptionCaught(final @NotNull ChannelHandlerContext ctx,
-                              final @NotNull Throwable cause) throws Exception {
-    // Close the channel if we encounter any errors.
+  public void exceptionCaught(final @NotNull ChannelHandlerContext ctx, final Throwable cause) throws Exception {
     ctx.close();
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackInboundHandlerAdapter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,30 +18,28 @@
 package xyz.jonesdev.sonar.common.fallback;
 
 import io.netty.channel.*;
-import io.netty.handler.codec.CorruptedFrameException;
 import lombok.AllArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.Sonar;
-import xyz.jonesdev.sonar.api.fallback.Fallback;
-import xyz.jonesdev.sonar.api.fallback.FallbackUser;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.api.fingerprint.FingerprintingUtil;
+import xyz.jonesdev.sonar.common.fallback.netty.FallbackTimeoutHandler;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketEncoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry;
 import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
 import xyz.jonesdev.sonar.common.util.GeyserUtil;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
+import xyz.jonesdev.sonar.common.util.exception.QuietDecoderException;
 
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
 import java.util.Map;
-import java.util.Objects;
-import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
 import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
-import static xyz.jonesdev.sonar.common.fallback.FallbackUserWrapper.closeWith;
 import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer.*;
 
 @AllArgsConstructor
@@ -51,104 +49,99 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
   protected ProtocolVersion protocolVersion;
   protected RemovalListener channelRemovalListener = RemovalListener.EMPTY;
 
-  protected static final Fallback FALLBACK = Sonar.get().getFallback();
-
   /**
    * Validates and handles incoming handshake packets
-   *
-   * @param hostname Hostname (server address) sent by the client
-   * @param protocol Protocol version number sent by the client
    */
-  protected final void handleHandshake(final @NotNull Channel channel,
+  protected final void handleHandshake(final @NotNull ChannelHandlerContext ctx,
                                        final @NotNull String hostname,
                                        final int protocol) throws Exception {
     // Check if the hostname is invalid
     if (hostname.isEmpty()) {
-      throw new CorruptedFrameException("Hostname is empty");
+      throw QuietDecoderException.INSTANCE;
     }
     // Check if the player has already sent a handshake packet
     if (protocolVersion != null) {
-      throw new CorruptedFrameException("Already sent handshake");
+      throw QuietDecoderException.INSTANCE;
     }
-    // Store the protocol version
     protocolVersion = ProtocolVersion.fromId(protocol);
-    // Hook the traffic listener
-    channel.pipeline().addFirst(FALLBACK_BANDWIDTH, FallbackBandwidthHandler.INSTANCE);
+    ctx.pipeline().addFirst(FALLBACK_BANDWIDTH, FallbackBandwidthHandler.INSTANCE);
   }
 
   /**
    * Validates and handles incoming login packets
-   *
-   * @param channel       Forwarded client channel
-   * @param loginPacket   Login packet sent by the client
-   * @param username      Username sent by the client
-   * @param socketAddress Socket address of the client
    */
-  protected final void handleLogin(final @NotNull Channel channel,
-                                   final @NotNull ChannelHandlerContext ctx,
-                                   final @NotNull Runnable loginPacket,
+  protected final void handleLogin(final @NotNull ChannelHandlerContext ctx,
+                                   final @NotNull Runnable initialLoginAction,
                                    final @NotNull String username,
                                    final @NotNull InetSocketAddress socketAddress) throws Exception {
-    // Check if the player has already sent a login packet
-    if (this.username != null) {
-      throw new CorruptedFrameException("Already sent login");
+    // Count every single attempted login
+    GlobalSonarStatistics.countLogin();
+    // Ensure that the player sent a handshake packet
+    if (protocolVersion == null) {
+      throw QuietDecoderException.INSTANCE;
     }
     // Connections from unknown protocol versions will be discarded
-    // as this is the safest way of handling unwanted connections
+    // as this is the safest way of handling unwanted connections.
+    // Sonar does not support snapshots or Minecraft versions older than 1.7.2
     if (protocolVersion.isUnknown()) {
-      // Sonar does not support snapshots or Minecraft versions older than 1.7.2
-      throw new CorruptedFrameException("Unknown protocol version");
-    }
-    // Increase joins per second for the action bar verbose
-    GlobalSonarStatistics.countLogin();
-    // Store the username and IP address
-    this.username = username;
-    final FallbackInboundHandler inboundHandler = channel.pipeline().get(FallbackInboundHandler.class);
-    Objects.requireNonNull(inboundHandler).setInetAddress(socketAddress.getAddress());
-
-    // Check the blacklist here since we cannot let the player "ghost join"
-    if (FALLBACK.getBlacklist().asMap().containsKey(inboundHandler.getInetAddress())) {
-      customDisconnect(channel, protocolVersion, blacklisted);
+      customDisconnect(ctx.channel(), unsupportedVersion, ProtocolVersion.MINECRAFT_1_7_2);
       return;
     }
+    // Ensure that the player has not sent a login packet yet
+    if (this.username != null) {
+      throw QuietDecoderException.INSTANCE;
+    }
+    this.username = username;
+
+    final InetAddress inetAddress = socketAddress.getAddress();
+    ctx.pipeline().get(FallbackInboundHandler.class).setInetAddress(inetAddress);
 
     // Check if Fallback is already verifying a player with the same IP address
-    if (FALLBACK.getConnected().containsKey(inboundHandler.getInetAddress())) {
-      customDisconnect(channel, protocolVersion, alreadyVerifying);
+    if (Sonar.get().getFallback().getConnected().containsKey(inetAddress)) {
+      customDisconnect(ctx.channel(), alreadyVerifying, protocolVersion);
       return;
     }
 
     // Check if the protocol ID of the player is not allowed to enter the server
-    if (Sonar.get().getConfig().getVerification().getBlacklistedProtocols()
-      .contains(protocolVersion.getProtocol())) {
-      customDisconnect(channel, protocolVersion, protocolBlacklisted);
+    if (Sonar.get().getConfig().getVerification().getBlacklistedProtocols().contains(protocolVersion.getProtocol())) {
+      customDisconnect(ctx.channel(), protocolBlacklisted, protocolVersion);
       return;
     }
 
+    final String hostAddress = inetAddress.getHostAddress();
+    // Check if the player failed the verification too many times
+    final int limit = Sonar.get().getConfig().getVerification().getBlacklistThreshold();
+    if (limit > 0) {
+      final int score = Sonar.get().getFallback().getBlacklist().asMap().getOrDefault(hostAddress, 0);
+      if (score >= limit) {
+        customDisconnect(ctx.channel(), blacklisted, protocolVersion);
+        return;
+      }
+    }
+
     // Don't continue the verification process if the verification is disabled
     if (!Sonar.get().getFallback().shouldVerifyNewPlayers()) {
-      initialLogin(ctx, inboundHandler.getInetAddress(), loginPacket);
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
       return;
     }
 
     // Completely skip Geyser connections if configured
-    final boolean geyser = GeyserUtil.isGeyserConnection(channel, socketAddress);
+    final boolean geyser = GeyserUtil.isGeyserConnection(ctx.channel(), socketAddress);
     if (geyser && !Sonar.get().getConfig().getVerification().isCheckGeyser()) {
-      initialLogin(ctx, inboundHandler.getInetAddress(), loginPacket);
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
       return;
     }
 
     // Make sure we actually have to verify the player
-    final String offlineUuidString = "OfflinePlayer:" + username;
-    final UUID offlineUuid = UUID.nameUUIDFromBytes(offlineUuidString.getBytes(StandardCharsets.UTF_8));
-    if (Sonar.get().getVerifiedPlayerController().has(inboundHandler.getInetAddress().toString(), offlineUuid)) {
-      initialLogin(ctx, inboundHandler.getInetAddress(), loginPacket);
+    final String fingerprint = FingerprintingUtil.getFingerprint(username, hostAddress);
+    if (Sonar.get().getVerifiedPlayerController().getCache().contains(fingerprint)) {
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
       return;
     }
 
     // Check if the IP address is currently being rate-limited
-    if (!FALLBACK.getRatelimiter().attempt(inboundHandler.getInetAddress())) {
-      customDisconnect(channel, protocolVersion, reconnectedTooFast);
+    if (!Sonar.get().getFallback().getRatelimiter().attempt(inetAddress)) {
+      customDisconnect(ctx.channel(), reconnectedTooFast, protocolVersion);
       return;
     }
 
@@ -156,29 +149,41 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
     rewriteProtocol(ctx, channelRemovalListener);
 
     // Queue the connection for further processing
-    FALLBACK.getQueue().getPlayers().compute(inboundHandler.getInetAddress(), (inetAddress, runnable) -> {
+    Sonar.get().getFallback().getQueue().getPlayers().compute(inetAddress, (__, runnable) -> {
       // Check if the player is already queued since we don't want bots to flood the queue
       if (runnable != null) {
-        customDisconnect(channel, protocolVersion, alreadyQueued);
+        customDisconnect(ctx.channel(), alreadyQueued, protocolVersion);
         // Remove other instances of this IP address from the queue
         return null;
       }
 
-      return () -> {
-        // Check if the username matches the valid name regex to prevent
-        // UTF-16 names or other types of exploits
-        if (!Sonar.get().getConfig().getVerification().getValidNameRegex()
-          .matcher(username).matches()) {
-          customDisconnect(channel, protocolVersion, invalidUsername);
-          return;
-        }
+      // Create an instance for the user and let the verification handler take over the channel
+      return () -> new FallbackUserWrapper(ctx, inetAddress, protocolVersion, username, fingerprint, geyser);
+    });
+  }
 
-        // Create an instance for the Fallback connection
-        final FallbackUser user = new FallbackUserWrapper(
-          channel, inboundHandler.getInetAddress(), protocolVersion, offlineUuid, geyser);
-        // Let the verification handler take over the channel
-        user.hijack(username, offlineUuid);
-      };
+  /**
+   * Executes the maximum accounts per IP limit check before letting the player join
+   */
+  protected final void initialLogin(final @NotNull Channel channel,
+                                    final @NotNull InetAddress inetAddress,
+                                    final @NotNull Runnable loginPacket) throws Exception {
+    Sonar.get().getFallback().getOnline().compute(inetAddress, (__, count) -> {
+      final int maxOnlinePerIp = Sonar.get().getConfig().getMaxOnlinePerIp();
+      // Skip the maximum online per IP check if it's disabled in the configuration
+      if (count != null && maxOnlinePerIp > 0) {
+        // Check if the number of online players using the same IP address as
+        // the connecting player is greater than the configured amount
+        if (count >= maxOnlinePerIp) {
+          customDisconnect(channel, tooManyOnlinePerIP, protocolVersion);
+          return count + 1;
+        }
+      }
+
+      // Let the server know about the login packet
+      loginPacket.run();
+      // Increment the number of accounts with the same IP
+      return count == null ? 1 : count + 1;
     });
   }
 
@@ -206,72 +211,41 @@ public abstract class FallbackInboundHandlerAdapter extends ChannelInboundHandle
       TimeUnit.MILLISECONDS));
   }
 
-  /**
-   * Executes the maximum accounts per IP limit check before letting the player join
-   *
-   * @param ctx         Forwarded client channel context
-   * @param inetAddress Resolved client IP address
-   * @param loginPacket Login packet sent by the client
-   */
-  protected final void initialLogin(final @NotNull ChannelHandlerContext ctx,
-                                    final @NotNull InetAddress inetAddress,
-                                    final @NotNull Runnable loginPacket) throws Exception {
-    // Increment the number of accounts with the same IP
-    FALLBACK.getOnline().compute(inetAddress, (k, v) -> v == null ? 1 : v + 1);
-
-    final int maxOnlinePerIp = Sonar.get().getConfig().getMaxOnlinePerIp();
-    // Skip the maximum online per IP check if it's disabled in the configuration
-    if (maxOnlinePerIp > 0) {
-      // Check if the number of online players using the same IP address as
-      // the connecting player is greater than the configured amount
-      final int onlinePerIp = FALLBACK.getOnline().getOrDefault(inetAddress, 0);
-      if (onlinePerIp >= maxOnlinePerIp) {
-        customDisconnect(ctx.channel(), protocolVersion, tooManyOnlinePerIP);
-        return;
+  private static void customDisconnect(final @NotNull Channel channel,
+                                       final @NotNull FallbackPacket packet,
+                                       final @NotNull ProtocolVersion protocolVersion) {
+    if (channel.isActive()) {
+      if (channel.eventLoop().inEventLoop()) {
+        _customDisconnect(channel, packet, protocolVersion);
+      } else {
+        channel.eventLoop().execute(() -> _customDisconnect(channel, packet, protocolVersion));
       }
     }
-
-    // Let the server know about the login packet
-    loginPacket.run();
   }
 
-
   /**
    * Disconnect the player before verification (during login)
-   * by replacing the encoder before running the method.
-   *
-   * @param packet          Disconnect packet
-   * @param channel         Channel of the player
-   * @param protocolVersion Protocol version of the player
    */
-  private void customDisconnect(final @NotNull Channel channel,
-                                final @NotNull ProtocolVersion protocolVersion,
-                                final @NotNull FallbackPacket packet) {
-    if (channel.eventLoop().inEventLoop()) {
-      _customDisconnect(channel, protocolVersion, packet);
-    } else {
-      channel.eventLoop().execute(() -> _customDisconnect(channel, protocolVersion, packet));
-    }
-  }
-
-  private void _customDisconnect(final @NotNull Channel channel,
-                                 final @NotNull ProtocolVersion protocolVersion,
-                                 final @NotNull FallbackPacket packet) {
-    // Remove the main pipeline to completely take over the channel
-    final String handler = Sonar.get().getPlatform().getHandlerFunction().apply(channel.pipeline());
+  private static void _customDisconnect(final @NotNull Channel channel,
+                                        final @NotNull FallbackPacket packet,
+                                        final @NotNull ProtocolVersion protocolVersion) {
+    // TODO: recode this
+    // Remove the connection handler pipeline to completely take over the channel
+    final String handler = Sonar.get().getPlatform().getConnectionHandler();
     if (channel.pipeline().context(handler) != null) {
       channel.pipeline().remove(handler);
     }
-    final String encoder = Sonar.get().getPlatform().getEncoderFunction().apply(channel.pipeline());
+    final String encoder = Sonar.get().getPlatform().getEncoder().apply(channel.pipeline());
     final ChannelHandler currentEncoder = channel.pipeline().get(encoder);
-    // Close the channel if no decoder exists
+    // Close the channel if no encoder exists
     if (currentEncoder != null) {
-      // We don't need to update the encoder if it's already present
+      // We don't need to update the encoder if it has already been replaced by Sonar
       if (!(currentEncoder instanceof FallbackPacketEncoder)) {
         final FallbackPacketEncoder newEncoder = new FallbackPacketEncoder(protocolVersion);
+        newEncoder.updateRegistry(FallbackPacketRegistry.LOGIN);
         channel.pipeline().replace(encoder, FALLBACK_PACKET_ENCODER, newEncoder);
       }
-      closeWith(channel, protocolVersion, packet);
+      ProtocolUtil.closeWith(channel, protocolVersion, packet);
     } else {
       channel.close();
     }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/FallbackUserWrapper.java

@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.event.impl.UserVerifyJoinEvent;
+import xyz.jonesdev.sonar.api.fallback.FallbackUser;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.common.fallback.netty.FallbackTailExceptionsHandler;
+import xyz.jonesdev.sonar.common.fallback.netty.FallbackVarInt21FrameDecoder;
+import xyz.jonesdev.sonar.common.fallback.netty.FallbackVarIntLengthEncoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketDecoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketEncoder;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry;
+import xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.DisconnectPacket;
+import xyz.jonesdev.sonar.common.fallback.verification.FallbackPreJoinHandler;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
+
+import java.net.InetAddress;
+
+import static xyz.jonesdev.sonar.api.fallback.FallbackPipelines.*;
+
+@Getter
+@ToString(of = {"protocolVersion", "inetAddress", "geyser"})
+public final class FallbackUserWrapper implements FallbackUser {
+  @Accessors(fluent = true)
+  private final Channel channel;
+  private final InetAddress inetAddress;
+  private final ProtocolVersion protocolVersion;
+  private final String fingerprint;
+  private final String username;
+  private final boolean geyser;
+  private final SystemTimer loginTimer;
+  @Setter
+  private boolean forceCaptcha;
+
+  public FallbackUserWrapper(final @NotNull ChannelHandlerContext ctx,
+                             final @NotNull InetAddress inetAddress,
+                             final @NotNull ProtocolVersion protocolVersion,
+                             final @NotNull String username,
+                             final @NotNull String fingerprint,
+                             final boolean geyser) {
+    this.channel = ctx.channel();
+    this.inetAddress = inetAddress;
+    this.protocolVersion = protocolVersion;
+    this.username = username;
+    this.fingerprint = fingerprint;
+    this.geyser = geyser;
+    this.loginTimer = new SystemTimer();
+
+    GlobalSonarStatistics.totalAttemptedVerifications++;
+
+    if (Sonar.get().getConfig().getVerification().isLogConnections()
+      && (Sonar.get().getAttackTracker().getCurrentAttack() == null
+      || Sonar.get().getConfig().getVerification().isLogDuringAttack())) {
+      Sonar.get().getLogger().info(
+        Sonar.get().getConfig().getMessagesConfig().getString("verification.logs.connection")
+          .replace("<username>", username)
+          .replace("<ip>", Sonar.get().getConfig().formatAddress(inetAddress))
+          .replace("<protocol>", protocolVersion.getName()));
+    }
+
+    // Call the VerifyJoinEvent for external API usage
+    Sonar.get().getEventManager().publish(new UserVerifyJoinEvent(this));
+
+    // Run this in the channel's event loop to avoid issues
+    channel.eventLoop().execute(() -> {
+      // Make sure the channel is still active
+      if (!channel.isActive()) {
+        return;
+      }
+
+      // Mark the player as connected by caching them in a map of verifying players
+      Sonar.get().getFallback().getConnected().compute(inetAddress, (__, v) -> true);
+
+      // Replace normal encoder to allow custom packets
+      final FallbackPacketEncoder newEncoder = new FallbackPacketEncoder(protocolVersion);
+      channel.pipeline().addFirst(FALLBACK_FRAME_ENCODER, FallbackVarIntLengthEncoder.INSTANCE);
+      channel.pipeline().addLast(FALLBACK_PACKET_ENCODER, newEncoder);
+
+      // Replace normal decoder to allow custom packets
+      final FallbackPacketDecoder newDecoder = new FallbackPacketDecoder(protocolVersion);
+      channel.pipeline().addFirst(FALLBACK_FRAME_DECODER, new FallbackVarInt21FrameDecoder());
+      channel.pipeline().addLast(FALLBACK_PACKET_DECODER, newDecoder);
+
+      // We're sending the LoginSuccess packet now
+      newDecoder.updateRegistry(FallbackPacketRegistry.LOGIN);
+      newEncoder.updateRegistry(FallbackPacketRegistry.LOGIN);
+      // Send LoginSuccess packet to make the client think they are joining the server
+      write(FallbackPreparer.loginSuccess);
+
+      // pre-1.20.2 clients do not have the configuration stage
+      if (protocolVersion.lessThan(ProtocolVersion.MINECRAFT_1_20_2)) {
+        newDecoder.updateRegistry(FallbackPacketRegistry.GAME);
+        newEncoder.updateRegistry(FallbackPacketRegistry.GAME);
+      }
+
+      // Listen for all incoming packets by setting the packet listener
+      newDecoder.setListener(new FallbackPreJoinHandler(this));
+
+      // Make sure to catch all exceptions during the verification
+      channel.pipeline().addLast(FALLBACK_TAIL_EXCEPTIONS, FallbackTailExceptionsHandler.INSTANCE);
+    });
+  }
+
+  @Override
+  public void disconnect(final @NotNull Component reason) {
+    final FallbackPacketEncoder encoder = channel.pipeline().get(FallbackPacketEncoder.class);
+    final boolean duringLogin = encoder != null && encoder.getPacketRegistry() == FallbackPacketRegistry.LOGIN;
+    ProtocolUtil.closeWith(channel, protocolVersion, new DisconnectPacket(reason, duringLogin));
+  }
+}

common/src/main/java/xyz/jonesdev/sonar/common/fallback/netty/FallbackInjectedChannelInitializer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,16 +18,15 @@
 package xyz.jonesdev.sonar.common.fallback.netty;
 
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelPipeline;
 import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.ReflectiveOperationException;
 import xyz.jonesdev.sonar.api.Sonar;
 import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.common.fallback.FallbackInboundHandler;
 import xyz.jonesdev.sonar.common.util.FakeChannelUtil;
+import xyz.jonesdev.sonar.common.util.exception.ReflectiveOperationException;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
@@ -63,11 +62,11 @@ public final class FallbackInjectedChannelInitializer extends ChannelInitializer
 
     // Inject Sonar's channel handler into the pipeline;
     // Also make sure the player is not a fake player to avoid compatibility issues
-    if (channel.isActive() && !FakeChannelUtil.isFakePlayer(channel)) {
-      final ChannelHandler inboundHandler = new FallbackInboundHandler(sonarPipelineInjector);
+    if (channel.isActive() && !FakeChannelUtil.isFakeChannel(channel)) {
+      final FallbackInboundHandler inboundHandler = new FallbackInboundHandler(sonarPipelineInjector);
       // We need to be careful on Bukkit, as the encoder can be different
       if (Sonar.get().getPlatform() == SonarPlatform.BUKKIT) {
-        final String encoder = Sonar.get().getPlatform().getEncoderFunction().apply(channel.pipeline());
+        final String encoder = Sonar.get().getPlatform().getEncoder().apply(channel.pipeline());
         channel.pipeline().addBefore(encoder, FALLBACK_INBOUND_HANDLER, inboundHandler);
       } else {
         channel.pipeline().addFirst(FALLBACK_INBOUND_HANDLER, inboundHandler);

common/src/main/java/xyz/jonesdev/sonar/common/fallback/netty/FallbackTailExceptionsHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -30,8 +30,7 @@ public final class FallbackTailExceptionsHandler extends ChannelDuplexHandler {
   // does not have any other pipelines that could handle this error.
   // Additionally, this will also run after our custom decoder.
   @Override
-  public void exceptionCaught(final @NotNull ChannelHandlerContext ctx,
-                              final @NotNull Throwable cause) throws Exception {
+  public void exceptionCaught(final @NotNull ChannelHandlerContext ctx, final Throwable cause) throws Exception {
     // Close the channel if we encounter any errors.
     ctx.close();
   }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/netty/FallbackTimeoutHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.common.fallback;
+package xyz.jonesdev.sonar.common.fallback.netty;
 
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.timeout.IdleStateEvent;
@@ -26,12 +26,12 @@ import java.util.concurrent.TimeUnit;
 
 public final class FallbackTimeoutHandler extends IdleStateHandler {
   public FallbackTimeoutHandler(final int readTimeout, final int writeTimeout, final TimeUnit timeUnit) {
-    super(readTimeout, writeTimeout, 0L, timeUnit);
+    super(false, readTimeout, writeTimeout, 0L, timeUnit);
   }
 
   @Override
   protected void channelIdle(final @NotNull ChannelHandlerContext ctx,
-                             final @NotNull IdleStateEvent idleStateEvent) throws Exception {
+                             final IdleStateEvent idleStateEvent) throws Exception {
     // The netty (default) ReadTimeoutHandler would normally just throw an Exception
     // The default ReadTimeoutHandler does only check for the boolean 'closed' and
     // still throws the Exception even if the channel is closed

common/src/main/java/xyz/jonesdev/sonar/common/fallback/netty/FallbackVarInt21FrameDecoder.java

@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import io.netty.handler.codec.DecoderException;
+import io.netty.util.ByteProcessor;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
+import xyz.jonesdev.sonar.common.util.exception.QuietDecoderException;
+
+import java.util.List;
+
+// https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/MinecraftVarintFrameDecoder.java
+public final class FallbackVarInt21FrameDecoder extends ByteToMessageDecoder {
+
+  @Override
+  protected void decode(final @NotNull ChannelHandlerContext ctx,
+                        final @NotNull ByteBuf byteBuf,
+                        final @NotNull List<Object> out) throws Exception {
+    if (!ctx.channel().isActive()) {
+      byteBuf.clear();
+      return;
+    }
+
+    // Skip any runs of 0x00 we might find
+    final int packetStart = byteBuf.forEachByte(ByteProcessor.FIND_NON_NUL);
+    if (packetStart == -1) {
+      byteBuf.clear();
+      return;
+    }
+    byteBuf.readerIndex(packetStart);
+
+    // Try to read the length of the packet
+    byteBuf.markReaderIndex();
+    final int preIndex = byteBuf.readerIndex();
+    final int length = readRawVarInt21(byteBuf);
+    if (preIndex == byteBuf.readerIndex()) {
+      return;
+    }
+    if (length <= 0) {
+      throw ProtocolUtil.DEBUG ? new DecoderException("Bad VarInt length: " + length) : QuietDecoderException.INSTANCE;
+    }
+
+    if (byteBuf.readableBytes() < length) {
+      byteBuf.resetReaderIndex();
+    } else {
+      out.add(byteBuf.readRetainedSlice(length));
+    }
+  }
+
+  private static int readRawVarInt21(final @NotNull ByteBuf byteBuf) {
+    if (byteBuf.readableBytes() < 4) {
+      return readRawVarIntSmallBuffer(byteBuf);
+    }
+
+    // take the last three bytes and check if any of them have the high bit set
+    final int wholeOrMore = byteBuf.getIntLE(byteBuf.readerIndex());
+    final int atStop = ~wholeOrMore & 0x808080;
+    if (atStop == 0) {
+      throw ProtocolUtil.DEBUG ? new DecoderException("VarInt too big") : QuietDecoderException.INSTANCE;
+    }
+
+    final int bitsToKeep = Integer.numberOfTrailingZeros(atStop) + 1;
+    byteBuf.skipBytes(bitsToKeep >> 3);
+
+    // https://github.com/netty/netty/pull/14050#issuecomment-2107750734
+    int preservedBytes = wholeOrMore & (atStop ^ (atStop - 1));
+
+    // https://github.com/netty/netty/pull/14050#discussion_r1597896639
+    preservedBytes = (preservedBytes & 0x007F007F) | ((preservedBytes & 0x00007F00) >> 1);
+    preservedBytes = (preservedBytes & 0x00003FFF) | ((preservedBytes & 0x3FFF0000) >> 2);
+    return preservedBytes;
+  }
+
+  private static int readRawVarIntSmallBuffer(final @NotNull ByteBuf byteBuf) {
+    if (!byteBuf.isReadable()) {
+      return 0;
+    }
+    byteBuf.markReaderIndex();
+
+    byte tmp = byteBuf.readByte();
+    if (tmp >= 0) {
+      return tmp;
+    }
+    int result = tmp & 0x7F;
+    if (!byteBuf.isReadable()) {
+      byteBuf.resetReaderIndex();
+      return 0;
+    }
+    if ((tmp = byteBuf.readByte()) >= 0) {
+      return result | tmp << 7;
+    }
+    result |= (tmp & 0x7F) << 7;
+    if (!byteBuf.isReadable()) {
+      byteBuf.resetReaderIndex();
+      return 0;
+    }
+    if ((tmp = byteBuf.readByte()) >= 0) {
+      return result | tmp << 14;
+    }
+    return result | (tmp & 0x7F) << 14;
+  }
+}

common/src/main/java/xyz/jonesdev/sonar/common/fallback/netty/FallbackVarIntLengthEncoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,31 +20,28 @@ package xyz.jonesdev.sonar.common.fallback.netty;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.MessageToByteEncoder;
+import io.netty.handler.codec.MessageToMessageEncoder;
 import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
 
-import static xyz.jonesdev.sonar.common.util.ProtocolUtil.varIntBytes;
-import static xyz.jonesdev.sonar.common.util.ProtocolUtil.writeVarInt;
+import java.util.List;
 
-// Taken from
 // https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/MinecraftVarintLengthEncoder.java
 @ChannelHandler.Sharable
-public final class FallbackVarInt21FrameEncoder extends MessageToByteEncoder<ByteBuf> {
-  public static final FallbackVarInt21FrameEncoder INSTANCE = new FallbackVarInt21FrameEncoder();
+public final class FallbackVarIntLengthEncoder extends MessageToMessageEncoder<ByteBuf> {
+  public static final FallbackVarIntLengthEncoder INSTANCE = new FallbackVarIntLengthEncoder();
 
   @Override
   protected void encode(final @NotNull ChannelHandlerContext ctx,
-                        final @NotNull ByteBuf msg,
-                        final @NotNull ByteBuf out) throws Exception {
-    writeVarInt(out, msg.readableBytes());
-    out.writeBytes(msg);
-  }
+                        final @NotNull ByteBuf byteBuf,
+                        final @NotNull List<Object> out) throws Exception {
+    final int readableBytes = byteBuf.readableBytes();
+    final int length = ProtocolUtil.varIntBytes(readableBytes);
 
-  @Override
-  protected ByteBuf allocateBuffer(final @NotNull ChannelHandlerContext ctx,
-                                   final @NotNull ByteBuf msg,
-                                   final boolean preferDirect) throws Exception {
-    final int anticipatedRequiredCapacity = varIntBytes(msg.readableBytes()) + msg.readableBytes();
-    return ctx.alloc().buffer(anticipatedRequiredCapacity);
+    final ByteBuf lenBuf = ctx.alloc().buffer(length);
+
+    ProtocolUtil.writeVarInt(lenBuf, readableBytes);
+    out.add(lenBuf);
+    out.add(byteBuf.retain());
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/CaptchaPreparer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,11 +15,14 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package xyz.jonesdev.sonar.common.fallback.protocol.captcha;
+package xyz.jonesdev.sonar.common.fallback.protocol;
 
 import lombok.experimental.UtilityClass;
 import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.event.impl.CaptchaGenerationEndEvent;
 import xyz.jonesdev.sonar.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.common.fallback.protocol.map.MapCaptchaInfo;
+import xyz.jonesdev.sonar.common.fallback.protocol.map.MapColorPalette;
 
 import java.awt.image.BufferedImage;
 import java.util.Random;
@@ -54,18 +57,18 @@ public class CaptchaPreparer {
     // Prepare everything asynchronously
     PREPARATION_SERVICE.execute(() -> {
       for (preparedAmount = 0; preparedAmount < precomputeAmount;) {
-        // Generate CAPTCHA answer
+        // Generate CAPTCHA
         final char[] answer = new char[3 + RANDOM.nextInt(2)];
         for (int j = 0; j < answer.length; j++) {
           answer[j] = alphabet[RANDOM.nextInt(alphabet.length)];
         }
         final BufferedImage image = Sonar.get().getFallback().getCaptchaGenerator().createImage(answer);
         // Convert and cache converted Minecraft map bytes
-        final int[] buffer = MapColorPalette.getBufferFromImage(image);
-        cached[preparedAmount++] = new MapCaptchaInfo(new String(answer), buffer);
+        cached[preparedAmount++] = new MapCaptchaInfo(new String(answer), MapColorPalette.imageToBuffer(image));
       }
 
       Sonar.get().getLogger().info("Finished preparing {} CAPTCHA answers ({}s)!", preparedAmount, timer);
+      Sonar.get().getEventManager().publish(new CaptchaGenerationEndEvent(timer, preparedAmount));
     });
   }
 

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacket.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -39,20 +39,18 @@ public interface FallbackPacket {
   void decode(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) throws Exception;
 
   /**
-   * @param byteBuf         ByteBuf
    * @param protocolVersion Protocol version of the player
    * @return The minimum allowed length of the decoded packet
    */
-  default int expectedMinLength(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) {
+  default int expectedMinLength(final ProtocolVersion protocolVersion) {
     return -1;
   }
 
   /**
-   * @param byteBuf         ByteBuf
    * @param protocolVersion Protocol version of the player
    * @return The maximum allowed length of the decoded packet
    */
-  default int expectedMaxLength(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) {
+  default int expectedMaxLength(final ProtocolVersion protocolVersion) {
     return -1;
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketDecoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,35 +20,30 @@ package xyz.jonesdev.sonar.common.fallback.protocol;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
-import io.netty.handler.codec.CorruptedFrameException;
+import io.netty.handler.codec.DecoderException;
+import lombok.RequiredArgsConstructor;
 import lombok.Setter;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
+import xyz.jonesdev.sonar.common.util.exception.QuietDecoderException;
 
-import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.MINECRAFT_1_20_2;
-import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.Direction.SERVERBOUND;
-import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.GAME;
-import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.LOGIN;
-import static xyz.jonesdev.sonar.common.util.ProtocolUtil.readVarInt;
+import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPreparer.maxTotalPacketsSent;
 
+@RequiredArgsConstructor
 public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
   private final ProtocolVersion protocolVersion;
   private FallbackPacketRegistry.ProtocolRegistry registry;
   @Setter
   private FallbackPacketListener listener;
-
-  public FallbackPacketDecoder(final @NotNull ProtocolVersion protocolVersion) {
-    this.protocolVersion = protocolVersion;
-    updateRegistry(protocolVersion.compareTo(MINECRAFT_1_20_2) >= 0 ? LOGIN : GAME);
-  }
+  private int totalPacketsSent;
 
   public void updateRegistry(final @NotNull FallbackPacketRegistry registry) {
-    this.registry = registry.getProtocolRegistry(SERVERBOUND, protocolVersion);
+    this.registry = registry.getProtocolRegistry(FallbackPacketRegistry.Direction.SERVERBOUND, protocolVersion);
   }
 
   @Override
-  public void channelRead(final @NotNull ChannelHandlerContext ctx,
-                          final @NotNull Object msg) throws Exception {
+  public void channelRead(final @NotNull ChannelHandlerContext ctx, final Object msg) throws Exception {
     if (msg instanceof ByteBuf) {
       final ByteBuf byteBuf = (ByteBuf) msg;
 
@@ -60,8 +55,13 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
           return;
         }
 
+        // Don't allow the player to spam packets to overload netty
+        if (++totalPacketsSent > maxTotalPacketsSent) {
+          throw ProtocolUtil.DEBUG ? new DecoderException("Sent too many packets") : QuietDecoderException.INSTANCE;
+        }
+
         // Read the packet ID and then create the packet from it
-        final int packetId = readVarInt(byteBuf);
+        final int packetId = ProtocolUtil.readVarInt(byteBuf);
         final FallbackPacket packet = registry.createPacket(packetId);
 
         // Skip the packet if it's not registered within Sonar's packet registry
@@ -70,27 +70,27 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
         }
 
         // Ensure that the packet isn't too large or too small
-        checkPacketSize(byteBuf, packet);
+        checkPacketSize(byteBuf.readableBytes(), packet);
 
         try {
           // Try to decode the packet for the given protocol version
           packet.decode(byteBuf, protocolVersion);
         } catch (Throwable throwable) {
-          throw new CorruptedFrameException("Failed to decode packet");
+          throw ProtocolUtil.DEBUG ? new DecoderException(throwable) : QuietDecoderException.INSTANCE;
         }
 
         // Check if the packet still has bytes left after we decoded it
         if (byteBuf.isReadable()) {
-          throw new CorruptedFrameException("Could not read packet to end");
+          throw ProtocolUtil.DEBUG ? new DecoderException("Could not read packet to end ("
+            + byteBuf.readableBytes() + " bytes left)"): QuietDecoderException.INSTANCE;
         }
 
         // Let our verification handler process the packet
         if (listener != null) {
           listener.handle(packet);
+          // Make sure to let the timeout handler know about this packet
+          ctx.fireChannelRead(packet);
         }
-
-        // Fire channel read to avoid timeout
-        ctx.fireChannelRead(packet);
       } finally {
         // Release the ByteBuf to avoid memory leaks
         byteBuf.release();
@@ -98,16 +98,16 @@ public final class FallbackPacketDecoder extends ChannelInboundHandlerAdapter {
     }
   }
 
-  private void checkPacketSize(final @NotNull ByteBuf byteBuf,
-                               final @NotNull FallbackPacket packet) throws Exception {
-    final int expectedMaxLen = packet.expectedMaxLength(byteBuf, protocolVersion);
-    if (expectedMaxLen != -1 && byteBuf.readableBytes() > expectedMaxLen) {
-      throw new CorruptedFrameException("Packet too large");
+  private void checkPacketSize(final int packetSize, final @NotNull FallbackPacket packet) throws Exception {
+    final int expectedMaxLen = packet.expectedMaxLength(protocolVersion);
+    if (expectedMaxLen != -1 && packetSize > expectedMaxLen) {
+      throw ProtocolUtil.DEBUG ? new DecoderException("Packet too large: " + packetSize + " max: " + expectedMaxLen)
+        : QuietDecoderException.INSTANCE;
     }
-
-    final int expectedMinLen = packet.expectedMinLength(byteBuf, protocolVersion);
-    if (expectedMinLen != -1 && byteBuf.readableBytes() < expectedMinLen) {
-      throw new CorruptedFrameException("Packet too small");
+    final int expectedMinLen = packet.expectedMinLength(protocolVersion);
+    if (expectedMinLen != -1 && packetSize < expectedMinLen) {
+      throw ProtocolUtil.DEBUG ? new DecoderException("Packet too small: " + packetSize + " min: " + expectedMinLen)
+        : QuietDecoderException.INSTANCE;
     }
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketEncoder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,37 +21,31 @@ import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToByteEncoder;
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
 
-import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.Direction.CLIENTBOUND;
-import static xyz.jonesdev.sonar.common.fallback.protocol.FallbackPacketRegistry.LOGIN;
-import static xyz.jonesdev.sonar.common.util.ProtocolUtil.writeVarInt;
-
+@RequiredArgsConstructor
 public final class FallbackPacketEncoder extends MessageToByteEncoder<FallbackPacket> {
   private final ProtocolVersion protocolVersion;
   @Getter
   private FallbackPacketRegistry packetRegistry;
   private FallbackPacketRegistry.ProtocolRegistry protocolRegistry;
 
-  public FallbackPacketEncoder(final ProtocolVersion protocolVersion) {
-    this.protocolVersion = protocolVersion;
-    updateRegistry(LOGIN);
-  }
-
   public void updateRegistry(final @NotNull FallbackPacketRegistry packetRegistry) {
     this.packetRegistry = packetRegistry;
-    this.protocolRegistry = packetRegistry.getProtocolRegistry(CLIENTBOUND, protocolVersion);
+    this.protocolRegistry = packetRegistry.getProtocolRegistry(FallbackPacketRegistry.Direction.CLIENTBOUND, protocolVersion);
   }
 
   @Override
   protected void encode(final ChannelHandlerContext ctx,
                         final @NotNull FallbackPacket packet,
-                        final ByteBuf out) throws Exception {
-    final FallbackPacket originalPacket = packet instanceof FallbackPacketSnapshot
-      ? ((FallbackPacketSnapshot) packet).getOriginalPacket() : packet;
+                        final @NotNull ByteBuf out) throws Exception {
+    final Class<? extends FallbackPacket> originalPacket = packet instanceof FallbackPacketSnapshot
+      ? ((FallbackPacketSnapshot) packet).getOriginalPacketClass() : packet.getClass();
     final int packetId = protocolRegistry.getPacketId(originalPacket);
-    writeVarInt(out, packetId);
+    ProtocolUtil.writeVarInt(out, packetId);
     packet.encode(out, protocolVersion);
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,8 +20,8 @@ package xyz.jonesdev.sonar.common.fallback.protocol;
 import io.netty.util.collection.IntObjectHashMap;
 import io.netty.util.collection.IntObjectMap;
 import lombok.AccessLevel;
-import lombok.Data;
 import lombok.RequiredArgsConstructor;
+import lombok.ToString;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.configuration.FinishConfigurationPacket;
@@ -32,12 +32,14 @@ import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginStartPacke
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccessPacket;
 import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
 
-import java.util.*;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.function.Supplier;
 
 import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
 
-// Mostly taken from
 // https://github.com/PaperMC/Velocity/blob/dev/3.0.0/proxy/src/main/java/com/velocitypowered/proxy/protocol/StateRegistry.java
 public enum FallbackPacketRegistry {
   HANDSHAKE {
@@ -65,11 +67,11 @@ public enum FallbackPacketRegistry {
         map(0x01, MINECRAFT_1_20_2, true),
         map(0x02, MINECRAFT_1_20_5, true));
       clientbound.register(FinishConfigurationPacket.class, FinishConfigurationPacket::new,
-        map(0x02, MINECRAFT_1_20_2, false),
-        map(0x03, MINECRAFT_1_20_5, false));
+        map(0x02, MINECRAFT_1_20_2, true),
+        map(0x03, MINECRAFT_1_20_5, true));
       clientbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
-        map(0x03, MINECRAFT_1_20_2, false),
-        map(0x04, MINECRAFT_1_20_5, false));
+        map(0x03, MINECRAFT_1_20_2, true),
+        map(0x04, MINECRAFT_1_20_5, true));
       clientbound.register(RegistryDataPacket.class, RegistryDataPacket::new,
         map(0x05, MINECRAFT_1_20_2, true),
         map(0x07, MINECRAFT_1_20_5, true));
@@ -103,22 +105,24 @@ public enum FallbackPacketRegistry {
         map(0x24, MINECRAFT_1_19_3, true),
         map(0x28, MINECRAFT_1_19_4, true),
         map(0x29, MINECRAFT_1_20_2, true),
-        map(0x2B, MINECRAFT_1_20_5, true));
+        map(0x2B, MINECRAFT_1_20_5, true),
+        map(0x2C, MINECRAFT_1_21_2, true));
       clientbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
-        map(0x00, MINECRAFT_1_7_2, false),
-        map(0x1F, MINECRAFT_1_9, false),
-        map(0x21, MINECRAFT_1_13, false),
-        map(0x20, MINECRAFT_1_14, false),
-        map(0x21, MINECRAFT_1_15, false),
-        map(0x20, MINECRAFT_1_16, false),
-        map(0x1F, MINECRAFT_1_16_2, false),
-        map(0x21, MINECRAFT_1_17, false),
-        map(0x1E, MINECRAFT_1_19, false),
-        map(0x20, MINECRAFT_1_19_1, false),
-        map(0x1F, MINECRAFT_1_19_3, false),
-        map(0x23, MINECRAFT_1_19_4, false),
-        map(0x24, MINECRAFT_1_20_2, false),
-        map(0x26, MINECRAFT_1_20_5, false));
+        map(0x00, MINECRAFT_1_7_2, true),
+        map(0x1F, MINECRAFT_1_9, true),
+        map(0x21, MINECRAFT_1_13, true),
+        map(0x20, MINECRAFT_1_14, true),
+        map(0x21, MINECRAFT_1_15, true),
+        map(0x20, MINECRAFT_1_16, true),
+        map(0x1F, MINECRAFT_1_16_2, true),
+        map(0x21, MINECRAFT_1_17, true),
+        map(0x1E, MINECRAFT_1_19, true),
+        map(0x20, MINECRAFT_1_19_1, true),
+        map(0x1F, MINECRAFT_1_19_3, true),
+        map(0x23, MINECRAFT_1_19_4, true),
+        map(0x24, MINECRAFT_1_20_2, true),
+        map(0x26, MINECRAFT_1_20_5, true),
+        map(0x27, MINECRAFT_1_21_2, true));
       clientbound.register(DisconnectPacket.class, DisconnectPacket::new,
         map(0x40, MINECRAFT_1_7_2, true),
         map(0x1A, MINECRAFT_1_9, true),
@@ -149,7 +153,8 @@ public enum FallbackPacketRegistry {
         map(0x38, MINECRAFT_1_19_3, true),
         map(0x3C, MINECRAFT_1_19_4, true),
         map(0x3E, MINECRAFT_1_20_2, true),
-        map(0x40, MINECRAFT_1_20_5, true));
+        map(0x40, MINECRAFT_1_20_5, true),
+        map(0x42, MINECRAFT_1_21_2, true));
       clientbound.register(PlayerAbilitiesPacket.class, PlayerAbilitiesPacket::new,
         map(0x39, MINECRAFT_1_7_2, true),
         map(0x2B, MINECRAFT_1_9, true),
@@ -165,7 +170,8 @@ public enum FallbackPacketRegistry {
         map(0x30, MINECRAFT_1_19_3, true),
         map(0x34, MINECRAFT_1_19_4, true),
         map(0x36, MINECRAFT_1_20_2, true),
-        map(0x38, MINECRAFT_1_20_5, true));
+        map(0x38, MINECRAFT_1_20_5, true),
+        map(0x3A, MINECRAFT_1_21_2, true));
       clientbound.register(ChunkDataPacket.class, ChunkDataPacket::new,
         map(0x21, MINECRAFT_1_7_2, true),
         map(0x20, MINECRAFT_1_9, true),
@@ -180,7 +186,8 @@ public enum FallbackPacketRegistry {
         map(0x20, MINECRAFT_1_19_3, true),
         map(0x24, MINECRAFT_1_19_4, true),
         map(0x25, MINECRAFT_1_20_2, true),
-        map(0x27, MINECRAFT_1_20_5, true));
+        map(0x27, MINECRAFT_1_20_5, true),
+        map(0x28, MINECRAFT_1_21_2, true));
       clientbound.register(RemoveEntitiesPacket.class, RemoveEntitiesPacket::new,
         map(0x13, MINECRAFT_1_7_2, true),
         map(0x30, MINECRAFT_1_9, true),
@@ -198,7 +205,8 @@ public enum FallbackPacketRegistry {
         map(0x3E, MINECRAFT_1_19_4, true),
         map(0x3E, MINECRAFT_1_19_4, true),
         map(0x40, MINECRAFT_1_20_2, true),
-        map(0x42, MINECRAFT_1_20_5, true));
+        map(0x42, MINECRAFT_1_20_5, true),
+        map(0x47, MINECRAFT_1_21_2, true));
       clientbound.register(SetPassengersPacket.class, SetPassengersPacket::new,
         map(0x1B, MINECRAFT_1_7_2, true),
         map(0x40, MINECRAFT_1_9, true),
@@ -213,27 +221,27 @@ public enum FallbackPacketRegistry {
         map(0x59, MINECRAFT_1_19_4, true),
         map(0x5B, MINECRAFT_1_20_2, true),
         map(0x5D, MINECRAFT_1_20_3, true),
-        map(0x5F, MINECRAFT_1_20_5, true));
+        map(0x5F, MINECRAFT_1_20_5, true),
+        map(0x65, MINECRAFT_1_21_2, true));
+      clientbound.register(VehicleMovePacket.class, VehicleMovePacket::new,
+        map(0x29, MINECRAFT_1_9, true),
+        map(0x2B, MINECRAFT_1_13, true),
+        map(0x2C, MINECRAFT_1_14, true),
+        map(0x2D, MINECRAFT_1_15, true),
+        map(0x2C, MINECRAFT_1_16, true),
+        map(0x2B, MINECRAFT_1_16_2, true),
+        map(0x2C, MINECRAFT_1_17, true),
+        map(0x29, MINECRAFT_1_19, true),
+        map(0x2B, MINECRAFT_1_19_1, true),
+        map(0x2A, MINECRAFT_1_19_3, true),
+        map(0x2E, MINECRAFT_1_19_4, true),
+        map(0x2F, MINECRAFT_1_20_2, true),
+        map(0x31, MINECRAFT_1_20_5, true),
+        map(0x33, MINECRAFT_1_21_2, true));
       clientbound.register(SpawnEntityPacket.class, SpawnEntityPacket::new,
         map(0x0E, MINECRAFT_1_7_2, true),
         map(0x00, MINECRAFT_1_9, true),
         map(0x01, MINECRAFT_1_19_4, true));
-      clientbound.register(PlayerInfoPacket.class, PlayerInfoPacket::new,
-        map(0x38, MINECRAFT_1_7_2, true),
-        map(0x2D, MINECRAFT_1_9, true),
-        map(0x2E, MINECRAFT_1_12_1, true),
-        map(0x30, MINECRAFT_1_13, true),
-        map(0x33, MINECRAFT_1_14, true),
-        map(0x34, MINECRAFT_1_15, true),
-        map(0x33, MINECRAFT_1_16, true),
-        map(0x32, MINECRAFT_1_16_2, true),
-        map(0x36, MINECRAFT_1_17, true),
-        map(0x34, MINECRAFT_1_19, true),
-        map(0x37, MINECRAFT_1_19_1, true),
-        map(0x36, MINECRAFT_1_19_3, true),
-        map(0x3A, MINECRAFT_1_19_4, true),
-        map(0x3C, MINECRAFT_1_20_2, true),
-        map(0x3E, MINECRAFT_1_20_5, true));
       clientbound.register(UpdateSectionBlocksPacket.class, UpdateSectionBlocksPacket::new,
         map(0x22, MINECRAFT_1_7_2, true),
         map(0x10, MINECRAFT_1_9, true),
@@ -248,7 +256,8 @@ public enum FallbackPacketRegistry {
         map(0x43, MINECRAFT_1_19_4, true),
         map(0x45, MINECRAFT_1_20_2, true),
         map(0x47, MINECRAFT_1_20_3, true),
-        map(0x49, MINECRAFT_1_20_5, true));
+        map(0x49, MINECRAFT_1_20_5, true),
+        map(0x4E, MINECRAFT_1_21_2, true));
       clientbound.register(TransactionPacket.class, TransactionPacket::new,
         map(0x32, MINECRAFT_1_7_2, true),
         map(0x11, MINECRAFT_1_9, true),
@@ -262,7 +271,8 @@ public enum FallbackPacketRegistry {
         map(0x2E, MINECRAFT_1_19_3, true),
         map(0x32, MINECRAFT_1_19_4, true),
         map(0x33, MINECRAFT_1_20_2, true),
-        map(0x35, MINECRAFT_1_20_5, true));
+        map(0x35, MINECRAFT_1_20_5, true),
+        map(0x37, MINECRAFT_1_21_2, true));
       clientbound.register(SetDefaultSpawnPositionPacket.class, SetDefaultSpawnPositionPacket::new,
         map(0x05, MINECRAFT_1_7_2, true),
         map(0x43, MINECRAFT_1_9, true),
@@ -279,7 +289,8 @@ public enum FallbackPacketRegistry {
         map(0x50, MINECRAFT_1_19_4, true),
         map(0x52, MINECRAFT_1_20_2, true),
         map(0x54, MINECRAFT_1_20_3, true),
-        map(0x56, MINECRAFT_1_20_5, true));
+        map(0x56, MINECRAFT_1_20_5, true),
+        map(0x5B, MINECRAFT_1_21_2, true));
       clientbound.register(MapDataPacket.class, MapDataPacket::new,
         map(0x34, MINECRAFT_1_7_2, true),
         map(0x24, MINECRAFT_1_9, true),
@@ -293,7 +304,8 @@ public enum FallbackPacketRegistry {
         map(0x25, MINECRAFT_1_19_3, true),
         map(0x29, MINECRAFT_1_19_4, true),
         map(0x2A, MINECRAFT_1_20_2, true),
-        map(0x2C, MINECRAFT_1_20_5, true));
+        map(0x2C, MINECRAFT_1_20_5, true),
+        map(0x2D, MINECRAFT_1_21_2, true));
       clientbound.register(SetContainerSlotPacket.class, SetContainerSlotPacket::new,
         map(0x2F, MINECRAFT_1_7_2, true),
         map(0x16, MINECRAFT_1_9, true),
@@ -321,26 +333,30 @@ public enum FallbackPacketRegistry {
         map(0x56, MINECRAFT_1_19_4, true),
         map(0x58, MINECRAFT_1_20_2, true),
         map(0x5A, MINECRAFT_1_20_3, true),
-        map(0x5C, MINECRAFT_1_20_5, true));
+        map(0x5C, MINECRAFT_1_20_5, true),
+        map(0x61, MINECRAFT_1_21_2, true));
       clientbound.register(SystemChatPacket.class, SystemChatPacket::new,
-        map(0x02, MINECRAFT_1_7_2, false),
-        map(0x0F, MINECRAFT_1_9, false),
-        map(0x0E, MINECRAFT_1_13, false),
-        map(0x0F, MINECRAFT_1_15, false),
-        map(0x0E, MINECRAFT_1_16, false),
-        map(0x0F, MINECRAFT_1_17, false),
-        map(0x5F, MINECRAFT_1_19, false),
-        map(0x62, MINECRAFT_1_19_1, false),
-        map(0x60, MINECRAFT_1_19_3, false),
-        map(0x64, MINECRAFT_1_19_4, false),
-        map(0x67, MINECRAFT_1_20_2, false),
-        map(0x69, MINECRAFT_1_20_3, false),
-        map(0x6C, MINECRAFT_1_20_5, false));
+        map(0x02, MINECRAFT_1_7_2, true),
+        map(0x0F, MINECRAFT_1_9, true),
+        map(0x0E, MINECRAFT_1_13, true),
+        map(0x0F, MINECRAFT_1_15, true),
+        map(0x0E, MINECRAFT_1_16, true),
+        map(0x0F, MINECRAFT_1_17, true),
+        map(0x5F, MINECRAFT_1_19, true),
+        map(0x62, MINECRAFT_1_19_1, true),
+        map(0x60, MINECRAFT_1_19_3, true),
+        map(0x64, MINECRAFT_1_19_4, true),
+        map(0x67, MINECRAFT_1_20_2, true),
+        map(0x69, MINECRAFT_1_20_3, true),
+        map(0x6C, MINECRAFT_1_20_5, true),
+        map(0x73, MINECRAFT_1_21_2, true));
       clientbound.register(GameEventPacket.class, GameEventPacket::new,
         map(0x20, MINECRAFT_1_20_3, true),
-        map(0x22, MINECRAFT_1_20_5, true));
+        map(0x22, MINECRAFT_1_20_5, true),
+        map(0x23, MINECRAFT_1_21_2, true));
       clientbound.register(TransferPacket.class, TransferPacket::new,
-        map(0x73, MINECRAFT_1_20_5, true));
+        map(0x73, MINECRAFT_1_20_5, true),
+        map(0x7A, MINECRAFT_1_21_2, true));
       clientbound.register(SetHeldItemPacket.class, SetHeldItemPacket::new,
         map(0x09, MINECRAFT_1_7_2, true),
         map(0x37, MINECRAFT_1_9, true),
@@ -357,8 +373,37 @@ public enum FallbackPacketRegistry {
         map(0x4D, MINECRAFT_1_19_4, true),
         map(0x4F, MINECRAFT_1_20_2, true),
         map(0x51, MINECRAFT_1_20_3, true),
-        map(0x53, MINECRAFT_1_20_5, true));
+        map(0x53, MINECRAFT_1_20_5, true),
+        map(0x63, MINECRAFT_1_21_2, true));
+      clientbound.register(EntityAnimationPacket.class, EntityAnimationPacket::new,
+        map(0x0B, MINECRAFT_1_7_2, true),
+        map(0x06, MINECRAFT_1_9, true),
+        map(0x05, MINECRAFT_1_16, true),
+        map(0x06, MINECRAFT_1_17, true),
+        map(0x03, MINECRAFT_1_19, true),
+        map(0x04, MINECRAFT_1_19_4, true),
+        map(0x03, MINECRAFT_1_20_2, true));
+      clientbound.register(UpdateTimePacket.class, UpdateTimePacket::new,
+        map(0x03, MINECRAFT_1_7_2, true),
+        map(0x44, MINECRAFT_1_9, true),
+        map(0x46, MINECRAFT_1_12, true),
+        map(0x47, MINECRAFT_1_12_1, true),
+        map(0x4A, MINECRAFT_1_13, true),
+        map(0x4E, MINECRAFT_1_14, true),
+        map(0x4F, MINECRAFT_1_15, true),
+        map(0x4E, MINECRAFT_1_16, true),
+        map(0x58, MINECRAFT_1_17, true),
+        map(0x59, MINECRAFT_1_18, true),
+        map(0x5C, MINECRAFT_1_19_1, true),
+        map(0x5A, MINECRAFT_1_19_3, true),
+        map(0x5E, MINECRAFT_1_19_4, true),
+        map(0x60, MINECRAFT_1_20_2, true),
+        map(0x62, MINECRAFT_1_20_3, true),
+        map(0x64, MINECRAFT_1_20_5, true),
+        map(0x6B, MINECRAFT_1_21_2, true));
 
+      serverbound.register(ClientTickEndPacket.class, ClientTickEndPacket::new,
+        map(0x0B, MINECRAFT_1_21_2, false));
       serverbound.register(SetHeldItemPacket.class, SetHeldItemPacket::new,
         map(0x09, MINECRAFT_1_7_2, false),
         map(0x17, MINECRAFT_1_9, false),
@@ -371,7 +416,9 @@ public enum FallbackPacketRegistry {
         map(0x28, MINECRAFT_1_19_1, false),
         map(0x2B, MINECRAFT_1_20_2, false),
         map(0x2C, MINECRAFT_1_20_3, false),
-        map(0x2F, MINECRAFT_1_20_5, false));
+        map(0x2F, MINECRAFT_1_20_5, false),
+        map(0x31, MINECRAFT_1_21_2, false),
+        map(0x33, MINECRAFT_1_21_4, false));
       serverbound.register(PaddleBoatPacket.class, PaddleBoatPacket::new,
         map(0x11, MINECRAFT_1_9, false),
         map(0x12, MINECRAFT_1_12, false),
@@ -386,7 +433,8 @@ public enum FallbackPacketRegistry {
         map(0x19, MINECRAFT_1_19_4, false),
         map(0x1B, MINECRAFT_1_20_2, false),
         map(0x1C, MINECRAFT_1_20_3, false),
-        map(0x1F, MINECRAFT_1_20_5, false));
+        map(0x1F, MINECRAFT_1_20_5, false),
+        map(0x21, MINECRAFT_1_21_2, false));
       serverbound.register(PlayerInputPacket.class, PlayerInputPacket::new,
         map(0x0C, MINECRAFT_1_7_2, false),
         map(0x15, MINECRAFT_1_9, false),
@@ -401,7 +449,25 @@ public enum FallbackPacketRegistry {
         map(0x1F, MINECRAFT_1_19_4, false),
         map(0x22, MINECRAFT_1_20_2, false),
         map(0x23, MINECRAFT_1_20_3, false),
-        map(0x26, MINECRAFT_1_20_5, false));
+        map(0x26, MINECRAFT_1_20_5, false),
+        map(0x28, MINECRAFT_1_21_2, false),
+        map(0x29, MINECRAFT_1_21_4, false));
+      serverbound.register(VehicleMovePacket.class, VehicleMovePacket::new,
+        map(0x10, MINECRAFT_1_9, false),
+        map(0x11, MINECRAFT_1_12, false),
+        map(0x10, MINECRAFT_1_12_1, false),
+        map(0x13, MINECRAFT_1_13, false),
+        map(0x15, MINECRAFT_1_14, false),
+        map(0x16, MINECRAFT_1_16, false),
+        map(0x15, MINECRAFT_1_17, false),
+        map(0x17, MINECRAFT_1_19, false),
+        map(0x18, MINECRAFT_1_19_1, false),
+        map(0x17, MINECRAFT_1_19_3, false),
+        map(0x18, MINECRAFT_1_19_4, false),
+        map(0x1A, MINECRAFT_1_20_2, false),
+        map(0x1B, MINECRAFT_1_20_3, false),
+        map(0x1E, MINECRAFT_1_20_5, false),
+        map(0x20, MINECRAFT_1_21_2, false));
       serverbound.register(SystemChatPacket.class, SystemChatPacket::new,
         map(0x01, MINECRAFT_1_7_2, false),
         map(0x02, MINECRAFT_1_9, false),
@@ -411,7 +477,8 @@ public enum FallbackPacketRegistry {
         map(0x04, MINECRAFT_1_19, false),
         map(0x05, MINECRAFT_1_19_1, false),
         map(0x05, MINECRAFT_1_19_3, false),
-        map(0x06, MINECRAFT_1_20_5, false));
+        map(0x06, MINECRAFT_1_20_5, false),
+        map(0x07, MINECRAFT_1_21_2, false));
       serverbound.register(KeepAlivePacket.class, KeepAlivePacket::new,
         map(0x00, MINECRAFT_1_7_2, false),
         map(0x0B, MINECRAFT_1_9, false),
@@ -427,7 +494,8 @@ public enum FallbackPacketRegistry {
         map(0x12, MINECRAFT_1_19_4, false),
         map(0x14, MINECRAFT_1_20_2, false),
         map(0x15, MINECRAFT_1_20_3, false),
-        map(0x18, MINECRAFT_1_20_5, false));
+        map(0x18, MINECRAFT_1_20_5, false),
+        map(0x1A, MINECRAFT_1_21_2, false));
       serverbound.register(ClientInformationPacket.class, ClientInformationPacket::new,
         map(0x15, MINECRAFT_1_7_2, false),
         map(0x04, MINECRAFT_1_9, false),
@@ -439,7 +507,8 @@ public enum FallbackPacketRegistry {
         map(0x07, MINECRAFT_1_19_3, false),
         map(0x08, MINECRAFT_1_19_4, false),
         map(0x09, MINECRAFT_1_20_2, false),
-        map(0x0A, MINECRAFT_1_20_5, false));
+        map(0x0A, MINECRAFT_1_20_5, false),
+        map(0x0C, MINECRAFT_1_21_2, false));
       serverbound.register(PluginMessagePacket.class, PluginMessagePacket::new,
         map(0x17, MINECRAFT_1_7_2, false),
         map(0x09, MINECRAFT_1_9, false),
@@ -453,7 +522,8 @@ public enum FallbackPacketRegistry {
         map(0x0C, MINECRAFT_1_19_3, false),
         map(0x0D, MINECRAFT_1_19_4, false),
         map(0x0F, MINECRAFT_1_20_2, false),
-        map(0x12, MINECRAFT_1_21, false));
+        map(0x12, MINECRAFT_1_21, false),
+        map(0x14, MINECRAFT_1_21_2, false));
       serverbound.register(SetPlayerOnGround.class, SetPlayerOnGround::new,
         map(0x03, MINECRAFT_1_7_2, false),
         map(0x0F, MINECRAFT_1_9, false),
@@ -469,7 +539,8 @@ public enum FallbackPacketRegistry {
         map(0x17, MINECRAFT_1_19_4, false),
         map(0x19, MINECRAFT_1_20_2, false),
         map(0x1A, MINECRAFT_1_20_3, false),
-        map(0x1D, MINECRAFT_1_20_5, false));
+        map(0x1D, MINECRAFT_1_20_5, false),
+        map(0x1F, MINECRAFT_1_21_2, false));
       serverbound.register(SetPlayerPositionPacket.class, SetPlayerPositionPacket::new,
         map(0x04, MINECRAFT_1_7_2, false),
         map(0x0C, MINECRAFT_1_9, false),
@@ -485,7 +556,8 @@ public enum FallbackPacketRegistry {
         map(0x14, MINECRAFT_1_19_4, false),
         map(0x16, MINECRAFT_1_20_2, false),
         map(0x17, MINECRAFT_1_20_3, false),
-        map(0x1A, MINECRAFT_1_20_5, false));
+        map(0x1A, MINECRAFT_1_20_5, false),
+        map(0x1C, MINECRAFT_1_21_2, false));
       serverbound.register(SetPlayerRotationPacket.class, SetPlayerRotationPacket::new,
         map(0x05, MINECRAFT_1_7_2, false),
         map(0x0E, MINECRAFT_1_9, false),
@@ -501,7 +573,8 @@ public enum FallbackPacketRegistry {
         map(0x16, MINECRAFT_1_19_4, false),
         map(0x18, MINECRAFT_1_20_2, false),
         map(0x19, MINECRAFT_1_20_3, false),
-        map(0x1C, MINECRAFT_1_20_5, false));
+        map(0x1C, MINECRAFT_1_20_5, false),
+        map(0x1E, MINECRAFT_1_21_2, false));
       serverbound.register(SetPlayerPositionRotationPacket.class, SetPlayerPositionRotationPacket::new,
         map(0x06, MINECRAFT_1_7_2, false),
         map(0x0D, MINECRAFT_1_9, false),
@@ -517,7 +590,8 @@ public enum FallbackPacketRegistry {
         map(0x15, MINECRAFT_1_19_4, false),
         map(0x17, MINECRAFT_1_20_2, false),
         map(0x18, MINECRAFT_1_20_3, false),
-        map(0x1B, MINECRAFT_1_20_5, false));
+        map(0x1B, MINECRAFT_1_20_5, false),
+        map(0x1D, MINECRAFT_1_21_2, false));
       serverbound.register(ConfirmTeleportationPacket.class, ConfirmTeleportationPacket::new,
         map(0x00, MINECRAFT_1_9, false));
       serverbound.register(TransactionPacket.class, TransactionPacket::new,
@@ -534,7 +608,24 @@ public enum FallbackPacketRegistry {
         map(0x20, MINECRAFT_1_19_4, false),
         map(0x23, MINECRAFT_1_20_2, false),
         map(0x24, MINECRAFT_1_20_3, false),
-        map(0x27, MINECRAFT_1_20_5, false));
+        map(0x27, MINECRAFT_1_20_5, false),
+        map(0x29, MINECRAFT_1_21_2, false),
+        map(0x2B, MINECRAFT_1_21_4, false));
+      serverbound.register(AnimationPacket.class, AnimationPacket::new,
+        map(0x0A, MINECRAFT_1_7_2, false),
+        map(0x1A, MINECRAFT_1_9, false),
+        map(0x1D, MINECRAFT_1_12, false),
+        map(0x27, MINECRAFT_1_13, false),
+        map(0x2A, MINECRAFT_1_14, false),
+        map(0x2B, MINECRAFT_1_16, false),
+        map(0x2C, MINECRAFT_1_16_2, false),
+        map(0x2E, MINECRAFT_1_19, false),
+        map(0x2F, MINECRAFT_1_19_1, false),
+        map(0x32, MINECRAFT_1_20_2, false),
+        map(0x33, MINECRAFT_1_20_3, false),
+        map(0x36, MINECRAFT_1_20_5, false),
+        map(0x38, MINECRAFT_1_21_2, false),
+        map(0x3A, MINECRAFT_1_21_4, false));
     }
   };
 
@@ -551,30 +642,28 @@ public enum FallbackPacketRegistry {
     return (direction == Direction.SERVERBOUND ? serverbound : clientbound).getProtocolRegistry(version);
   }
 
-  public static class PacketRegistry {
-    private final Map<ProtocolVersion, ProtocolRegistry> versions;
+  public static final class PacketRegistry {
+    private final Map<ProtocolVersion, ProtocolRegistry> registries = new EnumMap<>(ProtocolVersion.class);
 
     PacketRegistry() {
-      final Map<ProtocolVersion, ProtocolRegistry> mutableVersions = new EnumMap<>(ProtocolVersion.class);
-      for (final ProtocolVersion version : ProtocolVersion.values()) {
-        if (!version.isUnknown()) {
-          mutableVersions.put(version, new ProtocolRegistry(version));
+      for (final ProtocolVersion protocolVersion : ProtocolVersion.values()) {
+        if (!protocolVersion.isUnknown()) {
+          registries.put(protocolVersion, new ProtocolRegistry(protocolVersion));
         }
       }
-      this.versions = Collections.unmodifiableMap(mutableVersions);
     }
 
-    ProtocolRegistry getProtocolRegistry(final ProtocolVersion version) {
-      final ProtocolRegistry registry = versions.get(version);
+    private @NotNull ProtocolRegistry getProtocolRegistry(final @NotNull ProtocolVersion protocolVersion) {
+      final ProtocolRegistry registry = registries.get(protocolVersion);
       if (registry == null) {
-        throw new IllegalArgumentException("Could not find data for protocol version " + version);
+        throw new IllegalArgumentException("Could not find data for protocol version " + protocolVersion);
       }
       return registry;
     }
 
-    <P extends FallbackPacket> void register(final Class<P> clazz,
-                                             final Supplier<P> packetSupplier,
-                                             final PacketMapping @NotNull ... mappings) {
+    private <T extends FallbackPacket> void register(final @NotNull Class<T> clazz,
+                                                     final @NotNull Supplier<T> supplier,
+                                                     final PacketMapping @NotNull ... mappings) {
       if (mappings.length == 0) {
         throw new IllegalArgumentException("At least one mapping must be provided.");
       }
@@ -584,21 +673,21 @@ public enum FallbackPacketRegistry {
         final PacketMapping next = (i + 1 < mappings.length) ? mappings[i + 1] : current;
 
         final ProtocolVersion from = current.protocolVersion;
-        final ProtocolVersion to = getProtocolVersion(current, next);
+        final ProtocolVersion to = current == next ? LATEST_VERSION : next.protocolVersion;
 
-        for (final ProtocolVersion protocol : EnumSet.range(from, to)) {
-          if (protocol == to && next != current) {
+        for (final ProtocolVersion protocolVersion : EnumSet.range(from, to)) {
+          if (protocolVersion == to && next != current) {
             break;
           }
 
-          final ProtocolRegistry registry = versions.get(protocol);
+          final ProtocolRegistry registry = registries.get(protocolVersion);
           if (registry == null) {
-            throw new IllegalArgumentException("Unknown protocol version " + from);
+            throw new IllegalArgumentException("Unknown protocol version " + protocolVersion);
           }
 
-          if (registry.packetIdToSupplier.containsKey(current.id)) {
+          if (registry.packetIdToSupplier.containsKey(current.packetId)) {
             throw new IllegalArgumentException("Can not register class " + clazz.getSimpleName()
-              + " with id " + current.id + " for " + registry.protocolVersion
+              + " with id " + current.packetId + " for " + registry.protocolVersion
               + " because another packet is already registered");
           }
 
@@ -608,18 +697,12 @@ public enum FallbackPacketRegistry {
           }
 
           if (!current.encodeOnly) {
-            registry.packetIdToSupplier.put(current.id, packetSupplier);
+            registry.packetIdToSupplier.put(current.packetId, supplier);
           }
-          registry.packetClassToId.put(clazz, current.id);
+          registry.packetClassToId.put(clazz, current.packetId);
         }
       }
     }
-
-    @NotNull
-    private static ProtocolVersion getProtocolVersion(final @NotNull PacketMapping current,
-                                                      final @NotNull PacketMapping next) {
-      return current == next ? LATEST_VERSION : next.protocolVersion;
-    }
   }
 
   @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
@@ -630,43 +713,38 @@ public enum FallbackPacketRegistry {
     private final Map<Class<? extends FallbackPacket>, Integer> packetClassToId =
       new HashMap<>(16, 0.5f);
 
-    public FallbackPacket createPacket(final int id) {
-      final Supplier<? extends FallbackPacket> supplier = packetIdToSupplier.get(id);
-
-      if (supplier == null) {
-        return null;
-      }
-      return supplier.get();
+    public FallbackPacket createPacket(final int packetId) {
+      final var supplier = packetIdToSupplier.get(packetId);
+      return supplier == null ? null : supplier.get();
     }
 
-    public int getPacketId(final @NotNull FallbackPacket packet) {
-      final int id = packetClassToId.getOrDefault(packet.getClass(), Integer.MIN_VALUE);
-
-      if (id == Integer.MIN_VALUE) {
-        throw new IllegalArgumentException("Could not find packet");
+    public int getPacketId(final @NotNull Class<? extends FallbackPacket> clazz) {
+      final int packetId = packetClassToId.getOrDefault(clazz, -1);
+      if (packetId == -1) {
+        throw new IllegalArgumentException("Could not find packet ID for " + clazz.getSimpleName());
       }
-      return id;
+      return packetId;
     }
   }
 
-  @Data
+  @ToString
   public static final class PacketMapping {
-    private final int id;
+    private final int packetId;
     private final ProtocolVersion protocolVersion;
     private final boolean encodeOnly;
 
-    PacketMapping(final int id,
+    PacketMapping(final int packetId,
                   final ProtocolVersion protocolVersion,
                   final boolean encodeOnly) {
-      this.id = id;
+      this.packetId = packetId;
       this.protocolVersion = protocolVersion;
       this.encodeOnly = encodeOnly;
     }
   }
 
-  private static @NotNull PacketMapping map(final int id,
+  private static @NotNull PacketMapping map(final int packetId,
                                             final ProtocolVersion protocolVersion,
                                             final boolean encodeOnly) {
-    return new PacketMapping(id, protocolVersion, encodeOnly);
+    return new PacketMapping(packetId, protocolVersion, encodeOnly);
   }
 }

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPacketSnapshot.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback.protocol;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.EncoderException;
+import io.netty.util.collection.IntObjectHashMap;
+import io.netty.util.collection.IntObjectMap;
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
+import xyz.jonesdev.sonar.common.util.exception.QuietDecoderException;
+
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.ID_TO_PROTOCOL_CONSTANT;
+
+// https://github.com/Nan1t/NanoLimbo/blob/main/src/main/java/ua/nanit/limbo/protocol/PacketSnapshot.java
+public final class FallbackPacketSnapshot implements FallbackPacket {
+  private final IntObjectMap<Integer> mappings = new IntObjectHashMap<>(ID_TO_PROTOCOL_CONSTANT.size());
+  private final IntObjectMap<byte[]> cachedBytes = new IntObjectHashMap<>(ID_TO_PROTOCOL_CONSTANT.size());
+  @Getter
+  private final Class<? extends FallbackPacket> originalPacketClass;
+
+  public FallbackPacketSnapshot(final @NotNull FallbackPacket originalPacket) {
+    this.originalPacketClass = originalPacket.getClass();
+
+    final IntObjectMap<Integer> hashedData = new IntObjectHashMap<>(ID_TO_PROTOCOL_CONSTANT.size());
+
+    for (final ProtocolVersion protocolVersion : ID_TO_PROTOCOL_CONSTANT.values()) {
+      // Allocate a buffer for each protocol version
+      final ByteBuf byteBuf = Unpooled.buffer();
+      try {
+        try {
+          originalPacket.encode(byteBuf, protocolVersion);
+        } catch (Throwable throwable) {
+          Sonar.get().getLogger().error("Could not encode packet {} for version {}: {}",
+            originalPacket, protocolVersion, throwable);
+          break;
+        }
+
+        final Integer protocol = protocolVersion.getProtocol();
+        final Integer hash = byteBuf.hashCode();
+        final Integer hashed = hashedData.getOrDefault(hash, -1);
+
+        if (hashed != -1) {
+          mappings.put(protocol, hashed);
+        } else {
+          hashedData.put(hash, protocol);
+          mappings.put(protocol, protocol);
+          // Cache the raw bytes of the encoded packet
+          final byte[] bytes = new byte[byteBuf.readableBytes()];
+          byteBuf.readBytes(bytes);
+          cachedBytes.put(protocol, bytes);
+        }
+      } finally {
+        // Make sure to release the buffer to avoid memory leaks
+        byteBuf.release();
+      }
+    }
+  }
+
+  @Override
+  public void encode(final @NotNull ByteBuf byteBuf, final @NotNull ProtocolVersion protocolVersion) throws Exception {
+    final Integer hash = mappings.get(protocolVersion.getProtocol());
+    if (hash == null) {
+      throw ProtocolUtil.DEBUG ? new EncoderException("Unable to find hash") : QuietDecoderException.INSTANCE;
+    }
+    final byte[] bytes = cachedBytes.get(hash);
+    if (bytes == null) {
+      throw ProtocolUtil.DEBUG ? new EncoderException("Unable to find cached packet") : QuietDecoderException.INSTANCE;
+    }
+    byteBuf.writeBytes(bytes);
+  }
+
+  @Override
+  public void decode(final ByteBuf byteBuf, final ProtocolVersion protocolVersion) throws Exception {
+    throw new UnsupportedOperationException();
+  }
+}

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/FallbackPreparer.java

@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback.protocol;
+
+import lombok.experimental.UtilityClass;
+import net.kyori.adventure.nbt.CompoundBinaryTag;
+import net.kyori.adventure.nbt.IntBinaryTag;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+import xyz.jonesdev.sonar.api.event.impl.CaptchaGenerationStartEvent;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.captcha.StandardCaptchaGenerator;
+import xyz.jonesdev.sonar.common.fallback.protocol.block.BlockType;
+import xyz.jonesdev.sonar.common.fallback.protocol.block.BlockUpdate;
+import xyz.jonesdev.sonar.common.fallback.protocol.dimension.DimensionRegistry;
+import xyz.jonesdev.sonar.common.fallback.protocol.dimension.DimensionType;
+import xyz.jonesdev.sonar.common.fallback.protocol.entity.EntityType;
+import xyz.jonesdev.sonar.common.fallback.protocol.item.ItemType;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.configuration.FinishConfigurationPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.configuration.RegistryDataPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.login.LoginSuccessPacket;
+import xyz.jonesdev.sonar.common.fallback.protocol.packets.play.*;
+import xyz.jonesdev.sonar.common.util.ComponentHolder;
+
+import java.util.Random;
+import java.util.UUID;
+
+@UtilityClass
+public class FallbackPreparer {
+  private final Random RANDOM = new Random();
+
+  public static final int PLAYER_ENTITY_ID = RANDOM.nextInt();
+  public static final int VEHICLE_ENTITY_ID = RANDOM.nextInt();
+
+  public static final BlockType[] POSSIBLE_BLOCK_TYPES = BlockType.values();
+  public final FallbackPacket[] BLOCKS_PACKETS = new FallbackPacket[POSSIBLE_BLOCK_TYPES.length];
+
+  public final int BLOCKS_PER_ROW = 8; // 8 * 8 = 64 (vanilla protocol maximum)
+  public final int SPAWN_X_POSITION = 16 / 2; // middle of the chunk
+  public final int SPAWN_Z_POSITION = 16 / 2; // middle of the chunk
+  public final int PLATFORM_Y_POSITION = 1 + RANDOM.nextInt(255); // 255 is the maximum Y position
+  public final int IN_AIR_Y_POSITION = 3000 + RANDOM.nextInt(500); // Random high altitude
+
+  public final int FIRST_TELEPORT_ID = RANDOM.nextInt();
+  public final int SECOND_TELEPORT_ID = RANDOM.nextInt();
+  public final int PRE_JOIN_KEEP_ALIVE_ID = RANDOM.nextInt();
+
+  private final int MAP_SLOT = RANDOM.nextInt(9);
+
+  public static final FallbackPacket CAPTCHA_SET_CONTAINER_SLOT = new SetContainerSlotPacket(
+    0, 36 + MAP_SLOT, 1, ItemType.FILLED_MAP, CompoundBinaryTag.builder()
+    .put("map", IntBinaryTag.intBinaryTag(0)) // map id
+    .build());
+  public final static FallbackPacket CAPTCHA_HELD_ITEM_SLOT = new SetHeldItemPacket(MAP_SLOT);
+  public final FallbackPacket DEFAULT_ABILITIES = new PlayerAbilitiesPacket(0x00, 0, 0);
+  public final FallbackPacket NO_MOVE_ABILITIES = new PlayerAbilitiesPacket(0x02, 0, 0);
+  public final FallbackPacket NO_MOVE_ABILITIES_BEDROCK = new PlayerAbilitiesPacket(0x06, 0, 0);
+  public final FallbackPacket CAPTCHA_POSITION = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
+    SPAWN_X_POSITION, 10000, SPAWN_Z_POSITION, 0, 90, 0, 0, false, false, true));
+  public final FallbackPacket EMPTY_CHUNK_DATA = new FallbackPacketSnapshot(new ChunkDataPacket(0, 0));
+  public final FallbackPacket FINISH_CONFIGURATION = new FinishConfigurationPacket();
+  public final FallbackPacket PRE_JOIN_KEEP_ALIVE = new FallbackPacketSnapshot(new KeepAlivePacket(PRE_JOIN_KEEP_ALIVE_ID));
+  public final FallbackPacket[] REGISTRY_SYNC_1_20 = new FallbackPacket[] {
+    new FallbackPacketSnapshot(new RegistryDataPacket(DimensionRegistry.CODEC_1_20, null, null))};
+  public final FallbackPacket[] REGISTRY_SYNC_1_20_5 = RegistryDataPacket.of(DimensionRegistry.CODEC_1_20_5);
+  public final FallbackPacket[] REGISTRY_SYNC_1_21 = RegistryDataPacket.of(DimensionRegistry.CODEC_1_21);
+  public final FallbackPacket[] REGISTRY_SYNC_1_21_2 = RegistryDataPacket.of(DimensionRegistry.CODEC_1_21_2);
+  public final FallbackPacket[] REGISTRY_SYNC_1_21_4 = RegistryDataPacket.of(DimensionRegistry.CODEC_1_21_4);
+  public final FallbackPacket START_WRITING_CHUNKS = new GameEventPacket(13, 0);
+  public final static FallbackPacket INVALID_HELD_ITEM_SLOT = new SetHeldItemPacket(-1);
+  public final FallbackPacket RANDOM_KEEP_ALIVE = new FallbackPacketSnapshot(new KeepAlivePacket(RANDOM.nextInt()));
+  public static final FallbackPacket SPAWN_BOAT_ENTITY = new FallbackPacketSnapshot(new SpawnEntityPacket(
+    VEHICLE_ENTITY_ID, EntityType.BOAT, SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION,
+    0, 0, 0, 0));
+  public static final FallbackPacket SPAWN_MINECART_ENTITY = new FallbackPacketSnapshot(new SpawnEntityPacket(
+    VEHICLE_ENTITY_ID, EntityType.MINECART, SPAWN_X_POSITION, IN_AIR_Y_POSITION - 16, SPAWN_Z_POSITION,
+    0, 0, 0, 0));
+  public static final FallbackPacket REMOVE_VEHICLE = new RemoveEntitiesPacket(VEHICLE_ENTITY_ID);
+  public static final FallbackPacket SET_VEHICLE_PASSENGERS = new FallbackPacketSnapshot(
+    new SetPassengersPacket(VEHICLE_ENTITY_ID, PLAYER_ENTITY_ID));
+
+  public FallbackPacket loginSuccess;
+  public FallbackPacket welcomeMessage;
+  public FallbackPacket enterCodeMessage;
+  public FallbackPacket incorrectCaptcha;
+  public static FallbackPacket joinGame;
+  public FallbackPacket defaultSpawnPosition;
+  public FallbackPacket spawnPosition;
+  public FallbackPacket fallStartPosition;
+  public FallbackPacket fallStartPositionLegacy;
+  public static FallbackPacket transferToOrigin;
+  public FallbackPacket blacklisted;
+  public FallbackPacket alreadyQueued;
+  public FallbackPacket alreadyVerifying;
+  public FallbackPacket reconnectedTooFast;
+  public FallbackPacket protocolBlacklisted;
+  public FallbackPacket unsupportedVersion;
+  public FallbackPacket tooManyOnlinePerIP;
+  public FallbackPacket[] xpCountdown;
+  public FallbackPacket updateTime;
+
+  public static int maxMovementTick, dynamicSpawnYPosition, maxTotalPacketsSent;
+
+  @SuppressWarnings("ResultOfMethodCallIgnored")
+  public void prepare() {
+    // Preload the packet registry to avoid CPU/RAM issues on 1st connection
+    Sonar.get().getLogger().info("Preloading all registered packets...");
+    FallbackPacketRegistry.values();
+
+    // Prepare LoginSuccess packet with capped username to 16 characters
+    final UUID uuid = UUID.randomUUID();
+    String username = Sonar.get().getConfig().getGeneralConfig().getString("verification.cached-username");
+    if (username.length() > 16) {
+      username = username.substring(0, 16);
+    }
+    loginSuccess = new FallbackPacketSnapshot(new LoginSuccessPacket(uuid, username, true));
+
+    // Prepare JoinGame packet
+    joinGame = new FallbackPacketSnapshot(new JoinGamePacket(PLAYER_ENTITY_ID,
+      Sonar.get().getConfig().getVerification().getGamemode().getId(),
+      -1, 0, 0,
+      RANDOM.nextInt(3), 1, 0, 0,
+      new String[]{"lol"}, "lol", "flat",
+      DimensionType.OVERWORLD, RANDOM.nextLong() & 1337,
+      false, true, false,
+      false, false, false, true));
+
+    // Prepare the gravity check
+    maxMovementTick = Sonar.get().getConfig().getVerification().getGravity().getMaxMovementTicks();
+
+    double motionY = 0, fallDistance = 0;
+
+    for (int i = 0; i < maxMovementTick; i++) {
+      motionY = (motionY - 0.1) * 0.98f;
+      fallDistance += Math.abs(motionY);
+    }
+
+    // Set the dynamic block and collide Y position based on the maximum fall distance
+    dynamicSpawnYPosition = PLATFORM_Y_POSITION + (int) Math.ceil(fallDistance);
+    defaultSpawnPosition = new FallbackPacketSnapshot(new SetDefaultSpawnPositionPacket(
+      SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION));
+    spawnPosition = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
+      SPAWN_X_POSITION, IN_AIR_Y_POSITION, SPAWN_Z_POSITION,
+      0, 0, FIRST_TELEPORT_ID, 0, false, false, true));
+    fallStartPosition = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
+      SPAWN_X_POSITION, dynamicSpawnYPosition - IN_AIR_Y_POSITION, SPAWN_Z_POSITION,
+      0, -90, SECOND_TELEPORT_ID, 1 << 1, false, false, true));
+    fallStartPositionLegacy = new FallbackPacketSnapshot(new SetPlayerPositionRotationPacket(
+      SPAWN_X_POSITION, dynamicSpawnYPosition, SPAWN_Z_POSITION,
+      0, -90, 0, 0, false, false, true));
+
+    // Prepare collision platform positions
+    final int length = BLOCKS_PER_ROW / 2;
+    for (int i = 0; i < BLOCKS_PACKETS.length; i++) {
+      final BlockUpdate[] blocks = new BlockUpdate[BLOCKS_PER_ROW * BLOCKS_PER_ROW];
+
+      int index = 0;
+      for (int x = 0; x < BLOCKS_PER_ROW; x++) {
+        for (int z = 0; z < BLOCKS_PER_ROW; z++) {
+          final BlockUpdate.BlockPosition position = new BlockUpdate.BlockPosition(
+            x + length, PLATFORM_Y_POSITION, z + length, 0, 0);
+          blocks[index++] = new BlockUpdate(position, POSSIBLE_BLOCK_TYPES[i]);
+        }
+      }
+      BLOCKS_PACKETS[i] = new FallbackPacketSnapshot(new UpdateSectionBlocksPacket(0, 0, blocks));
+    }
+
+    // Prepare disconnect packets during login
+    blacklisted = new FallbackPacketSnapshot(new DisconnectPacket(Sonar.get().getConfig().getVerification().getBlacklisted(), true));
+    alreadyVerifying = new FallbackPacketSnapshot(new DisconnectPacket(Sonar.get().getConfig().getVerification().getAlreadyVerifying(), true));
+    alreadyQueued = new FallbackPacketSnapshot(new DisconnectPacket(Sonar.get().getConfig().getVerification().getAlreadyQueued(), true));
+    protocolBlacklisted = new FallbackPacketSnapshot(new DisconnectPacket(Sonar.get().getConfig().getVerification().getProtocolBlacklisted(), true));
+    reconnectedTooFast = new FallbackPacketSnapshot(new DisconnectPacket(Sonar.get().getConfig().getVerification().getTooFastReconnect(), true));
+    unsupportedVersion = new FallbackPacketSnapshot(new DisconnectPacket(Sonar.get().getConfig().getVerification().getUnsupportedVersion(), true));
+    tooManyOnlinePerIP = new FallbackPacketSnapshot(new DisconnectPacket(Sonar.get().getConfig().getTooManyOnlinePerIp(), true));
+
+    // Prepare transfer packet
+    if (Sonar.get().getConfig().getGeneralConfig().getBoolean("verification.transfer.enabled")) {
+      transferToOrigin = new FallbackPacketSnapshot(new TransferPacket(
+        Sonar.get().getConfig().getGeneralConfig().getString("verification.transfer.destination-host"),
+        Sonar.get().getConfig().getGeneralConfig().getInt("verification.transfer.destination-port")));
+    } else {
+      transferToOrigin = null;
+    }
+
+    // Prepare update time packet
+    final int timeOfDay = Sonar.get().getConfig().getVerification().getTimeOfDay();
+    if (timeOfDay != 1000) {
+      updateTime = new UpdateTimePacket(0L, timeOfDay, false);
+    } else {
+      updateTime = null;
+    }
+
+    // If the welcome message is empty, we don't need to send a message to the player
+    final String welcome = Sonar.get().getConfig().getMessagesConfig().getString("verification.welcome");
+    if (welcome.isEmpty()) {
+      welcomeMessage = null;
+    } else {
+      welcomeMessage = new FallbackPacketSnapshot(new SystemChatPacket(new ComponentHolder(
+        MiniMessage.miniMessage().deserialize(welcome,
+          Placeholder.component("prefix", Sonar.get().getConfig().getPrefix())))));
+    }
+
+    if (Sonar.get().getConfig().getVerification().getMap().getTiming() != SonarConfiguration.Verification.Timing.NEVER
+      || Sonar.get().getConfig().getVerification().getGravity().isCaptchaOnFail()) {
+      // Prepare CAPTCHA messages
+      enterCodeMessage = new FallbackPacketSnapshot(new SystemChatPacket(new ComponentHolder(
+        MiniMessage.miniMessage().deserialize(
+          Sonar.get().getConfig().getMessagesConfig().getString("verification.captcha.enter"),
+          Placeholder.component("prefix", Sonar.get().getConfig().getPrefix())))));
+      incorrectCaptcha = new FallbackPacketSnapshot(new SystemChatPacket(new ComponentHolder(
+        MiniMessage.miniMessage().deserialize(
+          Sonar.get().getConfig().getMessagesConfig().getString("verification.captcha.incorrect"),
+          Placeholder.component("prefix", Sonar.get().getConfig().getPrefix())))));
+
+      // Prepare countdown
+      xpCountdown = new FallbackPacket[Sonar.get().getConfig().getVerification().getMap().getMaxDuration() / 1000];
+
+      for (int i = 0; i < xpCountdown.length; i++) {
+        final float bar = (float) i / xpCountdown.length;
+        xpCountdown[i] = new FallbackPacketSnapshot(new SetExperiencePacket(bar, i, 0));
+      }
+
+      // Update the CAPTCHA generator if necessary
+      final CaptchaGenerationStartEvent generationStartEvent = new CaptchaGenerationStartEvent(
+        Sonar.get().getFallback().getCaptchaGenerator());
+      Sonar.get().getEventManager().publish(generationStartEvent);
+
+      if (generationStartEvent.getCaptchaGenerator() == null
+        || generationStartEvent.getCaptchaGenerator() instanceof StandardCaptchaGenerator) {
+        Sonar.get().getFallback().setCaptchaGenerator(new StandardCaptchaGenerator(
+          Sonar.get().getConfig().getVerification().getMap().getBackgroundImage()));
+      } else {
+        Sonar.get().getLogger().info("Custom CAPTCHA generator detected, skipping reinitialization.");
+      }
+
+      // Prepare CAPTCHA answers
+      CaptchaPreparer.prepare();
+    } else {
+      // Throw away if not needed
+      enterCodeMessage = null;
+      incorrectCaptcha = null;
+      xpCountdown = null;
+      Sonar.get().getFallback().setCaptchaGenerator(null);
+    }
+
+    maxTotalPacketsSent = maxMovementTick + 2
+      + (xpCountdown == null ? 0 : xpCountdown.length) * 20 + 5
+      + Sonar.get().getConfig().getVerification().getVehicle().getMinimumPackets() * 4
+      + Sonar.get().getConfig().getVerification().getMap().getMaxTries()
+      + 150 /* some arbitrary leeway */;
+  }
+
+  public static FallbackPacket[] getRegistryPackets(final @NotNull ProtocolVersion protocolVersion) {
+    if (protocolVersion.greaterThanOrEquals(ProtocolVersion.MINECRAFT_1_21_4)) {
+      return REGISTRY_SYNC_1_21_4;
+    } else if (protocolVersion.greaterThanOrEquals(ProtocolVersion.MINECRAFT_1_21_2)) {
+      return REGISTRY_SYNC_1_21_2;
+    } else if (protocolVersion.greaterThanOrEquals(ProtocolVersion.MINECRAFT_1_21)) {
+      return REGISTRY_SYNC_1_21;
+    } else if (protocolVersion.greaterThanOrEquals(ProtocolVersion.MINECRAFT_1_20_5)) {
+      return REGISTRY_SYNC_1_20_5;
+    }
+    return REGISTRY_SYNC_1_20;
+  }
+}

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/block/BlockType.java

@@ -0,0 +1,330 @@
+/*
+ * Copyright (C) 2025 Sonar Contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package xyz.jonesdev.sonar.common.fallback.protocol.block;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion;
+
+import java.util.function.Function;
+
+import static xyz.jonesdev.sonar.api.fallback.protocol.ProtocolVersion.*;
+
+// TODO: load mappings from a separate file
+@Getter
+@SuppressWarnings("unused")
+@RequiredArgsConstructor
+public enum BlockType {
+  // Useful resources:
+  // - https://github.com/PrismarineJS/minecraft-data/blob/master/data/pc/
+  // - https://pokechu22.github.io/Burger/
+  // - https://github.com/ViaVersion/Mappings/tree/main/mappings
+  //STONE(protocolVersion -> 1, 1),
+  ENCHANTMENT_TABLE(protocolVersion -> {
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_12_2)) {
+      return 116;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_1)) {
+      return 4612;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_2)) {
+      return 4613;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_15_2)) {
+      return 5116;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_1)) {
+      return 5132;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_4)) {
+      return 5136;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_18_2)) {
+      return 5333;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_1)) {
+      return 5719;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_3)) {
+      return 7159;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_4)) {
+      return 7385;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21)) {
+      return 7389;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21_2)) {
+      return 7619;
+    }
+    return 8163;
+  }, protocolVersion -> (double) 0.75f),
+  TRAPDOOR(protocolVersion -> {
+    // We have to use wooden trapdoors for 1.7 since 1.7 doesn't have iron trapdoors
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_7_6)) {
+      return 96;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_12_2)) {
+      return 167;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_1)) {
+      return 6509;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_2)) {
+      return 6510;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_15_2)) {
+      return 7016;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_1)) {
+      return 7552;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_4)) {
+      return 7556;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_18_2)) {
+      return 7802;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_1)) {
+      return 8293;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_3)) {
+      return 9937;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_4)) {
+      return 10269;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_20)) {
+      return 10273;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21)) {
+      return 10414;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21_2)) {
+      return 10749;
+    }
+    return 11293;
+  }, protocolVersion -> 0.1875),
+  END_PORTAL_FRAME(protocolVersion -> {
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_12_2)) {
+      return 120;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_1)) {
+      return 4633;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_2)) {
+      return 4634;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_15_2)) {
+      return 5137;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_1)) {
+      return 5153;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_4)) {
+      return 5157;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_18_2)) {
+      return 5358;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_1)) {
+      return 5744;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_3)) {
+      return 7184;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_4)) {
+      return 7410;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21)) {
+      return 7414;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21_2)) {
+      return 7644;
+    }
+    return 8185;
+  }, protocolVersion -> 0.8125),
+  DAYLIGHT_SENSOR(protocolVersion -> {
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_12_2)) {
+      return 151;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_1)) {
+      return 5651;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_2)) {
+      return 5652;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_15_2)) {
+      return 6158;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_1)) {
+      return 6694;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_4)) {
+      return 6698;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_18_2)) {
+      return 6916;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_1)) {
+      return 7327;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_3)) {
+      return 8811;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_4)) {
+      return 9063;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_20)) {
+      return 9067;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21)) {
+      return 9207;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21_2)) {
+      return 9462;
+    }
+    return 10006;
+  }, protocolVersion -> 0.375),
+  COBBLESTONE_WALL(protocolVersion -> {
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_12_2)) {
+      return 139;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_1)) {
+      return 5196;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_2)) {
+      return 5197;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_15_2)) {
+      return 5700;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_1)) {
+      return 5660;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_4)) {
+      return 5664;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_18_2)) {
+      return 5866;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_1)) {
+      return 6252;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_3)) {
+      return 7692;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_4)) {
+      return 7918;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21)) {
+      return 7922;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21_2)) {
+      return 8152;
+    }
+    return 8696;
+  }, protocolVersion -> 1.5),
+  STONE_SLABS(protocolVersion -> {
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_12_2)) {
+      return 44;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_1)) {
+      return 7296;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_2)) {
+      return 7297;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_15_2)) {
+      return 7809;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_1)) {
+      return 8345;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_4)) {
+      return 8349;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_18_2)) {
+      return 8595;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_1)) {
+      return 9092;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_3)) {
+      return 10748;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_4)) {
+      return 11086;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_20)) {
+      return 11090;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21)) {
+      return 11231;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21_2)) {
+      return 11566;
+    }
+    return 12110;
+  }, protocolVersion -> 0.5),
+  WHITE_CARPET(protocolVersion -> {
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_12_2)) {
+      return 171;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_1)) {
+      return 6823;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_13_2)) {
+      return 6824;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_15_2)) {
+      return 7330;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_1)) {
+      return 7866;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_16_4)) {
+      return 7870;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_18_2)) {
+      return 8116;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_1)) {
+      return 8607;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_3)) {
+      return 10251;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_19_4)) {
+      return 10583;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_20)) {
+      return 10587;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21)) {
+      return 10728;
+    }
+    if (protocolVersion.lessThanOrEquals(MINECRAFT_1_21_2)) {
+      return 11063;
+    }
+    return 11607;
+  }, protocolVersion -> protocolVersion.compareTo(MINECRAFT_1_8) < 0 ? 0 : 0.0625);
+
+  private final Function<ProtocolVersion, Integer> id;
+  private final Function<ProtocolVersion, Double> blockHeight;
+}

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/block/BlockUpdate.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,18 +19,17 @@ package xyz.jonesdev.sonar.common.fallback.protocol.block;
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
-import lombok.ToString;
 import org.jetbrains.annotations.NotNull;
 
 @Getter
 public final class BlockUpdate {
-  private final @NotNull BlockPosition position;
-  private final BlockType type;
+  private final BlockPosition position;
+  private final BlockType blockType;
   private final int legacyBlockState, blockState;
 
-  public BlockUpdate(final @NotNull BlockPosition position, final BlockType type) {
+  public BlockUpdate(final @NotNull BlockPosition position, final BlockType blockType) {
     this.position = position;
-    this.type = type;
+    this.blockType = blockType;
     final int x = position.getX() - (position.getChunkX() << 4);
     final int y = position.getY();
     final int z = position.getZ() - (position.getChunkZ() << 4);
@@ -39,7 +38,6 @@ public final class BlockUpdate {
   }
 
   @Getter
-  @ToString
   @RequiredArgsConstructor
   public static final class BlockPosition {
     private final int x, y, z;

common/src/main/java/xyz/jonesdev/sonar/common/fallback/protocol/dimension/DimensionRegistry.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Sonar Contributors
+ * Copyright (C) 2025 Sonar Contributors
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,10 +18,8 @@
 package xyz.jonesdev.sonar.common.fallback.protocol.dimension;
 
 import lombok.experimental.UtilityClass;
-import net.kyori.adventure.nbt.BinaryTag;
 import net.kyori.adventure.nbt.BinaryTagIO;
 import net.kyori.adventure.nbt.CompoundBinaryTag;
-import net.kyori.adventure.nbt.ListBinaryTag;
 import org.jetbrains.annotations.NotNull;
 import xyz.jonesdev.sonar.api.Sonar;
 
@@ -30,41 +28,35 @@ import java.util.Objects;
 
 @UtilityClass
 public final class DimensionRegistry {
-  public final DimensionInfo DEFAULT_DIMENSION_1_16;
-  public final DimensionInfo DEFAULT_DIMENSION_1_18_2;
-
-  public final @NotNull CompoundBinaryTag CODEC_1_16;
-  public final @NotNull CompoundBinaryTag CODEC_1_18_2;
-  public final @NotNull CompoundBinaryTag CODEC_1_19;
-  public final @NotNull CompoundBinaryTag CODEC_1_19_1;
-  public final @NotNull CompoundBinaryTag CODEC_1_19_4;
-  public final @NotNull CompoundBinaryTag CODEC_1_20;
-  public final @NotNull CompoundBinaryTag CODEC_1_21;
-  public final @NotNull CompoundBinaryTag OLD_CODEC;
+  public final CompoundBinaryTag CODEC_1_16;
+  public final CompoundBinaryTag CODEC_1_16_2;
+  public final CompoundBinaryTag CODEC_1_18_2;
+  public final CompoundBinaryTag CODEC_1_19;
+  public final CompoundBinaryTag CODEC_1_19_1;
+  public final CompoundBinaryTag CODEC_1_19_4;
+  public final CompoundBinaryTag CODEC_1_20;
+  public final CompoundBinaryTag CODEC_1_20_5;
+  public final CompoundBinaryTag CODEC_1_21;
+  public final CompoundBinaryTag CODEC_1_21_2;
+  public final CompoundBinaryTag CODEC_1_21_4;
 
   static {
     CODEC_1_16 = getCodec("codec_1_16.nbt");
+    CODEC_1_16_2 = getCodec("codec_1_16_2.nbt");
     CODEC_1_18_2 = getCodec("codec_1_18_2.nbt");
     CODEC_1_19 = getCodec("codec_1_19.nbt");
     CODEC_1_19_1 = getCodec("codec_1_19_1.nbt");
     CODEC_1_19_4 = getCodec("codec_1_19_4.nbt");
     CODEC_1_20 = getCodec("codec_1_20.nbt");
+    CODEC_1_20_5 = getCodec("codec_1_20_5.nbt");
     CODEC_1_21 = getCodec("codec_1_21.nbt");
-    OLD_CODEC = getCodec("codec_old.nbt");
-
-    DEFAULT_DIMENSION_1_16 = getDimension(CODEC_1_16);
-    DEFAULT_DIMENSION_1_18_2 = getDimension(CODEC_1_18_2);
-  }
-
-  private static @NotNull DimensionInfo getDimension(final @NotNull CompoundBinaryTag tag) {
-    final ListBinaryTag dimensions = tag.getCompound("minecraft:dimension_type").getList("value");
-    final BinaryTag elementTag = ((CompoundBinaryTag) dimensions.get(0)).get("element");
-    return new DimensionInfo("minecraft:overworld", 0, (CompoundBinaryTag) elementTag);
+    CODEC_1_21_2 = getCodec("codec_1_21_2.nbt");
+    CODEC_1_21_4 = getCodec("codec_1_21_4.nbt");
   }
 
   private @NotNull CompoundBinaryTag getCodec(final @NotNull String fileName) {
     try (final InputStream inputStream = Sonar.class.getResourceAsStream("/assets/codecs/" + fileName)) {
-      return BinaryTagIO.reader().read(Objects.requireNonNull(inputStream), BinaryTagIO.Compression.GZIP);
+      return BinaryTagIO.unlimitedReader().read(Objects.requireNonNull(inputStream), BinaryTagIO.Compression.GZIP);
     } catch (Throwable throwable) {
       Sonar.get().getLogger().error("Could not load mappings for {}: {}", fileName, throwable);
       throw new IllegalStateException(throwable);