Merge branch 'update' into main

fix(client): handle borrows with async
fix(replay): rename paths to compile
2026-04-13 16:21:21 -04:00 · 2026-04-13 16:19:52 -04:00 · 2026-04-13 16:19:51 -04:00 · 2026-04-13 16:19:51 -04:00 · 2026-04-13 16:19:51 -04:00 · 2026-04-13 13:10:42 -04:00
29 changed files with 2656 additions and 1770 deletions
--- a/.envrc
+++ b/.envrc
@@ -0,0 +1,2 @@
+eval "$(devenv direnvrc)"
+use devenv
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,13 @@
 .luarc.json
 target
+
+# Devenv
+.devenv*
+devenv.local.nix
+devenv.local.yaml
+
+# direnv
+.direnv
+
+# pre-commit
+.pre-commit-config.yaml
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,7 @@ built = { git = "https://github.com/lukaslueg/built", features = ["git2"] }
 [dependencies]
 anyhow = "1"
 azalea = { git = "https://github.com/azalea-rs/azalea" }
+azalea-hax = { git = "https://github.com/azalea-rs/azalea-hax" }
 bevy_app = "0"
 bevy_ecs = "0"
 bevy_log = "0"
@@ -42,10 +43,13 @@ parking_lot = "0"
 serde = "1"
 serde_json = "1"
 tokio = { version = "1", features = ["full"] }
-zip = { version = "2", default-features = false, features = ["flate2"] }
+zip = { version = "8", default-features = false, features = [
+  "deflate",
+], optional = true }

 [features]
 console-subscriber = ["dep:console-subscriber"]
-default = ["matrix"]
+default = []
 matrix = ["dep:dirs", "dep:matrix-sdk"]
 mimalloc = ["dep:mimalloc"]
+replay = ["dep:zip"]
--- a/devenv.lock
+++ b/devenv.lock
@@ -0,0 +1,86 @@
+{
+  "nodes": {
+    "devenv": {
+      "locked": {
+        "dir": "src/modules",
+        "lastModified": 1775928269,
+        "narHash": "sha256-kolsui5s7citDkwz2RL4Au8/BUdH9/TYbfMthLrarrc=",
+        "owner": "cachix",
+        "repo": "devenv",
+        "rev": "b908ac3d4b59f28cb32e7294c621b1c7325002c7",
+        "type": "github"
+      },
+      "original": {
+        "dir": "src/modules",
+        "owner": "cachix",
+        "repo": "devenv",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "inputs": {
+        "nixpkgs-src": "nixpkgs-src"
+      },
+      "locked": {
+        "lastModified": 1774287239,
+        "narHash": "sha256-W3krsWcDwYuA3gPWsFA24YAXxOFUL6iIlT6IknAoNSE=",
+        "owner": "cachix",
+        "repo": "devenv-nixpkgs",
+        "rev": "fa7125ea7f1ae5430010a6e071f68375a39bd24c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "ref": "rolling",
+        "repo": "devenv-nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1773840656,
+        "narHash": "sha256-9tpvMGFteZnd3gRQZFlRCohVpqooygFuy9yjuyRL2C0=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "9cf7092bdd603554bd8b63c216e8943cf9b12512",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "devenv": "devenv",
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1775877051,
+        "narHash": "sha256-wpSQm2PD/w4uRo2wb8utk0b5hOBkkg/CZ1xICY+qB7M=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "08b4f3633471874c8894632ade1b78d75dbda002",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
--- a/devenv.nix
+++ b/devenv.nix
@@ -0,0 +1,19 @@
+{
+  pkgs,
+  ...
+}:
+
+{
+  packages = with pkgs; [
+    git
+    jujutsu
+
+    luajit
+    openssl
+  ];
+
+  languages.rust = {
+    enable = true;
+    channel = "nightly";
+  };
+}
--- a/devenv.yaml
+++ b/devenv.yaml
@@ -0,0 +1,8 @@
+inputs:
+  nixpkgs:
+    url: github:cachix/devenv-nixpkgs/rolling
+  rust-overlay:
+    url: github:oxalica/rust-overlay
+    inputs:
+      nixpkgs:
+        follows: nixpkgs
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -1,11 +1,15 @@
-use azalea::{brigadier::prelude::*, chat::ChatPacket, prelude::*};
+use azalea::{brigadier::prelude::*, client_chat::ChatPacket, prelude::*};
 use futures::lock::Mutex;
-use mlua::{Function, Table};
-use ncr::utils::prepend_header;
+use mlua::{Error, Result, Table, UserDataRef};
+use ncr::{
+    encoding::{Base64Encoding, Base64rEncoding, NewBase64rEncoding},
+    encryption::{CaesarEncryption, Cfb8Encryption, EcbEncryption, Encryption, GcmEncryption},
+    utils::prepend_header,
+};

 use crate::{
-    State,
-    lua::{eval, exec, reload},
+    State, crypt,
+    lua::{eval, exec, nochatreports::key::AesKey, reload},
 };

 pub type Ctx = CommandContext<Mutex<CommandSource>>;
@@ -19,15 +23,20 @@ pub struct CommandSource {

 impl CommandSource {
    pub fn reply(&self, message: &str) {
+        fn encrypt(options: &Table, plaintext: &str) -> Result<String> {
+            Ok(crypt!(encrypt, options, &prepend_header(plaintext)))
+        }
+
        for mut chunk in message
            .chars()
            .collect::<Vec<char>>()
            .chunks(if self.ncr_options.is_some() { 150 } else { 236 })
            .map(|chars| chars.iter().collect::<String>())
        {
-            if let Some(options) = &self.ncr_options
-                && let Ok(encrypt) = self.state.lua.globals().get::<Function>("ncr_encrypt")
-                && let Ok(ciphertext) = encrypt.call::<String>((options, prepend_header(&chunk)))
+            if let Some(ciphertext) = self
+                .ncr_options
+                .as_ref()
+                .and_then(|options| encrypt(options, &chunk).ok())
            {
                chunk = ciphertext;
            }
--- a/src/events.rs
+++ b/src/events.rs
@@ -1,18 +1,19 @@
-use std::{net::SocketAddr, process::exit};
+use std::net::SocketAddr;

-use anyhow::{Context, Result};
+use anyhow::Result;
 use azalea::{
-    brigadier::exceptions::BuiltInExceptions::DispatcherUnknownCommand, prelude::*,
-    protocol::packets::game::ClientboundGamePacket,
+    brigadier::errors::BuiltInError, prelude::*, protocol::packets::game::ClientboundGamePacket,
 };
 use hyper::{server::conn::http1, service::service_fn};
 use hyper_util::rt::TokioIo;
 use log::{debug, error, info, trace};
-use mlua::{Error, Function, IntoLuaMulti, Table};
+use mlua::{Function, IntoLuaMulti, Table};
 use ncr::utils::trim_header;
 use tokio::net::TcpListener;
 #[cfg(feature = "matrix")]
 use {crate::matrix, std::time::Duration, tokio::time::sleep};
+#[cfg(feature = "replay")]
+use {crate::replay::recorder::Recorder, anyhow::Context, mlua::Error, std::process::exit};

 use crate::{
    State,
@@ -20,7 +21,6 @@ use crate::{
    http::serve,
    lua::{client, direction::Direction, player::Player, vec3::Vec3},
    particle,
-    replay::recorder::Recorder,
 };

 #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
@@ -71,7 +71,7 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
                        }
                        .into(),
                    )
-                    && error.type_ != DispatcherUnknownCommand
+                    && *error.kind() != BuiltInError::DispatcherUnknownCommand
                {
                    CommandSource {
                        client,
@@ -97,6 +97,9 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
            })
            .await
        }
+        Event::ConnectionFailed(error) => {
+            call_listeners(&state, "connection_failed", || Ok(error.to_string())).await
+        }
        Event::Death(packet) => {
            if let Some(packet) = packet {
                call_listeners(&state, "death", || {
@@ -129,6 +132,7 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
            }
        }
        Event::KeepAlive(id) => call_listeners(&state, "keep_alive", || Ok(id)).await,
+        Event::ReceiveChunk(_) => Ok(()),
        Event::RemovePlayer(player_info) => {
            call_listeners(&state, "remove_player", || Ok(Player::from(player_info))).await
        }
@@ -186,8 +190,11 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
            ClientboundGamePacket::SetPassengers(packet) => {
                call_listeners(&state, "set_passengers", || {
                    let table = state.lua.create_table()?;
-                    table.set("vehicle", packet.vehicle)?;
-                    table.set("passengers", &*packet.passengers)?;
+                    table.set("vehicle", *packet.vehicle)?;
+                    table.set(
+                        "passengers",
+                        packet.passengers.iter().map(|id| id.0).collect::<Vec<_>>(),
+                    )?;
                    Ok(table)
                })
                .await
@@ -195,9 +202,7 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
            ClientboundGamePacket::SetTime(packet) => {
                call_listeners(&state, "set_time", || {
                    let table = state.lua.create_table()?;
-                    table.set("day_time", packet.day_time)?;
                    table.set("game_time", packet.game_time)?;
-                    table.set("tick_day_time", packet.tick_day_time)?;
                    Ok(table)
                })
                .await
@@ -213,13 +218,16 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
        Event::Init => {
            debug!("received init event");

+            #[cfg(feature = "replay")]
+            {
                let ecs = client.ecs.clone();
                ctrlc::set_handler(move || {
-                ecs.lock()
+                    ecs.write()
                        .remove_resource::<Recorder>()
                        .map(Recorder::finish);
                    exit(0);
                })?;
+            };

            let globals = state.lua.globals();
            lua_init(client, &state, &globals).await?;
@@ -268,11 +276,13 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
 }

 async fn lua_init(client: Client, state: &State, globals: &Table) -> Result<()> {
+    #[cfg(feature = "replay")]
+    {
        let ecs = client.ecs.clone();
        globals.set(
            "finish_replay_recording",
            state.lua.create_function_mut(move |_, (): ()| {
-            ecs.lock()
+                ecs.write()
                    .remove_resource::<Recorder>()
                    .context("recording not active")
                    .map_err(Error::external)?
@@ -280,6 +290,7 @@ async fn lua_init(client: Client, state: &State, globals: &Table) -> Result<()>
                    .map_err(Error::external)
            })?,
        )?;
+    }
    globals.set("client", client::Client(Some(client)))?;
    call_listeners(state, "init", || Ok(())).await
 }
--- a/src/hacks/anti_knockback.rs
+++ b/src/hacks/anti_knockback.rs
@@ -1,20 +0,0 @@
-use azalea::{
-    Vec3,
-    movement::{KnockbackEvent, KnockbackType},
-    prelude::Component,
-};
-use bevy_ecs::{event::EventMutator, query::With, system::Query};
-
-#[derive(Component)]
-pub struct AntiKnockback;
-
-pub fn anti_knockback(
-    mut events: EventMutator<KnockbackEvent>,
-    entity_query: Query<(), With<AntiKnockback>>,
-) {
-    for event in events.read() {
-        if entity_query.get(event.entity).is_ok() {
-            event.knockback = KnockbackType::Add(Vec3::default());
-        }
-    }
-}
--- a/src/hacks/mod.rs
+++ b/src/hacks/mod.rs
@@ -1,19 +0,0 @@
-#![allow(clippy::needless_pass_by_value)]
-
-pub mod anti_knockback;
-
-use anti_knockback::anti_knockback;
-use azalea::{connection::read_packets, movement::handle_knockback};
-use bevy_app::{App, Plugin, PreUpdate};
-use bevy_ecs::schedule::IntoScheduleConfigs;
-
-pub struct HacksPlugin;
-
-impl Plugin for HacksPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(
-            PreUpdate,
-            anti_knockback.after(read_packets).before(handle_knockback),
-        );
-    }
-}
--- a/src/lua/block.rs
+++ b/src/lua/block.rs
@@ -1,6 +1,6 @@
-use azalea::blocks::{
-    Block as AzaleaBlock, BlockState,
-    properties::{ChestType, Facing, LightLevel},
+use azalea::block::{
+    BlockState, BlockTrait,
+    properties::{ChestKind, Facing, LightLevel},
 };
 use mlua::{Function, Lua, Result, Table};

@@ -21,7 +21,7 @@ pub fn get_block_from_state(lua: &Lua, state: u32) -> Result<Option<Table>> {
    let Ok(state) = BlockState::try_from(state) else {
        return Ok(None);
    };
-    let block: Box<dyn AzaleaBlock> = state.into();
+    let block: Box<dyn BlockTrait> = state.into();
    let behavior = block.behavior();

    let table = lua.create_table()?;
@@ -46,10 +46,10 @@ pub async fn get_block_states(
        for block in
            (u32::MIN..u32::MAX).map_while(|possible_id| BlockState::try_from(possible_id).ok())
        {
-            if block_name == Into::<Box<dyn AzaleaBlock>>::into(block).id()
+            if block_name == Into::<Box<dyn BlockTrait>>::into(block).id()
                && (if let Some(filter_fn) = &filter_fn {
                    let table = lua.create_table()?;
-                    table.set("chest_type", block.property::<ChestType>().map(|v| v as u8))?;
+                    table.set("chest_kind", block.property::<ChestKind>().map(|v| v as u8))?;
                    table.set("facing", block.property::<Facing>().map(|v| v as u8))?;
                    table.set(
                        "light_level",
--- a/src/lua/client/container.rs
+++ b/src/lua/client/container.rs
@@ -1,19 +1,20 @@
 use azalea::{
    BlockPos,
-    inventory::{Inventory, Menu, Player, SlotList},
-    prelude::ContainerClientExt,
+    entity::inventory::Inventory,
+    inventory::{Menu, Player, SlotList},
    protocol::packets::game::ServerboundSetCarriedItem,
 };
 use mlua::{Lua, Result, UserDataRef, Value};

 use super::{Client, Container, ContainerRef, ItemStack, Vec3};
+use crate::unpack;

-pub fn container(_lua: &Lua, client: &Client) -> Result<Option<ContainerRef>> {
-    Ok(client.get_open_container().map(ContainerRef))
+pub fn container(_lua: &Lua, client: &Client) -> Result<ContainerRef> {
+    Ok(ContainerRef(client.get_inventory()))
 }

 pub fn held_item(_lua: &Lua, client: &Client) -> Result<ItemStack> {
-    Ok(ItemStack(client.component::<Inventory>().held_item()))
+    Ok(ItemStack(client.get_held_item()))
 }

 pub fn held_slot(_lua: &Lua, client: &Client) -> Result<u8> {
@@ -95,9 +96,10 @@ pub async fn open_container_at(
    client: UserDataRef<Client>,
    position: Vec3,
 ) -> Result<Option<Container>> {
+    let client = unpack!(client);
+
    #[allow(clippy::cast_possible_truncation)]
    Ok(client
-        .clone()
        .open_container_at(BlockPos::new(
            position.x as i32,
            position.y as i32,
@@ -116,17 +118,14 @@ pub fn set_held_slot(_lua: &Lua, client: &Client, slot: u8) -> Result<()> {
        return Ok(());
    }

-    {
-        let mut ecs = client.ecs.lock();
-        let mut inventory = client.query::<&mut Inventory>(&mut ecs);
-        if inventory.selected_hotbar_slot == slot {
-            return Ok(());
-        }
+    client.query_self::<&mut Inventory, _>(|mut inventory| {
+        if inventory.selected_hotbar_slot != slot {
            inventory.selected_hotbar_slot = slot;
-    };
-
+        }
+    });
    client.write_packet(ServerboundSetCarriedItem {
        slot: u16::from(slot),
    });
+
    Ok(())
 }
--- a/src/lua/client/interaction.rs
+++ b/src/lua/client/interaction.rs
@@ -1,13 +1,17 @@
 use azalea::{
-    BlockPos, BotClientExt, interact::StartUseItemEvent,
-    protocol::packets::game::s_interact::InteractionHand, world::MinecraftEntityId,
+    BlockPos,
+    core::entity_id::MinecraftEntityId,
+    protocol::packets::game::{ServerboundUseItem, s_interact::InteractionHand},
 };
 use mlua::{Lua, Result, UserDataRef};

 use super::{Client, Vec3};
+use crate::unpack;

 pub fn attack(_lua: &Lua, client: &Client, entity_id: i32) -> Result<()> {
-    client.attack(MinecraftEntityId(entity_id));
+    if let Some(entity) = client.entity_id_by_minecraft_id(MinecraftEntityId(entity_id)) {
+        client.attack(entity);
+    }
    Ok(())
 }

@@ -26,9 +30,10 @@ pub fn has_attack_cooldown(_lua: &Lua, client: &Client) -> Result<bool> {
 }

 pub async fn mine(_lua: Lua, client: UserDataRef<Client>, position: Vec3) -> Result<()> {
+    let client = unpack!(client);
+
    #[allow(clippy::cast_possible_truncation)]
    client
-        .clone()
        .mine(BlockPos::new(
            position.x as i32,
            position.y as i32,
@@ -54,13 +59,15 @@ pub fn start_mining(_lua: &Lua, client: &Client, position: Vec3) -> Result<()> {
 }

 pub fn start_use_item(_lua: &Lua, client: &Client, hand: Option<u8>) -> Result<()> {
-    client.ecs.lock().send_event(StartUseItemEvent {
-        entity: client.entity,
+    let direction = client.direction();
+    client.write_packet(ServerboundUseItem {
        hand: match hand {
            Some(1) => InteractionHand::OffHand,
            _ => InteractionHand::MainHand,
        },
-        force_block: None,
+        seq: 0,
+        x_rot: direction.x_rot(),
+        y_rot: direction.y_rot(),
    });
    Ok(())
 }
--- a/src/lua/client/mod.rs
+++ b/src/lua/client/mod.rs
@@ -6,9 +6,9 @@ mod movement;
 mod state;
 mod world;

-use std::ops::{Deref, DerefMut};
+use std::ops::Deref;

-use azalea::{Client as AzaleaClient, world::MinecraftEntityId};
+use azalea::{Client as AzaleaClient, core::entity_id::MinecraftEntityId};
 use mlua::{Lua, Result, UserData, UserDataFields, UserDataMethods};

 use super::{
@@ -28,18 +28,13 @@ impl Deref for Client {
    }
 }

-impl DerefMut for Client {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.0.as_mut().expect("should have received init event")
-    }
-}
-
 impl UserData for Client {
    fn add_fields<F: UserDataFields<Self>>(f: &mut F) {
        f.add_field_method_get("air_supply", state::air_supply);
        f.add_field_method_get("container", container::container);
        f.add_field_method_get("dimension", world::dimension);
        f.add_field_method_get("direction", movement::direction);
+        f.add_field_method_get("experience", state::experience);
        f.add_field_method_get("eye_position", movement::eye_position);
        f.add_field_method_get("go_to_reached", movement::go_to_reached);
        f.add_field_method_get("has_attack_cooldown", interaction::has_attack_cooldown);
@@ -52,7 +47,6 @@ impl UserData for Client {
        f.add_field_method_get("menu", container::menu);
        f.add_field_method_get("pathfinder", movement::pathfinder);
        f.add_field_method_get("position", movement::position);
-        f.add_field_method_get("score", state::score);
        f.add_field_method_get("tab_list", tab_list);
        f.add_field_method_get("username", username);
        f.add_field_method_get("uuid", uuid);
@@ -121,3 +115,12 @@ fn username(_lua: &Lua, client: &Client) -> Result<String> {
 fn uuid(_lua: &Lua, client: &Client) -> Result<String> {
    Ok(client.uuid().to_string())
 }
+
+#[macro_export]
+macro_rules! unpack {
+    ($client:ident) => {{
+        let inner = (**$client).clone();
+        drop($client);
+        inner
+    }};
+}
--- a/src/lua/client/movement.rs
+++ b/src/lua/client/movement.rs
@@ -1,18 +1,18 @@
 use azalea::{
-    BlockPos, BotClientExt, SprintDirection, WalkDirection,
-    core::hit_result::HitResult,
+    BlockPos, Client as AzaleaClient, SprintDirection, WalkDirection,
+    core::{entity_id::MinecraftEntityId, hit_result::HitResult},
    entity::Position,
-    interact::HitResultComponent,
+    interact::pick::HitResultComponent,
    pathfinder::{
-        ExecutingPath, Pathfinder, PathfinderClientExt,
-        goals::{BlockPosGoal, Goal, InverseGoal, RadiusGoal, ReachBlockPosGoal, XZGoal, YGoal},
+        ExecutingPath, Pathfinder, PathfinderClientExt, PathfinderOpts,
+        goals::{BlockPosGoal, Goal, RadiusGoal, ReachBlockPosGoal, XZGoal, YGoal},
    },
    protocol::packets::game::{ServerboundPlayerCommand, s_player_command::Action},
-    world::MinecraftEntityId,
 };
 use mlua::{FromLua, Lua, Result, Table, UserDataRef, Value};

 use super::{Client, Direction, Vec3};
+use crate::unpack;

 #[derive(Debug)]
 struct AnyGoal(Box<dyn Goal>);
@@ -28,7 +28,7 @@ impl Goal for AnyGoal {
 }

 #[allow(clippy::cast_possible_truncation)]
-fn to_goal(lua: &Lua, client: &Client, data: Table, options: &Table, kind: u8) -> Result<AnyGoal> {
+fn to_goal(lua: &Lua, client: &AzaleaClient, data: Table, kind: u8) -> Result<AnyGoal> {
    let goal: Box<dyn Goal> = match kind {
        1 => {
            let pos = Vec3::from_lua(data.get("position")?, lua)?;
@@ -61,11 +61,7 @@ fn to_goal(lua: &Lua, client: &Client, data: Table, options: &Table, kind: u8) -
        }
    };

-    Ok(AnyGoal(if options.get("inverse").unwrap_or_default() {
-        Box::new(InverseGoal(AnyGoal(goal)))
-    } else {
-        goal
-    }))
+    Ok(AnyGoal(goal))
 }

 pub fn go_to_reached(_lua: &Lua, client: &Client) -> Result<bool> {
@@ -73,6 +69,7 @@ pub fn go_to_reached(_lua: &Lua, client: &Client) -> Result<bool> {
 }

 pub async fn wait_until_goal_reached(_lua: Lua, client: UserDataRef<Client>, (): ()) -> Result<()> {
+    let client = unpack!(client);
    client.wait_until_goto_target_reached().await;
    Ok(())
 }
@@ -82,21 +79,23 @@ pub async fn go_to(
    client: UserDataRef<Client>,
    (data, metadata): (Table, Option<Table>),
 ) -> Result<()> {
+    let client = unpack!(client);
+
    let metadata = metadata.unwrap_or(lua.create_table()?);
    let options = metadata.get("options").unwrap_or(lua.create_table()?);
    let goal = to_goal(
        &lua,
        &client,
        data,
-        &options,
        metadata.get("type").unwrap_or_default(),
    )?;
-    if options.get("without_mining").unwrap_or_default() {
-        client.start_goto_without_mining(goal);
-        client.wait_until_goto_target_reached().await;
-    } else {
-        client.goto(goal).await;
-    }
+    client
+        .goto_with_opts(
+            goal,
+            PathfinderOpts::new().allow_mining(options.get("without_mining").unwrap_or_default()),
+        )
+        .await;
+
    Ok(())
 }

@@ -105,20 +104,20 @@ pub async fn start_go_to(
    client: UserDataRef<Client>,
    (data, metadata): (Table, Option<Table>),
 ) -> Result<()> {
+    let client = unpack!(client);
+
    let metadata = metadata.unwrap_or(lua.create_table()?);
    let options = metadata.get("options").unwrap_or(lua.create_table()?);
    let goal = to_goal(
        &lua,
        &client,
        data,
-        &options,
        metadata.get("type").unwrap_or_default(),
    )?;
-    if options.get("without_mining").unwrap_or_default() {
-        client.start_goto_without_mining(goal);
-    } else {
-        client.start_goto(goal);
-    }
+    client.start_goto_with_opts(
+        goal,
+        PathfinderOpts::new().allow_mining(options.get("without_mining").unwrap_or_default()),
+    );
    let _ = client.get_tick_broadcaster().recv().await;

    Ok(())
@@ -127,8 +126,8 @@ pub async fn start_go_to(
 pub fn direction(_lua: &Lua, client: &Client) -> Result<Direction> {
    let direction = client.direction();
    Ok(Direction {
-        y: direction.0,
-        x: direction.1,
+        y: direction.y_rot(),
+        x: direction.x_rot(),
    })
 }

@@ -143,7 +142,7 @@ pub fn jump(_lua: &Lua, client: &Client, (): ()) -> Result<()> {

 pub fn looking_at(lua: &Lua, client: &Client) -> Result<Option<Table>> {
    Ok(
-        if let HitResult::Block(ref result) = *client.component::<HitResultComponent>() {
+        if let HitResult::Block(ref result) = **client.component::<HitResultComponent>() {
            let table = lua.create_table()?;
            table.set("direction", Vec3::from(result.direction.normal()))?;
            table.set("inside", result.inside)?;
@@ -176,8 +175,8 @@ pub fn pathfinder(lua: &Lua, client: &Client) -> Result<Table> {
                Vec3::from(pathfinder.last_reached_node),
            )?;
            table.set(
-                "last_node_reach_elapsed",
-                pathfinder.last_node_reached_at.elapsed().as_millis(),
+                "ticks_since_last_node_reached",
+                pathfinder.ticks_since_last_node_reached,
            )?;
            table.set("is_path_partial", pathfinder.is_path_partial)?;
            true
@@ -189,7 +188,7 @@ pub fn pathfinder(lua: &Lua, client: &Client) -> Result<Table> {
 }

 pub fn position(_lua: &Lua, client: &Client) -> Result<Vec3> {
-    Ok(Vec3::from(&client.component::<Position>()))
+    Ok(Vec3::from(*client.component::<Position>()))
 }

 pub fn set_direction(_lua: &Lua, client: &Client, direction: Direction) -> Result<()> {
@@ -202,25 +201,17 @@ pub fn set_jumping(_lua: &Lua, client: &Client, jumping: bool) -> Result<()> {
    Ok(())
 }

-pub fn set_position(_lua: &Lua, client: &Client, new_position: Vec3) -> Result<()> {
-    let mut ecs = client.ecs.lock();
-    let mut position = client.query::<&mut Position>(&mut ecs);
-    position.x = new_position.x;
-    position.y = new_position.y;
-    position.z = new_position.z;
+pub fn set_position(_lua: &Lua, client: &Client, new_pos: Vec3) -> Result<()> {
+    client.query_self::<&mut Position, _>(|mut pos| {
+        pos.x = new_pos.x;
+        pos.y = new_pos.y;
+        pos.z = new_pos.z;
+    });
    Ok(())
 }

 pub fn set_sneaking(_lua: &Lua, client: &Client, sneaking: bool) -> Result<()> {
-    client.write_packet(ServerboundPlayerCommand {
-        id: client.component::<MinecraftEntityId>(),
-        action: if sneaking {
-            Action::PressShiftKey
-        } else {
-            Action::ReleaseShiftKey
-        },
-        data: 0,
-    });
+    client.set_crouching(sneaking);
    Ok(())
 }

@@ -240,7 +231,7 @@ pub fn stop_pathfinding(_lua: &Lua, client: &Client, (): ()) -> Result<()> {

 pub fn stop_sleeping(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
    client.write_packet(ServerboundPlayerCommand {
-        id: client.component::<MinecraftEntityId>(),
+        id: *client.component::<MinecraftEntityId>(),
        action: Action::StopSleeping,
        data: 0,
    });
--- a/src/lua/client/state.rs
+++ b/src/lua/client/state.rs
@@ -1,18 +1,26 @@
 use azalea::{
-    ClientInformation,
-    entity::metadata::{AirSupply, Score},
-    pathfinder::debug::PathfinderDebugParticles,
+    ClientInformation, entity::metadata::AirSupply, pathfinder::debug::PathfinderDebugParticles,
    protocol::common::client_information::ModelCustomization,
 };
+use azalea_hax::AntiKnockback;
 use mlua::{Error, Lua, Result, Table, UserDataRef};

 use super::Client;
-use crate::hacks::anti_knockback::AntiKnockback;
+use crate::unpack;

 pub fn air_supply(_lua: &Lua, client: &Client) -> Result<i32> {
    Ok(client.component::<AirSupply>().0)
 }

+pub fn experience(lua: &Lua, client: &Client) -> Result<Table> {
+    let experience = client.experience();
+    let table = lua.create_table()?;
+    table.set("progress", experience.progress)?;
+    table.set("total", experience.total)?;
+    table.set("level", experience.level)?;
+    Ok(table)
+}
+
 pub fn health(_lua: &Lua, client: &Client) -> Result<f32> {
    Ok(client.health())
 }
@@ -25,18 +33,15 @@ pub fn hunger(lua: &Lua, client: &Client) -> Result<Table> {
    Ok(table)
 }

-pub fn score(_lua: &Lua, client: &Client) -> Result<i32> {
-    Ok(client.component::<Score>().0)
-}
-
 pub async fn set_client_information(
    _lua: Lua,
    client: UserDataRef<Client>,
    info: Table,
 ) -> Result<()> {
+    let client = unpack!(client);
+
    let get_bool = |table: &Table, name| table.get(name).unwrap_or(true);
-    client
-        .set_client_information(ClientInformation {
+    client.set_client_information(ClientInformation {
        allows_listing: info.get("allows_listing")?,
        model_customization: info
            .get::<Table>("model_customization")
@@ -53,8 +58,7 @@ pub async fn set_client_information(
            .unwrap_or_default(),
        view_distance: info.get("view_distance").unwrap_or(8),
        ..ClientInformation::default()
-        })
-        .await;
+    });
    Ok(())
 }

@@ -65,7 +69,7 @@ pub fn set_component(
 ) -> Result<()> {
    macro_rules! set {
        ($name:ident) => {{
-            let mut ecs = client.ecs.lock();
+            let mut ecs = client.ecs.write();
            let mut entity = ecs.entity_mut(client.entity);
            if enabled.unwrap_or(true) {
                entity.insert($name)
--- a/src/lua/client/world/find.rs
+++ b/src/lua/client/world/find.rs
@@ -1,16 +1,16 @@
 use azalea::{
    BlockPos,
-    blocks::{BlockState, BlockStates},
+    block::{BlockState, BlockStates},
    ecs::query::{With, Without},
    entity::{
-        Dead, EntityKind, EntityUuid, LookDirection, Pose, Position as AzaleaPosition,
+        Dead, EntityKindComponent, EntityUuid, LookDirection, Pose, Position as AzaleaPosition,
        metadata::{CustomName, Owneruuid, Player},
    },
-    world::MinecraftEntityId,
 };
 use mlua::{Function, Lua, Result, Table, UserDataRef};

 use super::{Client, Direction, Vec3};
+use crate::{lua::client::MinecraftEntityId, unpack};

 pub fn blocks(
    _lua: &Lua,
@@ -39,6 +39,8 @@ pub fn blocks(
 }

 pub async fn all_entities(lua: Lua, client: UserDataRef<Client>, (): ()) -> Result<Vec<Table>> {
+    let client = unpack!(client);
+
    let mut matched = Vec::with_capacity(256);
    for (position, custom_name, kind, uuid, direction, id, owner_uuid, pose) in
        get_entities!(client)
@@ -65,6 +67,8 @@ pub async fn entities(
    client: UserDataRef<Client>,
    filter_fn: Function,
 ) -> Result<Vec<Table>> {
+    let client = unpack!(client);
+
    let mut matched = Vec::new();
    for (position, custom_name, kind, uuid, direction, id, owner_uuid, pose) in
        get_entities!(client)
@@ -89,6 +93,8 @@ pub async fn entities(
 }

 pub async fn all_players(lua: Lua, client: UserDataRef<Client>, (): ()) -> Result<Vec<Table>> {
+    let client = unpack!(client);
+
    let mut matched = Vec::new();
    for (id, uuid, kind, position, direction, pose) in get_players!(client) {
        let table = lua.create_table()?;
@@ -108,6 +114,8 @@ pub async fn players(
    client: UserDataRef<Client>,
    filter_fn: Function,
 ) -> Result<Vec<Table>> {
+    let client = unpack!(client);
+
    let mut matched = Vec::new();
    for (id, uuid, kind, position, direction, pose) in get_players!(client) {
        let table = lua.create_table()?;
--- a/src/lua/client/world/mod.rs
+++ b/src/lua/client/world/mod.rs
@@ -2,7 +2,7 @@
 mod queries;
 pub mod find;

-use azalea::{BlockPos, auto_tool::AutoToolClientExt, blocks::BlockState, world::InstanceName};
+use azalea::{BlockPos, block::BlockState, world::WorldName};
 use mlua::{Lua, Result, Table, Value};

 use super::{Client, Direction, Vec3};
@@ -19,7 +19,7 @@ pub fn best_tool_for_block(lua: &Lua, client: &Client, block_state: u16) -> Resu
 }

 pub fn dimension(_lua: &Lua, client: &Client) -> Result<String> {
-    Ok(client.component::<InstanceName>().to_string())
+    Ok(client.component::<WorldName>().to_string())
 }

 pub fn get_block_state(_lua: &Lua, client: &Client, position: Vec3) -> Result<Option<u16>> {
@@ -27,7 +27,7 @@ pub fn get_block_state(_lua: &Lua, client: &Client, position: Vec3) -> Result<Op
    Ok(client
        .world()
        .read()
-        .get_block_state(&BlockPos::new(
+        .get_block_state(BlockPos::new(
            position.x as i32,
            position.y as i32,
            position.z as i32,
@@ -37,7 +37,7 @@ pub fn get_block_state(_lua: &Lua, client: &Client, position: Vec3) -> Result<Op

 #[allow(clippy::cast_possible_truncation)]
 pub fn get_fluid_state(lua: &Lua, client: &Client, position: Vec3) -> Result<Option<Table>> {
-    let fluid_state = client.world().read().get_fluid_state(&BlockPos::new(
+    let fluid_state = client.world().read().get_fluid_state(BlockPos::new(
        position.x as i32,
        position.y as i32,
        position.z as i32,
--- a/src/lua/client/world/queries.rs
+++ b/src/lua/client/world/queries.rs
@@ -1,22 +1,23 @@
 #[macro_export]
 macro_rules! get_entities {
    ($client:ident) => {{
-        let mut ecs = $client.ecs.lock();
-        ecs.query::<(
+        let ecs = $client.ecs.read();
+        if let Some(mut query) = ecs.try_query::<(
            &AzaleaPosition,
            &CustomName,
-            &EntityKind,
+            &EntityKindComponent,
            &EntityUuid,
            &LookDirection,
            &MinecraftEntityId,
            Option<&Owneruuid>,
            &Pose,
-        )>()
+        )>() {
+            query
                .iter(&ecs)
                .map(
                    |(position, custom_name, kind, uuid, direction, id, owner_uuid, pose)| {
                        (
-                    Vec3::from(position),
+                            Vec3::from(*position),
                            custom_name.as_ref().map(ToString::to_string),
                            kind.to_string(),
                            uuid.to_string(),
@@ -28,32 +29,40 @@ macro_rules! get_entities {
                    },
                )
                .collect::<Vec<_>>()
+        } else {
+            Vec::new()
+        }
    }};
 }

 #[macro_export]
 macro_rules! get_players {
    ($client:ident) => {{
-        let mut ecs = $client.ecs.lock();
-        ecs.query_filtered::<(
+        let ecs = $client.ecs.read();
+        if let Some(mut query) = ecs.try_query_filtered::<(
            &MinecraftEntityId,
            &EntityUuid,
-            &EntityKind,
+            &EntityKindComponent,
            &AzaleaPosition,
            &LookDirection,
            &Pose,
        ), (With<Player>, Without<Dead>)>()
+        {
+            query
                .iter(&ecs)
                .map(|(id, uuid, kind, position, direction, pose)| {
                    (
                        id.0,
                        uuid.to_string(),
                        kind.to_string(),
-                    Vec3::from(position),
+                        Vec3::from(*position),
                        Direction::from(direction),
                        *pose as u8,
                    )
                })
                .collect::<Vec<_>>()
+        } else {
+            Vec::new()
+        }
    }};
 }
--- a/src/lua/container/item_stack.rs
+++ b/src/lua/container/item_stack.rs
@@ -1,5 +1,5 @@
 use azalea::inventory::{
-    self,
+    self, ItemStackData,
    components::{Consumable, CustomName, Damage, Food, MaxDamage},
 };
 use mlua::{UserData, UserDataFields, UserDataMethods};
@@ -14,8 +14,7 @@ impl UserData for ItemStack {
        f.add_field_method_get("kind", |_, this| Ok(this.0.kind().to_string()));
        f.add_field_method_get("custom_name", |_, this| {
            Ok(this.0.as_present().map(|data| {
-                data.components
-                    .get::<CustomName>()
+                data.get_component::<CustomName>()
                    .map(|c| c.name.to_string())
            }))
        });
@@ -23,13 +22,13 @@ impl UserData for ItemStack {
            Ok(this
                .0
                .as_present()
-                .map(|data| data.components.get::<Damage>().map(|d| d.amount)))
+                .map(|data| data.get_component::<Damage>().map(|d| d.amount)))
        });
        f.add_field_method_get("max_damage", |_, this| {
            Ok(this
                .0
                .as_present()
-                .map(|data| data.components.get::<MaxDamage>().map(|d| d.amount)))
+                .map(|data| data.get_component::<MaxDamage>().map(|d| d.amount)))
        });

        f.add_field_method_get("consumable", |lua, this| {
@@ -37,7 +36,7 @@ impl UserData for ItemStack {
                if let Some(consumable) = this
                    .0
                    .as_present()
-                    .and_then(|data| data.components.get::<Consumable>())
+                    .and_then(ItemStackData::get_component::<Consumable>)
                {
                    let table = lua.create_table()?;
                    table.set("animation", consumable.animation as u8)?;
@@ -55,13 +54,12 @@ impl UserData for ItemStack {
                if let Some(food) = this
                    .0
                    .as_present()
-                    .and_then(|data| data.components.get::<Food>())
+                    .and_then(ItemStackData::get_component::<Food>)
                {
                    let table = lua.create_table()?;
                    table.set("nutrition", food.nutrition)?;
                    table.set("saturation", food.saturation)?;
                    table.set("can_always_eat", food.can_always_eat)?;
-                    table.set("eat_seconds", food.eat_seconds)?;
                    Some(table)
                } else {
                    None
--- a/src/lua/direction.rs
+++ b/src/lua/direction.rs
@@ -10,8 +10,8 @@ pub struct Direction {
 impl From<&LookDirection> for Direction {
    fn from(d: &LookDirection) -> Self {
        Self {
-            y: d.y_rot,
-            x: d.x_rot,
+            y: d.y_rot(),
+            x: d.x_rot(),
        }
    }
 }
--- a/src/lua/nochatreports/crypt.rs
+++ b/src/lua/nochatreports/crypt.rs
@@ -3,9 +3,8 @@ macro_rules! crypt {
    ($op:ident, $options:expr, $text:expr) => {{
        macro_rules! crypt_with {
            ($algo:ident) => {{
-                let encoding = $options.get("encoding").unwrap_or_default();
                let key = &$options.get::<UserDataRef<AesKey>>("key")?.0;
-                match encoding {
+                match $options.get("encoding").unwrap_or_default() {
                    1 => $algo::<Base64Encoding>::$op($text, &key),
                    2 => $algo::<Base64rEncoding>::$op($text, &key),
                    _ => $algo::<NewBase64rEncoding>::$op($text, &key),
--- a/src/lua/player.rs
+++ b/src/lua/player.rs
@@ -1,4 +1,4 @@
-use azalea::PlayerInfo;
+use azalea::player::PlayerInfo;
 use mlua::{IntoLua, Lua, Result, Value};

 #[derive(Clone)]
--- a/src/lua/vec3.rs
+++ b/src/lua/vec3.rs
@@ -28,8 +28,8 @@ impl From<azalea::Vec3> for Vec3 {
    }
 }

-impl From<&Position> for Vec3 {
-    fn from(p: &Position) -> Self {
+impl From<Position> for Vec3 {
+    fn from(p: Position) -> Self {
        Self {
            x: p.x,
            y: p.y,
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,3 @@
-#![feature(if_let_guard, let_chains)]
 #![warn(clippy::pedantic, clippy::nursery)]
 #![allow(clippy::significant_drop_tightening)]

@@ -6,15 +5,16 @@ mod arguments;
 mod build_info;
 mod commands;
 mod events;
-mod hacks;
 mod http;
 mod lua;
 mod particle;
-mod replay;

 #[cfg(feature = "matrix")]
 mod matrix;

+#[cfg(feature = "replay")]
+mod replay;
+
 use std::{
    collections::HashMap,
    env,
@@ -22,11 +22,12 @@ use std::{
    sync::Arc,
 };

-use anyhow::{Context, Result};
+use anyhow::{Context, Result, bail};
 use arguments::Arguments;
 use azalea::{
-    DefaultBotPlugins, DefaultPlugins, brigadier::prelude::CommandDispatcher, prelude::*,
+    DefaultPlugins, bot::DefaultBotPlugins, brigadier::prelude::CommandDispatcher, prelude::*,
 };
+use azalea_hax::HaxPlugin;
 use bevy_app::PluginGroup;
 use bevy_log::{
    LogPlugin,
@@ -36,10 +37,13 @@ use clap::Parser;
 use commands::{CommandSource, register};
 use futures::lock::Mutex;
 use futures_locks::RwLock;
-use hacks::HacksPlugin;
 use log::debug;
-use mlua::{Function, Lua, Table};
-use replay::{plugin::RecordPlugin, recorder::Recorder};
+use mlua::{Function, Lua};
+#[cfg(feature = "replay")]
+use {
+    mlua::Table,
+    replay::{plugin::RecordPlugin, recorder::Recorder},
+};

 #[cfg(feature = "mimalloc")]
 #[global_allocator]
@@ -95,21 +99,25 @@ async fn main() -> Result<()> {
        DefaultPlugins.set(LogPlugin {
            custom_layer: |_| {
                env::var("LOG_FILE").ok().map(|path| {
-                    layer()
-                        .with_writer(
-                            OpenOptions::new()
+                    let file = OpenOptions::new()
                        .append(true)
                        .create(true)
                        .open(&path)
-                                .expect(&(path + " should be accessible")),
-                        )
-                        .boxed()
+                        .expect(&(path + " should be accessible"));
+                    layer().with_writer(file).boxed()
                })
            },
            ..Default::default()
        })
    };
-    let record_plugin = RecordPlugin {
+
+    let builder = ClientBuilder::new_without_plugins()
+        .add_plugins(default_plugins)
+        .add_plugins(DefaultBotPlugins)
+        .add_plugins(HaxPlugin);
+
+    #[cfg(feature = "replay")]
+    let builder = builder.add_plugins(RecordPlugin {
        recorder: Arc::new(parking_lot::Mutex::new(
            if let Ok(options) = globals.get::<Table>("ReplayRecordingOptions")
                && let Ok(path) = options.get::<String>("path")
@@ -125,17 +133,15 @@ async fn main() -> Result<()> {
                None
            },
        )),
-    };
+    });
+
    let account = if username.contains('@') {
        Account::microsoft(&username).await?
    } else {
        Account::offline(&username)
    };
-    let Err(err) = ClientBuilder::new_without_plugins()
-        .add_plugins(DefaultBotPlugins)
-        .add_plugins(HacksPlugin)
-        .add_plugins(default_plugins)
-        .add_plugins(record_plugin)
+
+    if let AppExit::Error(code) = builder
        .set_handler(events::handle_event)
        .set_state(State {
            lua: Arc::new(lua),
@@ -143,8 +149,10 @@ async fn main() -> Result<()> {
            commands: Arc::new(commands),
        })
        .start(account, server)
-        .await;
-    eprintln!("{err}");
+        .await
+    {
+        bail!("azalea exited with code {code}")
+    }

    Ok(())
 }
--- a/src/particle.rs
+++ b/src/particle.rs
@@ -1,121 +1,124 @@
-use azalea::{entity::particle::Particle, registry::ParticleKind};
+use azalea::{entity::particle::Particle, registry::builtin::ParticleKind};

 #[allow(clippy::too_many_lines)]
 pub const fn to_kind(particle: &Particle) -> ParticleKind {
    match particle {
        Particle::AngryVillager => ParticleKind::AngryVillager,
+        Particle::Ash => ParticleKind::Ash,
        Particle::Block(_) => ParticleKind::Block,
+        Particle::BlockCrumble => ParticleKind::BlockCrumble,
        Particle::BlockMarker(_) => ParticleKind::BlockMarker,
        Particle::Bubble => ParticleKind::Bubble,
+        Particle::BubbleColumnUp => ParticleKind::BubbleColumnUp,
+        Particle::BubblePop => ParticleKind::BubblePop,
+        Particle::CampfireCosySmoke => ParticleKind::CampfireCosySmoke,
+        Particle::CampfireSignalSmoke => ParticleKind::CampfireSignalSmoke,
+        Particle::CherryLeaves => ParticleKind::CherryLeaves,
        Particle::Cloud => ParticleKind::Cloud,
+        Particle::Composter => ParticleKind::Composter,
+        Particle::CopperFireFlame => ParticleKind::CopperFireFlame,
+        Particle::CrimsonSpore => ParticleKind::CrimsonSpore,
        Particle::Crit => ParticleKind::Crit,
+        Particle::CurrentDown => ParticleKind::CurrentDown,
        Particle::DamageIndicator => ParticleKind::DamageIndicator,
+        Particle::Dolphin => ParticleKind::Dolphin,
        Particle::DragonBreath => ParticleKind::DragonBreath,
+        Particle::DrippingDripstoneLava => ParticleKind::DrippingDripstoneLava,
+        Particle::DrippingDripstoneWater => ParticleKind::DrippingDripstoneWater,
+        Particle::DrippingHoney => ParticleKind::DrippingHoney,
        Particle::DrippingLava => ParticleKind::DrippingLava,
-        Particle::FallingLava => ParticleKind::FallingLava,
-        Particle::LandingLava => ParticleKind::LandingLava,
+        Particle::DrippingObsidianTear => ParticleKind::DrippingObsidianTear,
        Particle::DrippingWater => ParticleKind::DrippingWater,
-        Particle::FallingWater => ParticleKind::FallingWater,
        Particle::Dust(_) => ParticleKind::Dust,
        Particle::DustColorTransition(_) => ParticleKind::DustColorTransition,
+        Particle::DustPillar => ParticleKind::DustPillar,
+        Particle::DustPlume => ParticleKind::DustPlume,
        Particle::Effect => ParticleKind::Effect,
+        Particle::EggCrack => ParticleKind::EggCrack,
        Particle::ElderGuardian => ParticleKind::ElderGuardian,
-        Particle::EnchantedHit => ParticleKind::EnchantedHit,
+        Particle::ElectricSpark => ParticleKind::ElectricSpark,
        Particle::Enchant => ParticleKind::Enchant,
+        Particle::EnchantedHit => ParticleKind::EnchantedHit,
        Particle::EndRod => ParticleKind::EndRod,
        Particle::EntityEffect(_) => ParticleKind::EntityEffect,
-        Particle::ExplosionEmitter => ParticleKind::ExplosionEmitter,
        Particle::Explosion => ParticleKind::Explosion,
-        Particle::Gust => ParticleKind::Gust,
-        Particle::SonicBoom => ParticleKind::SonicBoom,
+        Particle::ExplosionEmitter => ParticleKind::ExplosionEmitter,
+        Particle::FallingDripstoneLava => ParticleKind::FallingDripstoneLava,
+        Particle::FallingDripstoneWater => ParticleKind::FallingDripstoneWater,
        Particle::FallingDust(_) => ParticleKind::FallingDust,
+        Particle::FallingHoney => ParticleKind::FallingHoney,
+        Particle::FallingLava => ParticleKind::FallingLava,
+        Particle::FallingNectar => ParticleKind::FallingNectar,
+        Particle::FallingObsidianTear => ParticleKind::FallingObsidianTear,
+        Particle::FallingSporeBlossom => ParticleKind::FallingSporeBlossom,
+        Particle::FallingWater => ParticleKind::FallingWater,
+        Particle::Firefly => ParticleKind::Firefly,
        Particle::Firework => ParticleKind::Firework,
        Particle::Fishing => ParticleKind::Fishing,
        Particle::Flame => ParticleKind::Flame,
-        Particle::CherryLeaves => ParticleKind::CherryLeaves,
-        Particle::PaleOakLeaves => ParticleKind::PaleOakLeaves,
-        Particle::TintedLeaves => ParticleKind::TintedLeaves,
-        Particle::SculkSoul => ParticleKind::SculkSoul,
-        Particle::SculkCharge(_) => ParticleKind::SculkCharge,
-        Particle::SculkChargePop => ParticleKind::SculkChargePop,
-        Particle::SoulFireFlame => ParticleKind::SoulFireFlame,
-        Particle::Soul => ParticleKind::Soul,
        Particle::Flash => ParticleKind::Flash,
+        Particle::Glow => ParticleKind::Glow,
+        Particle::GlowSquidInk => ParticleKind::GlowSquidInk,
+        Particle::Gust => ParticleKind::Gust,
+        Particle::GustEmitterLarge => ParticleKind::GustEmitterLarge,
+        Particle::GustEmitterSmall => ParticleKind::GustEmitterSmall,
        Particle::HappyVillager => ParticleKind::HappyVillager,
-        Particle::Composter => ParticleKind::Composter,
        Particle::Heart => ParticleKind::Heart,
+        Particle::Infested => ParticleKind::Infested,
        Particle::InstantEffect => ParticleKind::InstantEffect,
        Particle::Item(_) => ParticleKind::Item,
-        Particle::Vibration(_) => ParticleKind::Vibration,
+        Particle::ItemCobweb => ParticleKind::ItemCobweb,
        Particle::ItemSlime => ParticleKind::ItemSlime,
        Particle::ItemSnowball => ParticleKind::ItemSnowball,
+        Particle::LandingHoney => ParticleKind::LandingHoney,
+        Particle::LandingLava => ParticleKind::LandingLava,
+        Particle::LandingObsidianTear => ParticleKind::LandingObsidianTear,
        Particle::LargeSmoke => ParticleKind::LargeSmoke,
        Particle::Lava => ParticleKind::Lava,
        Particle::Mycelium => ParticleKind::Mycelium,
+        Particle::Nautilus => ParticleKind::Nautilus,
        Particle::Note => ParticleKind::Note,
+        Particle::OminousSpawning => ParticleKind::OminousSpawning,
+        Particle::PaleOakLeaves => ParticleKind::PaleOakLeaves,
+        Particle::PauseMobGrowth => ParticleKind::PauseMobGrowth,
        Particle::Poof => ParticleKind::Poof,
        Particle::Portal => ParticleKind::Portal,
+        Particle::RaidOmen => ParticleKind::RaidOmen,
        Particle::Rain => ParticleKind::Rain,
+        Particle::ResetMobGrowth => ParticleKind::ResetMobGrowth,
+        Particle::ReversePortal => ParticleKind::ReversePortal,
+        Particle::Scrape => ParticleKind::Scrape,
+        Particle::SculkCharge(_) => ParticleKind::SculkCharge,
+        Particle::SculkChargePop => ParticleKind::SculkChargePop,
+        Particle::SculkSoul => ParticleKind::SculkSoul,
+        Particle::Shriek(_) => ParticleKind::Shriek,
+        Particle::SmallFlame => ParticleKind::SmallFlame,
+        Particle::SmallGust => ParticleKind::SmallGust,
        Particle::Smoke => ParticleKind::Smoke,
-        Particle::WhiteSmoke => ParticleKind::WhiteSmoke,
        Particle::Sneeze => ParticleKind::Sneeze,
+        Particle::Snowflake => ParticleKind::Snowflake,
+        Particle::SonicBoom => ParticleKind::SonicBoom,
+        Particle::Soul => ParticleKind::Soul,
+        Particle::SoulFireFlame => ParticleKind::SoulFireFlame,
        Particle::Spit => ParticleKind::Spit,
+        Particle::Splash => ParticleKind::Splash,
+        Particle::SporeBlossomAir => ParticleKind::SporeBlossomAir,
        Particle::SquidInk => ParticleKind::SquidInk,
        Particle::SweepAttack => ParticleKind::SweepAttack,
+        Particle::TintedLeaves => ParticleKind::TintedLeaves,
        Particle::TotemOfUndying => ParticleKind::TotemOfUndying,
-        Particle::Underwater => ParticleKind::Underwater,
-        Particle::Splash => ParticleKind::Splash,
-        Particle::Witch => ParticleKind::Witch,
-        Particle::BubblePop => ParticleKind::BubblePop,
-        Particle::CurrentDown => ParticleKind::CurrentDown,
-        Particle::BubbleColumnUp => ParticleKind::BubbleColumnUp,
-        Particle::Nautilus => ParticleKind::Nautilus,
-        Particle::Dolphin => ParticleKind::Dolphin,
-        Particle::CampfireCosySmoke => ParticleKind::CampfireCosySmoke,
-        Particle::CampfireSignalSmoke => ParticleKind::CampfireSignalSmoke,
-        Particle::DrippingHoney => ParticleKind::DrippingHoney,
-        Particle::FallingHoney => ParticleKind::FallingHoney,
-        Particle::LandingHoney => ParticleKind::LandingHoney,
-        Particle::FallingNectar => ParticleKind::FallingNectar,
-        Particle::FallingSporeBlossom => ParticleKind::FallingSporeBlossom,
-        Particle::Ash => ParticleKind::Ash,
-        Particle::CrimsonSpore => ParticleKind::CrimsonSpore,
-        Particle::WarpedSpore => ParticleKind::WarpedSpore,
-        Particle::SporeBlossomAir => ParticleKind::SporeBlossomAir,
-        Particle::DrippingObsidianTear => ParticleKind::DrippingObsidianTear,
-        Particle::FallingObsidianTear => ParticleKind::FallingObsidianTear,
-        Particle::LandingObsidianTear => ParticleKind::LandingObsidianTear,
-        Particle::ReversePortal => ParticleKind::ReversePortal,
-        Particle::WhiteAsh => ParticleKind::WhiteAsh,
-        Particle::SmallFlame => ParticleKind::SmallFlame,
-        Particle::Snowflake => ParticleKind::Snowflake,
-        Particle::DrippingDripstoneLava => ParticleKind::DrippingDripstoneLava,
-        Particle::FallingDripstoneLava => ParticleKind::FallingDripstoneLava,
-        Particle::DrippingDripstoneWater => ParticleKind::DrippingDripstoneWater,
-        Particle::FallingDripstoneWater => ParticleKind::FallingDripstoneWater,
-        Particle::GlowSquidInk => ParticleKind::GlowSquidInk,
-        Particle::Glow => ParticleKind::Glow,
-        Particle::WaxOn => ParticleKind::WaxOn,
-        Particle::WaxOff => ParticleKind::WaxOff,
-        Particle::ElectricSpark => ParticleKind::ElectricSpark,
-        Particle::Scrape => ParticleKind::Scrape,
-        Particle::Shriek(_) => ParticleKind::Shriek,
-        Particle::EggCrack => ParticleKind::EggCrack,
-        Particle::DustPlume => ParticleKind::DustPlume,
-        Particle::SmallGust => ParticleKind::SmallGust,
-        Particle::GustEmitterLarge => ParticleKind::GustEmitterLarge,
-        Particle::GustEmitterSmall => ParticleKind::GustEmitterSmall,
-        Particle::Infested => ParticleKind::Infested,
-        Particle::ItemCobweb => ParticleKind::ItemCobweb,
+        Particle::Trail => ParticleKind::Trail,
+        Particle::TrialOmen => ParticleKind::TrialOmen,
        Particle::TrialSpawnerDetection => ParticleKind::TrialSpawnerDetection,
        Particle::TrialSpawnerDetectionOminous => ParticleKind::TrialSpawnerDetectionOminous,
+        Particle::Underwater => ParticleKind::Underwater,
        Particle::VaultConnection => ParticleKind::VaultConnection,
-        Particle::DustPillar => ParticleKind::DustPillar,
-        Particle::OminousSpawning => ParticleKind::OminousSpawning,
-        Particle::RaidOmen => ParticleKind::RaidOmen,
-        Particle::TrialOmen => ParticleKind::TrialOmen,
-        Particle::Trail => ParticleKind::Trail,
-        Particle::BlockCrumble => ParticleKind::BlockCrumble,
-        Particle::Firefly => ParticleKind::Firefly,
+        Particle::Vibration(_) => ParticleKind::Vibration,
+        Particle::WarpedSpore => ParticleKind::WarpedSpore,
+        Particle::WaxOff => ParticleKind::WaxOff,
+        Particle::WaxOn => ParticleKind::WaxOn,
+        Particle::WhiteAsh => ParticleKind::WhiteAsh,
+        Particle::WhiteSmoke => ParticleKind::WhiteSmoke,
+        Particle::Witch => ParticleKind::Witch,
    }
 }
--- a/src/replay/plugin.rs
+++ b/src/replay/plugin.rs
@@ -3,7 +3,6 @@
 use std::sync::Arc;

 use azalea::{
-    ecs::event::EventReader,
    packet::{
        config::ReceiveConfigPacketEvent, game::ReceiveGamePacketEvent,
        login::ReceiveLoginPacketEvent,
@@ -11,7 +10,7 @@ use azalea::{
    protocol::packets::login::ClientboundLoginPacket,
 };
 use bevy_app::{App, First, Plugin};
-use bevy_ecs::system::ResMut;
+use bevy_ecs::{message::MessageReader, system::ResMut};
 use log::error;
 use parking_lot::Mutex;

@@ -35,7 +34,7 @@ impl Plugin for RecordPlugin {

 fn record_login_packets(
    recorder: Option<ResMut<Recorder>>,
-    mut events: EventReader<ReceiveLoginPacketEvent>,
+    mut events: MessageReader<ReceiveLoginPacketEvent>,
 ) {
    if let Some(mut recorder) = recorder {
        for event in events.read() {
@@ -54,7 +53,7 @@ fn record_login_packets(

 fn record_configuration_packets(
    recorder: Option<ResMut<Recorder>>,
-    mut events: EventReader<ReceiveConfigPacketEvent>,
+    mut events: MessageReader<ReceiveConfigPacketEvent>,
 ) {
    if let Some(mut recorder) = recorder {
        for event in events.read() {
@@ -67,7 +66,7 @@ fn record_configuration_packets(

 fn record_game_packets(
    recorder: Option<ResMut<Recorder>>,
-    mut events: EventReader<ReceiveGamePacketEvent>,
+    mut events: MessageReader<ReceiveGamePacketEvent>,
 ) {
    if let Some(mut recorder) = recorder {
        for event in events.read() {
--- a/src/replay/recorder.rs
+++ b/src/replay/recorder.rs
@@ -6,7 +6,7 @@ use std::{

 use anyhow::Result;
 use azalea::{
-    buf::AzaleaWriteVar,
+    buf::AzBufVar,
    prelude::Resource,
    protocol::packets::{PROTOCOL_VERSION, ProtocolPacket, VERSION_NAME},
 };
Author	SHA1	Message	Date
ErrorNoInternet	612018194c	Merge branch 'update' into main	2026-04-13 16:21:21 -04:00
ErrorNoInternet	4e129a459d	fix(client): handle borrows with async	2026-04-13 16:19:52 -04:00
ErrorNoInternet	3c3184c974	fix(replay): rename paths to compile Haven't tested yet though.	2026-04-13 16:19:51 -04:00
ErrorNoInternet	e7080a69a7	feat(client)!: replace score with experience	2026-04-13 16:19:51 -04:00
ErrorNoInternet	07bfca309a	build(deps)!: update azalea and fix ecs changes	2026-04-13 16:19:51 -04:00
ErrorNoInternet	f7b2cf8596	build: disable matrix feature by default	2026-04-13 13:10:42 -04:00
ErrorNoInternet	d6b90dd7a5	feat: add nix flake	2026-04-13 13:10:42 -04:00
ErrorNoInternet	2cf4265732	refactor(commands): directly use native encryption function	2025-04-29 08:11:52 -04:00
ErrorNoInternet	ca8c9d4d1c	style(events): allow clippy::cognitive_complexity for handler	2025-04-28 21:01:16 -04:00
ErrorNoInternet	64c96450a4	perf(commands): move ncr data to binding	2025-04-28 20:49:14 -04:00