Exclude CODEOWNERS from language statistics

Add CODEOWNERS (one staff approval)
Fix message placeholder keys (#592 )
2026-10-26 12:28:35 -04:00 · 2026-10-26 05:47:04 -04:00 · 2026-06-14 20:12:34 +02:00 · 2026-06-14 17:42:19 +02:00 · 2026-06-08 09:59:56 +02:00 · 2026-06-06 17:25:37 +02:00
325 changed files with 20075 additions and 10531 deletions
@@ -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}]
@@ -22,3 +22,4 @@

 # Common build-tool wrapper scripts ('.cmd' versions are handled by 'Common.gitattributes')
 gradlew         text eol=lf
+.gitea/CODEOWNERS linguist-detectable=false
@@ -0,0 +1,3 @@
+# Pull requests request review from the eligible staff team(s).
+# One approval from either an Admin or Developer satisfies branch protection.
+*   @trueog/Admins @trueog/Developers
@@ -1,14 +1,13 @@
 Before you start contributing, please take a moment to review our contributing guidelines.
 If you can't contribute but like the project, feel free to show your support by starring the project on GitHub or
-joining the [Discord](https://jonesdev.xyz/discord).
+joining the [Discord](https://sonar.top/discord).

 ## Contributing Guidelines:

 1. Fork the repository and create a new branch for your contribution.
-2. Follow the coding guidelines for your code.
+2. Adhere to the Coding Guidelines and LLM Guidelines.
 3. Test your code before committing and pushing it.
 4. Use [semantic](https://gist.github.com/joshbuchea/6f47e86d2510bce28f8e7f42ae84c716) commit messages for your commits.
-5. Create a feature branch or push to the `dev` branch.

 ## Coding Guidelines:

@@ -18,6 +17,17 @@ joining the [Discord](https://jonesdev.xyz/discord).
 - Write clear comments to explain complex parts of your code.
 - Ensure your code is easy to read and maintain.

+## LLM Guidelines
+
+Keep the use of AI (including LLMs) for code generation to an absolute minimum. If possible, avoid using AI entirely due to potential complications regarding authorship, intellectual property, and copyright.
+
+If AI was utilized during the development of a Pull Request, you must disclose its exact use in the PR description. This includes:
+- The specific tool and model used (e.g., GPT 5.4, Claude 4.7 Sonnet, Gemini 3.1 Pro)
+- The nature of its use (e.g., optimization)
+- The exact prompts used, where relevant
+
+Please note that submissions will be rejected if AI usage raises concerns regarding code quality, licensing, or integrity.
+
 ## Bug Reports:

 1. Check if someone has already reported the bug.
@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Documentation
+    url: https://docs.jonesdev.xyz/
+    about: Need help configuring Sonar or have questions regarding the installation and usage?
+  - name: Discord
+    url: https://sonar.top/discord/
+    about: If you have any further questions, please feel free to join the Discord server and open a ticket.
@@ -1,21 +1,19 @@
 <div align="center">
  <!-- Introduction -->
-  <p>
-    <h1>💫 Sonar</h1>
-    Lightweight and easy-to-use anti-bot plugin for your Minecraft server. Supporting every client and server version.
-    <br>
-    An effective and extensible solution for protecting your Minecraft server against all kinds of bot attacks
-  </p>
-  
+  <h1>💫 Sonar</h1>
+  Lightweight and easy-to-use anti-bot plugin for your Minecraft server.
+  <br>
+  Sonar keeps your server safe from common and even sophisticated bot attacks.
+  <br><br>
+
  <!-- Badges & icons -->
  [![](https://github.com/jonesdevelopment/sonar/actions/workflows/gradle.yml/badge.svg)](https://github.com/jonesdevelopment/sonar/actions/workflows/gradle.yml)
  [![](https://www.codefactor.io/repository/github/jonesdevelopment/sonar/badge/main)](https://www.codefactor.io/repository/github/jonesdevelopment/sonar/overview/main)
  [![](https://img.shields.io/github/v/release/jonesdevelopment/sonar)](https://github.com/jonesdevelopment/sonar/releases)
  [![](https://img.shields.io/github/issues/jonesdevelopment/sonar)](https://github.com/jonesdevelopment/sonar/issues)
-  [![](https://img.shields.io/discord/923308209769426994.svg?logo=discord)](https://jonesdev.xyz/discord)
+  [![](https://img.shields.io/discord/923308209769426994.svg?logo=discord)](https://sonar.top/discord)
  [![](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
  <br>
-  <br>
  <!-- Quick navigation -->
  [Releases](https://github.com/jonesdevelopment/sonar/releases)
  |
@@ -23,13 +21,19 @@
  |
  [Pull Requests](https://github.com/jonesdevelopment/sonar/pulls)
  |
-  [Discord](https://jonesdev.xyz/discord)
+  [Discord](https://sonar.top/discord)
  |
  [License](https://github.com/jonesdevelopment/sonar/?tab=readme-ov-file#license)
+  |
+  [Documentation](https://docs.jonesdev.xyz/)
 </div>

-## Design and Goal
+> ### Notice about Sonar 3.0
+> 
+> If you want more robust protection, better performance, and awesome new features, check out Sonar 3.0 at https://sonar.top/!
+> You can read more about what sets Sonar 3.0 apart from Sonar 2.0 [here](<https://sonar.top/docs/features>).

+## Design and Goal
 * Effective, lightweight, and easy-to-use
 * No unnecessary features and clean code
 * Protection against all kinds of bot attacks
@@ -38,44 +42,38 @@
 * Multi-platform support (See [supported versions](https://docs.jonesdev.xyz/sonar/supported-versions))

 ## Checks
+Sonar analyzes a player's behavior before joining the actual server, therefore stopping malicious traffic from ever reaching the backend. It is supposed to be an instant, powerful, and simple method of verification that should prevent all typical and advanced types of bots.

- [Fallback](https://github.com/jonesdevelopment/sonar#fallback) is Sonar's main anti-bot component
- Sonar queues new player logins to prevent spam login attacks
- Sonar checks the handshake packets for legitimacy
- Sonar makes sure some packets cannot be duplicated illegitimately
+1. Sonar sends the player to a lightweight fake server when they connect for the first time.
+2. Sonar verifies that players obey the laws of Minecraft's physics, including gravity and proper block collision.
+3. Sonar verifies that players send legitimate packets when interacting with vehicles (e.g. boats).
+4. Sonar makes sure that players send legitimate packets according to the [vanilla Minecraft protocol](<https://wiki.vg/Protocol>).

-### Fallback
-
-Fallback analyzes a player's behavior before joining the actual server, therefore stopping malicious traffic from ever reaching the backend.
-It is supposed to be an instant, powerful, and invisible method of verification that should prevent all typical and advanced types of bots.
-
-* Sends the player to a lightweight fake server when they connect for the first time.
-* Analyzes if the player is sending the necessary packets.
-* Analyzes if the player is sending legitimate packets.
-* Checks if the player is obeying client gravity.
-* Checks if the player is colliding with blocks correctly.
-
-Fallback also protects against huge spambot attacks since it queues the incoming connections, therefore making it technically impossible to have a ton of bots join the server at the same time.
+Sonar also protects against spambot attacks since it queues the incoming connections, therefore making it technically impossible to have a ton of bots join the server at the same time.

 ### False positives
+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://sonar.top/discord/).

-Fallback 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. However, there are some edge cases where Fallback might not receive packets within the necessary time period. In this case, Sonar tries to account for these edge cases in order to prevent false positives. 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) or a ticket on [Discord](https://jonesdev.xyz/discord/).
+## Sponsors
+If you are interested in sponsoring this project, please contact me via [Discord](https://sonar.top/discord/).
+
+### Past Sponsors
+
+<a href="https://github.com/Chumb3x"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/79834154?v=4&h=50&w=50&fit=cover&mask=circle&maxage=7d" alt="logo" align="center"></a>
+<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>
+<a href="https://github.com/ItzErpandX"><img src="https://images.weserv.nl/?url=avatars.githubusercontent.com/u/84748484?v=4?s=400?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/sonar/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>
 You can also take a look at the [gradle documentation](https://docs.gradle.org/current/userguide/userguide.html) for a better understanding of Gradle.

 ## Contributing
-
 If you are interested in contributing, you can check out the [Contributing Guidelines](https://github.com/jonesdevelopment/sonar/blob/main/.github/CONTRIBUTING.md) for detailed instructions.

 ## License
-
 Sonar is licensed under the [GNU General Public License 3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).

 ## Credits
-
 - Special thanks to the [contributors of Sonar](https://github.com/jonesdevelopment/sonar/graphs/contributors).
- The Varint decoding was taken from [Velocity](https://github.com/PaperMC/Velocity).
@@ -13,7 +13,7 @@ If you discover a security vulnerability within Sonar, please follow these steps

 ## Contact

-If you have any questions or concerns regarding the security of this project, please open a ticket on Discord or contact me via email at contact@jonesdev.xyz.
+If you have any questions or concerns regarding the security of this project, please open a ticket on Discord or contact me via email at support@sonar.top.

 ## Acknowledgments

@@ -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,44 @@ 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 21
+        uses: actions/setup-java@v3
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Build with Gradle
+        run: ./gradlew 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 Paper Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Sonar-Paper
+          path: paper/build/libs/Sonar-Paper.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
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) ${YEAR} Sonar Contributors
+ * Copyright (C) 2026 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/>.
 */
+
@@ -0,0 +1,16 @@
+repositories {
+  maven(url = "https://jitpack.io/") // simple-yaml
+}
+
+dependencies {
+  compileOnly(rootProject.libs.simpleyaml) {
+    exclude(group = "org.yaml")
+  }
+  compileOnly(rootProject.libs.annotations)
+}
+
+tasks {
+  shadowJar {
+    archiveFileName = "sonar-api-${rootProject.version}.jar"
+  }
+}
@@ -0,0 +1,185 @@
+/*
+ * 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;
+
+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.antibot.AntiBot;
+import xyz.jonesdev.sonar.api.command.subcommand.SubcommandRegistry;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+import xyz.jonesdev.sonar.api.database.controller.VerifiedPlayerController;
+import xyz.jonesdev.sonar.api.event.SonarEventManager;
+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.tracker.AttackTracker;
+
+import java.text.DecimalFormat;
+import java.util.UUID;
+
+public interface Sonar {
+  DecimalFormat DECIMAL_FORMAT = new DecimalFormat("#,###.##");
+
+  /**
+   * Since we want to use Adventure on every server platform,
+   * we have to use their platform module to support BungeeCord and Bukkit.
+   */
+  @ApiStatus.Internal
+  @Nullable Audience audience(final @Nullable UUID uniqueId);
+
+  @ApiStatus.Internal
+  @NotNull Audience sender(final @NotNull Object object);
+
+  /**
+   * Gets the platform Sonar is running on (e.g., Bukkit, BungeeCord, Velocity).
+   *
+   * @return The {@link SonarPlatform} enum representing the current platform.
+   */
+  @NotNull SonarPlatform getPlatform();
+
+  /**
+   * Gets the logger instance for Sonar.
+   *
+   * @return The {@link LoggerWrapper} instance.
+   */
+  @NotNull LoggerWrapper getLogger();
+
+  /**
+   * Gets the Sonar configuration.
+   *
+   * @return The {@link SonarConfiguration} instance.
+   */
+  @NotNull SonarConfiguration getConfig();
+
+  /**
+   * Gets the subcommand registry for Sonar commands.
+   *
+   * @return The {@link SubcommandRegistry} instance.
+   */
+  @NotNull SubcommandRegistry getSubcommandRegistry();
+
+  /**
+   * Gets the controller for verified players.
+   * Used for managing players who have passed the verification.
+   *
+   * @return The {@link VerifiedPlayerController} instance.
+   */
+  VerifiedPlayerController getVerifiedPlayerController();
+
+  /**
+   * Gets the handler for action bar notifications.
+   *
+   * @return The {@link ActionBarNotificationHandler} instance.
+   */
+  @NotNull ActionBarNotificationHandler getActionBarNotificationHandler();
+
+  /**
+   * Gets the handler for chat notifications.
+   *
+   * @return The {@link ChatNotificationHandler} instance.
+   */
+  @NotNull ChatNotificationHandler getChatNotificationHandler();
+
+  /**
+   * Gets the system timer used for tracking plugin launch time.
+   *
+   * @return The {@link SystemTimer} instance.
+   */
+  @NotNull SystemTimer getLaunchTimer();
+
+  /**
+   * Gets the statistics tracker for Sonar.
+   *
+   * @return The {@link SonarStatistics} instance.
+   */
+  @NotNull SonarStatistics getStatistics();
+
+  @SuppressWarnings("unused")
+  void setActionBarNotificationHandler(final @NotNull ActionBarNotificationHandler notificationHandler);
+
+  @SuppressWarnings("unused")
+  void setChatNotificationHandler(final @NotNull ChatNotificationHandler notificationHandler);
+
+  /**
+   * Reloads the Sonar configuration.
+   */
+  void reload();
+
+  /**
+   * Gets the current version of Sonar.
+   *
+   * @return The {@link SonarVersion} instance.
+   */
+  @NotNull default SonarVersion getVersion() {
+    return SonarVersion.INSTANCE;
+  }
+
+  /**
+   * Gets the event manager for Sonar.
+   *
+   * @return The {@link SonarEventManager} instance.
+   */
+  @NotNull default SonarEventManager getEventManager() {
+    return SonarEventManager.INSTANCE;
+  }
+
+  /**
+   * Gets the attack tracker for Sonar.
+   *
+   * @return The {@link AttackTracker} instance.
+   */
+  @NotNull default AttackTracker getAttackTracker() {
+    return AttackTracker.INSTANCE;
+  }
+
+  /**
+   * Gets the anti-bot handler for Sonar.
+   *
+   * @return The {@link AntiBot} instance.
+   */
+  @NotNull default AntiBot getAntiBot() {
+    return AntiBot.INSTANCE;
+  }
+
+  /**
+   * Gets the instance of the Sonar API.
+   *
+   * @return The {@link Sonar} instance.
+   * @throws IllegalStateException If Sonar has not been initialized.
+   */
+  @NotNull static Sonar get() {
+    return SonarSupplier.get();
+  }
+
+  /**
+   * Gets the instance of the Sonar API.
+   * Only use this method if you understand the implications,
+   * and have a specific reason to bypass the standard {@link #get()} method.
+   * In most cases, {@link #get()} is the preferred way to access the Sonar API.
+   *
+   * @return The Sonar instance.
+   */
+  @ApiStatus.Internal
+  @NotNull static Sonar get0() {
+    return SonarSupplier.sonar;
+  }
+}
@@ -0,0 +1,42 @@
+/*
+ * 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;
+
+import io.netty.channel.ChannelPipeline;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.function.Function;
+
+@Getter
+@RequiredArgsConstructor
+public enum SonarPlatform {
+  BUKKIT("Bukkit", 19110, "packet_handler",
+    pipeline -> pipeline.context("outbound_config") != null ? "outbound_config" : "encoder"),
+  BUNGEE("BungeeCord", 19109, "inbound-boss",
+    pipeline -> "packet-encoder"),
+  PAPER("Paper", 19110, "packet_handler",
+    pipeline -> pipeline.context("outbound_config") != null ? "outbound_config" : "encoder"),
+  VELOCITY("Velocity", 19107, "handler",
+    pipeline -> "minecraft-encoder");
+
+  private final String displayName;
+  private final int metricsId;
+  private final String connectionHandler;
+  private final Function<ChannelPipeline, String> encoder;
+}
@@ -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
@@ -20,20 +20,21 @@ 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);
+    sonar = _sonar;
  }

-  public @NotNull Sonar get() {
+  public Sonar get() {
+    if (sonar == null) {
+      throw new IllegalStateException("Sonar is not initialized yet");
+    }
    return sonar;
  }
 }
@@ -0,0 +1,69 @@
+/*
+ * 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;
+
+import lombok.Getter;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.jar.Manifest;
+
+@Getter
+public final class SonarVersion {
+  static final SonarVersion INSTANCE = new SonarVersion();
+
+  private final String version, formatted, gitBranch, gitCommit;
+
+  SonarVersion() {
+    // No need to null-check since we'll always just throw an exception if
+    // we can't find the version information in this file.
+    final Manifest manifest = getManifest();
+
+    this.version = manifest.getMainAttributes().getValue("Implementation-Version");
+    this.gitBranch = manifest.getMainAttributes().getValue("Git-Branch");
+    this.gitCommit = manifest.getMainAttributes().getValue("Git-Commit");
+    this.formatted = version + " (" + gitCommit + ")";
+  }
+
+  // https://github.com/PaperMC/Velocity/pull/1336/
+  private static @NotNull Manifest getManifest() {
+    final String classLocation = "/" + Sonar.class.getName().replace(".", "/") + ".class";
+    final URL resource = Sonar.class.getResource(classLocation);
+
+    if (resource == null) {
+      throw new IllegalStateException("Could not find version information. Is the manifest missing?");
+    }
+
+    final String classFilePath = resource.toString().replace("\\", "/");
+    final String archivePath = classFilePath.substring(0, classFilePath.length() - classLocation.length());
+    final String manifestPath = archivePath + "/META-INF/MANIFEST.MF";
+
+    try (final InputStream stream = new URL(manifestPath).openStream()) {
+      return new Manifest(stream);
+    } catch (IOException exception) {
+      throw new IllegalStateException(exception);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return formatted;
+  }
+}
@@ -0,0 +1,64 @@
+/*
+ * 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.antibot;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.antibot.captcha.CaptchaGenerator;
+import xyz.jonesdev.sonar.api.antibot.ratelimit.Ratelimiter;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+
+import java.net.InetAddress;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class AntiBot {
+  public static final AntiBot INSTANCE = new AntiBot();
+
+  private final ConcurrentMap<InetAddress, Integer> online = new ConcurrentHashMap<>(128);
+  private final ConcurrentMap<InetAddress, Boolean> connected = new ConcurrentHashMap<>(256);
+  private final LoginQueue queue = new LoginQueue();
+  @Setter
+  private Cache<String, Integer> blacklist;
+  @Setter
+  private long blacklistTime;
+  @Setter
+  private CaptchaGenerator captchaGenerator;
+  @Setter
+  private Ratelimiter<InetAddress> ratelimiter;
+
+  public boolean shouldVerifyNewPlayers() {
+    return shouldPerform(Sonar.get0().getConfig().getVerification().getTiming());
+  }
+
+  public boolean shouldPerformCaptcha() {
+    return shouldPerform(Sonar.get0().getConfig().getVerification().getMap().getTiming());
+  }
+
+  public static boolean shouldPerform(final SonarConfiguration.Verification.Timing timing) {
+    return timing == SonarConfiguration.Verification.Timing.ALWAYS
+      || (timing == SonarConfiguration.Verification.Timing.DURING_ATTACK
+      && Sonar.get0().getAttackTracker().getCurrentAttack() != null);
+  }
+}
@@ -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.antibot;
+
+public interface ChannelPipelines {
+  String SONAR_INACTIVE_LISTENER = "sonar-inactive-listener";
+  String SONAR_INBOUND_HANDLER = "sonar-inbound-handler";
+  String SONAR_FRAME_DECODER = "sonar-frame-decoder";
+  String SONAR_FRAME_ENCODER = "sonar-frame-encoder";
+  String SONAR_TIMEOUT = "sonar-timeout";
+  String SONAR_PACKET_HANDLER = "sonar-packet-handler";
+  String SONAR_PACKET_ENCODER = "sonar-packet-encoder";
+  String SONAR_PACKET_DECODER = "sonar-packet-decoder";
+  String SONAR_TAIL_EXCEPTIONS = "sonar-exception-tail";
+  String SONAR_BANDWIDTH = "sonar-bandwidth-counter";
+}
@@ -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.antibot;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import xyz.jonesdev.sonar.api.Sonar;
+
+import java.net.InetAddress;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@Getter
+@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
+public final class LoginQueue {
+  // 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<>(512);
+
+  public void poll() {
+    final int maxQueuePolls = Math.min(players.size(), Sonar.get0().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
+    QUEUE_EXECUTOR.execute(() -> {
+      final var iterator = players.entrySet().iterator();
+      for (int index = 0; index < maxQueuePolls && iterator.hasNext(); index++) {
+        iterator.next().getValue().run();
+        iterator.remove();
+      }
+    });
+  }
+}
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2026 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.antibot;
+
+import io.netty.channel.Channel;
+import io.netty.util.ReferenceCountUtil;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.antibot.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+
+import java.net.InetAddress;
+
+public interface SonarUser {
+  @NotNull Channel channel();
+
+  @NotNull InetAddress getInetAddress();
+
+  @NotNull ProtocolVersion getProtocolVersion();
+
+  @NotNull SystemTimer getLoginTimer();
+
+  @NotNull String getFingerprint();
+
+  @NotNull String getUsername();
+
+  boolean isForceCaptcha();
+
+  void setForceCaptcha(final boolean isForceCaptcha);
+
+  boolean isGeyser();
+
+  @Nullable String getHostname();
+
+  /**
+   * Disconnect the player during/after verification
+   * using our custom Disconnect packet.
+   *
+   * @param reason      Disconnect message component
+   */
+  void disconnect(final @NotNull Component reason);
+
+  /**
+   * Sends a packet/message to the player
+   *
+   * @param msg Message to send to the player
+   */
+  default void write(final @NotNull Object msg) {
+    if (channel().isActive()) {
+      channel().writeAndFlush(msg, channel().voidPromise());
+    } else {
+      ReferenceCountUtil.release(msg);
+    }
+  }
+
+  /**
+   * Queues a buffered message that will be
+   * sent once all messages are flushed.
+   */
+  default void delayedWrite(final @NotNull Object msg) {
+    if (channel().isActive()) {
+      channel().write(msg, channel().voidPromise());
+    } else {
+      ReferenceCountUtil.release(msg);
+    }
+  }
+}
@@ -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.antibot.captcha;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.image.BufferedImage;
+
+@FunctionalInterface
+public interface CaptchaGenerator {
+
+  /**
+   * Generates a {@link java.awt.image.BufferedImage} that shows the answer to the CAPTCHA
+   */
+  @NotNull BufferedImage createImage(final char @NotNull [] answer);
+}
@@ -0,0 +1,125 @@
+/*
+ * 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.antibot.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"),
+  MINECRAFT_1_21_5(770, "1.21.5"),
+  MINECRAFT_1_21_6(771, "1.21.6"),
+  MINECRAFT_1_21_7(772, "1.21.7"),
+  MINECRAFT_1_21_9(773, "1.21.9"),
+  MINECRAFT_1_21_11(774, "1.21.11"),
+  MINECRAFT_26_1(775, "26.1");
+
+  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;
+  }
+}
@@ -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
@@ -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.antibot.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);
 }
@@ -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
@@ -21,36 +21,28 @@ 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;

@Getter
@RequiredArgsConstructor
-public abstract class InvocationSource {
-  private final String name;
+public final class InvocationSource {
+  private final UUID uuid;
  private final Audience audience;
-  private final boolean player;
  private final Predicate<String> permissionFunction;

  /**
-   * Sends an empty chat message to the command executor
+   * @return true if {@link InvocationSource#uuid} is not null
   */
-  public final void sendMessage() {
-    sendMessage(Component.empty());
+  public boolean isPlayer() {
+    return uuid != null;
  }

  /**
   * Sends a message to the command executor
   */
-  public final void sendMessage(final String legacy) {
-    sendMessage(MiniMessage.miniMessage().deserialize(legacy));
-  }
-
-  /**
-   * Sends a message to the command executor
-   */
-  public final void sendMessage(final Component component) {
+  public void sendMessage(final Component component) {
    audience.sendMessage(component);
  }
 }
@@ -0,0 +1,128 @@
+/*
+ * 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.command;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.event.ClickEvent;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.Tag;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+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.*;
+
+public interface SonarCommand {
+  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")) {
+      if (Sonar.get0().getConfig().getNoPermission() != null) {
+        source.sendMessage(Sonar.get0().getConfig().getNoPermission());
+      }
+      return;
+    }
+
+    Optional<Subcommand> subcommand = Optional.empty();
+
+    if (args.length > 0) {
+      // Search subcommand if command arguments are present
+      subcommand = Sonar.get0().getSubcommandRegistry().getSubcommands().stream()
+        .filter(sub -> sub.getInfo().name().equalsIgnoreCase(args[0])
+          || Arrays.stream(sub.getInfo().aliases()).anyMatch(alias -> alias.equalsIgnoreCase(args[0])))
+        .findFirst();
+    }
+
+    subcommand.ifPresentOrElse(command -> {
+      // Check permissions for subcommands
+      if (!command.getInfo().onlyConsole()
+        && !source.getPermissionFunction().test(command.getPermission())) {
+        source.sendMessage(MiniMessage.miniMessage().deserialize(
+          Sonar.get0().getConfig().getMessagesConfig().getString("commands.subcommand-no-permission"),
+          Placeholder.component("prefix", Sonar.get0().getConfig().getPrefix()),
+          Placeholder.unparsed("permission", command.getPermission())));
+        return;
+      }
+      // Invoke subcommand
+      command.invoke(source, args);
+    }, () -> {
+      final UpdateChecker.CheckResult checkResult = UpdateChecker.getLastCheckResult();
+      Component version = Component.text(Sonar.get0().getVersion().getFormatted());
+      if (checkResult.getConfigKey() != null) {
+        version = version.append(MiniMessage.miniMessage().deserialize(
+          Sonar.get0().getConfig().getMessagesConfig().getString("commands.main." + checkResult.getConfigKey())));
+      }
+
+      // Print standard help message
+      source.sendMessage(MiniMessage.miniMessage().deserialize(
+        String.join("<newline>",
+          Sonar.get0().getConfig().getMessagesConfig().getStringList("commands.main.header")),
+        Placeholder.component("version", version),
+        Placeholder.unparsed("platform", Sonar.get0().getPlatform().getDisplayName()),
+        Placeholder.unparsed("copyright-year", String.valueOf(Calendar.getInstance().get(Calendar.YEAR)))));
+
+      final Component yes = MiniMessage.miniMessage().deserialize(
+        Sonar.get0().getConfig().getMessagesConfig().getString("commands.main.tick"));
+      final Component no = MiniMessage.miniMessage().deserialize(
+        Sonar.get0().getConfig().getMessagesConfig().getString("commands.main.cross"));
+
+      Sonar.get0().getSubcommandRegistry().getSubcommands().forEach(command -> {
+        source.sendMessage(MiniMessage.miniMessage().deserialize(
+          Sonar.get0().getConfig().getMessagesConfig().getString("commands.main.subcommands"),
+          TagResolver.resolver("suggest-subcommand",
+            (queue, context) -> Tag.styling(ClickEvent.suggestCommand("/sonar " + command.getInfo().name()))),
+          Placeholder.unparsed("subcommand", command.getInfo().name()),
+          Placeholder.unparsed("description", command.getDescription()),
+          Placeholder.unparsed("permission", command.getPermission()),
+          Placeholder.unparsed("aliases", command.getAliases()),
+          Placeholder.component("only-players", command.getInfo().onlyPlayers() ? yes : no),
+          Placeholder.component("only-console", command.getInfo().onlyConsole() ? yes : no)));
+      });
+    });
+  }
+
+  static void prepareCachedTabSuggestions() {
+    if (TAB_SUGGESTIONS.isEmpty()) {
+      final List<String> subcommandsAndAliases = new ArrayList<>();
+      for (final Subcommand subcommand : Sonar.get0().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 <= 2) {
+      final int subcommandHash = arguments.length <= 1 ? -1 : arguments[0].toLowerCase().hashCode();
+      return TAB_SUGGESTIONS.getOrDefault(subcommandHash, Collections.emptyList());
+    }
+    return Collections.emptyList();
+  }
+}
@@ -0,0 +1,102 @@
+/*
+ * 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.command.subcommand;
+
+import lombok.Getter;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+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.InvocationSource;
+
+import java.util.Objects;
+import java.util.regex.Pattern;
+
+@Getter
+public abstract class Subcommand {
+  private final @NotNull SubcommandInfo info;
+  private final String permission, aliases, arguments;
+
+  public Subcommand() {
+    this.info = Objects.requireNonNull(getClass().getAnnotation(SubcommandInfo.class));
+    this.permission = "sonar." + info.name();
+    this.aliases = info.aliases().length == 0 ? "No aliases."
+      : String.join(", ", info.aliases());
+    this.arguments = info.arguments().length == 0 ? ""
+      : String.join(", ", info.arguments());
+  }
+
+  private static final Pattern IPv4_REGEX = Pattern.compile("^((25[0-5]|(2[0-4]|1\\d|[1-9]|)\\d)\\.?\\b){4}$");
+  private static final Pattern IPv6_REGEX = Pattern.compile("(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))");
+
+  protected static @Nullable String validateIP(final InvocationSource source, final String raw) {
+    if (!IPv4_REGEX.matcher(raw).matches() && !IPv6_REGEX.matcher(raw).matches()) {
+      source.sendMessage(MiniMessage.miniMessage().deserialize(
+        Sonar.get0().getConfig().getMessagesConfig().getString("commands.invalid-ip-address"),
+        Placeholder.component("prefix", Sonar.get0().getConfig().getPrefix())));
+      return null;
+    }
+    return raw;
+  }
+
+  protected final void incorrectUsage(final @NotNull InvocationSource invocationSource) {
+    incorrectUsage(invocationSource, info.name() + " (" + arguments + ")");
+  }
+
+  protected final void incorrectUsage(final @NotNull InvocationSource invocationSource, final String usage) {
+    invocationSource.sendMessage(MiniMessage.miniMessage().deserialize(
+      Sonar.get0().getConfig().getMessagesConfig().getString("commands.incorrect-usage"),
+      Placeholder.component("prefix", Sonar.get0().getConfig().getPrefix()),
+      Placeholder.unparsed("subcommand-usage", usage)));
+  }
+
+  public final void invoke(final @NotNull InvocationSource invocationSource, final String @NotNull [] arguments) {
+    // Check if the subcommand can only be executed by players
+    if (info.onlyPlayers() && !invocationSource.isPlayer()) {
+      invocationSource.sendMessage(MiniMessage.miniMessage().deserialize(
+        Sonar.get0().getConfig().getMessagesConfig().getString("commands.player-only"),
+        Placeholder.component("prefix", Sonar.get0().getConfig().getPrefix())));
+      return;
+    }
+
+    // Check if the subcommand can only be executed though console
+    if (info.onlyConsole() && invocationSource.isPlayer()) {
+      invocationSource.sendMessage(MiniMessage.miniMessage().deserialize(
+        Sonar.get0().getConfig().getMessagesConfig().getString("commands.console-only"),
+        Placeholder.component("prefix", Sonar.get0().getConfig().getPrefix())));
+      return;
+    }
+
+    // The subcommands has arguments which are not present in the executed command
+    if (info.argumentsRequired() && info.arguments().length > 0 && arguments.length <= 1) {
+      incorrectUsage(invocationSource);
+      return;
+    }
+
+    // Execute the sub command from the invocation source with the given arguments
+    execute(invocationSource, arguments);
+  }
+
+  public final @NotNull String getDescription() {
+    final String path = String.format("commands.%s.description", info.name());
+    return Objects.requireNonNull(Sonar.get0().getConfig().getMessagesConfig().getString(path));
+  }
+
+  protected abstract void execute(final @NotNull InvocationSource source, final String @NotNull [] args);
+}
@@ -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,8 +17,6 @@

 package xyz.jonesdev.sonar.api.command.subcommand;

-import xyz.jonesdev.sonar.api.command.subcommand.argument.Argument;
-
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -27,39 +25,15 @@ import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
 public @interface SubcommandInfo {
-
-  /**
-   * @return Name of the subcommand
-   */
  String name();

-  /**
-   * @return Description of the subcommand
-   */
-  String description();
-
-  /**
-   * @return Aliases of the subcommand
-   */
  String[] aliases() default {};

-  /**
-   * @return Arguments of the subcommand
-   */
-  Argument[] arguments() default {};
+  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;
 }
@@ -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,30 +17,24 @@

 package xyz.jonesdev.sonar.api.command.subcommand;

+import lombok.Getter;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Unmodifiable;

 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.Vector;

-public interface SubcommandRegistry {
-  List<Subcommand> SUBCOMMANDS = new Vector<>();
-
-  @NotNull
-  @Unmodifiable
-  default List<Subcommand> getSubcommands() {
-    return Collections.unmodifiableList(SUBCOMMANDS);
-  }
+@Getter
+public final class SubcommandRegistry {
+  private final List<Subcommand> subcommands = new Vector<>();

  /**
   * Registers a single or multiple subcommand(s)
   *
   * @param subcommand Array of Subcommands to register
   */
-  default void register(final Subcommand @NotNull ... subcommand) {
-    SUBCOMMANDS.addAll(Arrays.asList(subcommand));
+  public void register(final Subcommand @NotNull ... subcommand) {
+    subcommands.addAll(Arrays.asList(subcommand));
  }

  /**
@@ -49,7 +43,7 @@ public interface SubcommandRegistry {
   * @param subcommand Array of Subcommands to unregister
   */
  @SuppressWarnings("unused")
-  default void unregister(final Subcommand @NotNull ... subcommand) {
-    SUBCOMMANDS.removeAll(Arrays.asList(subcommand));
+  public void unregister(final Subcommand @NotNull ... subcommand) {
+    subcommands.removeAll(Arrays.asList(subcommand));
  }
 }
@@ -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,7 @@ import lombok.Getter;
 import org.jetbrains.annotations.NotNull;

@Getter
-enum Language {
+public enum Language {
  SYSTEM("system"),
  AB("Abkhazian"),
  AA("Afar"),
@@ -140,6 +140,7 @@ enum Language {
  FA("Persian"),
  PL("Polish"),
  PT("Portuguese"),
+  PT_BR("Brazilian Portuguese", "pt-br"),
  PS("Pushto"),
  QU("Quechua"),
  RM("Raeto-Romance"),
@@ -203,7 +204,18 @@ enum Language {
    this.code = name().toLowerCase();
  }

+  Language(final String name, final String code) {
+    this.name = name;
+    this.code = code;
+  }
+
  public static Language fromCode(final @NotNull String code) {
-    return Language.valueOf(code.toUpperCase());
+    for (final Language language : values()) {
+      if (language.code.equalsIgnoreCase(code)) {
+        return language;
+      }
+    }
+    // Fallback to English
+    return EN;
  }
 }
@@ -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
@@ -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;
@@ -88,84 +87,45 @@ public final class SimpleYamlConfig {
    yaml.set(path, v);
  }

-  public int getInt(final String path, final int def) {
-    yaml.addDefault(path, def);
-    return yaml.getInt(path, def);
-  }
-
  public int getInt(final String path) {
    if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get0().getLogger().warn("Could not find {} in {}.", path, file.getName());
      return 0;
    }
    return yaml.getInt(path);
  }

-  public boolean getBoolean(final String path, final boolean def) {
-    yaml.addDefault(path, def);
-    return yaml.getBoolean(path, def);
-  }
-
  public boolean getBoolean(final String path) {
    if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get0().getLogger().warn("Could not find {} in {}.", path, file.getName());
      return false;
    }
    return yaml.getBoolean(path);
  }

-  public String getString(final String path, final String def) {
-    final Object object = getObject(path, def);
-    if (object instanceof String) {
-      return (String) object;
-    }
-    LOGGER.info("[config] Migrated {} to {}", path, def);
-    set(path, def);
-    return def;
-  }
-
  public @NotNull String getString(final String path) {
    if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get0().getLogger().warn("Could not find {} in {}.", path, file.getName());
      return "";
    }
-    final Object object = getObject(path);
+    final Object object = yaml.get(path);
    if (object instanceof String) {
      return (String) object;
    }
    throw new IllegalStateException("Invalid entry " + path);
  }

-  public Object getObject(final String path, final Object def) {
-    yaml.addDefault(path, def);
-    return yaml.get(path, def);
-  }
-
-  public Object getObject(final String path) {
-    return yaml.get(path);
-  }
-
-  public List<String> getStringList(final String path, final List<String> def) {
-    yaml.addDefault(path, def);
-    return yaml.getStringList(path);
-  }
-
  public List<String> getStringList(final String path) {
    if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get0().getLogger().warn("Could not find {} in {}.", path, file.getName());
      return new ArrayList<>(0);
    }
    return yaml.getStringList(path);
  }

-  public List<Integer> getIntList(final String path, final List<Integer> def) {
-    yaml.addDefault(path, def);
-    return yaml.getIntegerList(path);
-  }
-
  public List<Integer> getIntList(final String path) {
    if (!yaml.contains(path)) {
-      LOGGER.warn("Could not find {} in {}.", path, file.getName());
+      Sonar.get0().getLogger().warn("Could not find {} in {}.", path, file.getName());
      return new ArrayList<>(0);
    }
    return yaml.getIntegerList(path);
@@ -0,0 +1,535 @@
+/*
+ * 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.config;
+
+import com.alessiodp.libby.Library;
+import com.j256.ormlite.db.DatabaseType;
+import lombok.*;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+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.SonarCommand;
+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.database.ormlite.PostgresDatabaseTypeAdapter;
+import xyz.jonesdev.sonar.api.webhook.DiscordWebhook;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetAddress;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.*;
+import java.util.regex.Pattern;
+
+public final class SonarConfiguration {
+  @Getter
+  private final SimpleYamlConfig generalConfig, messagesConfig, webhookConfig;
+  @Getter
+  private final File languageFile, pluginFolder;
+  @Getter
+  private Language language;
+
+  public SonarConfiguration(final @NotNull File pluginFolder) {
+    this.pluginFolder = pluginFolder;
+    this.messagesConfig = new SimpleYamlConfig(new File(pluginFolder, "messages.yml"));
+    this.generalConfig = new SimpleYamlConfig(new File(pluginFolder, "config.yml"));
+    this.webhookConfig = new SimpleYamlConfig(new File(pluginFolder, "webhook.yml"));
+    this.languageFile = new File(pluginFolder, "language.properties");
+  }
+
+  private static final Language DEFAULT_FALLBACK_LANGUAGE = Language.EN;
+
+  private Language getPreferredLanguage() {
+    if (!languageFile.exists()) {
+      final URL defaultLanguageFile = Sonar.class.getResource("/assets/language.properties");
+      // Make sure the file actually exists before trying to copy it
+      if (defaultLanguageFile == null) {
+        Sonar.get0().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) {
+        Sonar.get0().getLogger().error("Error copying file: {}", exception);
+        return DEFAULT_FALLBACK_LANGUAGE;
+      }
+    }
+
+    // Try to read the property from the file
+    try (final InputStream input = new FileInputStream(languageFile)) {
+      final Properties properties = new Properties();
+      properties.load(input);
+      final String property = properties.getProperty("language");
+      try {
+        // Try parsing the property as a language
+        return Language.fromCode(property);
+      } catch (Throwable throwable) {
+        Sonar.get0().getLogger().error("Could not find requested language: {}", throwable);
+        Sonar.get0().getLogger().error("You can view a full list of valid language codes here:");
+        Sonar.get0().getLogger().error("https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes");
+        Sonar.get0().getLogger().error("If a translation does not exist yet, Sonar will use English (en).");
+      }
+    } catch (IOException exception) {
+      Sonar.get0().getLogger().error("Error reading language file: {}", exception);
+    }
+    return DEFAULT_FALLBACK_LANGUAGE;
+  }
+
+  public void load() {
+    // Make sure the plugin folder actually exists before trying to copy files into it
+    if (!pluginFolder.exists() && !pluginFolder.mkdirs()) {
+      throw new IllegalStateException("Could not create plugin folder (insufficient permissions?)");
+    }
+
+    // Generate the language file and check what it's set to
+    language = getPreferredLanguage();
+    if (language == Language.SYSTEM) {
+      try {
+        // Try using the system language to determine the language file
+        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
+        Sonar.get0().getLogger().info("Using system language ({}) for translations.", language);
+      } catch (Exception exception) {
+        Sonar.get0().getLogger().warn("Could not use system language for translations.");
+        Sonar.get0().getLogger().warn("Using default language ({}) for translations.", language);
+      }
+    } else {
+      Sonar.get0().getLogger().info("Using custom language ({}) for translations.", language);
+    }
+
+    // Load all configurations
+    try {
+      generalConfig.load(getAsset("config", language));
+      messagesConfig.load(getAsset("messages", language));
+      webhookConfig.load(getAsset("webhook", language));
+    } catch (Exception exception) {
+      throw new IllegalStateException("Error loading configuration", exception);
+    }
+
+    // Load all values
+    loadValues();
+  }
+
+  public void loadValues() {
+    // Since we are loading from a file, we don't need to provide default values
+
+    // General settings
+    logPlayerAddresses = generalConfig.getBoolean("general.log-player-addresses");
+    maxOnlinePerIp = clamp(generalConfig.getInt("general.max-online-per-ip"), -1, 99);
+
+    // Attack tracker
+    minPlayersForAttack = clamp(generalConfig.getInt("attack-tracker.min-players-for-attack"), 2, 1024);
+    minAttackDuration = clamp(generalConfig.getInt("attack-tracker.min-attack-duration"), 1000, 900000);
+    minAttackThreshold = clamp(generalConfig.getInt("attack-tracker.min-attack-threshold"), 0, 20);
+    attackCooldownDelay = clamp(generalConfig.getInt("attack-tracker.attack-cooldown-delay"), 100, 30000);
+
+    // Database
+    database.type = Database.Type.valueOf(generalConfig.getString("database.type").toUpperCase());
+    database.maximumAge = clamp(generalConfig.getInt("database.maximum-age"), 1, 365);
+
+    // Queue
+    queue.maxQueuePolls = clamp(generalConfig.getInt("queue.max-polls"), 1, 1000);
+
+    // Verification
+    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) {
+      Sonar.get0().getLogger().warn(" ");
+      Sonar.get0().getLogger().warn("You have set the verification timing to 'NEVER'.");
+      Sonar.get0().getLogger().warn("Sonar will NOT perform the bot verification at all, therefore making it useless.");
+      Sonar.get0().getLogger().warn("It is highly suggested to set this option to either 'DURING_ATTACK' or 'ALWAYS'.");
+      Sonar.get0().getLogger().warn("Please only edit this option if you really know what you are doing.");
+      Sonar.get0().getLogger().warn(" ");
+    }
+
+    verification.gravity.timing = Verification.Timing.valueOf(generalConfig.getString("verification.checks.gravity.timing"));
+    verification.gravity.collisionTiming = Verification.Timing.valueOf(generalConfig.getString("verification.checks.collision.timing"));
+    verification.gravity.captchaOnFail = generalConfig.getBoolean("verification.checks.gravity.captcha-on-fail");
+    verification.gravity.maxMovementTicks = clamp(generalConfig.getInt("verification.checks.gravity.max-movement-ticks"), 2, 100);
+
+    verification.vehicle.timing = Verification.Timing.valueOf(generalConfig.getString("verification.checks.vehicle.timing"));
+    verification.vehicle.minimumPackets = clamp(generalConfig.getInt("verification.checks.vehicle.minimum-packets"), 0, 20);
+
+    verification.map.timing = Verification.Timing.valueOf(generalConfig.getString("verification.checks.map-captcha.timing"));
+    verification.map.precomputeAmount = clamp(generalConfig.getInt("verification.checks.map-captcha.precompute"), 10, 5000);
+    verification.map.maxDuration = clamp(generalConfig.getInt("verification.checks.map-captcha.max-duration"), 5000, 360000);
+    verification.map.maxTries = clamp(generalConfig.getInt("verification.checks.map-captcha.max-tries"), 1, 100);
+    verification.map.alphabet = generalConfig.getString("verification.checks.map-captcha.alphabet");
+    verification.map.backgroundImage = null;
+    verification.map.placeInOffhand = generalConfig.getBoolean("verification.checks.map-captcha.place-in-offhand");
+
+    final String backgroundPath = generalConfig.getString("verification.checks.map-captcha.background");
+    if (!backgroundPath.isEmpty()) {
+      final File backgroundFile = new File(pluginFolder, backgroundPath);
+      if (backgroundFile.exists()) {
+        verification.map.backgroundImage = backgroundFile;
+      } else {
+        Sonar.get0().getLogger().error("Could not find background image {}", backgroundFile.getAbsolutePath());
+      }
+    }
+
+    verification.brand.enabled = generalConfig.getBoolean("verification.checks.client-brand.enabled");
+    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.checkGeyser = generalConfig.getBoolean("verification.check-geyser-players");
+    verification.checkEagler = generalConfig.getBoolean("verification.check-eagler-players");
+    verification.logConnections = generalConfig.getBoolean("verification.log-connections");
+    verification.logDuringAttack = generalConfig.getBoolean("verification.log-during-attack");
+    verification.debugXYZPositions = generalConfig.getBoolean("verification.debug-xyz-positions");
+    verification.readTimeout = clamp(generalConfig.getInt("verification.read-timeout"), 1000, 30000);
+    verification.writeTimeout = clamp(generalConfig.getInt("verification.write-timeout"), 1000, 30000);
+    verification.maxPacketCount = clamp(generalConfig.getInt("verification.max-packets"), 200, 9999);
+    verification.reconnectDelay = clamp(generalConfig.getInt("verification.rejoin-delay"), 0, 100000);
+    verification.rememberTime = clamp(generalConfig.getInt("verification.remember-time"), 0, 86400000);
+    verification.blacklistTime = clamp(generalConfig.getInt("verification.blacklist-time"), 0, 86400000);
+    verification.blacklistThreshold = clamp(generalConfig.getInt("verification.blacklist-threshold"), 0, 100);
+    verification.blacklistedProtocols.clear();
+    verification.blacklistedProtocols.addAll(generalConfig.getIntList("verification.blacklisted-protocols"));
+
+    // Webhooks
+    webhook.url = webhookConfig.getString("webhook.url");
+    webhook.username = webhookConfig.getString("webhook.username");
+    webhook.avatarUrl = webhookConfig.getString("webhook.avatar-url");
+    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");
+    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()) {
+        throw new IllegalStateException("Webhook username cannot be empty");
+      }
+      webhook.discordWebhook = new DiscordWebhook(webhook.url);
+    } else if (webhook.discordWebhook != null) {
+      // Reset if Discord webhooks were disabled
+      webhook.discordWebhook = null;
+    }
+
+    // Messages
+    prefix = MiniMessage.miniMessage().deserialize(messagesConfig.getString("prefix"));
+
+    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")
+      .replace("jonesdev.xyz", "sonar.top") // Migration: Replace legacy URL
+      .trim();
+    if (supportUrl.contains("://sonar.top/")) {
+      Sonar.get0().getLogger().warn("Consider entering a custom support URL (if applicable).");
+    }
+    header = MiniMessage.miniMessage().deserialize(
+      String.join("<newline>", messagesConfig.getStringList("header")),
+      Placeholder.unparsed("support-url", supportUrl),
+      Placeholder.component("prefix", prefix));
+    footer = MiniMessage.miniMessage().deserialize(
+      String.join("<newline>", messagesConfig.getStringList("footer")),
+      Placeholder.unparsed("support-url", supportUrl),
+      Placeholder.component("prefix", prefix));
+
+    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");
+    verification.blacklisted = deserializeDisconnectMessage("verification.blacklisted");
+    verification.invalidUsername = deserializeDisconnectMessage("verification.invalid-username");
+    verification.protocolBlacklisted = deserializeDisconnectMessage("verification.blacklisted-protocol");
+    verification.verificationSuccess = deserializeDisconnectMessage("verification.success");
+    verification.verificationFailed = deserializeDisconnectMessage("verification.failed");
+
+    verboseAnimation = Collections.unmodifiableList(messagesConfig.getStringList("verbose.animation"));
+  }
+
+  private @NotNull Component deserializeDisconnectMessage(final String path) {
+    return MiniMessage.miniMessage().deserialize(
+      String.join("<newline>", messagesConfig.getStringList(path)),
+      Placeholder.component("prefix", prefix),
+      Placeholder.component("header", header),
+      Placeholder.component("footer", footer),
+      Placeholder.unparsed("support-url", supportUrl));
+  }
+
+  private @NotNull URL getAsset(final String url, final @NotNull Language language) {
+    final String resourceName = url + "/" + language.getCode() + ".yml";
+    URL result = Sonar.class.getResource("/assets/" + resourceName);
+    if (result == null) {
+      Sonar.get0().getLogger().warn("Could not find " + resourceName + "! Using en.yml!");
+      result = Objects.requireNonNull(Sonar.class.getResource("/assets/" + url + "/en.yml"));
+    }
+    return result;
+  }
+
+  private static int clamp(final int v, final int max, final int min) {
+    final int output = Math.max(Math.min(v, min), max);
+    if (output != v) {
+      Sonar.get0().getLogger().warn("Clamped configuration value {} to {}", v, output);
+    }
+    return output;
+  }
+
+  public @NotNull String formatAddress(final @NotNull InetAddress inetAddress) {
+    return logPlayerAddresses ? inetAddress.getHostAddress() : "<ip address withheld>";
+  }
+
+  @Getter
+  private final Queue queue = new Queue();
+  @Getter
+  private final Verification verification = new Verification();
+  @Getter
+  private final Database database = new Database();
+  @Getter
+  private final Webhook webhook = new Webhook();
+
+  @Getter
+  private Component prefix;
+  private String supportUrl;
+  private Component header;
+  private Component footer;
+  @Getter
+  private Component noPermission;
+  private boolean logPlayerAddresses;
+  @Getter
+  private int maxOnlinePerIp;
+  @Getter
+  private int minPlayersForAttack;
+  @Getter
+  private int minAttackDuration;
+  @Getter
+  private int minAttackThreshold;
+  @Getter
+  private int attackCooldownDelay;
+  @Getter
+  private Component tooManyOnlinePerIp;
+  @Getter
+  private List<String> verboseAnimation;
+
+  @Getter
+  @NoArgsConstructor(access = AccessLevel.PRIVATE)
+  public static final class Queue {
+    private int maxQueuePolls;
+  }
+
+  @Getter
+  @NoArgsConstructor(access = AccessLevel.PRIVATE)
+  public static final class Verification {
+    private Timing timing;
+
+    @Getter
+    @RequiredArgsConstructor
+    public enum Timing {
+      ALWAYS("Always"),
+      DURING_ATTACK("During Attack"),
+      NEVER("Never");
+
+      private final String displayName;
+    }
+
+    private final Map map = new Map();
+    private final Gravity gravity = new Gravity();
+    private final Vehicle vehicle = new Vehicle();
+    private final Brand brand = new Brand();
+
+    @Getter
+    public static final class Map {
+      private Timing timing;
+      private int precomputeAmount;
+      private int maxDuration;
+      private int maxTries;
+      private String alphabet;
+      private File backgroundImage;
+      private boolean placeInOffhand;
+    }
+
+    @Getter
+    public static final class Gravity {
+      private Timing timing;
+      private Timing collisionTiming;
+      private boolean captchaOnFail;
+      private int maxMovementTicks;
+    }
+
+    @Getter
+    public static final class Vehicle {
+      private Timing timing;
+      private int minimumPackets;
+    }
+
+    @Getter
+    public static final class Brand {
+      private boolean enabled;
+      private int maxLength;
+      private Pattern validRegex;
+    }
+
+    private Gamemode gamemode;
+
+    @Getter
+    @RequiredArgsConstructor
+    public enum Gamemode {
+      NOT_SET(-1),
+      SURVIVAL(0),
+      CREATIVE(1),
+      ADVENTURE(2);
+
+      private final int id;
+
+      public boolean isSurvivalOrAdventure() {
+        return this == SURVIVAL || this == ADVENTURE;
+      }
+    }
+
+    private int timeOfDay;
+    private boolean checkGeyser;
+    private boolean checkEagler;
+    private boolean logConnections;
+    private boolean logDuringAttack;
+    private boolean debugXYZPositions;
+    private Pattern validNameRegex;
+
+    private int readTimeout;
+    private int writeTimeout;
+    private int maxPacketCount;
+    private int reconnectDelay;
+    private int rememberTime;
+    private int blacklistTime;
+    private int blacklistThreshold;
+    private final Collection<Integer> blacklistedProtocols = new HashSet<>(0);
+
+    private Component tooFastReconnect;
+    private Component invalidUsername;
+    private Component verificationSuccess;
+    private Component verificationFailed;
+    private Component alreadyVerifying;
+    private Component alreadyQueued;
+    private Component blacklisted;
+    private Component protocolBlacklisted;
+    private Component currentlyPreparing;
+    private Component unsupportedVersion;
+  }
+
+  @Getter
+  @NoArgsConstructor(access = AccessLevel.PRIVATE)
+  public static final class Database {
+
+    @Getter
+    @RequiredArgsConstructor
+    public enum Type {
+      MYSQL("MySQL", "jdbc:mysql://%s:%d/%s%s", new MysqlDatabaseTypeAdapter(),
+        Library.builder()
+          .groupId("com{}mysql")
+          .artifactId("mysql-connector-j")
+          .version("9.0.0")
+          .relocate("com{}mysql", "xyz{}jonesdev{}sonar{}libs{}mysql")
+          .build()),
+      MARIADB("MariaDB", "jdbc:mariadb://%s:%d/%s%s", new MariaDbDatabaseTypeAdapter(),
+        Library.builder()
+          .groupId("org{}mariadb{}jdbc")
+          .artifactId("mariadb-java-client")
+          .version("3.4.1")
+          .relocate("org{}mariadb", "xyz{}jonesdev{}sonar{}libs{}mariadb")
+          .build()),
+      H2("H2", "jdbc:h2:file:%s", new H2DatabaseTypeAdapter(),
+        Library.builder()
+          .groupId("com{}h2database")
+          .artifactId("h2")
+          .version("2.2.220")
+          .relocate("org{}h2", "xyz{}jonesdev{}sonar{}libs{}h2")
+          .build()),
+      POSTGRESQL("PostgreSQL", "jdbc:postgresql://%s:%d/%s%s", new PostgresDatabaseTypeAdapter(),
+        Library.builder()
+          .groupId("org{}postgresql")
+          .artifactId("postgresql")
+          .version("42.7.8")
+          .relocate("org{}postgresql", "xyz{}jonesdev{}sonar{}libs{}postgresql")
+          .build()),
+      NONE("None", null, null, null);
+
+      private final String displayName;
+      private final String connectionString;
+      private final DatabaseType databaseType;
+      private final Library databaseDriver;
+      @Setter
+      private boolean loaded;
+    }
+
+    private Type type;
+    private int maximumAge;
+  }
+
+  @Getter
+  @NoArgsConstructor(access = AccessLevel.PRIVATE)
+  public static final class Webhook {
+    private String url;
+    private String username;
+    private String avatarUrl;
+    private String content;
+
+    private final Footer footer = new Footer();
+
+    @Getter
+    @NoArgsConstructor(access = AccessLevel.PRIVATE)
+    public static final class Footer {
+      private String text;
+      private String iconUrl;
+    }
+
+    private final Embed embed = new Embed();
+
+    @Getter
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static final class Embed {
+      private String title;
+      private String titleUrl;
+      @Setter
+      private String description;
+      private int r, g, b;
+    }
+
+    @Getter
+    private @Nullable DiscordWebhook discordWebhook;
+  }
+}
@@ -0,0 +1,258 @@
+/*
+ * 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.jdbc.JdbcPooledConnectionSource;
+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();
+  @Getter
+  private int maximumAge;
+
+  public VerifiedPlayerController(final @NotNull LibraryManager libraryManager) {
+    final SonarConfiguration.Database database = Sonar.get0().getConfig().getDatabase();
+    cachedDatabaseType = database.getType();
+
+    if (cachedDatabaseType == SonarConfiguration.Database.Type.NONE) {
+      Sonar.get0().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.get0().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.get0().getConfig().getPluginFolder(),
+          Sonar.get0().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.get0().getConfig().getGeneralConfig().getString("database.host"),
+          Sonar.get0().getConfig().getGeneralConfig().getInt("database.port"),
+          Sonar.get0().getConfig().getGeneralConfig().getString("database.name"),
+          "?autoReconnect=true");
+      }
+
+      final String user = Sonar.get0().getConfig().getGeneralConfig().getString("database.username");
+      final String pass = Sonar.get0().getConfig().getGeneralConfig().getString("database.password");
+      connectionSource = cachedDatabaseType == SonarConfiguration.Database.Type.H2
+        ? new JdbcConnectionSource(jdbcURL, user, pass, cachedDatabaseType.getDatabaseType())
+        : new JdbcPooledConnectionSource(jdbcURL, user, pass, 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();
+      maximumAge = database.getMaximumAge();
+
+      // 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(maximumAge, false);
+            // 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) {
+      // Shut down the update service before letting it re-use the connection.
+      updateService.shutdown();
+      try {
+        connectionSource.close();
+      } catch (Exception exception) {
+        exception.printStackTrace(System.err);
+      }
+      // Make sure not to reuse a closed connection
+      connectionSource = null;
+    }
+  }
+
+  /**
+   * Clear all old entries using the given timestamp
+   */
+  public void clearOld(final @Range(from = 1, to = 365) int maximumAge,
+                       final boolean removeExisting) 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);
+        if (removeExisting) {
+          cache.remove(player.getFingerprint());
+        }
+      }
+      Sonar.get0().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);
+      }
+    }
+  }
+}
@@ -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
@@ -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;
@@ -23,34 +23,25 @@ import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.ToString;
+import org.jetbrains.annotations.NotNull;

 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",
@@ -58,9 +49,9 @@ public final class VerifiedPlayer {
  )
  private Timestamp timestamp;

-  public VerifiedPlayer(final String inetAddress, final UUID playerUUID, final long timestamp) {
-    this.inetAddress = inetAddress;
-    this.playerUUID = playerUUID;
+  public VerifiedPlayer(final @NotNull String fingerprint,
+                        final long timestamp) {
+    this.fingerprint = fingerprint;
    this.timestamp = new Timestamp(timestamp);
  }
 }
@@ -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
@@ -15,18 +15,17 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.api.command;
+package xyz.jonesdev.sonar.api.database.ormlite;

-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import lombok.ToString;
-import xyz.jonesdev.sonar.api.command.subcommand.Subcommand;
+import com.j256.ormlite.jdbc.db.H2DatabaseType;
+import org.jetbrains.annotations.NotNull;

-@Getter
-@RequiredArgsConstructor
-@ToString(of = "rawArguments")
-public final class CommandInvocation {
-  private final InvocationSource sender;
-  private final Subcommand subcommand;
-  private final String[] rawArguments;
+public final class H2DatabaseTypeAdapter extends H2DatabaseType {
+
+  // We need to override the default driver class name
+  // to use the custom relocated H2 driver
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+    return new String[]{"xyz.jonesdev.sonar.libs.h2.Driver"};
+  }
 }
@@ -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.database.ormlite;
+
+import com.j256.ormlite.jdbc.db.MariaDbDatabaseType;
+import org.jetbrains.annotations.NotNull;
+
+public final class MariaDbDatabaseTypeAdapter extends MariaDbDatabaseType {
+
+  // We need to override the default driver class name
+  // to use the custom relocated MariaDB driver
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+    return new String[]{"xyz.jonesdev.sonar.libs.mariadb.jdbc.Driver"};
+  }
+}
@@ -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.database.ormlite;
+
+import com.j256.ormlite.jdbc.db.MysqlDatabaseType;
+import org.jetbrains.annotations.NotNull;
+
+public final class MysqlDatabaseTypeAdapter extends MysqlDatabaseType {
+
+  // We need to override the default driver class name
+  // to use the custom relocated MySQL driver
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+    return new String[]{"xyz.jonesdev.sonar.libs.mysql.cj.jdbc.Driver"};
+  }
+}
@@ -0,0 +1,14 @@
+package xyz.jonesdev.sonar.api.database.ormlite;
+
+import com.j256.ormlite.jdbc.db.PostgresDatabaseType;
+import org.jetbrains.annotations.NotNull;
+
+public final class PostgresDatabaseTypeAdapter extends PostgresDatabaseType {
+
+  // We need to override the default driver class name
+  // to use the custom relocated Postgres driver
+  @Override
+  protected String @NotNull [] getDriverClassNames() {
+     return new String[]{"xyz.jonesdev.sonar.libs.postgresql.Driver"};
+  }
+}
@@ -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
@@ -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,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);
 }
@@ -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
@@ -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;
    }
@@ -50,7 +47,7 @@ public final class SonarEventManager {
        try {
          eventListener.handle(event);
        } catch (Throwable throwable) {
-          Sonar.get().getLogger().error("Could not pass {} to listener: {}",
+          Sonar.get0().getLogger().error("Could not pass {} to listener: {}",
            event.getClass().getSimpleName(), throwable);
        }
      }
@@ -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));
+    }
  }
 }
@@ -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
@@ -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,16 +17,14 @@

 package xyz.jonesdev.sonar.api.event.impl;

-import lombok.EqualsAndHashCode;
 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
-@EqualsAndHashCode
@RequiredArgsConstructor
 public final class AttackMitigatedEvent implements SonarEvent {
  private final AttackTracker.AttackStatistics attackStatistics;
@@ -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
@@ -15,18 +15,18 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.common.fallback.protocol.dimension;
+package xyz.jonesdev.sonar.api.event.impl;

 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
-import net.kyori.adventure.nbt.CompoundBinaryTag;
+import xyz.jonesdev.sonar.api.event.SonarEvent;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;

@Getter
@ToString
@RequiredArgsConstructor
-public final class DimensionInfo {
-  private final String identifier;
-  private final int id;
-  private final CompoundBinaryTag tag;
+public final class CaptchaGenerationEndEvent implements SonarEvent {
+  private final SystemTimer timer;
+  private final int amountGenerated;
 }
@@ -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.antibot.captcha.CaptchaGenerator;
+import xyz.jonesdev.sonar.api.event.SonarEvent;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public final class CaptchaGenerationStartEvent implements SonarEvent {
+  private CaptchaGenerator captchaGenerator;
+}
@@ -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,19 +17,15 @@

 package xyz.jonesdev.sonar.api.event.impl;

-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
-import org.jetbrains.annotations.ApiStatus;
+import xyz.jonesdev.sonar.api.antibot.SonarUser;
 import xyz.jonesdev.sonar.api.event.SonarEvent;
-import xyz.jonesdev.sonar.api.fallback.FallbackUser;

@Getter
@ToString
-@EqualsAndHashCode
@RequiredArgsConstructor
 public final class UserBlacklistedEvent implements SonarEvent {
-  @ApiStatus.Experimental
-  private final FallbackUser user;
+  private final SonarUser user;
 }
@@ -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
@@ -15,16 +15,19 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.common.fallback.protocol.block;
+package xyz.jonesdev.sonar.api.event.impl;

 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.antibot.SonarUser;
+import xyz.jonesdev.sonar.api.event.SonarEvent;

@Getter
@ToString
@RequiredArgsConstructor
-public final class BlockPosition {
-  private final int x, y, z;
-  private final int chunkX, chunkZ;
+public final class UserVerifyFailedEvent implements SonarEvent {
+  private final @NotNull SonarUser user;
+  private final @NotNull String reason;
 }
@@ -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,18 +17,15 @@

 package xyz.jonesdev.sonar.api.event.impl;

-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
+import xyz.jonesdev.sonar.api.antibot.SonarUser;
 import xyz.jonesdev.sonar.api.event.SonarEvent;
-import xyz.jonesdev.sonar.api.fallback.FallbackUser;

@Getter
@ToString
-@EqualsAndHashCode
@RequiredArgsConstructor
 public final class UserVerifyJoinEvent implements SonarEvent {
-  private final String username;
-  private final FallbackUser user;
+  private final SonarUser user;
 }
@@ -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,22 +17,15 @@

 package xyz.jonesdev.sonar.api.event.impl;

-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.ToString;
+import xyz.jonesdev.sonar.api.antibot.SonarUser;
 import xyz.jonesdev.sonar.api.event.SonarEvent;
-import xyz.jonesdev.sonar.api.fallback.FallbackUser;
-
-import java.util.UUID;

@Getter
@ToString
-@EqualsAndHashCode
@RequiredArgsConstructor
 public final class UserVerifySuccessEvent implements SonarEvent {
-  private final String username;
-  private final UUID offlineUuid;
-  private final FallbackUser user;
-  private final long timeTakenToVerify;
+  private final SonarUser user;
 }
@@ -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
@@ -15,19 +15,24 @@
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package xyz.jonesdev.sonar.bungee.command;
+package xyz.jonesdev.sonar.api.fingerprint;

-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
+import lombok.experimental.UtilityClass;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.command.InvocationSource;
-import xyz.jonesdev.sonar.bungee.SonarBungee;

-public final class BungeeInvocationSource extends InvocationSource {
-  public BungeeInvocationSource(final @NotNull CommandSender sender) {
-    super(sender.getName(),
-      SonarBungee.INSTANCE.getBungeeAudiences().sender(sender),
-      sender instanceof ProxiedPlayer,
-      sender::hasPermission);
+@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);
  }
 }
@@ -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
@@ -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();
@@ -0,0 +1,92 @@
+/*
+ * 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.notification;
+
+import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
+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.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.profiler.SimpleProcessProfiler.*;
+import static xyz.jonesdev.sonar.api.timer.SystemTimer.DATE_FORMATTER;
+
+@Getter
+public class ActionBarNotificationHandler extends NotificationHandler {
+  protected int animationIndex;
+
+  @Override
+  public void handleNotification() {
+    // Don't prepare component if there are no subscribers
+    if (subscribers.isEmpty()) {
+      return;
+    }
+
+    // Prepare the action bar verbose
+    final AttackTracker.AttackStatistics attackStatistics = Sonar.get0().getAttackTracker().getCurrentAttack();
+    final SystemTimer attackTimer = attackStatistics == null ? null : attackStatistics.getDuration();
+    final String attackDuration = attackTimer == null ? "00:00" : DATE_FORMATTER.format(attackTimer.delay());
+
+    final Component actionBarComponent = MiniMessage.miniMessage().deserialize(attackTimer == null
+        ? Sonar.get0().getConfig().getMessagesConfig().getString("verbose.layout.normal")
+        : Sonar.get0().getConfig().getMessagesConfig().getString("verbose.layout.attack"),
+      Placeholder.component("prefix", Sonar.get0().getConfig().getPrefix()),
+      Placeholder.unparsed("attack-duration", attackDuration),
+      Placeholder.unparsed("animation", nextAnimation()),
+      Placeholder.unparsed("process-cpu", Sonar.DECIMAL_FORMAT.format(getProcessCPUUsage())),
+      Placeholder.unparsed("system-cpu", Sonar.DECIMAL_FORMAT.format(getSystemCPUUsage())),
+      Placeholder.unparsed("queued", DECIMAL_FORMAT.format(Sonar.get0().getAntiBot().getQueue().getPlayers().size())),
+      Placeholder.unparsed("verifying", DECIMAL_FORMAT.format(Sonar.get0().getAntiBot().getConnected().size())),
+      Placeholder.unparsed("blacklisted", DECIMAL_FORMAT.format(Sonar.get0().getAntiBot().getBlacklist().estimatedSize())),
+      Placeholder.unparsed("total-joins", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getTotalPlayersJoined())),
+      Placeholder.unparsed("logins-per-second", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getLoginsPerSecond())),
+      Placeholder.unparsed("connections-per-second", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getConnectionsPerSecond())),
+      Placeholder.unparsed("verify-total", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getTotalAttemptedVerifications())),
+      Placeholder.unparsed("verify-success", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getTotalSuccessfulVerifications())),
+      Placeholder.unparsed("verify-failed", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getTotalFailedVerifications())),
+      Placeholder.unparsed("incoming-traffic", Sonar.get0().getStatistics().getPerSecondIncomingBandwidthFormatted()),
+      Placeholder.unparsed("outgoing-traffic", Sonar.get0().getStatistics().getPerSecondOutgoingBandwidthFormatted()),
+      Placeholder.unparsed("incoming-traffic-ttl", formatMemory(Sonar.get0().getStatistics().getTotalIncomingBandwidth())),
+      Placeholder.unparsed("outgoing-traffic-ttl", formatMemory(Sonar.get0().getStatistics().getTotalOutgoingBandwidth())),
+      Placeholder.unparsed("used-memory", formatMemory(getUsedMemory())),
+      Placeholder.unparsed("free-memory", formatMemory(getFreeMemory())),
+      Placeholder.unparsed("total-memory", formatMemory(getTotalMemory())),
+      Placeholder.unparsed("max-memory", formatMemory(getMaxMemory())));
+
+    // Send the action bar to all online players
+    for (final UUID subscriber : subscribers) {
+      final Audience audience = Sonar.get0().audience(subscriber);
+      if (audience == null) continue;
+
+      // Send the action bar to all online subscribers
+      audience.sendActionBar(actionBarComponent);
+    }
+  }
+
+  public String nextAnimation() {
+    final var animations = Sonar.get0().getConfig().getVerboseAnimation();
+    final int nextIndex = ++animationIndex % animations.size();
+    return animations.toArray(new String[0])[nextIndex];
+  }
+}
@@ -0,0 +1,89 @@
+/*
+ * 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.notification;
+
+import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.title.Title;
+import xyz.jonesdev.sonar.api.Sonar;
+
+import java.util.List;
+import java.util.UUID;
+
+import static xyz.jonesdev.sonar.api.Sonar.DECIMAL_FORMAT;
+import static xyz.jonesdev.sonar.api.profiler.SimpleProcessProfiler.*;
+
+@Getter
+public final class ChatNotificationHandler extends NotificationHandler {
+
+  @Override
+  public void handleNotification() {
+    // Don't prepare component if there are no subscribers
+    if (subscribers.isEmpty()) {
+      return;
+    }
+
+    // Prepare the chat notification
+    final Component notificationTitle = MiniMessage.miniMessage().deserialize(
+      Sonar.get0().getConfig().getMessagesConfig().getString("notifications.title"));
+    final Component notificationSubtitle = MiniMessage.miniMessage().deserialize(
+      Sonar.get0().getConfig().getMessagesConfig().getString("notifications.subtitle"));
+    final Title title = Title.title(notificationTitle, notificationSubtitle);
+
+    final List<String> chatNotification = Sonar.get0().getConfig().getMessagesConfig().getStringList("notifications.chat");
+    final Component[] chatNotificationComponents = new Component[chatNotification.size()];
+
+    for (int i = 0; i < chatNotificationComponents.length; i++) {
+      chatNotificationComponents[i] = MiniMessage.miniMessage().deserialize(chatNotification.get(i),
+        Placeholder.component("prefix", Sonar.get0().getConfig().getPrefix()),
+        Placeholder.unparsed("queued", DECIMAL_FORMAT.format(Sonar.get0().getAntiBot().getQueue().getPlayers().size())),
+        Placeholder.unparsed("verifying", DECIMAL_FORMAT.format(Sonar.get0().getAntiBot().getConnected().size())),
+        Placeholder.unparsed("blacklisted", DECIMAL_FORMAT.format(Sonar.get0().getAntiBot().getBlacklist().estimatedSize())),
+        Placeholder.unparsed("total-joins", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getTotalPlayersJoined())),
+        Placeholder.unparsed("logins-per-second", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getLoginsPerSecond())),
+        Placeholder.unparsed("connections-per-second", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getConnectionsPerSecond())),
+        Placeholder.unparsed("verify-total", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getTotalAttemptedVerifications())),
+        Placeholder.unparsed("verify-success", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getTotalSuccessfulVerifications())),
+        Placeholder.unparsed("verify-failed", DECIMAL_FORMAT.format(Sonar.get0().getStatistics().getTotalFailedVerifications())),
+        Placeholder.unparsed("incoming-traffic", Sonar.get0().getStatistics().getPerSecondIncomingBandwidthFormatted()),
+        Placeholder.unparsed("outgoing-traffic", Sonar.get0().getStatistics().getPerSecondOutgoingBandwidthFormatted()),
+        Placeholder.unparsed("incoming-traffic-ttl", formatMemory(Sonar.get0().getStatistics().getTotalIncomingBandwidth())),
+        Placeholder.unparsed("outgoing-traffic-ttl", formatMemory(Sonar.get0().getStatistics().getTotalOutgoingBandwidth())),
+        Placeholder.unparsed("used-memory", formatMemory(getUsedMemory())),
+        Placeholder.unparsed("free-memory", formatMemory(getFreeMemory())),
+        Placeholder.unparsed("total-memory", formatMemory(getTotalMemory())),
+        Placeholder.unparsed("max-memory", formatMemory(getMaxMemory())));
+    }
+
+    // Send the title and chat messages to all online players
+    for (final UUID subscriber : Sonar.get0().getChatNotificationHandler().getSubscribers()) {
+      final Audience audience = Sonar.get0().audience(subscriber);
+      if (audience == null) continue;
+
+      // Send the message to all online subscribers
+      for (Component component : chatNotificationComponents) {
+        audience.sendMessage(component);
+      }
+      // Send the title to all online subscribers
+      audience.showTitle(title);
+    }
+  }
+}
@@ -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,34 +15,40 @@
 * 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;

 import java.util.Collection;
+import java.util.UUID;
+import java.util.Vector;

-public interface Observable {
-  Collection<String> getSubscribers();
+@Getter
+public abstract class NotificationHandler {
+  protected final @NotNull Collection<UUID> subscribers = new Vector<>(0);
+
+  public abstract void handleNotification();

  /**
-   * @param name Name of the audience
+   * @param uuid UUID of the player
   * @return Whether the audience is subscribed or not
   */
-  default boolean isSubscribed(final @NotNull String name) {
-    return getSubscribers().contains(name);
+  public final boolean isSubscribed(final @NotNull UUID uuid) {
+    return getSubscribers().contains(uuid);
  }

  /**
-   * @param name Name of the audience to subscribe
+   * @param uuid UUID of the player
   */
-  default void subscribe(final String name) {
-    getSubscribers().add(name);
+  public final void subscribe(final UUID uuid) {
+    getSubscribers().add(uuid);
  }

  /**
-   * @param name Name of the audience to unsubscribe
+   * @param uuid UUID of the player
   */
-  default void unsubscribe(final String name) {
-    getSubscribers().remove(name);
+  public final void unsubscribe(final UUID uuid) {
+    getSubscribers().remove(uuid);
  }
 }
@@ -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
@@ -15,65 +15,92 @@
 * 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;

 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'};
+  private final char[] MEMORY_UNITS = {'K', 'M', 'G', 'T', 'P', 'E'};
+  private final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("#.#");

  public String formatMemory(final long size) {
    if (size < 1024L) {
      return size + " B";
    }
+    // https://stackoverflow.com/questions/3758606/how-can-i-convert-byte-size-into-a-human-readable-format-in-java
    final int group = (63 - Long.numberOfLeadingZeros(size)) / 10;
    final double formattedSize = (double) size / (1L << (group * 10));
    final char unit = MEMORY_UNITS[group - 1];
-    return String.format("%.1f %sB", formattedSize, unit);
+    // https://en.wikipedia.org/wiki/Byte#Multiple-byte_units
+    return DECIMAL_FORMAT.format(formattedSize) + " " + unit + "iB";
  }

+  /**
+   * @return Number of available processors for the JVM
+   */
  public int getVirtualCores() {
    return RUNTIME.availableProcessors();
  }

+  /**
+   * @return Current process CPU usage in percent
+   */
  public double getProcessCPUUsage() {
    return MX.getProcessCpuLoad() * 100;
  }

+  /**
+   * @return Current per-core process CPU usage in percent
+   */
  public double getAverageProcessCPUUsage() {
    return getProcessCPUUsage() / getVirtualCores();
  }

+  /**
+   * @return Current system CPU usage in percent
+   */
  public double getSystemCPUUsage() {
    return MX.getSystemCpuLoad() * 100;
  }

+  /**
+   * @return Current per-core system CPU usage in percent
+   */
  public double getAverageSystemCPUUsage() {
    return getSystemCPUUsage() / getVirtualCores();
  }

-  public double getSystemLoadAverage() {
-    return MX.getSystemLoadAverage() * 100;
-  }
-
+  /**
+   * @return Memory (in bytes) the JVM will attempt to use
+   */
  public long getMaxMemory() {
    return RUNTIME.maxMemory();
  }

+  /**
+   * @return Memory (in bytes) available to the host machine
+   */
  public long getTotalMemory() {
    return RUNTIME.totalMemory();
  }

+  /**
+   * @return Memory (in bytes) the JVM can allocate
+   */
  public long getFreeMemory() {
    return RUNTIME.freeMemory();
  }

+  /**
+   * @return Memory (in bytes) the JVM is using
+   */
  public long getUsedMemory() {
    return getTotalMemory() - getFreeMemory();
  }
@@ -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,8 +17,7 @@

 package xyz.jonesdev.sonar.api.statistics;

-import org.jetbrains.annotations.ApiStatus;
-
+@SuppressWarnings("unused")
 public interface SonarStatistics {
  long getConnectionsPerSecond();

@@ -32,13 +31,9 @@ public interface SonarStatistics {

  long getTotalOutgoingBandwidth();

-  String getCurrentIncomingBandwidthFormatted();
+  String getPerSecondIncomingBandwidthFormatted();

-  String getCurrentOutgoingBandwidthFormatted();
-
-  String getTotalIncomingBandwidthFormatted();
-
-  String getTotalOutgoingBandwidthFormatted();
+  String getPerSecondOutgoingBandwidthFormatted();

  int getTotalPlayersJoined();

@@ -55,7 +50,4 @@ public interface SonarStatistics {
  long getCurrentBlacklistSize();

  long getTotalBlacklistSize();
-
-  @ApiStatus.Internal
-  void cleanUpCache();
 }
@@ -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
@@ -18,13 +18,12 @@
 package xyz.jonesdev.sonar.api.timer;

 import lombok.Getter;
-import org.jetbrains.annotations.NotNull;

 import java.text.SimpleDateFormat;

@Getter
 public final class SystemTimer {
-  private static final SimpleDateFormat FORMATTER = new SimpleDateFormat("mm:ss");
+  public static final SimpleDateFormat DATE_FORMATTER = new SimpleDateFormat("mm:ss");

  private long start = System.currentTimeMillis();

@@ -32,18 +31,20 @@ public final class SystemTimer {
    start = System.currentTimeMillis();
  }

+  /**
+   * @return Time between the current timestamp and the start timestamp
+   */
  public long delay() {
    return System.currentTimeMillis() - start;
  }

+  /**
+   * @apiNote Read more: {@link SystemTimer#delay}
+   */
  public boolean elapsed(final long amount) {
    return delay() >= amount;
  }

-  public @NotNull String formattedDelay() {
-    return FORMATTER.format(delay());
-  }
-
  @Override
  public String toString() {
    return String.format("%.3f", delay() / 1000D);
@@ -0,0 +1,153 @@
+/*
+ * 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.tracker;
+
+import lombok.*;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.config.SonarConfiguration;
+import xyz.jonesdev.sonar.api.event.impl.AttackDetectedEvent;
+import xyz.jonesdev.sonar.api.event.impl.AttackMitigatedEvent;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+
+import java.util.Optional;
+
+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;
+
+  @Getter
+  @ToString
+  @RequiredArgsConstructor
+  public static final class AttackStatistics {
+    private final SystemTimer duration = new SystemTimer();
+    private final SystemTimer timer = new SystemTimer();
+    private long peakJoinsPerSecond;
+    private long peakConnectionsPerSecond;
+    private double peakProcessCPUUsage;
+    private long peakProcessMemoryUsage;
+    // Calculate during-attack-statistics using their deltas
+    private int successfulVerifications, failedVerifications;
+  }
+
+  public void checkIfUnderAttack() {
+    final long joinsPerSecond = Sonar.get0().getStatistics().getLoginsPerSecond();
+    final int verifyingPlayers = Sonar.get0().getAntiBot().getConnected().size();
+    final int queuedPlayers = Sonar.get0().getAntiBot().getQueue().getPlayers().size();
+    final int minPlayers = Sonar.get0().getConfig().getMinPlayersForAttack();
+
+    if (joinsPerSecond > minPlayers // Check the number of bots/joins per second.
+      || verifyingPlayers > minPlayers // Check the number of verifying players.
+      || queuedPlayers > minPlayers) { // Check the number of queued players.
+      // Increment attack threshold
+      ++attackThreshold;
+
+      // An attack has been detected
+      if (currentAttack == null) {
+        currentAttack = new AttackStatistics();
+        currentAttack.successfulVerifications = Sonar.get0().getVerifiedPlayerController().getCache().size();
+        currentAttack.failedVerifications = Sonar.get0().getStatistics().getTotalFailedVerifications();
+        Sonar.get0().getEventManager().publish(new AttackDetectedEvent());
+        Sonar.get0().getChatNotificationHandler().handleNotification();
+      } else {
+        // Reset attack timer if we're still under attack
+        currentAttack.timer.reset();
+      }
+
+      // Update attack statistics
+      if (joinsPerSecond > currentAttack.peakJoinsPerSecond) {
+        // Update joins per second peak if necessary
+        currentAttack.peakJoinsPerSecond = joinsPerSecond;
+      }
+      final long connectionsPerSecond = Sonar.get0().getStatistics().getConnectionsPerSecond();
+      if (connectionsPerSecond > currentAttack.peakConnectionsPerSecond) {
+        // Update connections per second peak if necessary
+        currentAttack.peakConnectionsPerSecond = connectionsPerSecond;
+      }
+      final double processCPUUsage = getProcessCPUUsage();
+      if (processCPUUsage > currentAttack.peakProcessCPUUsage) {
+        // Update cpu usage peak if necessary
+        currentAttack.peakProcessCPUUsage = processCPUUsage;
+      }
+      final long processMemoryUsage = getUsedMemory();
+      if (processMemoryUsage > currentAttack.peakProcessMemoryUsage) {
+        // Update memory consumption peak if necessary
+        currentAttack.peakProcessMemoryUsage = processMemoryUsage;
+      }
+    } else if (currentAttack != null) {
+      if (currentAttack.duration.delay() > Sonar.get0().getConfig().getMinAttackDuration()
+        && currentAttack.timer.delay() > Sonar.get0().getConfig().getAttackCooldownDelay()) {
+        // The current attack has stopped
+        Sonar.get0().getEventManager().publish(new AttackMitigatedEvent(currentAttack));
+
+        if (++attackThreshold > Sonar.get0().getConfig().getMinAttackThreshold()) {
+          // Post webhook to Discord
+          Optional.ofNullable(Sonar.get0().getConfig().getWebhook().getDiscordWebhook())
+            .ifPresent(webhook -> {
+              // Save attack statistics
+              final long deltaInMillis = currentAttack.duration.delay();
+              final String peakCPU = Sonar.DECIMAL_FORMAT.format(currentAttack.peakProcessCPUUsage);
+              final String peakMem = formatMemory(currentAttack.peakProcessMemoryUsage);
+              final String peakBPS = Sonar.DECIMAL_FORMAT.format(currentAttack.peakJoinsPerSecond);
+              final String peakCPS = Sonar.DECIMAL_FORMAT.format(currentAttack.peakConnectionsPerSecond);
+              final long minutes = deltaInMillis / (60 * 1000); // Convert milliseconds to minutes
+              final double seconds = (deltaInMillis % (60 * 1000)) / 1000D; // Convert remaining milliseconds to seconds
+              final String formattedDuration = String.format("%d minutes, %.0f seconds", minutes, seconds);
+              final String startTimestamp = String.valueOf(currentAttack.duration.getStart() / 1000L);
+              final String endTimestamp = String.valueOf(System.currentTimeMillis() / 1000L);
+              final long blacklisted = Sonar.get0().getAntiBot().getBlacklist().estimatedSize();
+              // Calculate during-attack-statistics using their deltas
+              final long totalVerified = Sonar.get0().getVerifiedPlayerController().getCache().size();
+              final long verified = Math.max(totalVerified - currentAttack.successfulVerifications, 0);
+              final long totalFailed = Sonar.get0().getStatistics().getTotalFailedVerifications();
+              final long failed = Math.max(totalFailed - currentAttack.failedVerifications, 0);
+
+              webhook.post(() -> {
+                final SonarConfiguration.Webhook.Embed config = Sonar.get0().getConfig().getWebhook().getEmbed();
+                final String description = config.getDescription()
+                  .replace("<start-timestamp>", startTimestamp)
+                  .replace("<end-timestamp>", endTimestamp)
+                  .replace("<attack-duration>", formattedDuration)
+                  .replace("<peak-cpu>", peakCPU)
+                  .replace("<peak-memory>", peakMem)
+                  .replace("<peak-bps>", peakBPS)
+                  .replace("<peak-cps>", peakCPS)
+                  .replace("<total-blacklisted>", Sonar.DECIMAL_FORMAT.format(blacklisted))
+                  .replace("<total-failed>", Sonar.DECIMAL_FORMAT.format(failed))
+                  .replace("<total-success>", Sonar.DECIMAL_FORMAT.format(verified));
+                return new SonarConfiguration.Webhook.Embed(
+                  config.getTitle(), config.getTitleUrl(), description, config.getR(), config.getG(), config.getB());
+              });
+            });
+        }
+
+        // Reset the attack status
+        currentAttack = null;
+        attackThreshold = 0;
+      }
+    } else {
+      attackThreshold = 0;
+    }
+  }
+}
@@ -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
@@ -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,63 @@ import java.util.concurrent.Executors;
@UtilityClass
 public class UpdateChecker {
  private final ExecutorService ASYNC_EXECUTOR = Executors.newSingleThreadExecutor();
+  @Getter
+  private CheckResult lastCheckResult = CheckResult.UNRESOLVED;

-  private final LoggerWrapper LOGGER = new LoggerWrapper() {
+  public void checkForUpdates() {
+    ASYNC_EXECUTOR.execute(() -> {
+      try {
+        final URL url = new URL("https://api.github.com/repos/jonesdevelopment/sonar/releases/latest");
+        final HttpsURLConnection urlConnection = prepareConnection(url);
+        final JsonObject json = parseJson(urlConnection);
+        final String latestStableRelease = json.get("tag_name").getAsString();
+        final int convertedLatestVersion = convertVersion(latestStableRelease);
+        final int convertedCurrentVersion = convertVersion(Sonar.get0().getVersion().getVersion());

-    @Override
-    public void info(final String message, final Object... args) {
-      Sonar.get().getLogger().info("[update-checker] " + message, args);
+        if (convertedCurrentVersion < convertedLatestVersion) {
+          Sonar.get0().getLogger().warn("A new version of Sonar is available: {}", latestStableRelease);
+          Sonar.get0().getLogger().warn("Please make sure to update to the latest version to ensure stability and security:");
+          Sonar.get0().getLogger().warn("https://github.com/jonesdevelopment/sonar/releases/latest");
+          lastCheckResult = CheckResult.OUTDATED_VERSION;
+        } else if (convertedCurrentVersion > convertedLatestVersion || !Sonar.get0().getVersion().getGitBranch().equals("main")) {
+          Sonar.get0().getLogger().warn("You are currently using an unreleased version of Sonar!");
+          Sonar.get0().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.get0().getLogger().info("You are currently using the latest stable release of Sonar!");
+          lastCheckResult = CheckResult.LATEST_VERSION;
+        }
+      } catch (Throwable throwable) {
+        Sonar.get0().getLogger().warn("Failed to check for updates (is your firewall set up properly?): {}",
+          throwable);
+        lastCheckResult = CheckResult.API_ERROR;
+      }
+    });
+  }
+
+  private @NotNull JsonObject parseJson(final @NotNull HttpsURLConnection urlConnection) throws IOException {
+    try (final InputStream inputStream = urlConnection.getInputStream();
+         final InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
+         final BufferedReader bufferedReader = new BufferedReader(inputStreamReader)) {
+      // Parse site content as JSON using Gson
+      final JsonParser jsonParser = new JsonParser();
+      return jsonParser.parse(bufferedReader).getAsJsonObject();
    }
+  }

-    @Override
-    public void warn(final String message, final Object... args) {
-      Sonar.get().getLogger().warn("[update-checker] " + message, args);
+  private @NotNull HttpsURLConnection prepareConnection(final @NotNull URL url) throws Exception {
+    final HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
+    // Set connection timeout
+    urlConnection.setConnectTimeout(15000);
+    urlConnection.setReadTimeout(15000);
+    // Set necessary properties
+    urlConnection.setRequestProperty("Accept", "application/vnd.github.v3+json");
+    // Only continue if the connection is a success
+    if (urlConnection.getResponseCode() != 200) {
+      throw new IllegalStateException("Unexpected response code " + urlConnection.getResponseCode());
    }
-
-    @Override
-    public void error(final String message, final Object... args) {
-      Sonar.get().getLogger().error("[update-checker] " + message, args);
-    }
-  };
+    return urlConnection;
+  }

  private int convertVersion(final @NotNull String version) throws NumberFormatException, IllegalStateException {
    final String[] convertedParts = version.split("\\.");
@@ -69,65 +109,15 @@ public class UpdateChecker {
    return convertedMajor + convertedMinor + patch; // sum the converted version parts
  }

-  public void checkForUpdates() {
-    ASYNC_EXECUTOR.execute(() -> {
-      try {
-        final URL url = new URL("https://api.github.com/repos/jonesdevelopment/sonar/releases/latest");
-        final HttpsURLConnection urlConnection = prepareConnection(url);
-        final JsonObject json = parseJson(urlConnection);
-        final String latestStableRelease = json.get("tag_name").getAsString();
-        final int convertedLatestVersion = convertVersion(latestStableRelease);
-        final int convertedCurrentVersion = convertVersion(Sonar.get().getVersion().getSemanticVersion());
+  @Getter
+  @RequiredArgsConstructor
+  public enum CheckResult {
+    API_ERROR("api-error"),
+    OUTDATED_VERSION("outdated-version"),
+    UNSTABLE_VERSION("unstable-version"),
+    LATEST_VERSION(null),
+    UNRESOLVED(null);

-        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);
-        } else if (convertedCurrentVersion > convertedLatestVersion || !Sonar.get().getVersion().isOnMainBranch()) {
-          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!");
-        }
-      } catch (Exception exception) {
-        LOGGER.warn("Could not retrieve latest version information: {}", exception);
-      }
-    });
-  }
-
-  private @NotNull JsonObject parseJson(final @NotNull HttpsURLConnection urlConnection) throws IOException {
-    try (final InputStream inputStream = urlConnection.getInputStream()) {
-      try (final InputStreamReader inputStreamReader = new InputStreamReader(inputStream)) {
-        final StringBuilder content = new StringBuilder();
-
-        // Read the entire page content
-        try (final BufferedReader bufferedReader = new BufferedReader(inputStreamReader)) {
-          String line;
-
-          while ((line = bufferedReader.readLine()) != null) {
-            content.append(line);
-          }
-        }
-
-        // Parse site content as JSON using Gson
-        final JsonParser jsonParser = new JsonParser();
-        return jsonParser.parse(content.toString()).getAsJsonObject();
-      }
-    }
-  }
-
-  private @NotNull HttpsURLConnection prepareConnection(final @NotNull URL url) throws Exception {
-    final HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
-    // Set connection timeout
-    urlConnection.setConnectTimeout(15000);
-    urlConnection.setReadTimeout(15000);
-    // Set necessary properties
-    urlConnection.setRequestMethod("GET");
-    urlConnection.setRequestProperty("Accept", "application/vnd.github.v3+json");
-    // Only continue if the connection is a success
-    if (urlConnection.getResponseCode() != 200) {
-      throw new IllegalStateException("Unexpected response code " + urlConnection.getResponseCode());
-    }
-    return urlConnection;
+    private final String configKey;
  }
 }
@@ -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
@@ -34,14 +34,18 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.Supplier;

+import static java.net.HttpURLConnection.HTTP_NO_CONTENT;
+
@RequiredArgsConstructor
 public final class DiscordWebhook {
  private final String url;

-  private static final Gson GSON = new GsonBuilder().disableInnerClassSerialization().create();
-
+  private static final Gson GSON = new GsonBuilder().create();
  private static final ExecutorService HTTP_REQUEST_SERVICE = Executors.newSingleThreadExecutor();

+  /**
+   * Asynchronously posts a Discord webhook via HTTPS
+   */
  public void post(final Supplier<SonarConfiguration.Webhook.Embed> embed) {
    HTTP_REQUEST_SERVICE.execute(() -> {
      try {
@@ -51,20 +55,22 @@ public final class DiscordWebhook {
        try (final OutputStream outputStream = urlConnection.getOutputStream()) {
          outputStream.write(serializedContent.getBytes(StandardCharsets.UTF_8));
        }
-        // Check if the connection was a success
-        if (urlConnection.getResponseCode() != 204) {
-          throw new IllegalStateException("Unexpected response code " + urlConnection.getResponseCode());
+
+        // Discord replies with HTTP_NO_CONTENT (204) if the request is successful
+        final int code = urlConnection.getResponseCode();
+        if (code != HTTP_NO_CONTENT) {
+          Sonar.get0().getLogger().warn("Unexpected Discord webhook response code {}", code);
        }
      } catch (Exception exception) {
-        Sonar.get().getLogger().error("Could not send webhook: {}", exception);
+        Sonar.get0().getLogger().error("Could not send webhook: {}", exception);
      }
    });
  }

-  private String prepareSerializedContent(final SonarConfiguration.Webhook.@NotNull Embed embed) {
-    final String content = Sonar.get().getConfig().getWebhook().getContent();
-    final String username = Sonar.get().getConfig().getWebhook().getUsername();
-    final String avatarUrl = Sonar.get().getConfig().getWebhook().getAvatarUrl();
+  private static String prepareSerializedContent(final SonarConfiguration.Webhook.@NotNull Embed embed) {
+    final String content = Sonar.get0().getConfig().getWebhook().getContent();
+    final String username = Sonar.get0().getConfig().getWebhook().getUsername();
+    final String avatarUrl = Sonar.get0().getConfig().getWebhook().getAvatarUrl();

    int rgb = embed.getR();
    rgb = (rgb << 8) + embed.getG();
@@ -72,8 +78,8 @@ public final class DiscordWebhook {

    final Webhook.EmbedMessage embedMessage = new Webhook.EmbedMessage(
      embed.getTitle(), embed.getDescription(), embed.getTitleUrl(), rgb, new Webhook.Field[0],
-      new Webhook.Footer(Sonar.get().getConfig().getWebhook().getFooter().getText(),
-        Sonar.get().getConfig().getWebhook().getFooter().getIconUrl()));
+      new Webhook.Footer(Sonar.get0().getConfig().getWebhook().getFooter().getText(),
+        Sonar.get0().getConfig().getWebhook().getFooter().getIconUrl()));
    final List<Webhook.EmbedMessage> embeds = Collections.singletonList(embedMessage);

    final Webhook webhook = new Webhook(content, username, avatarUrl, false, embeds);
@@ -1,106 +1,109 @@
-buildscript {
-  dependencies {
-    classpath("gradle.plugin.io.toolebox:gradle-git-versioner:1.6.7")
-  }
-}
+import net.kyori.indra.git.IndraGitExtension

 plugins {
-  id("java")
-  id("io.github.goooler.shadow") version "8.1.5"
-  id("io.toolebox.git-versioner") version "1.6.7"
-}
-
-apply(plugin = "io.toolebox.git-versioner")
-
-versioner {
-  pattern {
-    pattern = "$version-%h-%c-%b"
-  }
+  java
+  alias(libs.plugins.shadow)
+  alias(libs.plugins.indra.git)
+  alias(libs.plugins.spotless)
 }

 allprojects {
  repositories {
-    mavenCentral() // Lombok
+    mavenCentral()
    maven(url = "https://repo.jonesdev.xyz/releases/") // Bungee & Velocity proxy module
-    maven(url = "https://s01.oss.sonatype.org/content/repositories/snapshots/") // libby
+    maven(url = "https://repo.alessiodp.com/snapshots/") // libby
  }

  apply(plugin = "java")
-  apply(plugin = "io.github.goooler.shadow")
+  apply(plugin = "com.gradleup.shadow")
+  apply(plugin = "com.diffplug.spotless")

  dependencies {
-    compileOnly("org.projectlombok:lombok:1.18.30")
-    annotationProcessor("org.projectlombok:lombok:1.18.30")
+    compileOnly(rootProject.libs.lombok)
+    annotationProcessor(rootProject.libs.lombok)

-    testCompileOnly("org.projectlombok:lombok:1.18.30")
-    testAnnotationProcessor("org.projectlombok:lombok:1.18.30")
+    testCompileOnly(rootProject.libs.lombok)
+    testAnnotationProcessor(rootProject.libs.lombok)

-    // adventure
-    implementation("net.kyori:adventure-text-minimessage:4.16.0")
-    implementation("net.kyori:adventure-text-serializer-gson:4.16.0")
-    implementation("net.kyori:adventure-nbt:4.16.0")
-
-    compileOnly("com.j256.ormlite:ormlite-jdbc:6.1") // ORMLite
-    compileOnly("com.github.ben-manes.caffeine:caffeine:3.1.8") // caching
-    compileOnly("io.netty:netty-all:4.1.107.Final") // netty
-
-    // Library/dependency loading
-    compileOnly("com.alessiodp.libby:libby-core:2.0.0-SNAPSHOT")
+    compileOnly(rootProject.libs.adventure.minimessage)
+    compileOnly(rootProject.libs.adventure.serializer)
+    compileOnly(rootProject.libs.ormlite)
+    compileOnly(rootProject.libs.caffeine)
+    compileOnly(rootProject.libs.netty)
+    compileOnly(rootProject.libs.libby.core)
  }
-}

-dependencies {
-  sequenceOf("api", "bukkit", "bungee", "common", "velocity").forEach {
-    // We want the jar to actually contain our modules
-    implementation(project(":$it"))
+  spotless {
+    java {
+      endWithNewline()
+      formatAnnotations()
+      removeUnusedImports()
+      trimTrailingWhitespace()
+      indentWithSpaces(2)
+    }
+  }
+
+  tasks {
+    shadowJar {
+      // Set the file name of the shadowed jar
+      archiveFileName.set("${rootProject.name}-${project.name.replaceFirstChar { it.uppercase() }}.jar")
+
+      // Remove file timestamps
+      isPreserveFileTimestamps = false
+
+      // Relocate libraries
+      relocate("org.bstats", "xyz.jonesdev.sonar.libs.bstats")
+      relocate("com.alessiodp.libby", "xyz.jonesdev.sonar.libs.libby")
+      relocate("com.simpleyaml", "xyz.jonesdev.sonar.libs.yaml")
+      relocate("com.google.gson", "xyz.jonesdev.sonar.libs.gson")
+      relocate("com.j256.ormlite", "xyz.jonesdev.sonar.libs.ormlite")
+      relocate("com.github.benmanes.caffeine", "xyz.jonesdev.sonar.libs.caffeine")
+      relocate("com.mysql", "xyz.jonesdev.sonar.libs.mysql")
+      relocate("org.mariadb", "xyz.jonesdev.sonar.libs.mariadb")
+      relocate("org.h2", "xyz.jonesdev.sonar.libs.h2")
+      relocate("com.jhlabs", "xyz.jonesdev.sonar.libs.jhlabs")
+      relocate("org.postgresql", "xyz.jonesdev.sonar.libs.postgresql")
+
+      // Exclude unnecessary metadata information
+      exclude("META-INF/*/**")
+
+      // Minimize shadowed jar file
+      minimize {
+        exclude(project(":api"))
+      }
+    }
+
+    compileJava {
+      options.encoding = "UTF-8"
+    }
+
+    jar {
+      manifest {
+        val indra = rootProject.extensions.getByType(IndraGitExtension::class.java)
+        val gitBranch = indra.branchName() ?: "unknown"
+        val gitCommit = indra.commit()?.name?.substring(0, 8) ?: "unknown"
+
+        // Set the implementation version, so we can create exact version
+        // information in-game and make it accessible to the user.
+        attributes["Implementation-Title"] = rootProject.name
+        attributes["Implementation-Version"] = rootProject.version
+        attributes["Implementation-Vendor"] = "Jones Development, Sonar Contributors"
+        // Include the Git branch and Git commit SHA
+        attributes["Git-Branch"] = gitBranch
+        attributes["Git-Commit"] = gitCommit
+      }
+    }
+
+    java.sourceCompatibility = JavaVersion.VERSION_11
+    java.targetCompatibility = JavaVersion.VERSION_11
  }
 }

 tasks {
-  jar {
-    manifest {
-      // Set the implementation version, so we can create exact version
-      // information in-game and make it accessible to the user.
-      attributes["Implementation-Version"] = version
-      attributes["Implementation-Vendor"] = "Jones Development, Sonar Contributors"
-    }
-  }
-
-  shadowJar {
-    // Set the file name of the shadowed jar
-    archiveFileName.set("${rootProject.name}.jar")
-
-    // Remove file timestamps
-    isPreserveFileTimestamps = false
-
-    // Relocate libraries
-    relocate("org.bstats", "xyz.jonesdev.sonar.libs.bstats")
-    relocate("com.alessiodp.libby", "xyz.jonesdev.sonar.libs.libby")
-    relocate("com.simpleyaml", "xyz.jonesdev.sonar.libs.yaml")
-    relocate("com.google.gson", "xyz.jonesdev.sonar.libs.gson")
-    relocate("com.j256.ormlite", "xyz.jonesdev.sonar.libs.ormlite")
-    relocate("com.github.benmanes.caffeine", "xyz.jonesdev.sonar.libs.caffeine")
-
-    // TODO: actually fix this :/
-    // We have to be careful here, so we don't accidentally break adventure
-    relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori") {
-      exclude("net.kyori.adventure.text.**")
-      exclude("net.kyori.adventure.audience.Audience")
-      exclude("net.kyori.adventure.title.*")
-    }
-
-    // Exclude unnecessary metadata information
-    exclude("META-INF/*/**")
-    // We want to load our own Gson dynamically
-    exclude("com/google/gson/**")
-  }
-
-  compileJava {
-    options.encoding = "UTF-8"
-  }
-
  // This is a small wrapper tasks to simplify the building process
  register("build-sonar") {
-    dependsOn(clean, shadowJar)
+    val subprojects = listOf("api", "captcha", "common", "bukkit", "bungeecord", "paper", "velocity")
+    val buildTasks = subprojects.flatMap { listOf("$it:clean", "$it:spotlessApply", "$it:shadowJar") }
+    dependsOn(buildTasks)
  }
 }
@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-# Fix permissions so we are actually able to run our gradle script
-chmod +x gradle*
-# You can also use clean shadowJar if something goes wrong here
-# e.g. "./gradlew clean shadowJar --stacktrace"
-./gradlew build-sonar --stacktrace
@@ -0,0 +1,47 @@
+import net.minecrell.pluginyml.bukkit.BukkitPluginDescription
+
+plugins {
+  alias(libs.plugins.pluginyml.bukkit) apply true
+}
+
+bukkit {
+  name = rootProject.name
+  main = "xyz.jonesdev.sonar.bukkit.SonarBukkitPlugin"
+  authors = listOf("Jones Development", "Sonar Contributors")
+  website = "https://sonar.top/discord/"
+  load = BukkitPluginDescription.PluginLoadOrder.POSTWORLD
+  softDepend = listOf("Geyser-Spigot", "floodgate", "Protocolize", "ProtocolSupport",
+    "ViaVersion", "packetevents", "ProtocolLib", "FastLogin")
+  apiVersion = "1.13" // ignore legacy plugin warning
+  foliaSupported = true
+
+  commands {
+    register("sonar") {
+      // No permission checks here
+    }
+  }
+}
+
+repositories {
+  maven(url = "https://hub.spigotmc.org/nexus/content/repositories/snapshots/") // Spigot
+  maven(url = "https://oss.sonatype.org/content/repositories/snapshots/") // BungeeCord Chat API
+}
+
+dependencies {
+  implementation(project(":api"))
+  implementation(project(":common"))
+
+  compileOnly(rootProject.libs.spigot)
+
+  implementation(rootProject.libs.adventure.platform.bukkit) {
+    exclude(module = "adventure-nbt")
+  }
+  implementation(rootProject.libs.bstats.bukkit)
+  implementation(rootProject.libs.libby.bukkit)
+}
+
+tasks {
+  shadowJar {
+    relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori")
+  }
+}
@@ -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
@@ -19,28 +19,28 @@ package xyz.jonesdev.sonar.bukkit;

 import com.alessiodp.libby.BukkitLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
+import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
+import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
-import xyz.jonesdev.sonar.bukkit.audience.AudienceListener;
+import xyz.jonesdev.sonar.bukkit.antibot.BukkitInjector;
 import xyz.jonesdev.sonar.bukkit.command.BukkitSonarCommand;
+import xyz.jonesdev.sonar.bukkit.listener.BukkitJoinListener;
 import xyz.jonesdev.sonar.common.boot.SonarBootstrap;
-import xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics;

 import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;

@Getter
 public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
-  public static SonarBukkit INSTANCE;
-
  public SonarBukkit(final @NotNull SonarBukkitPlugin plugin) {
-    super(plugin, new BukkitLibraryManager(
-        plugin, plugin.getDataFolder().getName()),
-      plugin.getDataFolder(), SonarPlatform.BUKKIT);
-    INSTANCE = this;
+    super(plugin, SonarPlatform.BUKKIT, plugin.getDataFolder(), new BukkitLibraryManager(plugin));
  }

  /**
@@ -48,6 +48,19 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
   */
  private final BukkitAudiences bukkitAudiences = BukkitAudiences.create(getPlugin());

+  @Override
+  public @Nullable Audience audience(final @Nullable UUID uniqueId) {
+    if (uniqueId == null) {
+      return null;
+    }
+    return bukkitAudiences.player(uniqueId);
+  }
+
+  @Override
+  public @NotNull Audience sender(final @NotNull Object object) {
+    return bukkitAudiences.sender((CommandSender) object);
+  }
+
  /**
   * Create a wrapper for the plugin logger, so we can use it outside
   * the velocity module.
@@ -72,28 +85,44 @@ public final class SonarBukkit extends SonarBootstrap<SonarBukkitPlugin> {
    }
  };

+  private Metrics metrics;
+
+  public static final CompletableFuture<Void> INITIALIZE_LISTENER = new CompletableFuture<>();
+
  @Override
  public void enable() {
-
    // Initialize bStats.org metrics
-    new Metrics(getPlugin(), getPlatform().getMetricsId());
+    metrics = new Metrics(getPlugin(), getPlatform().getMetricsId());
+
+    // Add charts for some configuration options
+    metrics.addCustomChart(new SimplePie("verification",
+      () -> getConfig().getVerification().getTiming().getDisplayName()));
+    metrics.addCustomChart(new SimplePie("captcha",
+      () -> getConfig().getVerification().getMap().getTiming().getDisplayName()));
+    metrics.addCustomChart(new SimplePie("language",
+      () -> getConfig().getLanguage().getName()));
+    metrics.addCustomChart(new SimplePie("database_type",
+      () -> getConfig().getDatabase().getType().getDisplayName()));

    // Register Sonar command
    Objects.requireNonNull(getPlugin().getCommand("sonar")).setExecutor(new BukkitSonarCommand());

-    // Register audience register listener
-    getPlugin().getServer().getPluginManager().registerEvents(new AudienceListener(), getPlugin());
+    // Try to inject into the server
+    if (BukkitInjector.isLateBindEnabled()) {
+      getPlugin().getServer().getScheduler().runTask(getPlugin(), BukkitInjector::inject);
+    } else {
+      getPlugin().getServer().getPluginManager().registerEvents(new BukkitJoinListener(), getPlugin());
+    }

-    // Register traffic service
-    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
-      CachedBandwidthStatistics::reset, 20L, 20L);
+    // Let the injector know that the plugin has been enabled
+    INITIALIZE_LISTENER.complete(null);
+  }

-    // Register queue service
-    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
-      getFallback().getQueue().getPollTask(), 10L, 10L);
-
-    // Register verbose service
-    getPlugin().getServer().getScheduler().runTaskTimerAsynchronously(getPlugin(),
-      Sonar.get().getVerboseHandler()::update, 4L, 4L);
+  @Override
+  public void disable() {
+    // Make sure to properly stop the metrics
+    if (metrics != null) {
+      metrics.shutdown();
+    }
  }
 }
@@ -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
@@ -18,10 +18,19 @@
 package xyz.jonesdev.sonar.bukkit;

 import org.bukkit.plugin.java.JavaPlugin;
+import xyz.jonesdev.sonar.bukkit.antibot.BukkitInjector;

 public final class SonarBukkitPlugin extends JavaPlugin {
  private SonarBukkit bootstrap;

+  @Override
+  public void onLoad() {
+    // Inject early if late-bind is disabled
+    if (!BukkitInjector.isLateBindEnabled()) {
+      BukkitInjector.inject();
+    }
+  }
+
  @Override
  public void onEnable() {
    bootstrap = new SonarBukkit(this);
@@ -0,0 +1,154 @@
+/*
+ * 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.antibot;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.DecoderException;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.antibot.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.common.InboundHandlerAdapter;
+import xyz.jonesdev.sonar.common.protocol.SonarPacket;
+import xyz.jonesdev.sonar.common.protocol.SonarPacketRegistry;
+import xyz.jonesdev.sonar.common.protocol.packets.handshake.HandshakePacket;
+import xyz.jonesdev.sonar.common.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.antibot.ChannelPipelines.SONAR_INBOUND_HANDLER;
+import static xyz.jonesdev.sonar.common.protocol.packets.handshake.HandshakePacket.*;
+
+final class BukkitInboundHandler extends InboundHandlerAdapter {
+  private static final ProtocolVersion DEFAULT_PROTOCOL_VERSION = ProtocolVersion.MINECRAFT_1_7_2;
+
+  private SonarPacketRegistry.ProtocolRegistry registry;
+
+  BukkitInboundHandler() {
+    updateRegistry(SonarPacketRegistry.HANDSHAKE, DEFAULT_PROTOCOL_VERSION);
+
+    super.channelRemovalListener = (pipeline, name, handler) -> {
+      final ChannelInactiveListener inactiveListener = pipeline.get(ChannelInactiveListener.class);
+
+      if (inactiveListener != null) {
+        inactiveListener.add(handler);
+      }
+    };
+  }
+
+  public void updateRegistry(final @NotNull SonarPacketRegistry registry,
+                             final @NotNull ProtocolVersion protocolVersion) {
+    this.registry = registry.getProtocolRegistry(SonarPacketRegistry.Direction.SERVERBOUND, protocolVersion);
+  }
+
+  @Override
+  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;
+       * 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);
+
+      // Don't continue if the ByteBuf isn't readable or the channel is closed
+      if (!ctx.channel().isActive() || !byteBuf.isReadable()) {
+        byteBuf.release();
+        return;
+      }
+
+      final int packetId = ProtocolUtil.readVarInt(byteBuf);
+      final SonarPacket packet = registry.createPacket(packetId);
+
+      // Skip the packet if it's not registered within Sonar's packet registry
+      if (packet == null) {
+        byteBuf.release();
+        return;
+      }
+
+      try {
+        // Try to decode the packet for the given protocol version
+        packet.decode(byteBuf, protocolVersion == null ? DEFAULT_PROTOCOL_VERSION : protocolVersion);
+      } catch (Throwable throwable) {
+        byteBuf.release();
+        throw ProtocolUtil.DEBUG ? new DecoderException(throwable) : QuietDecoderException.INSTANCE;
+      }
+
+      // Check if the packet still has bytes left after we decoded it
+      if (byteBuf.isReadable()) {
+        byteBuf.release();
+        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
+       */
+      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.pipeline().remove(this);
+            break;
+          case LOGIN:
+          case TRANSFER:
+            // Let the actual handler know about the handshake packet
+            handleHandshake(ctx, handshake.getHostname(), handshake.getProtocolVersionId());
+            // Be ready for the next packet (which is supposed to be a login packet)
+            updateRegistry(SonarPacketRegistry.LOGIN, Objects.requireNonNull(protocolVersion));
+            break;
+          default:
+            byteBuf.release();
+            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.pipeline().remove(this);
+        // Let Sonar process the login packet
+        handleLogin(ctx, () -> {
+          byteBuf.readerIndex(originalReaderIndex);
+          ctx.fireChannelRead(byteBuf.retain());
+          // TODO: recode this?
+          final ChannelHandler inboundHandler = ctx.pipeline().remove(SONAR_INBOUND_HANDLER);
+          if (inboundHandler != null && channelRemovalListener != null) {
+            channelRemovalListener.accept(ctx.pipeline(), SONAR_INBOUND_HANDLER, inboundHandler);
+          }
+        }, loginStart.getUsername(), socketAddress);
+        byteBuf.release();
+        return;
+      }
+
+      byteBuf.readerIndex(originalReaderIndex);
+      ctx.fireChannelRead(byteBuf);
+    } else {
+      ctx.fireChannelRead(msg);
+    }
+  }
+}
@@ -0,0 +1,273 @@
+/*
+ * 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.antibot;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelInitializer;
+import lombok.Getter;
+import lombok.experimental.UtilityClass;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.common.netty.SonarInjectedChannelInitializer;
+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.antibot.ChannelPipelines.SONAR_INACTIVE_LISTENER;
+import static xyz.jonesdev.sonar.api.antibot.ChannelPipelines.SONAR_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
+// https://github.com/dmulloy2/ProtocolLib/blob/master/TinyProtocol/src/main/java/com/comphenix/tinyprotocol/TinyProtocol.java
+// https://github.com/ViaVersion/ViaVersion/blob/master/bukkit/src/main/java/com/viaversion/viaversion/bukkit/handlers/BukkitChannelInitializer.java
+@UtilityClass
+public class BukkitInjector {
+  private final String LEGACY_NMS_PACKAGE;
+  private final String OBC_PACKAGE;
+
+  private final BukkitServerVersion SERVER_VERSION;
+  private final boolean USES_LEGACY_PACKAGING, OBFUSCATED;
+
+  private final Class<?> MINECRAFT_SERVER_CLASS;
+  private final Class<?> CRAFTBUKKIT_SERVER_CLASS;
+  private final Class<?> SERVER_CONNECTION_CLASS;
+  private final Object SERVER_INSTANCE;
+
+  @Getter
+  private boolean lateBindEnabled;
+
+  static {
+    SERVER_VERSION = resolveServerVersion();
+    USES_LEGACY_PACKAGING = SERVER_VERSION.compareTo(BukkitServerVersion.MINECRAFT_1_17) < 0;
+
+    try {
+      final String bukkitPackage = Bukkit.getServer().getClass().getPackage().getName();
+
+      String modifiedPackageName;
+      if (SERVER_VERSION.compareTo(BukkitServerVersion.MINECRAFT_1_20_5) >= 0) {
+        // Example: org.bukkit.craftbukkit
+        modifiedPackageName = bukkitPackage.split("\\.")[2];
+      } else {
+        // Example: org.bukkit.craftbukkit.v1_16_R3
+        modifiedPackageName = bukkitPackage.split("\\.")[3];
+      }
+
+      LEGACY_NMS_PACKAGE = "net.minecraft.server." + modifiedPackageName + ".";
+      OBC_PACKAGE = bukkitPackage + ".";
+
+      OBFUSCATED = isObfuscated();
+      // Minecraft classes
+      MINECRAFT_SERVER_CLASS = getNMSClass("server.MinecraftServer", "MinecraftServer");
+      SERVER_CONNECTION_CLASS = getNMSClass(OBFUSCATED ? "server.network.ServerConnection" : "server.network.ServerConnectionListener", "ServerConnection");
+      // CraftBukkit classes
+      CRAFTBUKKIT_SERVER_CLASS = getOBCClass("CraftServer");
+
+      Object minecraftServerInstance;
+      try {
+        // 1.20.5+
+        minecraftServerInstance = getFieldAt(MINECRAFT_SERVER_CLASS, MINECRAFT_SERVER_CLASS, 0).get(null);
+      } catch (Exception exception) {
+        minecraftServerInstance = getFieldAt(CRAFTBUKKIT_SERVER_CLASS, MINECRAFT_SERVER_CLASS, 0).get(Bukkit.getServer());
+      }
+      SERVER_INSTANCE = minecraftServerInstance;
+
+      checkLateBind();
+    } catch (Exception exception) {
+      throw new ReflectiveOperationException(exception);
+    }
+  }
+
+  private void checkLateBind() {
+    try {
+      try {
+        Class.forName("org.bukkit.event.server.ServerLoadEvent");
+        // late-bind does not exist on these versions, ignore this case
+        return;
+      } catch (ClassNotFoundException ignored) {
+      }
+
+      final Class<?> spigotConfiguration = Class.forName("org.spigotmc.SpigotConfig");
+      final Method initFieldMethod = spigotConfiguration.getDeclaredMethod("lateBind");
+      initFieldMethod.setAccessible(true);
+      initFieldMethod.invoke(null);
+
+      if ((boolean) spigotConfiguration.getField("lateBind").get(null)) {
+        lateBindEnabled = true;
+      }
+    } catch (java.lang.ReflectiveOperationException ignore) {
+    }
+  }
+
+  public @NotNull Field getFieldAt(final @NotNull Class<?> clazz,
+                                   final @NotNull Class<?> type,
+                                   final int index) {
+    int currentIndex = 0;
+    for (final Field field : clazz.getDeclaredFields()) {
+      field.setAccessible(true);
+
+      if (type.isAssignableFrom(field.getType())) {
+        if (currentIndex++ == index) {
+          return field;
+        }
+      }
+    }
+
+    if (clazz.getSuperclass() != null) {
+      return getFieldAt(clazz.getSuperclass(), type, index);
+    }
+    throw new IllegalStateException("Could not find field #" + index + " in " + clazz.getName());
+  }
+
+  public static @NotNull Field findField(final boolean checkSuperClass,
+                                         final @NotNull Class<?> clazz,
+                                         final String @NotNull ... types) throws NoSuchFieldException {
+    for (final Field field : clazz.getDeclaredFields()) {
+      final String fieldTypeName = field.getType().getSimpleName();
+      for (final String type : types) {
+        if (fieldTypeName.equals(type)) {
+          if (!Modifier.isPublic(field.getModifiers())) {
+            field.setAccessible(true);
+          }
+          return field;
+        }
+      }
+    }
+    if (checkSuperClass && clazz != Object.class && clazz.getSuperclass() != null) {
+      return findField(true, clazz.getSuperclass(), types);
+    }
+    throw new NoSuchFieldException(types[0]);
+  }
+
+  private @NotNull BukkitServerVersion resolveServerVersion() {
+    final String bukkitVersion = Bukkit.getBukkitVersion();
+
+    for (final BukkitServerVersion serverVersion : BukkitServerVersion.REVERSED_VALUES) {
+      if (bukkitVersion.contains(serverVersion.getRelease())) {
+        return serverVersion;
+      }
+    }
+
+    // Throw an error if we cannot find the server version
+    throw new IllegalStateException("Could not find server version " + bukkitVersion);
+  }
+
+  private boolean isObfuscated() {
+    try {
+      Class.forName("net.minecraft.server.network.PlayerConnection");
+      return true;
+    } catch (ClassNotFoundException exception) {
+      return false;
+    }
+  }
+
+  private @NotNull Class<?> getNMSClass(final String modern, final String legacy) throws ClassNotFoundException {
+    return Class.forName(USES_LEGACY_PACKAGING ? LEGACY_NMS_PACKAGE + legacy : "net.minecraft." + modern);
+  }
+
+  public @NotNull Class<?> getOBCClass(final String clazz) throws ClassNotFoundException {
+    return Class.forName(OBC_PACKAGE + clazz);
+  }
+
+  @SuppressWarnings("unchecked")
+  public void inject() {
+    try {
+      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>
+        if (!field.getGenericType().getTypeName().contains(ChannelFuture.class.getName())) {
+          continue;
+        }
+
+        final var list = (List<?>) field.get(getFieldAt(MINECRAFT_SERVER_CLASS, SERVER_CONNECTION_CLASS, 0).get(SERVER_INSTANCE));
+
+        for (final Object object : list) {
+          final ChannelFuture channelFuture = (ChannelFuture) object;
+          final List<String> names = channelFuture.channel().pipeline().names();
+
+          ChannelHandler bootstrap = null;
+
+          for (final String name : names) {
+            try {
+              final ChannelHandler handler = channelFuture.channel().pipeline().get(name);
+              final Field childHandlerField = handler.getClass().getDeclaredField("childHandler");
+              childHandlerField.setAccessible(true);
+              final var childHandler = (ChannelInitializer<?>) childHandlerField.get(handler);
+
+              if (childHandler != null) {
+                bootstrap = handler;
+              }
+              break;
+            } catch (Exception exception) {
+              // Some plugins modify this, so we better skip any exceptions
+            }
+          }
+
+          if (bootstrap == null) {
+            // Default to the first channel future if we couldn't find a childHandler
+            bootstrap = channelFuture.channel().pipeline().first();
+          }
+
+          final Field childHandlerField = bootstrap.getClass().getDeclaredField("childHandler");
+          childHandlerField.setAccessible(true);
+          final var originalInitializer = (ChannelInitializer<Channel>) childHandlerField.get(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<>() {
+
+              @Override
+              protected void initChannel(final @NotNull Channel channel) {
+                channel.close();
+              }
+            });
+          }
+
+          final ChannelHandler _bootstrap = bootstrap;
+
+          INITIALIZE_LISTENER.thenAccept(__ -> {
+            try {
+              childHandlerField.set(_bootstrap, new SonarInjectedChannelInitializer(originalInitializer,
+                pipeline -> {
+                  pipeline.addAfter("splitter", SONAR_PACKET_DECODER, new BukkitInboundHandler());
+                  pipeline.addFirst(SONAR_INACTIVE_LISTENER, new ChannelInactiveListener());
+                }
+              ));
+            } catch (IllegalAccessException exception) {
+              throw new ReflectiveOperationException(exception);
+            }
+          });
+        }
+        return;
+      }
+    } catch (Exception exception) {
+      Sonar.get0().getLogger().error("An error occurred while injecting {}", exception);
+    }
+  }
+}
@@ -0,0 +1,107 @@
+/*
+ * 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.antibot;
+
+import lombok.Getter;
+
+@Getter
+public enum BukkitServerVersion {
+  MINECRAFT_1_7_10,
+  MINECRAFT_1_8,
+  MINECRAFT_1_8_3,
+  MINECRAFT_1_8_8,
+  MINECRAFT_1_9,
+  MINECRAFT_1_9_2,
+  MINECRAFT_1_9_4,
+  MINECRAFT_1_10,
+  MINECRAFT_1_10_1,
+  MINECRAFT_1_10_2,
+  MINECRAFT_1_11,
+  MINECRAFT_1_11_2,
+  MINECRAFT_1_12,
+  MINECRAFT_1_12_1,
+  MINECRAFT_1_12_2,
+  MINECRAFT_1_13,
+  MINECRAFT_1_13_1,
+  MINECRAFT_1_13_2,
+  MINECRAFT_1_14,
+  MINECRAFT_1_14_1,
+  MINECRAFT_1_14_2,
+  MINECRAFT_1_14_3,
+  MINECRAFT_1_14_4,
+  MINECRAFT_1_15,
+  MINECRAFT_1_15_1,
+  MINECRAFT_1_15_2,
+  MINECRAFT_1_16,
+  MINECRAFT_1_16_1,
+  MINECRAFT_1_16_2,
+  MINECRAFT_1_16_3,
+  MINECRAFT_1_16_4,
+  MINECRAFT_1_16_5,
+  MINECRAFT_1_17,
+  MINECRAFT_1_17_1,
+  MINECRAFT_1_18,
+  MINECRAFT_1_18_1,
+  MINECRAFT_1_18_2,
+  MINECRAFT_1_19,
+  MINECRAFT_1_19_1,
+  MINECRAFT_1_19_2,
+  MINECRAFT_1_19_3,
+  MINECRAFT_1_19_4,
+  MINECRAFT_1_20,
+  MINECRAFT_1_20_1,
+  MINECRAFT_1_20_2,
+  MINECRAFT_1_20_3,
+  MINECRAFT_1_20_4,
+  MINECRAFT_1_20_5,
+  MINECRAFT_1_20_6,
+  MINECRAFT_1_21,
+  MINECRAFT_1_21_1,
+  MINECRAFT_1_21_2,
+  MINECRAFT_1_21_3,
+  MINECRAFT_1_21_4,
+  MINECRAFT_1_21_5,
+  MINECRAFT_1_21_6,
+  MINECRAFT_1_21_7,
+  MINECRAFT_1_21_8,
+  MINECRAFT_1_21_9,
+  MINECRAFT_1_21_10,
+  MINECRAFT_1_21_11,
+  MINECRAFT_26_1;
+
+  static final BukkitServerVersion[] REVERSED_VALUES;
+
+  static {
+    REVERSED_VALUES = values().clone();
+
+    final int size = REVERSED_VALUES.length;
+    final int half = size / 2;
+
+    for (int i = 0; i < half; i++) {
+      final BukkitServerVersion temp = REVERSED_VALUES[i];
+      REVERSED_VALUES[i] = REVERSED_VALUES[size - 1 - i];
+      REVERSED_VALUES[size - 1 - i] = temp;
+    }
+  }
+
+  private final String release;
+
+  BukkitServerVersion() {
+    this.release = name().substring(10).replace("_", ".");
+  }
+}
@@ -0,0 +1,268 @@
+/*
+ * 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.antibot;
+
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.channel.*;
+import io.netty.util.Attribute;
+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;
+import java.util.Set;
+
+public final class ChannelInactiveListener extends ChannelInboundHandlerAdapter {
+  private final Set<ChannelInboundHandler> handlers = new HashSet<>();
+
+  @Override
+  public void channelInactive(final @NotNull ChannelHandlerContext ctx) throws Exception {
+    final ProxiedChannelHandlerContext proxy = new ProxiedChannelHandlerContext(ctx);
+    for (final ChannelInboundHandler handler : handlers) {
+      try {
+        handler.channelInactive(proxy);
+      } catch (Exception exception) {
+        handler.exceptionCaught(proxy, exception);
+      }
+    }
+    super.channelInactive(ctx);
+  }
+
+  public void add(final @NotNull ChannelHandler channelHandler) {
+    if (channelHandler instanceof ChannelInboundHandler) {
+      handlers.add((ChannelInboundHandler) channelHandler);
+    }
+  }
+
+  @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+  public static final class ProxiedChannelHandlerContext implements ChannelHandlerContext {
+    private final ChannelHandlerContext ctx;
+
+    // Overwrite to prevent call this method on next handler
+
+    @Override
+    public ChannelHandlerContext fireChannelInactive() {
+      return this;
+    }
+
+    @Override
+    public ChannelHandlerContext fireExceptionCaught(Throwable throwable) {
+      return this;
+    }
+
+    @Override
+    public Channel channel() {
+      return ctx.channel();
+    }
+
+    @Override
+    public EventExecutor executor() {
+      return ctx.executor();
+    }
+
+    @Override
+    public String name() {
+      return ctx.name();
+    }
+
+    @Override
+    public ChannelHandler handler() {
+      return ctx.handler();
+    }
+
+    @Override
+    public boolean isRemoved() {
+      return ctx.isRemoved();
+    }
+
+    @Override
+    public ChannelHandlerContext fireChannelRegistered() {
+      return ctx.fireChannelRegistered();
+    }
+
+    @Override
+    public ChannelHandlerContext fireChannelUnregistered() {
+      return ctx.fireChannelUnregistered();
+    }
+
+    @Override
+    public ChannelHandlerContext fireChannelActive() {
+      return ctx.fireChannelActive();
+    }
+
+    @Override
+    public ChannelHandlerContext fireUserEventTriggered(Object o) {
+      return ctx.fireUserEventTriggered(o);
+    }
+
+    @Override
+    public ChannelHandlerContext fireChannelRead(Object o) {
+      return ctx.fireChannelRead(o);
+    }
+
+    @Override
+    public ChannelHandlerContext fireChannelReadComplete() {
+      return ctx.fireChannelReadComplete();
+    }
+
+    @Override
+    public ChannelHandlerContext fireChannelWritabilityChanged() {
+      return ctx.fireChannelWritabilityChanged();
+    }
+
+    @Override
+    public ChannelFuture bind(SocketAddress socketAddress) {
+      return ctx.bind(socketAddress);
+    }
+
+    @Override
+    public ChannelFuture connect(SocketAddress socketAddress) {
+      return ctx.connect(socketAddress);
+    }
+
+    @Override
+    public ChannelFuture connect(SocketAddress socketAddress, SocketAddress socketAddress1) {
+      return ctx.connect(socketAddress, socketAddress1);
+    }
+
+    @Override
+    public ChannelFuture disconnect() {
+      return ctx.disconnect();
+    }
+
+    @Override
+    public ChannelFuture close() {
+      return ctx.close();
+    }
+
+    @Override
+    public ChannelFuture deregister() {
+      return ctx.deregister();
+    }
+
+    @Override
+    public ChannelFuture bind(SocketAddress socketAddress, ChannelPromise channelPromise) {
+      return ctx.bind(socketAddress, channelPromise);
+    }
+
+    @Override
+    public ChannelFuture connect(SocketAddress socketAddress, ChannelPromise channelPromise) {
+      return ctx.connect(socketAddress, channelPromise);
+    }
+
+    @Override
+    public ChannelFuture connect(SocketAddress socketAddress, SocketAddress socketAddress1, ChannelPromise channelPromise) {
+      return ctx.connect(socketAddress, socketAddress1, channelPromise);
+    }
+
+    @Override
+    public ChannelFuture disconnect(ChannelPromise channelPromise) {
+      return ctx.disconnect(channelPromise);
+    }
+
+    @Override
+    public ChannelFuture close(ChannelPromise channelPromise) {
+      return ctx.close(channelPromise);
+    }
+
+    @Override
+    public ChannelFuture deregister(ChannelPromise channelPromise) {
+      return ctx.deregister(channelPromise);
+    }
+
+    @Override
+    public ChannelHandlerContext read() {
+      return ctx.read();
+    }
+
+    @Override
+    public ChannelFuture write(Object o) {
+      return ctx.write(o);
+    }
+
+    @Override
+    public ChannelFuture write(Object o, ChannelPromise channelPromise) {
+      return ctx.write(o, channelPromise);
+    }
+
+    @Override
+    public ChannelHandlerContext flush() {
+      return ctx.flush();
+    }
+
+    @Override
+    public ChannelFuture writeAndFlush(Object o, ChannelPromise channelPromise) {
+      return ctx.writeAndFlush(o, channelPromise);
+    }
+
+    @Override
+    public ChannelFuture writeAndFlush(Object o) {
+      return ctx.writeAndFlush(o);
+    }
+
+    @Override
+    public ChannelPromise newPromise() {
+      return ctx.newPromise();
+    }
+
+    @Override
+    public ChannelProgressivePromise newProgressivePromise() {
+      return ctx.newProgressivePromise();
+    }
+
+    @Override
+    public ChannelFuture newSucceededFuture() {
+      return ctx.newSucceededFuture();
+    }
+
+    @Override
+    public ChannelFuture newFailedFuture(Throwable throwable) {
+      return ctx.newFailedFuture(throwable);
+    }
+
+    @Override
+    public ChannelPromise voidPromise() {
+      return ctx.voidPromise();
+    }
+
+    @Override
+    public ChannelPipeline pipeline() {
+      return ctx.pipeline();
+    }
+
+    @Override
+    public ByteBufAllocator alloc() {
+      return ctx.alloc();
+    }
+
+    @Override
+    @Deprecated
+    public <T> Attribute<T> attr(AttributeKey<T> attributeKey) {
+      return ctx.attr(attributeKey);
+    }
+
+    @Override
+    @Deprecated
+    public <T> boolean hasAttr(AttributeKey<T> attributeKey) {
+      return ctx.hasAttr(attributeKey);
+    }
+  }
+}
@@ -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
@@ -21,14 +21,15 @@ import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
+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
@@ -37,10 +38,13 @@ public final class BukkitSonarCommand implements CommandExecutor, TabExecutor, S
                           final String label,
                           final String[] args) {
    // Create our own invocation source wrapper to handle messages properly
-    final InvocationSource invocationSource = new BukkitInvocationSource(sender);
+    final InvocationSource invocationSource = new InvocationSource(
+      sender instanceof Player ? ((Player) sender).getUniqueId() : null,
+      Sonar.get0().sender(sender),
+      sender::hasPermission);
    // Pass the invocation source and command arguments to our command handler
    handle(invocationSource, args);
-    return true; // Valid
+    return true;
  }

  @Override
@@ -49,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();
  }
 }
@@ -0,0 +1,98 @@
+/*
+ * 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.listener;
+
+import io.netty.channel.Channel;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.bukkit.antibot.BukkitInjector;
+import xyz.jonesdev.sonar.common.util.FakeChannelUtil;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import static xyz.jonesdev.sonar.api.antibot.ChannelPipelines.SONAR_BANDWIDTH;
+
+// 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;
+  // ServerGamePacketListenerImpl aka. PlayerConnection
+  private static MethodHandle _listenerField;
+  private static MethodHandle _networkManagerField;
+  private static MethodHandle _channelField;
+
+  private static boolean initialized;
+
+  static {
+    try {
+      final Method handleMethod = BukkitInjector.getOBCClass("entity.CraftPlayer")
+        .getDeclaredMethod("getHandle");
+      final Field listenerField = BukkitInjector.findField(false, handleMethod.getReturnType(),
+        "PlayerConnection", "ServerGamePacketListenerImpl");
+      final Field networkManagerField = BukkitInjector.findField(true, listenerField.getType(),
+        "NetworkManager", "Connection");
+      final Field channelField = BukkitInjector.getFieldAt(networkManagerField.getType(), Channel.class, 0);
+
+      _handleMethod = MethodHandles.lookup().unreflect(handleMethod);
+      _listenerField = MethodHandles.lookup().unreflectGetter(listenerField);
+      _networkManagerField = MethodHandles.lookup().unreflectGetter(networkManagerField);
+      _channelField = MethodHandles.lookup().unreflectGetter(channelField);
+      initialized = true;
+    } catch (Exception exception) {
+      initialized = false;
+    }
+  }
+
+  @EventHandler(priority = EventPriority.HIGHEST)
+  public void handle(final @NotNull PlayerJoinEvent event) {
+    // Make sure the player is not an NPC
+    if (!initialized || event.getPlayer().hasMetadata("NPC")) {
+      return;
+    }
+
+    try {
+      final Object handle = _handleMethod.invoke(event.getPlayer());
+      final Object listener = _listenerField.invoke(handle);
+      final Object networkManager = _networkManagerField.invoke(listener);
+      final Channel channel = (Channel) _channelField.invoke(networkManager);
+
+      // Don't continue if the channel isn't found or if the channel is inactive
+      if (channel == null || !channel.isActive()) {
+        return;
+      }
+
+      // Make sure the player is not a fake player
+      if (FakeChannelUtil.isFakeChannel(channel)) {
+        return;
+      }
+
+      // Close the channel if Sonar's handlers are not found when the PlayerJoinEvent is called
+      if (channel.pipeline().context(SONAR_BANDWIDTH) == null) {
+        channel.close();
+      }
+    } catch (Throwable throwable) {
+      Sonar.get0().getLogger().warn("Couldn't find {}: {}", event.getPlayer().getName(), throwable);
+    }
+  }
+}
@@ -0,0 +1,31 @@
+plugins {
+  alias(libs.plugins.pluginyml.bungee) apply true
+}
+
+bungee {
+  name = rootProject.name
+  main = "xyz.jonesdev.sonar.bungee.SonarBungeePlugin"
+  author = "Jones Development, Sonar Contributors"
+  softDepends = setOf("Geyser-BungeeCord", "floodgate", "Protocolize", "ViaVersion", "packetevents", "FastLogin")
+}
+
+dependencies {
+  implementation(project(":api"))
+  implementation(project(":common"))
+
+  compileOnly(rootProject.libs.bungeecord)
+
+  implementation(rootProject.libs.adventure.platform.bungee) {
+    exclude(module = "adventure-nbt")
+  }
+  implementation(rootProject.libs.bstats.bungee)
+  implementation(rootProject.libs.libby.bungee)
+}
+
+tasks {
+  shadowJar {
+    relocate("net.kyori", "xyz.jonesdev.sonar.libs.kyori")
+
+    archiveFileName = "Sonar-Bungee.jar" // Hardcode a shortened version of the name
+  }
+}
@@ -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
@@ -19,28 +19,25 @@ package xyz.jonesdev.sonar.bungee;

 import com.alessiodp.libby.BungeeLibraryManager;
 import lombok.Getter;
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.bungeecord.BungeeAudiences;
+import net.md_5.bungee.api.CommandSender;
 import org.bstats.bungeecord.Metrics;
+import org.bstats.charts.SimplePie;
 import org.jetbrains.annotations.NotNull;
-import xyz.jonesdev.sonar.api.Sonar;
+import org.jetbrains.annotations.Nullable;
 import xyz.jonesdev.sonar.api.SonarPlatform;
 import xyz.jonesdev.sonar.api.logger.LoggerWrapper;
-import xyz.jonesdev.sonar.bungee.audience.AudienceListener;
+import xyz.jonesdev.sonar.bungee.antibot.BungeeInjector;
 import xyz.jonesdev.sonar.bungee.command.BungeeSonarCommand;
-import xyz.jonesdev.sonar.bungee.fallback.FallbackInjectionHelper;
-import xyz.jonesdev.sonar.bungee.fallback.FallbackLoginListener;
 import xyz.jonesdev.sonar.common.boot.SonarBootstrap;
-import xyz.jonesdev.sonar.common.statistics.CachedBandwidthStatistics;

-import java.util.concurrent.TimeUnit;
+import java.util.UUID;

@Getter
 public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
-  public static SonarBungee INSTANCE;
-
  public SonarBungee(final @NotNull SonarBungeePlugin plugin) {
-    super(plugin, new BungeeLibraryManager(plugin), plugin.getDataFolder(), SonarPlatform.BUNGEE);
-    INSTANCE = this;
+    super(plugin, SonarPlatform.BUNGEE, plugin.getDataFolder(), new BungeeLibraryManager(plugin));
  }

  /**
@@ -48,6 +45,19 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
   */
  private final BungeeAudiences bungeeAudiences = BungeeAudiences.create(getPlugin());

+  @Override
+  public @Nullable Audience audience(final @Nullable UUID uniqueId) {
+    if (uniqueId == null) {
+      return null;
+    }
+    return bungeeAudiences.player(uniqueId);
+  }
+
+  @Override
+  public @NotNull Audience sender(final @NotNull Object object) {
+    return bungeeAudiences.sender((CommandSender) object);
+  }
+
  /**
   * Create a wrapper for the plugin logger, so we can use it outside
   * the velocity module.
@@ -72,34 +82,39 @@ public final class SonarBungee extends SonarBootstrap<SonarBungeePlugin> {
    }
  };

+  private Metrics metrics;
+
  @Override
  public void enable() {
+    // Add warning because of questionable design choices that haunt me in my dreams.
+    logger.warn("The use of BungeeCord is supported but not condoned.");
+    logger.warn("Consider upgrading to Velocity (https://velocitypowered.com)");

    // Initialize bStats.org metrics
-    new Metrics(getPlugin(), getPlatform().getMetricsId());
+    metrics = new Metrics(getPlugin(), getPlatform().getMetricsId());
+
+    // Add charts for some configuration options
+    metrics.addCustomChart(new SimplePie("verification",
+      () -> getConfig().getVerification().getTiming().getDisplayName()));
+    metrics.addCustomChart(new SimplePie("captcha",
+      () -> getConfig().getVerification().getMap().getTiming().getDisplayName()));
+    metrics.addCustomChart(new SimplePie("language",
+      () -> getConfig().getLanguage().getName()));
+    metrics.addCustomChart(new SimplePie("database_type",
+      () -> getConfig().getDatabase().getType().getDisplayName()));

    // Register Sonar command
    getPlugin().getServer().getPluginManager().registerCommand(getPlugin(), new BungeeSonarCommand());

-    // Register Fallback listener
-    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new FallbackLoginListener());
-
-    // Register audience register listener
-    getPlugin().getServer().getPluginManager().registerListener(getPlugin(), new AudienceListener());
-
-    // Register traffic service
-    getPlugin().getServer().getScheduler().schedule(getPlugin(), CachedBandwidthStatistics::reset,
-      1L, 1L, TimeUnit.SECONDS);
-
-    // Register queue service
-    getPlugin().getServer().getScheduler().schedule(getPlugin(), getFallback().getQueue().getPollTask(),
-      500L, 500L, TimeUnit.MILLISECONDS);
-
-    // Register verbose service
-    getPlugin().getServer().getScheduler().schedule(getPlugin(), Sonar.get().getVerboseHandler()::update,
-      200L, 200L, TimeUnit.MILLISECONDS);
-
    // Make sure to inject into the server's connection handler
-    FallbackInjectionHelper.inject();
+    BungeeInjector.inject();
+  }
+
+  @Override
+  public void disable() {
+    // Make sure to properly stop the metrics
+    if (metrics != null) {
+      metrics.shutdown();
+    }
  }
 }
@@ -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
@@ -0,0 +1,92 @@
+/*
+ * 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.bungee.antibot;
+
+import io.netty.channel.ChannelHandlerContext;
+import net.md_5.bungee.netty.ChannelWrapper;
+import net.md_5.bungee.netty.HandlerBoss;
+import net.md_5.bungee.protocol.DefinedPacket;
+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.common.InboundHandlerAdapter;
+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.protocol.packets.handshake.HandshakePacket.STATUS;
+
+final class BungeeInboundHandler extends InboundHandlerAdapter {
+
+  private static final MethodHandle CHANNEL_WRAPPER_GETTER;
+
+  static {
+    try {
+      CHANNEL_WRAPPER_GETTER = MethodHandles.privateLookupIn(HandlerBoss.class, MethodHandles.lookup())
+        .findGetter(HandlerBoss.class, "channel", ChannelWrapper.class);
+    } catch (Exception exception) {
+      throw new ReflectiveOperationException(exception);
+    }
+  }
+
+  @Override
+  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;
+      // Skip any unknown or invalid packets
+      if (wrappedPacket != null) {
+        if (wrappedPacket instanceof Handshake) {
+          final Handshake handshake = (Handshake) wrappedPacket;
+          // We don't care about server pings; remove the handler
+          if (handshake.getRequestedProtocol() == STATUS) {
+            ctx.pipeline().remove(this);
+          } else {
+            handleHandshake(ctx, handshake.getHost(), handshake.getProtocolVersion());
+          }
+        } else if (wrappedPacket instanceof LoginRequest) {
+          // Make sure to use the potentially modified, real IP
+          final LoginRequest loginRequest = (LoginRequest) wrappedPacket;
+          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;
+          }
+        }
+      }
+    }
+    ctx.fireChannelRead(msg);
+  }
+}
@@ -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.bungee.antibot;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelInitializer;
+import lombok.experimental.UtilityClass;
+import lombok.val;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.netty.PipelineUtils;
+import net.md_5.bungee.protocol.channel.BungeeChannelInitializer;
+import org.jetbrains.annotations.NotNull;
+import sun.misc.Unsafe;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.common.netty.SonarInjectedChannelInitializer;
+
+import java.lang.reflect.Field;
+
+import static net.md_5.bungee.netty.PipelineUtils.PACKET_DECODER;
+import static xyz.jonesdev.sonar.api.antibot.ChannelPipelines.SONAR_PACKET_HANDLER;
+
+@UtilityClass
+public class BungeeInjector {
+  public void inject() {
+    try {
+      final Field childField;
+
+      try {
+        // This field only exists on BungeeCord build 1908 and below.
+        // See https://github.com/SpigotMC/BungeeCord/pull/3776 for more info.
+        //noinspection all
+        childField = PipelineUtils.class.getField("SERVER_CHILD");
+      } catch (NoSuchFieldException exception) {
+        injectOnModernBungeeCord();
+        return;
+      }
+
+      childField.setAccessible(true);
+      injectOnOldBungeeCord(childField);
+    } catch (Exception exception) {
+      Sonar.get0().getLogger().error("An error occurred while injecting {}", exception);
+    }
+  }
+
+  private static void injectOnOldBungeeCord(final @NotNull Field childField) throws Exception {
+    // Make sure to store the original channel initializer
+    //noinspection unchecked
+    val originalInitializer = (ChannelInitializer<Channel>) childField.get(null);
+    final ChannelInitializer<Channel> injectedInitializer = new SonarInjectedChannelInitializer(
+      originalInitializer, pipeline -> pipeline.addAfter(PACKET_DECODER, SONAR_PACKET_HANDLER,
+      new BungeeInboundHandler()));
+
+    final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
+    unsafeField.setAccessible(true);
+    final Unsafe unsafe = (Unsafe) unsafeField.get(null);
+
+    final Object base = unsafe.staticFieldBase(childField);
+    final long offset = unsafe.staticFieldOffset(childField);
+
+    // Replace the original channel initializer with our new injected initializer
+    unsafe.putObject(base, offset, injectedInitializer);
+  }
+
+  // See https://github.com/SpigotMC/BungeeCord/pull/3787
+  private static void injectOnModernBungeeCord() {
+    // The order is important...
+    final BungeeChannelInitializer original = ProxyServer.getInstance().unsafe().getFrontendChannelInitializer();
+    final BungeeChannelInitializer newInitializer = BungeeChannelInitializer.create(
+      channel -> {
+        // https://github.com/SpigotMC/BungeeCord/pull/3787#issuecomment-2661059876
+        if (!original.getChannelAcceptor().accept(channel)) {
+          return false;
+        }
+        SonarInjectedChannelInitializer.inject(channel,
+          pipeline -> pipeline.addAfter(PACKET_DECODER, SONAR_PACKET_HANDLER,
+            new BungeeInboundHandler()));
+        return true;
+      });
+    ProxyServer.getInstance().unsafe().setFrontendChannelInitializer(newInitializer);
+  }
+}
@@ -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
@@ -18,13 +18,15 @@
 package xyz.jonesdev.sonar.bungee.command;

 import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.plugin.Command;
 import net.md_5.bungee.api.plugin.TabExecutor;
 import org.jetbrains.annotations.NotNull;
+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() {
@@ -34,7 +36,10 @@ public final class BungeeSonarCommand extends Command implements TabExecutor, So
  @Override
  public void execute(final @NotNull CommandSender sender, final String[] args) {
    // Create our own invocation source wrapper to handle messages properly
-    final InvocationSource invocationSource = new BungeeInvocationSource(sender);
+    final InvocationSource invocationSource = new InvocationSource(
+      sender instanceof ProxiedPlayer ? ((ProxiedPlayer) sender).getUniqueId() : null,
+      Sonar.get0().sender(sender),
+      sender::hasPermission);
    // Pass the invocation source and command arguments to our command handler
    handle(invocationSource, args);
  }
@@ -42,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();
  }
 }
@@ -0,0 +1,7 @@
+dependencies {
+  compileOnly(project(":api"))
+  compileOnly(rootProject.libs.imagefilters)
+
+  testImplementation(project(":api"))
+  testImplementation(rootProject.libs.imagefilters)
+}
@@ -0,0 +1,173 @@
+/*
+ * 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.captcha;
+
+import com.jhlabs.image.FBMFilter;
+import com.jhlabs.image.SmearFilter;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.antibot.captcha.CaptchaGenerator;
+import xyz.jonesdev.sonar.captcha.filters.CurvesOverlayFilter;
+import xyz.jonesdev.sonar.captcha.filters.NoiseOverlayFilter;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+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.util.Arrays;
+import java.util.Random;
+
+@Getter
+@RequiredArgsConstructor
+public final class StandardCaptchaGenerator implements CaptchaGenerator {
+  private static final CurvesOverlayFilter CURVES = new CurvesOverlayFilter(3);
+  //private static final CircleInverseFilter CIRCLES = new CircleInverseFilter(1, 30, 10);
+  private static final NoiseOverlayFilter NOISE = new NoiseOverlayFilter(1, 20);
+  private static final SmearFilter SMEAR = new SmearFilter();
+  private static final FBMFilter FBM = new FBMFilter();
+  private static final Random RANDOM = new Random();
+  private static final Color[] COLORS = new Color[4];
+  private static final float[] COLOR_FRACTIONS = new float[COLORS.length];
+  static final Font FONT;
+
+  static {
+    FONT = TTFFontProvider.loadFont("/assets/fonts/Kingthings_Trypewriter_2.ttf");
+
+    FBM.setAmount(0.6f);
+    FBM.setScale(15);
+
+    SMEAR.setShape(SmearFilter.SQUARES);
+    SMEAR.setDensity(0.1f);
+    SMEAR.setDistance(0);
+    SMEAR.setMix(0.35f);
+
+    // Create fractions based on the number of colors
+    for (int i = 0; i < COLOR_FRACTIONS.length; i++) {
+      COLOR_FRACTIONS[i] = (float) i / (COLOR_FRACTIONS.length - 1);
+    }
+  }
+
+  private final int width = 128, height = 128;
+  private final @Nullable File background;
+  private @Nullable BufferedImage backgroundImage;
+
+  @Override
+  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);
+    // Draw characters and other effects on the image
+    applyRandomColorGradient(graphics);
+    drawCharacters(graphics, answer);
+    CURVES.transform(image, graphics);
+    NOISE.transform(image);
+    //SMEAR.filter(image, image);
+    //CIRCLES.transform(image); // TODO: check if the text is still easy to read after this
+    // Make sure to dispose the graphics instance
+    graphics.dispose();
+    return image;
+  }
+
+  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) {
+      // Fill the entire image with a noise texture
+      return FBM.filter(image, image);
+    }
+    // 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) {
+    // Randomize the colors for the gradient effect
+    for (int i = 0; i < COLORS.length; i++) {
+      final float random = 0.9f + RANDOM.nextFloat() * 0.1f;
+      COLORS[i] = Color.getHSBColor(RANDOM.nextFloat(), random * 0.8f, random);
+    }
+
+    // Apply the random gradient effect
+    graphics.setPaint(new RadialGradientPaint(0, 0, width,
+      COLOR_FRACTIONS, COLORS, MultipleGradientPaint.CycleMethod.REFLECT));
+  }
+
+  private void drawCharacters(final @NotNull Graphics2D graphics,
+                              final char @NotNull [] answer) {
+    final FontRenderContext ctx = graphics.getFontRenderContext();
+    final GlyphVector[] glyphs = new GlyphVector[answer.length];
+
+    for (int i = 0; i < answer.length; i++) {
+      // Create a glyph vector for the character with a random font
+      glyphs[i] = FONT.createGlyphVector(ctx, String.valueOf(answer[i]));
+    }
+
+    final double scalingXY = 5 - Math.min(answer.length, 5) * 0.65;
+
+    // Calculate first X and Y positions
+    final double totalWidth = Arrays.stream(glyphs)
+      .mapToDouble(glyph -> glyph.getLogicalBounds().getWidth() * scalingXY - 1)
+      .sum();
+    double beginX = Math.max(Math.min(width / 2D - totalWidth / 2D, totalWidth), 0);
+    double beginY = (height + TTFFontProvider.STANDARD_FONT_SIZE / 2D) / 2D + scalingXY;
+
+    // Draw each glyph one by one
+    for (final GlyphVector glyph : glyphs) {
+      final AffineTransform transformation = AffineTransform.getTranslateInstance(beginX, beginY);
+      // Shear the glyph by a random amount
+      final double shearXY = Math.sin(beginX + beginY) / 6;
+      transformation.shear(shearXY, shearXY);
+      // Scale the glyph to perfectly fit the image
+      transformation.scale(scalingXY, scalingXY);
+      // Draw the glyph to the buffered image
+      final Shape transformedShape = transformation.createTransformedShape(glyph.getOutline());
+      graphics.fill(transformedShape);
+      // Draw a random outline around the glyph
+      if (RANDOM.nextFloat() < 0.25f) {
+        createGlyphOutline(graphics, transformedShape);
+      }
+      // Make sure the next glyph isn't drawn at the same position
+      beginX += glyph.getVisualBounds().getWidth() * scalingXY + 2;
+      beginY += -10 + RANDOM.nextFloat() * 20;
+    }
+  }
+
+  private void createGlyphOutline(final @NotNull Graphics2D graphics, final @NotNull Shape shape) {
+    final float txy = 1.25f + RANDOM.nextFloat();
+    final float width = 1 + RANDOM.nextFloat();
+
+    // Create a randomly translated and stroked shape based on the original glyph shape
+    final AffineTransform translation = AffineTransform.getTranslateInstance(txy, txy);
+    final Shape strokedShape = new BasicStroke(width).createStrokedShape(shape);
+
+    graphics.fill(translation.createTransformedShape(strokedShape));
+  }
+}
@@ -0,0 +1,39 @@
+/*
+ * 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.captcha;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.*;
+import java.io.InputStream;
+import java.util.Objects;
+
+public final class TTFFontProvider {
+  static final int STANDARD_FONT_SIZE = 25;
+
+  public static Font loadFont(final @NotNull String path) {
+    try (final InputStream inputStream = StandardCaptchaGenerator.class.getResourceAsStream(path)) {
+      // Load the font from the TTF file
+      final Font customFont = Font.createFont(Font.TRUETYPE_FONT, Objects.requireNonNull(inputStream));
+      // Set the font size and style
+      return customFont.deriveFont(Font.PLAIN, STANDARD_FONT_SIZE);
+    } catch (Exception exception) {
+      throw new IllegalStateException("Error loading font. Does your environment support fonts?", exception);
+    }
+  }
+}
@@ -0,0 +1,210 @@
+/*
+ * 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.captcha.complex;
+
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.antibot.captcha.CaptchaGenerator;
+import xyz.jonesdev.sonar.captcha.TTFFontProvider;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.awt.font.FontRenderContext;
+import java.awt.font.TextLayout;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.QuadCurve2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.security.SecureRandom;
+import java.util.Random;
+
+@RequiredArgsConstructor
+public final class ComplexCaptchaGenerator implements CaptchaGenerator {
+  private final File background;
+  private final int width = 128, height = 128;
+  private BufferedImage backgroundImage;
+
+  private static final Font[] FONTS = {
+    TTFFontProvider.loadFont("/assets/fonts/dotness.ttf"), // by http://bythebutterfly.com/
+    TTFFontProvider.loadFont("/assets/fonts/DotMatrix.ttf"),
+  };
+  private static final Random RANDOM = new SecureRandom();
+  private static final double MAX_ROTATION_RADIANS = Math.toRadians(15);
+  private static final int LINE_COUNT = 8;
+  private static final int MIN_LINE_COLOR = 100;
+  private static final int MAX_TEXT_COLOR = 150;
+  private static final int DOT_COUNT = 100;
+
+  private @NotNull BufferedImage createBackgroundImage() {
+    final BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
+    final Graphics2D graphics = image.createGraphics();
+    if (background == null) {
+      graphics.setBackground(Color.WHITE);
+      graphics.clearRect(0, 0, image.getWidth(), image.getHeight());
+      return image;
+    }
+    if (backgroundImage == null) {
+      try {
+        backgroundImage = ImageIO.read(background);
+      } catch (IOException exception) {
+        throw new IllegalStateException("Could not read background image", exception);
+      }
+    }
+    graphics.drawImage(backgroundImage, 0, 0, Color.WHITE, null);
+    return image;
+  }
+
+  @Override
+  public @NotNull BufferedImage createImage(char @NotNull [] answer) {
+    final BufferedImage image = createBackgroundImage();
+    final Graphics2D graphics = image.createGraphics();
+
+    final String text = new String(answer);
+    final int padding = 12;
+    final double maxWidth = width - 2D * padding;
+    final double maxHeight = height - 2D * padding;
+
+    graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+    graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+
+    final FontRenderContext frc = graphics.getFontRenderContext();
+    float optimalSize = 24;
+    final float trialSize = 100;
+
+    final Rectangle2D trialBounds = FONTS[0].deriveFont(trialSize).getStringBounds(text, frc);
+
+    if (trialBounds.getWidth() > 0 && trialBounds.getHeight() > 0) {
+      final double scaleFactorWidth = maxWidth / trialBounds.getWidth();
+      final double scaleFactorHeight = maxHeight / trialBounds.getHeight();
+      optimalSize = (float) (trialSize * Math.min(scaleFactorWidth, scaleFactorHeight));
+    }
+
+    if (optimalSize < 1f) {
+      optimalSize = 1f;
+    }
+
+    final Font finalFont = FONTS[0].deriveFont(optimalSize);
+    graphics.setFont(finalFont);
+
+    final Rectangle2D fullBounds = finalFont.getStringBounds(text, frc);
+
+    double currentX = (width - fullBounds.getWidth()) / 2D;
+
+    final double baselineY = (height / 2D) - (fullBounds.getHeight() / 2D) - fullBounds.getY();
+    double currentY = baselineY;
+
+    for (final char c : answer) {
+      final Font font = FONTS[RANDOM.nextInt(FONTS.length)].deriveFont(optimalSize);
+      graphics.setFont(font);
+
+      final String character = String.valueOf(c);
+      final Rectangle2D charBounds = font.getStringBounds(character, frc);
+
+      final double charWidth = charBounds.getWidth();
+      final double charHeight = charBounds.getHeight();
+      final double charCenterX = currentX + charWidth / 2D;
+      final double charCenterY = baselineY + charBounds.getY() + charHeight / 2D;
+
+      final Color[] colors = new Color[2 + RANDOM.nextInt(2)];
+      final float[] colorFractions = new float[colors.length];
+      for (int i = 0; i < colors.length; i++) {
+        colors[i] = getRandomTextColor();
+        colorFractions[i] = i / (float) colors.length;
+      }
+
+      graphics.setPaint(new RadialGradientPaint((float) currentX, (float) currentY, (float) charWidth,
+        colorFractions, colors, MultipleGradientPaint.CycleMethod.REFLECT));
+
+      final double rotation = (RANDOM.nextDouble() * 2 * MAX_ROTATION_RADIANS) - MAX_ROTATION_RADIANS;
+
+      final AffineTransform originalTransform = graphics.getTransform();
+
+      graphics.rotate(rotation, charCenterX, charCenterY);
+
+      final TextLayout layout = new TextLayout(character, font, frc);
+
+      final AffineTransform translate = AffineTransform.getTranslateInstance(currentX, currentY);
+      final Shape outline = layout.getOutline(translate);
+      graphics.fill(outline);
+      graphics.setTransform(originalTransform);
+
+      currentX += charWidth;
+      currentY += RANDOM.nextDouble(charHeight / 4) - charHeight / 8;
+    }
+
+    drawNoiseLines(graphics);
+    drawNoiseDots(graphics);
+    graphics.dispose();
+    return image;
+  }
+
+  private @NotNull Color getRandomTextColor() {
+    final int r = Math.min(RANDOM.nextInt(256), MAX_TEXT_COLOR);
+    final int g = Math.min(RANDOM.nextInt(256), MAX_TEXT_COLOR);
+    final int b = Math.min(RANDOM.nextInt(256), MAX_TEXT_COLOR);
+    return new Color(r, g, b, 220);
+  }
+
+  private @NotNull Color getRandomColor() {
+    final int r = Math.max(RANDOM.nextInt(256), MIN_LINE_COLOR);
+    final int g = Math.max(RANDOM.nextInt(256), MIN_LINE_COLOR);
+    final int b = Math.max(RANDOM.nextInt(256), MIN_LINE_COLOR);
+    final int a = Math.max(Math.min(RANDOM.nextInt(256), 200), MIN_LINE_COLOR);
+    return new Color(r, g, b, a);
+  }
+
+  private void drawNoiseLines(final @NotNull Graphics2D graphics) {
+    for (int i = 0; i < LINE_COUNT; i++) {
+      graphics.setColor(getRandomColor());
+      graphics.setStroke(new BasicStroke(1f + RANDOM.nextFloat() * 2f,
+        BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
+
+      if (RANDOM.nextBoolean()) {
+        float x1 = RANDOM.nextInt(width);
+        float y1 = RANDOM.nextInt(height);
+        float ctrlX = RANDOM.nextInt(width);
+        float ctrlY = RANDOM.nextInt(height);
+        float x2 = RANDOM.nextInt(width);
+        float y2 = RANDOM.nextInt(height);
+
+        graphics.draw(new QuadCurve2D.Float(x1, y1, ctrlX, ctrlY, x2, y2));
+      } else {
+        int x1 = RANDOM.nextInt(width);
+        int y1 = RANDOM.nextInt(height);
+        int x2 = RANDOM.nextInt(width);
+        int y2 = RANDOM.nextInt(height);
+
+        graphics.drawLine(x1, y1, x2, y2);
+      }
+    }
+  }
+
+  private void drawNoiseDots(final @NotNull Graphics2D graphics) {
+    for (int i = 0; i < DOT_COUNT; i++) {
+      graphics.setColor(getRandomColor());
+
+      final int x = RANDOM.nextInt(width);
+      final int y = RANDOM.nextInt(height);
+      final int radius = 1 + RANDOM.nextInt(5);
+
+      graphics.fillOval(x, y, radius, radius);
+    }
+  }
+}
@@ -0,0 +1,62 @@
+/*
+ * 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.captcha.filters;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.*;
+import java.awt.geom.CubicCurve2D;
+import java.awt.image.BufferedImage;
+import java.util.Random;
+
+@Getter
+@RequiredArgsConstructor
+public final class CurvesOverlayFilter {
+  private final int amount;
+
+  private static final Random RANDOM = new Random();
+
+  public void transform(final @NotNull BufferedImage image,
+                        final @NotNull Graphics2D graphics) {
+    // Randomize the stroke width
+    graphics.setStroke(new BasicStroke(1 + RANDOM.nextFloat()));
+
+    final int halfWidth = image.getWidth() / 2;
+
+    for (int i = 0; i < amount; ++i) {
+      final float randomX = image.getWidth() * RANDOM.nextFloat();
+      final float randomY = image.getHeight() * RANDOM.nextFloat();
+      final float amplitude = 6.2831855f * (RANDOM.nextFloat() - 0.5f);
+      final float sin = (float) Math.sin(amplitude) * halfWidth;
+      final float cos = (float) Math.cos(amplitude) * halfWidth;
+      final float x1 = randomX - cos;
+      final float y1 = randomY - sin;
+      final float x2 = randomX + cos;
+      final float y2 = randomY + sin;
+      // Control points for the cubic curve
+      final float ctrlX1 = randomX + sin / 2;
+      final float ctrlY1 = randomY - cos / 2;
+      final float ctrlX2 = randomX - sin / 2;
+      final float ctrlY2 = randomY + cos / 2;
+      // Draw a cubic curve instead of a straight line
+      graphics.draw(new CubicCurve2D.Float(x1, y1, ctrlX1, ctrlY1, ctrlX2, ctrlY2, x2, y2));
+    }
+  }
+}
@@ -0,0 +1,55 @@
+/*
+ * 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.captcha.filters;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.image.BufferedImage;
+import java.util.Random;
+
+@Getter
+@RequiredArgsConstructor
+public final class NoiseOverlayFilter {
+  private final float density, amount;
+
+  private static final Random RANDOM = new Random();
+
+  private int randomGaussian(int x) {
+    x += (int) (RANDOM.nextGaussian() * amount);
+    return Math.max(Math.min(x, 0xff), 0);
+  }
+
+  public void transform(final @NotNull BufferedImage image) {
+    for (int x = 0; x < image.getWidth(); x++) {
+      for (int y = 0; y < image.getHeight(); y++) {
+        if (RANDOM.nextFloat() <= density) {
+          final int rgb = image.getRGB(x, y);
+          int r = (rgb >> 16) & 0xff;
+          int g = (rgb >> 8) & 0xff;
+          int b = rgb & 0xff;
+          r = randomGaussian(r);
+          g = randomGaussian(g);
+          b = randomGaussian(b);
+          image.setRGB(x, y, (r << 16) | (g << 8) | b);
+        }
+      }
+    }
+  }
+}
@@ -0,0 +1,212 @@
+/*
+ * 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.captcha.legacy;
+
+import com.jhlabs.image.*;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.antibot.captcha.CaptchaGenerator;
+import xyz.jonesdev.sonar.captcha.filters.NoiseOverlayFilter;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+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.util.Objects;
+import java.util.Random;
+
+@Getter
+@RequiredArgsConstructor
+public final class LegacyCaptchaGenerator implements CaptchaGenerator {
+  private static final ScratchFilter SCRATCHES = new ScratchFilter(4);
+  private static final NoiseOverlayFilter NOISE = new NoiseOverlayFilter(1, 7);
+  private static final SmearFilter SMEAR = new SmearFilter();
+  private static final SaturationFilter SATURATION = new SaturationFilter();
+  private static final RippleFilter RIPPLE = new RippleFilter();
+  private static final Random RANDOM = new Random();
+
+  static {
+    RIPPLE.setXAmplitude(0);
+    float yAmplitude = 10 - RANDOM.nextInt(20);
+    if (Math.abs(yAmplitude) < 5) {
+      yAmplitude = yAmplitude >= 0 ? 5 : -5;
+    }
+    RIPPLE.setYAmplitude(yAmplitude);
+
+    SATURATION.setAmount(0.45f + RANDOM.nextFloat() * 0.15f);
+
+    SMEAR.setShape(SmearFilter.CIRCLES);
+    SMEAR.setMix(0.15f);
+    SMEAR.setDensity(0.1f);
+    SMEAR.setDistance(5);
+  }
+
+  private final int width = 128, height = 128;
+  private final @Nullable File background;
+  private @Nullable BufferedImage backgroundImage;
+  private GradientPaint gradient;
+
+  public BufferedImage createCachedBackgroundImage() {
+    // Create a new image buffer with a 3-byte color spectrum
+    BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
+    if (background == null) {
+      if (backgroundImage != null) {
+        return backgroundImage;
+      }
+      // Don't use any special background image
+      image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+      // Fill the entire background image with a noise texture
+      image = new CausticsFilter().filter(image, null);
+      // Adjust the saturation of the randomly generated background noise
+      final SaturationFilter saturationFilter = new SaturationFilter();
+      saturationFilter.setAmount(0.4f + RANDOM.nextFloat() * 0.2f);
+      image = saturationFilter.filter(image, null);
+      // Un-sharpen the background a bit
+      image = new UnsharpFilter().filter(image, null);
+      return image;
+    }
+    // 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 @NotNull BufferedImage mergeImages(final @NotNull BufferedImage background,
+                                             final @NotNull BufferedImage foreground) {
+    // Get the background image and create a new foreground image
+    final BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR);
+    // Create a new image with transparency for the merged result
+    final Graphics2D graphics = image.createGraphics();
+    // Draw the foreground image on top of the background at specified coordinates
+    graphics.drawImage(background, 0, 0, null);
+    // Set AlphaComposite to handle transparency for the foreground image
+    graphics.setComposite(AlphaComposite.SrcOver);
+    // Draw the foreground image on top of the background at specified coordinates
+    graphics.drawImage(foreground, 0, 0, null);
+    graphics.dispose();
+    return image;
+  }
+
+  @Override
+  public @NotNull BufferedImage createImage(final char @NotNull [] answer) {
+    final Color color0 = Color.getHSBColor(RANDOM.nextFloat(), 1, 1);
+    final Color color1 = Color.getHSBColor(RANDOM.nextFloat(), 1, 0.5f);
+    gradient = new GradientPaint(0, 0, color0, width, height, color1);
+
+    // Get the background image and create a new foreground image
+    BufferedImage foreground = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+    final Graphics2D graphics = foreground.createGraphics();
+
+    final FontRenderContext ctx = graphics.getFontRenderContext();
+    // Change some rendering hints for anti aliasing
+    graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+    // Draw characters
+    drawCharacters(graphics, ctx, answer);
+    // Make sure to dispose the graphics after using it
+    graphics.dispose();
+
+    // Apply any given filter to the foreground
+    new BumpFilter().filter(foreground, foreground);
+    SMEAR.filter(foreground, foreground);
+    RIPPLE.filter(foreground, foreground);
+    SCRATCHES.filter(foreground, foreground);
+
+    final BufferedImage merged = mergeImages(createCachedBackgroundImage(), foreground);
+    NOISE.transform(merged);
+    return merged;
+  }
+
+  private void drawCharacters(final @NotNull Graphics2D graphics,
+                              final @NotNull FontRenderContext ctx,
+                              final char[] answer) {
+    // Create font render context
+    final int fontSize = 62 - answer.length * 2;
+    final Font font = new Font(Font.MONOSPACED, Font.PLAIN, fontSize);
+
+    // Calculate string width
+    final double stringWidth = font.getStringBounds(answer, 0, answer.length, ctx).getWidth();
+    // Calculate character positions
+    int beginX = (int) ((width - stringWidth) / 2D + stringWidth / (answer.length * 2.5D));
+    final int beginY = (int) ((height + fontSize / 2D) / 2D);
+    double rotation = 0;
+
+    if (gradient != null) {
+      graphics.setPaint(gradient);
+    }
+
+    // Draw each character one by one
+    for (final char character : answer) {
+      // Create a glyph vector for the character
+      final GlyphVector glyphVector = font.createGlyphVector(ctx, String.valueOf(character));
+      final int visualBoundsWidth = (int) glyphVector.getVisualBounds().getWidth();
+      if (gradient == null) {
+        Objects.requireNonNull(backgroundImage);
+        // Use the inverse color by checking the background image
+        // Then, create a gradient for the text by using the colors
+        final int x0 = Math.min(Math.max(beginX + 5 /* small threshold */, 0), width);
+        final int x1 = Math.min(Math.max(beginX + (int) visualBoundsWidth, 0), width);
+        final int y = beginY + fontSize / 2;
+        final Color color0 = new Color(~backgroundImage.getRGB(x0, y));
+        final Color color1 = new Color(~backgroundImage.getRGB(x1, y));
+        final GradientPaint gradient = new GradientPaint(0, 0, color0, width, height, color1);
+        graphics.setPaint(gradient);
+      }
+
+      // Apply a transformation to the glyph vector using AffineTransform
+      final AffineTransform transformation = AffineTransform.getTranslateInstance(beginX, beginY);
+
+      // Add a bit of randomization to the rotation
+      rotation += Math.toRadians(6 - RANDOM.nextInt(12));
+      transformation.rotate(rotation);
+      transformation.scale(1, 1.25);
+
+      // Draw the glyph to the buffered image
+      final Shape transformedShape = transformation.createTransformedShape(glyphVector.getOutline());
+      graphics.fill(transformedShape);
+      // Add text outline/shadow to confuse an AI's edge detection
+      addTextOutline(graphics, transformedShape);
+      // Update next X position
+      beginX += visualBoundsWidth + 2;
+    }
+  }
+
+  private static void addTextOutline(final @NotNull Graphics2D graphics,
+                                     final @NotNull Shape transformedShape) {
+    // Create a stroked copy of the text and slightly offset/distort it
+    final Shape strokedShape = new BasicStroke().createStrokedShape(transformedShape);
+
+    final double tx = 0.5 + RANDOM.nextDouble();
+    final double ty = 0.5 + RANDOM.nextDouble();
+
+    // Draw the stroked shape
+    final AffineTransform transform = AffineTransform.getTranslateInstance(tx, ty);
+    graphics.fill(transform.createTransformedShape(strokedShape));
+  }
+}
@@ -0,0 +1,44 @@
+/*
+ * 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.captcha.legacy;
+
+import com.jhlabs.image.TransformFilter;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public final class RippleFilter extends TransformFilter {
+  private float xAmplitude, yAmplitude;
+
+  @Override
+  protected void transformInverse(final int x, final int y, final float @NotNull [] out) {
+    final float nx = (float) y / 13f;
+    final float ny = (float) x / 13f;
+    final float fx = (float) Math.sin(nx);
+    final float fy = (float) Math.sin(ny);
+
+    out[0] = (float) x + xAmplitude * fx;
+    out[1] = (float) y + yAmplitude * fy;
+  }
+}
@@ -0,0 +1,62 @@
+/*
+ * 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.captcha.legacy;
+
+import com.jhlabs.image.AbstractBufferedImageOp;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.Random;
+
+@RequiredArgsConstructor
+public final class ScratchFilter extends AbstractBufferedImageOp {
+  private static final Random RANDOM = new Random();
+
+  private final int amount;
+
+  @Override
+  public @NotNull BufferedImage filter(final @NotNull BufferedImage src, final BufferedImage dst) {
+    final Graphics2D graphics = src.createGraphics();
+
+    // Apply some gradient effect on them
+    final Color color0 = Color.getHSBColor(RANDOM.nextFloat(), RANDOM.nextFloat(), 1);
+    final Color color1 = new Color(~color0.getRGB());
+    final GradientPaint gradient = new GradientPaint(0, 0, color0, src.getWidth(), src.getHeight(), color1);
+    graphics.setPaint(gradient);
+
+    final float halfWidth = src.getWidth() * 0.5f;
+
+    for (int i = 0; i < amount; ++i) {
+      final float randomX = src.getWidth() * RANDOM.nextFloat();
+      final float randomY = src.getHeight() * RANDOM.nextFloat();
+      final float amplitude = 6.2831855f * (RANDOM.nextFloat() - 0.5f);
+      final float sin = (float) Math.sin(amplitude) * halfWidth;
+      final float cos = (float) Math.cos(amplitude) * halfWidth;
+      final float x1 = randomX - cos;
+      final float y1 = randomY - sin;
+      final float x2 = randomX + cos;
+      final float y2 = randomY + sin;
+      graphics.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
+    }
+
+    graphics.dispose();
+    return src;
+  }
+}
@@ -0,0 +1,5 @@
+My fonts are free for personal use. You also MAY redistribute the fonts on your website as long as you guve credit to http://bythebutterfly.com as the creator of the fonts. If you are interested in commercial use, please email me at BYTHEBUTTERFLY@GMAIL.COM
+
+Thanks, and enjoy :)
+
+Vanessa
@@ -0,0 +1,12 @@
+Kingthings EULA - (End User License Agreement).
+
+All the fonts currently published on my website (www.kingthingsfonts.co.uk) are free for you to use for any purpose you wish.  Please do not change my original font files (.TTF).
+
+There are some paid-for versions of my fonts (with much enhanced character sets) available from to buy from www.cheapprofonts.com, these contain their own EULA and are not included or implied in this notice.
+
+Please enjoy all your creative work - and if you come up with anything you like, I would appreciate a picture.
+
+Regards
+
+Kevin King
+Exeter, England - February 2009
@@ -0,0 +1,52 @@
+/*
+ * 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/>.
+ */
+
+import lombok.experimental.UtilityClass;
+import xyz.jonesdev.sonar.api.antibot.captcha.CaptchaGenerator;
+import xyz.jonesdev.sonar.captcha.complex.ComplexCaptchaGenerator;
+
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.Random;
+
+@UtilityClass
+public class Main {
+  public void main(final String... args) throws IOException {
+    final Random random = new Random();
+    final CaptchaGenerator standardCaptchaGenerator = new ComplexCaptchaGenerator(null);
+
+    final long start = System.currentTimeMillis();
+    final char[] dictionary = {'a', 'b', 'c', 'd', 'e', 'f'/*, 'g'*/, 'h'/*, 'i'*/, 'j',
+      'k', 'm', 'n', 'o', 'p'/*, 'q'*/, 'r', 's', 't', 'u'/*, 'v', 'w'*/, 'x', 'y', 'z'};
+
+    // Generate image
+    final int amount = 1;
+    for (int i = 0; i < amount; i++) {
+      final char[] answer = new char[3 + random.nextInt(2)];
+      for (int j = 0; j < answer.length; j++) {
+        answer[j] = dictionary[random.nextInt(dictionary.length)];
+      }
+      final BufferedImage bufferedImage = standardCaptchaGenerator.createImage(answer);
+
+      // Save image
+      ImageIO.write(bufferedImage, "png", new File(i + ".png"));
+    }
+    System.out.println("Took " + (System.currentTimeMillis() - start) + "ms to generate " + amount + " image(s)");
+  }
+}
@@ -0,0 +1,5 @@
+dependencies {
+  compileOnly(project(":api"))
+  implementation(project(":captcha"))
+  compileOnly(rootProject.libs.adventure.nbt)
+}
@@ -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
@@ -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;

 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelDuplexHandler;
@@ -25,37 +25,30 @@ 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)
-public final class FallbackBandwidthHandler extends ChannelDuplexHandler {
-  public static final ChannelHandler INSTANCE = new FallbackBandwidthHandler();
+public final class BandwidthHandler extends ChannelDuplexHandler {
+  public static final ChannelHandler INSTANCE = new BandwidthHandler();

  @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 amount of readable bytes
-      INCOMING.increment(((ByteBuf) msg).readableBytes());
+      // Increment the incoming traffic by the number of readable bytes
+      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 amount of readable bytes
-      OUTGOING.increment(((ByteBuf) msg).readableBytes());
+      // Increment the outgoing traffic by the number of readable bytes
+      final int readableBytes = ((ByteBuf) msg).readableBytes();
+      GlobalSonarStatistics.perSecondOutgoingTraffic += readableBytes;
    }
-    // Make sure to let the server handle the rest
    ctx.write(msg, promise);
  }
 }
@@ -0,0 +1,93 @@
+/*
+ * 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;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelPipeline;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.common.netty.TailExceptionsHandler;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+
+import java.net.InetAddress;
+import java.util.function.Consumer;
+
+@RequiredArgsConstructor
+public final class InboundHandler extends ChannelInboundHandlerAdapter {
+  private final Consumer<ChannelPipeline> sonarPipelineInjector;
+  @Setter
+  @Getter
+  private InetAddress inetAddress;
+
+  @Override
+  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 this
+    ctx.fireChannelActive();
+    // Add the packet handler pipeline
+    sonarPipelineInjector.accept(ctx.pipeline());
+  }
+
+  @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 queue
+      Sonar.get0().getAntiBot().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.get0().getAntiBot().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.get0().getAntiBot().getOnline().compute(inetAddress,
+                (ignored1, count) -> count == null || count <= 1 ? null : count - 1);
+            }
+            return null;
+          });
+        }
+        return null;
+      });
+    }
+  }
+
+  /*
+   * 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 Throwable cause) throws Exception {
+    ctx.close();
+    if (TailExceptionsHandler.LOG_EXCEPTIONS) {
+      cause.printStackTrace(System.err);
+    }
+  }
+}
@@ -0,0 +1,267 @@
+/*
+ * 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;
+
+import io.netty.channel.*;
+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.antibot.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.api.fingerprint.FingerprintingUtil;
+import xyz.jonesdev.sonar.common.netty.SonarTimeoutHandler;
+import xyz.jonesdev.sonar.common.protocol.SonarPacket;
+import xyz.jonesdev.sonar.common.protocol.SonarPacketEncoder;
+import xyz.jonesdev.sonar.common.protocol.SonarPacketRegistry;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+import xyz.jonesdev.sonar.common.util.EaglerUtil;
+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.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static xyz.jonesdev.sonar.api.antibot.ChannelPipelines.*;
+import static xyz.jonesdev.sonar.common.protocol.SonarPacketPreparer.*;
+
+@AllArgsConstructor
+@RequiredArgsConstructor
+public abstract class InboundHandlerAdapter extends ChannelInboundHandlerAdapter {
+  protected @Nullable String username;
+  protected ProtocolVersion protocolVersion;
+  protected @Nullable String handshakeHostname;
+  protected @Nullable RemovalListener channelRemovalListener;
+
+  /**
+   * Validates and handles incoming handshake packets
+   */
+  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 QuietDecoderException.INSTANCE;
+    }
+    // Check if the player has already sent a handshake packet
+    if (protocolVersion != null) {
+      throw QuietDecoderException.INSTANCE;
+    }
+    protocolVersion = ProtocolVersion.fromId(protocol);
+    handshakeHostname = hostname;
+    ctx.pipeline().addFirst(SONAR_BANDWIDTH, BandwidthHandler.INSTANCE);
+  }
+
+  /**
+   * Validates and handles incoming login packets
+   */
+  protected final void handleLogin(final @NotNull ChannelHandlerContext ctx,
+                                   final @NotNull Runnable initialLoginAction,
+                                   final @NotNull String username,
+                                   final @NotNull InetSocketAddress socketAddress) throws Exception {
+    // 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.
+    // Sonar does not support snapshots or Minecraft versions older than 1.7.2
+    if (protocolVersion.isUnknown()) {
+      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(InboundHandler.class).setInetAddress(inetAddress);
+
+    // Check if Sonar is already verifying a player with the same IP address
+    if (Sonar.get0().getAntiBot().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.get0().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.get0().getConfig().getVerification().getBlacklistThreshold();
+    if (limit > 0) {
+      final int score = Sonar.get0().getAntiBot().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.get0().getAntiBot().shouldVerifyNewPlayers()) {
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
+      return;
+    }
+
+    // Completely skip Geyser connections if configured
+    final boolean geyser = GeyserUtil.isGeyserConnection(ctx.channel(), socketAddress);
+    if (geyser && !Sonar.get0().getConfig().getVerification().isCheckGeyser()) {
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
+      return;
+    }
+
+    // Completely skip EaglercraftX connections if configured
+    if (EaglerUtil.isEaglerConnection(ctx.channel())
+      && !Sonar.get0().getConfig().getVerification().isCheckEagler()) {
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
+      return;
+    }
+
+    // Make sure we actually have to verify the player
+    final String fingerprint = FingerprintingUtil.getFingerprint(username, hostAddress);
+    if (Sonar.get0().getVerifiedPlayerController().getCache().contains(fingerprint)) {
+      initialLogin(ctx.channel(), inetAddress, initialLoginAction);
+      return;
+    }
+
+    // Check if the IP address is currently being rate-limited
+    if (!Sonar.get0().getAntiBot().getRatelimiter().attempt(inetAddress)) {
+      customDisconnect(ctx.channel(), reconnectedTooFast, protocolVersion);
+      return;
+    }
+
+    // Remove all other pipelines that could still mess up something
+    rewriteProtocol(ctx, channelRemovalListener);
+
+    // Queue the connection for further processing
+    Sonar.get0().getAntiBot().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(ctx.channel(), alreadyQueued, protocolVersion);
+        // Remove other instances of this IP address from the queue
+        return null;
+      }
+
+      // Create an instance for the user and let the verification handler take over the channel
+      return () -> new UserWrapper(ctx, inetAddress, protocolVersion, username, fingerprint, geyser,
+        handshakeHostname);
+    });
+  }
+
+  /**
+   * 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 {
+    final int maxOnlinePerIp = Sonar.get0().getConfig().getMaxOnlinePerIp();
+    if (maxOnlinePerIp > 0) {
+      final int newCount = Sonar.get0().getAntiBot().getOnline().compute(inetAddress,
+        (__, count) -> count == null ? 1 : count + 1);
+      if (newCount > maxOnlinePerIp) {
+        customDisconnect(channel, tooManyOnlinePerIP, protocolVersion);
+        return;
+      }
+    }
+    loginPacket.run();
+  }
+
+  /**
+   * Removes all pipelines and rewrites them using our custom handlers
+   */
+  private static void rewriteProtocol(final @NotNull ChannelHandlerContext ctx,
+                                      final @Nullable RemovalListener removalListener) {
+    for (final Map.Entry<String, ChannelHandler> entry : ctx.pipeline()) {
+      // Don't accidentally remove Sonar's handlers
+      if (entry.getKey().startsWith("sonar")
+        // Don't remove floodgate's pipelines
+        || entry.getKey().startsWith("geyser")
+        || entry.getKey().startsWith("floodgate")
+        || entry.getKey().startsWith("eagler")
+        || entry.getKey().equals("DefaultChannelPipeline$TailContext#0")) {
+        continue;
+      }
+      ctx.pipeline().remove(entry.getValue());
+      if (removalListener != null) {
+        removalListener.accept(ctx.pipeline(), entry.getKey(), entry.getValue());
+      }
+    }
+    // Add our read/write timeout handler
+    ctx.pipeline().addFirst(SONAR_TIMEOUT, new SonarTimeoutHandler(
+      Sonar.get0().getConfig().getVerification().getReadTimeout(),
+      Sonar.get0().getConfig().getVerification().getWriteTimeout(),
+      TimeUnit.MILLISECONDS));
+  }
+
+  private static void customDisconnect(final @NotNull Channel channel,
+                                       final @NotNull SonarPacket packet,
+                                       final @NotNull ProtocolVersion protocolVersion) {
+    if (channel.isActive()) {
+      if (channel.eventLoop().inEventLoop()) {
+        _customDisconnect(channel, packet, protocolVersion);
+      } else {
+        channel.eventLoop().execute(() -> _customDisconnect(channel, packet, protocolVersion));
+      }
+    }
+  }
+
+  /**
+   * Disconnect the player before verification (during login)
+   */
+  private static void _customDisconnect(final @NotNull Channel channel,
+                                        final @NotNull SonarPacket packet,
+                                        final @NotNull ProtocolVersion protocolVersion) {
+    // TODO: recode this
+    // Remove the connection handler pipeline to completely take over the channel
+    final String handler = Sonar.get0().getPlatform().getConnectionHandler();
+    if (channel.pipeline().context(handler) != null) {
+      channel.pipeline().remove(handler);
+    }
+    final String encoder = Sonar.get0().getPlatform().getEncoder().apply(channel.pipeline());
+    final ChannelHandler currentEncoder = channel.pipeline().get(encoder);
+    // Close the channel if no encoder exists
+    if (currentEncoder != null) {
+      // We don't need to update the encoder if it has already been replaced by Sonar
+      if (!(currentEncoder instanceof SonarPacketEncoder)) {
+        final SonarPacketEncoder newEncoder = new SonarPacketEncoder(protocolVersion);
+        newEncoder.updateRegistry(SonarPacketRegistry.LOGIN);
+        channel.pipeline().replace(encoder, SONAR_PACKET_ENCODER, newEncoder);
+      }
+      ProtocolUtil.closeWith(channel, protocolVersion, packet);
+    } else {
+      channel.close();
+    }
+  }
+
+  @FunctionalInterface
+  public interface RemovalListener {
+    void accept(final @NotNull ChannelPipeline pipeline,
+                final @NotNull String name,
+                final @NotNull ChannelHandler handler);
+  }
+}
@@ -0,0 +1,148 @@
+/*
+ * 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;
+
+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 org.jetbrains.annotations.Nullable;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.antibot.SonarUser;
+import xyz.jonesdev.sonar.api.antibot.protocol.ProtocolVersion;
+import xyz.jonesdev.sonar.api.event.impl.UserVerifyJoinEvent;
+import xyz.jonesdev.sonar.api.timer.SystemTimer;
+import xyz.jonesdev.sonar.common.netty.MinecraftVarInt21FrameDecoder;
+import xyz.jonesdev.sonar.common.netty.MinecraftVarIntLengthEncoder;
+import xyz.jonesdev.sonar.common.netty.TailExceptionsHandler;
+import xyz.jonesdev.sonar.common.protocol.SonarPacketDecoder;
+import xyz.jonesdev.sonar.common.protocol.SonarPacketEncoder;
+import xyz.jonesdev.sonar.common.protocol.SonarPacketPreparer;
+import xyz.jonesdev.sonar.common.protocol.SonarPacketRegistry;
+import xyz.jonesdev.sonar.common.protocol.packets.play.DisconnectPacket;
+import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
+import xyz.jonesdev.sonar.common.verification.LoginHandler;
+
+import java.net.InetAddress;
+
+import static xyz.jonesdev.sonar.api.antibot.ChannelPipelines.*;
+
+@Getter
+@ToString(of = {"protocolVersion", "inetAddress", "hostname", "geyser"})
+public final class UserWrapper implements SonarUser {
+  @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 @Nullable String hostname;
+  private final SystemTimer loginTimer;
+  @Setter
+  private boolean forceCaptcha;
+
+  public UserWrapper(final @NotNull ChannelHandlerContext ctx,
+                     final @NotNull InetAddress inetAddress,
+                     final @NotNull ProtocolVersion protocolVersion,
+                     final @NotNull String username,
+                     final @NotNull String fingerprint,
+                     final boolean geyser,
+                     final @Nullable String hostname) {
+    this.channel = ctx.channel();
+    this.inetAddress = inetAddress;
+    this.protocolVersion = protocolVersion;
+    this.username = username;
+    this.fingerprint = fingerprint;
+    this.geyser = geyser;
+    this.hostname = hostname;
+    this.loginTimer = new SystemTimer();
+
+    GlobalSonarStatistics.totalAttemptedVerifications++;
+
+    if (Sonar.get0().getConfig().getVerification().isLogConnections()
+      && (Sonar.get0().getAttackTracker().getCurrentAttack() == null
+      || Sonar.get0().getConfig().getVerification().isLogDuringAttack())) {
+      Sonar.get0().getLogger().info(
+        Sonar.get0().getConfig().getMessagesConfig().getString("verification.logs.connection")
+          .replace("<username>", username)
+          .replace("<ip>", Sonar.get0().getConfig().formatAddress(inetAddress))
+          .replace("<protocol>", protocolVersion.getName()));
+    }
+
+    // Call the VerifyJoinEvent for external API usage
+    Sonar.get0().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;
+      }
+
+      // How? Is there some kind of de-sync or race condition?
+      if (channel.pipeline().context(SONAR_FRAME_ENCODER) != null) {
+        channel.close(); // Nope ¯\_(ツ)_/¯
+        return;
+      }
+
+      // Mark the player as connected by caching them in a map of verifying players
+      Sonar.get0().getAntiBot().getConnected().compute(inetAddress, (__, v) -> true);
+
+      // Replace normal encoder to allow custom packets
+      final SonarPacketEncoder newEncoder = new SonarPacketEncoder(protocolVersion);
+      channel.pipeline().addFirst(SONAR_FRAME_ENCODER, MinecraftVarIntLengthEncoder.INSTANCE);
+      channel.pipeline().addLast(SONAR_PACKET_ENCODER, newEncoder);
+
+      // Replace normal decoder to allow custom packets
+      final SonarPacketDecoder newDecoder = new SonarPacketDecoder(protocolVersion);
+      channel.pipeline().addFirst(SONAR_FRAME_DECODER, new MinecraftVarInt21FrameDecoder());
+      channel.pipeline().addLast(SONAR_PACKET_DECODER, newDecoder);
+
+      // We're sending the LoginSuccess packet now
+      newDecoder.updateRegistry(SonarPacketRegistry.LOGIN);
+      newEncoder.updateRegistry(SonarPacketRegistry.LOGIN);
+      // Send LoginSuccess packet to make the client think they are joining the server
+      write(SonarPacketPreparer.loginSuccess);
+
+      // pre-1.20.2 clients do not have the configuration stage
+      if (protocolVersion.lessThan(ProtocolVersion.MINECRAFT_1_20_2)) {
+        newDecoder.updateRegistry(SonarPacketRegistry.GAME);
+        newEncoder.updateRegistry(SonarPacketRegistry.GAME);
+      }
+
+      // Listen for all incoming packets by setting the packet listener
+      newDecoder.setListener(new LoginHandler(this));
+
+      // Make sure to catch all exceptions during the verification
+      channel.pipeline().addLast(SONAR_TAIL_EXCEPTIONS, TailExceptionsHandler.INSTANCE);
+    });
+  }
+
+  @Override
+  public void disconnect(final @NotNull Component reason) {
+    final SonarPacketEncoder encoder = channel.pipeline().get(SonarPacketEncoder.class);
+    final boolean duringLogin = encoder != null && encoder.getPacketRegistry() == SonarPacketRegistry.LOGIN;
+    ProtocolUtil.closeWith(channel, protocolVersion, new DisconnectPacket(reason, duringLogin));
+  }
+}
@@ -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,10 +21,11 @@ import com.alessiodp.libby.Library;
 import com.alessiodp.libby.LibraryManager;
 import lombok.experimental.UtilityClass;
 import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.SonarPlatform;

@UtilityClass
 class LibraryLoader {
-  void loadLibraries(final @NotNull LibraryManager libraryManager) {
+  void loadLibraries(final @NotNull LibraryManager libraryManager, final @NotNull SonarPlatform platform) {
    libraryManager.addMavenCentral();
    libraryManager.addJitPack();
    libraryManager.loadLibraries(
@@ -39,14 +40,14 @@ class LibraryLoader {
      Library.builder()
        .groupId("com{}google{}code{}gson")
        .artifactId("gson")
-        .version("2.10.1")
+        .version("2.11.0")
        .relocate("com{}google{}gson", "xyz{}jonesdev{}sonar{}libs{}gson")
        .build(),
      // Caffeine
      Library.builder()
-        .groupId("com.github.ben-manes.caffeine")
+        .groupId("com{}github{}ben-manes{}caffeine")
        .artifactId("caffeine")
-        .version("3.1.8")
+        .version("3.2.3")
        .relocate("com{}github{}benmanes{}caffeine", "xyz{}jonesdev{}sonar{}libs{}caffeine")
        .build(),
      // ORMLite
@@ -56,12 +57,49 @@ class LibraryLoader {
        .version("6.1")
        .relocate("com{}j256{}ormlite", "xyz{}jonesdev{}sonar{}libs{}ormlite")
        .build(),
-      // MySQL driver
+      // JHLabs image filters
      Library.builder()
-        .groupId("com{}mysql")
-        .artifactId("mysql-connector-j")
-        .version("8.3.0")
+        .groupId("com{}jhlabs")
+        .artifactId("filters")
+        .version("2.0.235-1")
+        .relocate("com{}jhlabs", "xyz{}jonesdev{}sonar{}libs{}jhlabs")
        .build()
    );
+
+    // Only load adventure if not on Velocity
+    if (platform != SonarPlatform.VELOCITY) {
+      if (platform != SonarPlatform.PAPER) {
+        libraryManager.loadLibraries(
+          Library.builder()
+            .groupId("net{}kyori")
+            .artifactId("adventure-text-minimessage")
+            .version("4.21.0")
+            .relocate("net{}kyori", "xyz{}jonesdev{}sonar{}libs{}kyori")
+            .build(),
+          Library.builder()
+            .groupId("net{}kyori")
+            .artifactId("adventure-text-serializer-gson")
+            .version("4.21.0")
+            .relocate("net{}kyori", "xyz{}jonesdev{}sonar{}libs{}kyori")
+            .build(),
+          Library.builder()
+            .groupId("net{}kyori")
+            .artifactId("adventure-nbt")
+            .version("4.21.0")
+            .relocate("net{}kyori", "xyz{}jonesdev{}sonar{}libs{}kyori")
+            .build()
+        );
+      } else {
+        // On Paper, we only relocate the nbt package since the rest of adventure is bundled with the server.
+        libraryManager.loadLibrary(
+          Library.builder()
+            .groupId("net{}kyori")
+            .artifactId("adventure-nbt")
+            .version("4.21.0")
+            .relocate("net{}kyori{}adventure{}nbt", "xyz{}jonesdev{}sonar{}libs{}kyori{}adventure{}nbt")
+            .build()
+        );
+      }
+    }
  }
 }
@@ -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
@@ -19,6 +19,9 @@ package xyz.jonesdev.sonar.common.boot;

 import com.alessiodp.libby.LibraryManager;
 import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.Ticker;
+import com.j256.ormlite.logger.Level;
+import com.j256.ormlite.logger.Logger;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import lombok.Setter;
@@ -28,15 +31,18 @@ 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.common.fallback.protocol.FallbackPreparer;
+import xyz.jonesdev.sonar.common.protocol.SonarPacketPreparer;
+import xyz.jonesdev.sonar.common.ratelimit.CaffeineCacheRatelimiter;
+import xyz.jonesdev.sonar.common.ratelimit.NoopCacheRatelimiter;
+import xyz.jonesdev.sonar.common.service.ScheduledServiceManager;
 import xyz.jonesdev.sonar.common.statistics.GlobalSonarStatistics;
-import xyz.jonesdev.sonar.common.subcommand.SubcommandRegistryHolder;
-import xyz.jonesdev.sonar.common.update.UpdateChecker;
+import xyz.jonesdev.sonar.common.subcommand.*;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;

 import java.io.File;
 import java.time.Duration;
@@ -46,12 +52,11 @@ 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 File dataDirectory;
  private final LibraryManager libraryManager;
  private final SonarStatistics statistics;
  private final SonarPlatform platform;
@@ -59,34 +64,39 @@ public abstract class SonarBootstrap<T> implements Sonar {
  private final SystemTimer launchTimer = new SystemTimer();

  public SonarBootstrap(final @NotNull T plugin,
-                        final LibraryManager libraryManager,
-                        final File dataDirectory,
-                        final SonarPlatform platform) {
+                        final @NotNull SonarPlatform platform,
+                        final @NotNull File dataDirectory,
+                        final @NotNull LibraryManager libraryManager) {
+    // Load all libraries before anything else
+    LibraryLoader.loadLibraries(libraryManager, platform);
+    this.libraryManager = libraryManager;
+    // Check if Netty is up to date
+    ProtocolUtil.checkNettyVersion();
    // Set the Sonar API
    SonarSupplier.set(this);
-    // Store our library manager for the API
-    this.libraryManager = libraryManager;
-    // Load all libraries before anything else
-    LibraryLoader.loadLibraries(libraryManager);
    // Set the plugin instance
    this.plugin = plugin;
-    this.dataDirectory = dataDirectory;
    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);
-    this.subcommandRegistry = new SubcommandRegistryHolder();
+    // Register all subcommands
+    this.subcommandRegistry = new SubcommandRegistry();
+    this.subcommandRegistry.register(
+      new BlacklistCommand(),
+      new VerifiedCommand(),
+      new StatisticsCommand(),
+      new VerboseCommand(),
+      new ReloadCommand(),
+      new DumpCommand(),
+      new NotifyCommand());
+    // Hide unnecessary debug information
+    Logger.setGlobalLogLevel(Level.WARNING);
  }

  public final void initialize() {
-    // Check if the branch is not the main branch to warn about unstable versions
-    if (!getVersion().isOnMainBranch()) {
-      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...");

@@ -100,17 +110,17 @@ public abstract class SonarBootstrap<T> implements Sonar {
      // Run the per-platform initialization method
      enable();

+      // Start threads
+      getLogger().info("Starting all managed threads...");
+      ScheduledServiceManager.start();
+
      // Done
      getLogger().info("Done ({}s)!", launchTimer);
    } catch (Throwable throwable) {
      // 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
-    UpdateChecker.checkForUpdates();
  }

  public abstract void enable();
@@ -122,30 +132,31 @@ public abstract class SonarBootstrap<T> implements Sonar {
    // Warn player if they reloaded and changed the database type
    if (verifiedPlayerController != null
      && verifiedPlayerController.getCachedDatabaseType() != getConfig().getDatabase().getType()) {
-      getLogger().warn("Reloading the server after changing the database type"
-        + " is generally not recommended as it can sometimes cause data loss.");
+      getLogger().warn("Reloading after changing the database type is not recommended as it may cause data loss.");
    }

    // Prepare cached packets
-    FallbackPreparer.prepare();
+    getLogger().info("Taking cached snapshots of all packets...");
+    SonarPacketPreparer.prepare();

    // Update ratelimiter cache
-    getFallback().getRatelimiter().setExpiringCache(Caffeine.newBuilder()
-      .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getReconnectDelay()))
-      .build());
+    getAntiBot().setRatelimiter(getConfig().getVerification().getReconnectDelay() > 0L
+      ? new CaffeineCacheRatelimiter(Duration.ofMillis(getConfig().getVerification().getReconnectDelay()))
+      : NoopCacheRatelimiter.INSTANCE);

    // Update blacklist cache
    final long blacklistTime = getConfig().getVerification().getBlacklistTime();
-    final boolean blacklistExists = getFallback().getBlacklist() != null;
+    final boolean blacklistExists = getAntiBot().getBlacklist() != null;
    // Make sure the blacklist is only set when we need it to prevent data loss
    if (!blacklistExists // Make sure we create a new cache if it doesn't exist yet
-      || getFallback().getBlacklistTime() != blacklistTime) {
-      // Create new cache with the configured blacklist time
-      getFallback().setBlacklist(Caffeine.newBuilder()
+      || getAntiBot().getBlacklistTime() != blacklistTime) {
+      // Create a new cache with the configured blacklist time
+      getAntiBot().setBlacklist(Caffeine.newBuilder()
        .expireAfterWrite(Duration.ofMillis(getConfig().getVerification().getBlacklistTime()))
+        .ticker(Ticker.systemTicker())
        .build());
      // Store the new blacklist time, so we don't have to reset the blacklist every reload
-      getFallback().setBlacklistTime(blacklistTime);
+      getAntiBot().setBlacklistTime(blacklistTime);
      // Warn the user about changing the expiry of the blacklist values
      if (blacklistExists) {
        getLogger().warn("The blacklist has been reset as the duration of entries has changed.");
@@ -153,14 +164,27 @@ public abstract class SonarBootstrap<T> implements Sonar {
    }

    // Reinitialize database controller
-    verifiedPlayerController = new VerifiedPlayerController();
+    if (verifiedPlayerController != null) {
+      // Close the old connection first
+      verifiedPlayerController.close();
+    }
+    verifiedPlayerController = new VerifiedPlayerController(libraryManager);
  }

-  public void shutdown() {
+  public final void shutdown() {
+    // Initialize the shutdown process
    getLogger().info("Starting shutdown process...");
-
-    // ...
-
+    // Interrupt threads
+    ScheduledServiceManager.stop();
+    // Close database connection if present
+    if (verifiedPlayerController != null) {
+      verifiedPlayerController.close();
+    }
+    // Run the per-platform disable method
+    disable();
+    // Thank the user for using Sonar
    getLogger().info("Successfully shut down. Goodbye!");
  }
+
+  public abstract void disable();
 }
@@ -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.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 MinecraftVarInt21FrameDecoder 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;
+  }
+}
@@ -0,0 +1,47 @@
+/*
+ * 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.netty;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToMessageEncoder;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.common.util.ProtocolUtil;
+
+import java.util.List;
+
+// 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 MinecraftVarIntLengthEncoder extends MessageToMessageEncoder<ByteBuf> {
+  public static final MinecraftVarIntLengthEncoder INSTANCE = new MinecraftVarIntLengthEncoder();
+
+  @Override
+  protected void encode(final @NotNull ChannelHandlerContext ctx,
+                        final @NotNull ByteBuf byteBuf,
+                        final @NotNull List<Object> out) throws Exception {
+    final int readableBytes = byteBuf.readableBytes();
+    final int length = ProtocolUtil.varIntBytes(readableBytes);
+
+    final ByteBuf lenBuf = ctx.alloc().buffer(length);
+
+    ProtocolUtil.writeVarInt(lenBuf, readableBytes);
+    out.add(lenBuf);
+    out.add(byteBuf.retain());
+  }
+}
@@ -0,0 +1,84 @@
+/*
+ * 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.netty;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelPipeline;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import xyz.jonesdev.sonar.api.Sonar;
+import xyz.jonesdev.sonar.api.SonarPlatform;
+import xyz.jonesdev.sonar.common.InboundHandler;
+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;
+import java.lang.invoke.MethodType;
+import java.util.function.Consumer;
+
+import static xyz.jonesdev.sonar.api.antibot.ChannelPipelines.SONAR_INBOUND_HANDLER;
+
+@RequiredArgsConstructor
+public final class SonarInjectedChannelInitializer extends ChannelInitializer<Channel> {
+  private static final MethodHandle INIT_CHANNEL_METHOD;
+
+  static {
+    try {
+      INIT_CHANNEL_METHOD = MethodHandles.privateLookupIn(ChannelInitializer.class, MethodHandles.lookup())
+        .findVirtual(ChannelInitializer.class, "initChannel", MethodType.methodType(void.class, Channel.class));
+    } catch (Throwable throwable) {
+      throw new ReflectiveOperationException(throwable);
+    }
+  }
+
+  private final @NotNull ChannelInitializer<Channel> originalChannelInitializer;
+  private final @NotNull Consumer<ChannelPipeline> sonarPipelineInjector;
+
+  @Override
+  protected void initChannel(final Channel channel) throws Exception {
+    if (!channel.isActive()) {
+      return;
+    }
+
+    // Invoke the original method
+    try {
+      INIT_CHANNEL_METHOD.invokeExact(originalChannelInitializer, channel);
+    } catch (Throwable throwable) {
+      throw new ReflectiveOperationException(throwable);
+    }
+
+    inject(channel, sonarPipelineInjector);
+  }
+
+  public static void inject(final @NotNull Channel channel, final Consumer<ChannelPipeline> sonarPipelineInjector) {
+    // 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.isFakeChannel(channel)) {
+      final InboundHandler inboundHandler = new InboundHandler(sonarPipelineInjector);
+      // We need to be careful on Bukkit, as the encoder can be different
+      if (Sonar.get0().getPlatform() == SonarPlatform.BUKKIT) {
+        final String encoder = Sonar.get0().getPlatform().getEncoder().apply(channel.pipeline());
+        channel.pipeline().addBefore(encoder, SONAR_INBOUND_HANDLER, inboundHandler);
+      } else {
+        channel.pipeline().addFirst(SONAR_INBOUND_HANDLER, inboundHandler);
+      }
+    }
+  }
+}
@@ -0,0 +1,42 @@
+/*
+ * 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.netty;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.timeout.IdleStateEvent;
+import io.netty.handler.timeout.IdleStateHandler;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.TimeUnit;
+
+public final class SonarTimeoutHandler extends IdleStateHandler {
+  public SonarTimeoutHandler(final int readTimeout, final int writeTimeout, final TimeUnit timeUnit) {
+    super(false, readTimeout, writeTimeout, 0L, timeUnit);
+  }
+
+  @Override
+  protected void channelIdle(final @NotNull ChannelHandlerContext ctx,
+                             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
+    if (ctx.channel().isActive()) {
+      ctx.close();
+    }
+  }
+}