diff --git a/crates/pumpkin/src/plugin/api/context.rs b/crates/pumpkin/src/plugin/api/context.rs
index d0e6c8660..795f2964c 100644
--- a/crates/pumpkin/src/plugin/api/context.rs
+++ b/crates/pumpkin/src/plugin/api/context.rs
@@ -8,11 +8,11 @@ use crate::{
     LoggerOption, command::client_suggestions, net::ClientPlatform, plugin::PluginMetadata,
     plugin_log,
 };
+use arc_swap::ArcSwap;
 use pumpkin_util::{
     PermissionLvl,
     permission::{Permission, PermissionManager},
 };
-use tokio::sync::RwLock;
 use tracing::Level;
 
 use crate::{
@@ -31,11 +31,11 @@ use super::{EventPriority, Payload};
 /// # Fields
 /// - `metadata`: Metadata of the plugin.
 /// - `server`: A reference to the server on which the plugin operates.
-/// - `handlers`: A map of event handlers, protected by a read-write lock for safe access across threads.
+/// - `handlers`: A map of event handlers, wrapped in `ArcSwap` for lock-free read access across threads.
 pub struct Context {
     metadata: PluginMetadata,
     pub server: Arc<Server>,
-    pub handlers: Arc<RwLock<HandlerMap>>,
+    pub handlers: Arc<ArcSwap<HandlerMap>>,
     pub plugin_manager: Arc<PluginManager>,
     pub permission_manager: Arc<PermissionManager>,
     pub logger: Arc<OnceLock<LoggerOption>>,
@@ -54,7 +54,7 @@ impl Context {
     pub fn new(
         metadata: PluginMetadata,
         server: Arc<Server>,
-        handlers: Arc<RwLock<HandlerMap>>,
+        handlers: Arc<ArcSwap<HandlerMap>>,
         plugin_manager: Arc<PluginManager>,
         logger: Arc<OnceLock<LoggerOption>>,
     ) -> Self {
@@ -257,7 +257,7 @@ impl Context {
             .has_permission(player_uuid, permission, player_op_level)
     }
 
-    /// Asynchronously registers an event handler for a specific event type.
+    /// Registers an event handler for a specific event type.
     ///
     /// # Type Parameters
     /// - `E`: The event type that the handler will respond to.
@@ -270,7 +270,7 @@ impl Context {
     ///
     /// # Constraints
     /// The handler must implement the `EventHandler<E>` trait.
-    pub async fn register_event<E: Payload + 'static, H>(
+    pub fn register_event<E: Payload + 'static, H>(
         &self,
         handler: Arc<H>,
         priority: EventPriority,
@@ -278,19 +278,21 @@ impl Context {
     ) where
         H: EventHandler<E> + 'static,
     {
-        let mut handlers = self.handlers.write().await;
-
-        let handlers_vec = handlers
-            .entry(E::get_name_static())
-            .or_insert_with(Vec::new);
-
-        let typed_handler = TypedEventHandler {
+        let typed_handler = Arc::new(TypedEventHandler {
             handler,
             priority,
             blocking,
             _phantom: std::marker::PhantomData,
-        };
-        handlers_vec.push(Box::new(typed_handler));
+        });
+
+        self.handlers.rcu(|handlers| {
+            let mut new_handlers = (**handlers).clone();
+            new_handlers
+                .entry(E::get_name_static())
+                .or_default()
+                .push(typed_handler.clone());
+            Arc::new(new_handlers)
+        });
     }
 
     /// Registers a custom plugin loader that can load additional plugin types.
diff --git a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/context.rs b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/context.rs
index 9ca6f341c..36a647ad8 100644
--- a/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/context.rs
+++ b/crates/pumpkin/src/plugin/loader/wasm/wasm_host/wit/v0_1/context.rs
@@ -21,14 +21,15 @@ use crate::plugin::loader::wasm::wasm_host::{
 
 macro_rules! register_host_event {
     ($resource:expr, $handler:expr, $priority:expr, $blocking:expr, $event_ty:ty) => {
-        $resource
-            .provider
-            .register_event::<$event_ty, _>(Arc::clone($handler), $priority, $blocking)
-            .await
+        $resource.provider.register_event::<$event_ty, _>(
+            Arc::clone($handler),
+            $priority,
+            $blocking,
+        )
     };
 }
 
-async fn register_typed_event<E: crate::plugin::Payload + ToFromWasmEvent + 'static>(
+fn register_typed_event<E: crate::plugin::Payload + ToFromWasmEvent + 'static>(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -38,7 +39,7 @@ async fn register_typed_event<E: crate::plugin::Payload + ToFromWasmEvent + 'sta
 }
 
 #[expect(clippy::too_many_lines)]
-async fn register_player_event(
+fn register_player_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -67,421 +68,364 @@ async fn register_player_event(
 
     match event_type {
         EventType::PlayerJoinEvent => {
-            register_typed_event::<PlayerJoinEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PlayerJoinEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerLeaveEvent => {
-            register_typed_event::<PlayerLeaveEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PlayerLeaveEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerLoginEvent => {
-            register_typed_event::<PlayerLoginEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PlayerLoginEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerChatEvent => {
-            register_typed_event::<PlayerChatEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PlayerChatEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerCommandSendEvent => {
-            register_typed_event::<PlayerCommandSendEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerCommandSendEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerPermissionCheckEvent => {
             register_typed_event::<PlayerPermissionCheckEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::PlayerMoveEvent => {
-            register_typed_event::<PlayerMoveEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PlayerMoveEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerTeleportEvent => {
-            register_typed_event::<PlayerTeleportEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerTeleportEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerChangeWorldEvent => {
-            register_typed_event::<PlayerChangeWorldEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerChangeWorldEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerRespawnEvent => {
-            register_typed_event::<PlayerRespawnEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PlayerRespawnEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerExpChangeEvent => {
-            register_typed_event::<PlayerExpChangeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerExpChangeEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerItemHeldEvent => {
-            register_typed_event::<PlayerItemHeldEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerItemHeldEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerChangedMainHandEvent => {
             register_typed_event::<PlayerChangedMainHandEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::PlayerGamemodeChangeEvent => {
             register_typed_event::<PlayerGamemodeChangeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::PlayerCustomPayloadEvent => {
-            register_typed_event::<PlayerCustomPayloadEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerCustomPayloadEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerFishEvent => {
-            register_typed_event::<PlayerFishEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PlayerFishEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerEggThrowEvent => {
-            register_typed_event::<PlayerEggThrowEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerEggThrowEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerInteractUnknownEntityEvent => {
             register_typed_event::<PlayerInteractUnknownEntityEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::PlayerInteractEntityEvent => {
             register_typed_event::<PlayerInteractEntityEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::PlayerInteractEvent => {
-            register_typed_event::<PlayerInteractEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerInteractEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerToggleSneakEvent => {
-            register_typed_event::<PlayerToggleSneakEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerToggleSneakEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerToggleFlightEvent => {
-            register_typed_event::<PlayerToggleFlightEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerToggleFlightEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerToggleSprintEvent => {
-            register_typed_event::<PlayerToggleSprintEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PlayerToggleSprintEvent>(resource, handler, priority, blocking);
         }
         EventType::InventoryClickEvent => {
-            register_typed_event::<InventoryClickEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<InventoryClickEvent>(resource, handler, priority, blocking);
         }
         EventType::InventoryCloseEvent => {
-            register_typed_event::<InventoryCloseEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<InventoryCloseEvent>(resource, handler, priority, blocking);
         }
         EventType::BedrockFormResponseEvent => {
-            register_typed_event::<BedrockFormResponseEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<BedrockFormResponseEvent>(resource, handler, priority, blocking);
         }
         EventType::CustomClickActionEvent => {
-            register_typed_event::<CustomClickActionEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<CustomClickActionEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerItemConsumeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_item_consume::PlayerItemConsumeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerItemDamageEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_item_damage::PlayerItemDamageEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerDropItemEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_drop_item::PlayerDropItemEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerBedEnterEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_bed::PlayerBedEnterEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerBedLeaveEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_bed::PlayerBedLeaveEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerBucketEmptyEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_bucket::PlayerBucketEmptyEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerBucketFillEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_bucket::PlayerBucketFillEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::AsyncPlayerChatEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::async_player_chat::AsyncPlayerChatEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::AsyncPlayerPreLoginEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::async_player_pre_login::AsyncPlayerPreLoginEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerAdvancementDoneEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_advancement_done::PlayerAdvancementDoneEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerAnimationEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_animation::PlayerAnimationEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerArmorStandManipulateEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_armor_stand_manipulate::PlayerArmorStandManipulateEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerBucketEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_bucket_entity::PlayerBucketEntityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerChangedWorldEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_changed_world::PlayerChangedWorldEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerChannelEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_channel::PlayerChannelEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerCommandPreprocessEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_command_preprocess::PlayerCommandPreprocessEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerEditBookEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_edit_book::PlayerEditBookEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerElytraBoostEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_elytra_boost::PlayerElytraBoostEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerExpCooldownChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_exp_cooldown_change::PlayerExpCooldownChangeEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerHarvestBlockEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_harvest_block::PlayerHarvestBlockEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerHideEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_hide_entity::PlayerHideEntityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerItemBreakEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_item_break::PlayerItemBreakEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerItemMendEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_item_mend::PlayerItemMendEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerKickEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::player::player_kick::PlayerKickEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::player::player_kick::PlayerKickEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::PlayerLeashEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_leash_entity::PlayerLeashEntityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerLevelChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_level_change::PlayerLevelChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerLocaleChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_locale_change::PlayerLocaleChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerNameEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_name_entity::PlayerNameEntityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerOpenSignEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_open_sign::PlayerOpenSignEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerPortalEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_portal::PlayerPortalEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerPreLoginEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_pre_login::PlayerPreLoginEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerRiptideEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_riptide::PlayerRiptideEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerShearEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_shear_entity::PlayerShearEntityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerShowEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_show_entity::PlayerShowEntityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerSpawnChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_spawn_change::PlayerSpawnChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerStatisticIncrementEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_statistic_increment::PlayerStatisticIncrementEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerSwapHandsEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_swap_hands::PlayerSwapHandItemsEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerTakeLecternBookEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_take_lectern_book::PlayerTakeLecternBookEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerUnleashEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_unleash_entity::PlayerUnleashEntityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerVelocityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_velocity::PlayerVelocityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerInputEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_input::PlayerInputEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerInteractAtEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_interact_at_entity::PlayerInteractAtEntityEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerLinksSendEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_links_send::PlayerLinksSendEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerPickupArrowEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_pickup_arrow::PlayerPickupArrowEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerRecipeBookClickEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_recipe_book_click::PlayerRecipeBookClickEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerRecipeBookSettingsChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_recipe_book_settings_change::PlayerRecipeBookSettingsChangeEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerRecipeDiscoverEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_recipe_discover::PlayerRecipeDiscoverEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerRegisterChannelEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_register_channel::PlayerRegisterChannelEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerResourcePackStatusEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_resource_pack_status::PlayerResourcePackStatusEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::PlayerSpawnLocationEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_spawn_location::PlayerSpawnLocationEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PlayerUnregisterChannelEvent => {
             register_typed_event::<
                 crate::plugin::api::events::player::player_unregister_channel::PlayerUnregisterChannelEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         _ => {
             tracing::error!("non-player event should not be routed to register_player_event");
@@ -505,7 +449,7 @@ impl PluginHostState {
 }
 
 #[allow(clippy::too_many_lines)]
-async fn register_entity_event(
+fn register_entity_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -593,311 +537,263 @@ async fn register_entity_event(
 
     match event_type {
         EventType::EntityDamageEvent => {
-            register_typed_event::<EntityDamageEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityDamageEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityDeathEvent => {
-            register_typed_event::<EntityDeathEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityDeathEvent>(resource, handler, priority, blocking);
         }
         EventType::PlayerDeathEvent => {
-            register_typed_event::<PlayerDeathEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PlayerDeathEvent>(resource, handler, priority, blocking);
         }
         EventType::EntitySpawnEvent => {
-            register_typed_event::<EntitySpawnEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntitySpawnEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityCombustEvent => {
-            register_typed_event::<EntityCombustEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityCombustEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityRegainHealthEvent => {
-            register_typed_event::<EntityRegainHealthEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityRegainHealthEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityAirChangeEvent => {
-            register_typed_event::<EntityAirChangeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityAirChangeEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityBreedEvent => {
-            register_typed_event::<EntityBreedEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityBreedEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityDismountEvent => {
-            register_typed_event::<EntityDismountEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityDismountEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityDyeEvent => {
-            register_typed_event::<EntityDyeEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityDyeEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityEnterLoveModeEvent => {
-            register_typed_event::<EntityEnterLoveModeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityEnterLoveModeEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityExplodeEvent => {
-            register_typed_event::<EntityExplodeEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityExplodeEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityMountEvent => {
-            register_typed_event::<EntityMountEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityMountEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityPickupItemEvent => {
-            register_typed_event::<EntityPickupItemEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityPickupItemEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityPortalEvent => {
-            register_typed_event::<EntityPortalEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityPortalEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityResurrectEvent => {
-            register_typed_event::<EntityResurrectEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityResurrectEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityShootBowEvent => {
-            register_typed_event::<EntityShootBowEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityShootBowEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityTameEvent => {
-            register_typed_event::<EntityTameEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityTameEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityTargetEvent => {
-            register_typed_event::<EntityTargetEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityTargetEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityTeleportEvent => {
-            register_typed_event::<EntityTeleportEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityTeleportEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityToggleGlideEvent => {
-            register_typed_event::<EntityToggleGlideEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityToggleGlideEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityTransformEvent => {
-            register_typed_event::<EntityTransformEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityTransformEvent>(resource, handler, priority, blocking);
         }
         EventType::CreatureSpawnEvent => {
-            register_typed_event::<CreatureSpawnEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<CreatureSpawnEvent>(resource, handler, priority, blocking);
         }
         EventType::EnderDragonChangePhaseEvent => {
             register_typed_event::<EnderDragonChangePhaseEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::EntityBreakDoorEvent => {
-            register_typed_event::<EntityBreakDoorEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityBreakDoorEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityChangeBlockEvent => {
-            register_typed_event::<EntityChangeBlockEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityChangeBlockEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityDamageByBlockEvent => {
-            register_typed_event::<EntityDamageByBlockEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityDamageByBlockEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityDamageByEntityEvent => {
             register_typed_event::<EntityDamageByEntityEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::EntityDropItemEvent => {
-            register_typed_event::<EntityDropItemEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityDropItemEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityEnterBlockEvent => {
-            register_typed_event::<EntityEnterBlockEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityEnterBlockEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityExhaustionEvent => {
-            register_typed_event::<EntityExhaustionEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityExhaustionEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityInteractEvent => {
-            register_typed_event::<EntityInteractEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityInteractEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityKnockbackEvent => {
-            register_typed_event::<EntityKnockbackEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityKnockbackEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityPlaceEvent => {
-            register_typed_event::<EntityPlaceEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityPlaceEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityPoseChangeEvent => {
-            register_typed_event::<EntityPoseChangeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityPoseChangeEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityPotionEffectEvent => {
-            register_typed_event::<EntityPotionEffectEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityPotionEffectEvent>(resource, handler, priority, blocking);
         }
         EventType::EntitySpellCastEvent => {
-            register_typed_event::<EntitySpellCastEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntitySpellCastEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityTargetLivingEntityEvent => {
             register_typed_event::<EntityTargetLivingEntityEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::EntityToggleSwimEvent => {
-            register_typed_event::<EntityToggleSwimEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityToggleSwimEvent>(resource, handler, priority, blocking);
         }
         EventType::ExplosionPrimeEvent => {
-            register_typed_event::<ExplosionPrimeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<ExplosionPrimeEvent>(resource, handler, priority, blocking);
         }
         EventType::FireworkExplodeEvent => {
-            register_typed_event::<FireworkExplodeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<FireworkExplodeEvent>(resource, handler, priority, blocking);
         }
         EventType::FoodLevelChangeEvent => {
-            register_typed_event::<FoodLevelChangeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<FoodLevelChangeEvent>(resource, handler, priority, blocking);
         }
         EventType::ItemDespawnEvent => {
-            register_typed_event::<ItemDespawnEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<ItemDespawnEvent>(resource, handler, priority, blocking);
         }
         EventType::ItemMergeEvent => {
-            register_typed_event::<ItemMergeEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<ItemMergeEvent>(resource, handler, priority, blocking);
         }
         EventType::ItemSpawnEvent => {
-            register_typed_event::<ItemSpawnEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<ItemSpawnEvent>(resource, handler, priority, blocking);
         }
         EventType::PiglinBarterEvent => {
-            register_typed_event::<PiglinBarterEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PiglinBarterEvent>(resource, handler, priority, blocking);
         }
         EventType::ProjectileHitEvent => {
-            register_typed_event::<ProjectileHitEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<ProjectileHitEvent>(resource, handler, priority, blocking);
         }
         EventType::ProjectileLaunchEvent => {
-            register_typed_event::<ProjectileLaunchEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<ProjectileLaunchEvent>(resource, handler, priority, blocking);
         }
         EventType::SheepDyeWoolEvent => {
-            register_typed_event::<SheepDyeWoolEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<SheepDyeWoolEvent>(resource, handler, priority, blocking);
         }
         EventType::SheepRegrowWoolEvent => {
-            register_typed_event::<SheepRegrowWoolEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<SheepRegrowWoolEvent>(resource, handler, priority, blocking);
         }
         EventType::SlimeSplitEvent => {
-            register_typed_event::<SlimeSplitEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<SlimeSplitEvent>(resource, handler, priority, blocking);
         }
         EventType::StriderTemperatureChangeEvent => {
             register_typed_event::<StriderTemperatureChangeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::VillagerAcquireTradeEvent => {
             register_typed_event::<VillagerAcquireTradeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::VillagerCareerChangeEvent => {
             register_typed_event::<VillagerCareerChangeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::VillagerReplenishTradeEvent => {
             register_typed_event::<VillagerReplenishTradeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::WardenAngerChangeEvent => {
-            register_typed_event::<WardenAngerChangeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<WardenAngerChangeEvent>(resource, handler, priority, blocking);
         }
         EventType::AreaEffectCloudApplyEvent => {
             register_typed_event::<AreaEffectCloudApplyEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::ArrowBodyCountChangeEvent => {
             register_typed_event::<ArrowBodyCountChangeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::BatToggleSleepEvent => {
-            register_typed_event::<BatToggleSleepEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<BatToggleSleepEvent>(resource, handler, priority, blocking);
         }
         EventType::CreeperPowerEvent => {
-            register_typed_event::<CreeperPowerEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<CreeperPowerEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityCombustByBlockEvent => {
             register_typed_event::<EntityCombustByBlockEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::EntityCombustByEntityEvent => {
             register_typed_event::<EntityCombustByEntityEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::EntityKnockbackByEntityEvent => {
             register_typed_event::<EntityKnockbackByEntityEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::EntityPortalEnterEvent => {
-            register_typed_event::<EntityPortalEnterEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityPortalEnterEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityPortalExitEvent => {
-            register_typed_event::<EntityPortalExitEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityPortalExitEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityRemoveEvent => {
-            register_typed_event::<EntityRemoveEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityRemoveEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityTargetBlockEvent => {
-            register_typed_event::<EntityTargetBlockEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<EntityTargetBlockEvent>(resource, handler, priority, blocking);
         }
         EventType::EntityUnleashEvent => {
-            register_typed_event::<EntityUnleashEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EntityUnleashEvent>(resource, handler, priority, blocking);
         }
         EventType::ExpBottleEvent => {
-            register_typed_event::<ExpBottleEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<ExpBottleEvent>(resource, handler, priority, blocking);
         }
         EventType::HorseJumpEvent => {
-            register_typed_event::<HorseJumpEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<HorseJumpEvent>(resource, handler, priority, blocking);
         }
         EventType::LingeringPotionSplashEvent => {
             register_typed_event::<LingeringPotionSplashEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::PigZapEvent => {
-            register_typed_event::<PigZapEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PigZapEvent>(resource, handler, priority, blocking);
         }
         EventType::PigZombieAngerEvent => {
-            register_typed_event::<PigZombieAngerEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PigZombieAngerEvent>(resource, handler, priority, blocking);
         }
         EventType::PotionSplashEvent => {
-            register_typed_event::<PotionSplashEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PotionSplashEvent>(resource, handler, priority, blocking);
         }
         EventType::SpawnerSpawnEvent => {
-            register_typed_event::<SpawnerSpawnEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<SpawnerSpawnEvent>(resource, handler, priority, blocking);
         }
         EventType::TrialSpawnerSpawnEvent => {
-            register_typed_event::<TrialSpawnerSpawnEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<TrialSpawnerSpawnEvent>(resource, handler, priority, blocking);
         }
         EventType::VillagerReputationChangeEvent => {
             register_typed_event::<VillagerReputationChangeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         _ => {
             tracing::error!("non-entity event should not be routed to register_entity_event");
@@ -905,7 +801,7 @@ async fn register_entity_event(
     }
 }
 
-async fn register_inventory_event(
+fn register_inventory_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -928,83 +824,71 @@ async fn register_inventory_event(
 
     match event_type {
         EventType::InventoryOpenEvent => {
-            register_typed_event::<InventoryOpenEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<InventoryOpenEvent>(resource, handler, priority, blocking);
         }
         EventType::InventoryDragEvent => {
-            register_typed_event::<InventoryDragEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<InventoryDragEvent>(resource, handler, priority, blocking);
         }
         EventType::CraftItemEvent => {
-            register_typed_event::<CraftItemEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<CraftItemEvent>(resource, handler, priority, blocking);
         }
         EventType::FurnaceSmeltEvent => {
-            register_typed_event::<FurnaceSmeltEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<FurnaceSmeltEvent>(resource, handler, priority, blocking);
         }
         EventType::BrewEvent => {
-            register_typed_event::<BrewEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<BrewEvent>(resource, handler, priority, blocking);
         }
         EventType::BrewingStandFuelEvent => {
-            register_typed_event::<BrewingStandFuelEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<BrewingStandFuelEvent>(resource, handler, priority, blocking);
         }
         EventType::FurnaceBurnEvent => {
-            register_typed_event::<FurnaceBurnEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<FurnaceBurnEvent>(resource, handler, priority, blocking);
         }
         EventType::FurnaceExtractEvent => {
-            register_typed_event::<FurnaceExtractEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<FurnaceExtractEvent>(resource, handler, priority, blocking);
         }
         EventType::FurnaceStartSmeltEvent => {
-            register_typed_event::<FurnaceStartSmeltEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<FurnaceStartSmeltEvent>(resource, handler, priority, blocking);
         }
         EventType::HopperInventorySearchEvent => {
             register_typed_event::<HopperInventorySearchEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::InventoryCreativeEvent => {
-            register_typed_event::<InventoryCreativeEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<InventoryCreativeEvent>(resource, handler, priority, blocking);
         }
         EventType::InventoryInteractEvent => {
-            register_typed_event::<InventoryInteractEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<InventoryInteractEvent>(resource, handler, priority, blocking);
         }
         EventType::InventoryMoveItemEvent => {
-            register_typed_event::<InventoryMoveItemEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<InventoryMoveItemEvent>(resource, handler, priority, blocking);
         }
         EventType::InventoryPickupItemEvent => {
-            register_typed_event::<InventoryPickupItemEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<InventoryPickupItemEvent>(resource, handler, priority, blocking);
         }
         EventType::PrepareAnvilEvent => {
-            register_typed_event::<PrepareAnvilEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PrepareAnvilEvent>(resource, handler, priority, blocking);
         }
         EventType::PrepareGrindstoneEvent => {
-            register_typed_event::<PrepareGrindstoneEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PrepareGrindstoneEvent>(resource, handler, priority, blocking);
         }
         EventType::PrepareInventoryResultEvent => {
             register_typed_event::<PrepareInventoryResultEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::PrepareItemCraftEvent => {
-            register_typed_event::<PrepareItemCraftEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PrepareItemCraftEvent>(resource, handler, priority, blocking);
         }
         EventType::PrepareSmithingEvent => {
-            register_typed_event::<PrepareSmithingEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PrepareSmithingEvent>(resource, handler, priority, blocking);
         }
         EventType::SmithItemEvent => {
-            register_typed_event::<SmithItemEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<SmithItemEvent>(resource, handler, priority, blocking);
         }
         EventType::TradeSelectEvent => {
-            register_typed_event::<TradeSelectEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<TradeSelectEvent>(resource, handler, priority, blocking);
         }
         _ => {
             tracing::error!("non-inventory event should not be routed to register_inventory_event");
@@ -1012,7 +896,7 @@ async fn register_inventory_event(
     }
 }
 
-async fn register_vehicle_event(
+fn register_vehicle_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -1032,40 +916,36 @@ async fn register_vehicle_event(
         EventType::VehicleBlockCollisionEvent => {
             register_typed_event::<VehicleBlockCollisionEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::VehicleCollisionEvent => {
-            register_typed_event::<VehicleCollisionEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<VehicleCollisionEvent>(resource, handler, priority, blocking);
         }
         EventType::VehicleCreateEvent => {
-            register_typed_event::<VehicleCreateEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<VehicleCreateEvent>(resource, handler, priority, blocking);
         }
         EventType::VehicleDamageEvent => {
-            register_typed_event::<VehicleDamageEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<VehicleDamageEvent>(resource, handler, priority, blocking);
         }
         EventType::VehicleDestroyEvent => {
-            register_typed_event::<VehicleDestroyEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<VehicleDestroyEvent>(resource, handler, priority, blocking);
         }
         EventType::VehicleEnterEvent => {
-            register_typed_event::<VehicleEnterEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<VehicleEnterEvent>(resource, handler, priority, blocking);
         }
         EventType::VehicleEntityCollisionEvent => {
             register_typed_event::<VehicleEntityCollisionEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::VehicleExitEvent => {
-            register_typed_event::<VehicleExitEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<VehicleExitEvent>(resource, handler, priority, blocking);
         }
         EventType::VehicleMoveEvent => {
-            register_typed_event::<VehicleMoveEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<VehicleMoveEvent>(resource, handler, priority, blocking);
         }
         EventType::VehicleUpdateEvent => {
-            register_typed_event::<VehicleUpdateEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<VehicleUpdateEvent>(resource, handler, priority, blocking);
         }
         _ => {
             tracing::error!("non-vehicle event should not be routed to register_vehicle_event");
@@ -1073,7 +953,7 @@ async fn register_vehicle_event(
     }
 }
 
-async fn register_enchantment_event(
+fn register_enchantment_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -1086,11 +966,10 @@ async fn register_enchantment_event(
 
     match event_type {
         EventType::PrepareItemEnchantEvent => {
-            register_typed_event::<PrepareItemEnchantEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PrepareItemEnchantEvent>(resource, handler, priority, blocking);
         }
         EventType::EnchantItemEvent => {
-            register_typed_event::<EnchantItemEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<EnchantItemEvent>(resource, handler, priority, blocking);
         }
         _ => {
             tracing::error!(
@@ -1101,7 +980,7 @@ async fn register_enchantment_event(
 }
 
 #[allow(clippy::too_many_lines)]
-async fn register_world_event(
+fn register_world_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -1115,124 +994,107 @@ async fn register_world_event(
 
     match event_type {
         EventType::SpawnChangeEvent => {
-            register_typed_event::<SpawnChangeEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<SpawnChangeEvent>(resource, handler, priority, blocking);
         }
         EventType::ChunkLoadEvent => {
-            register_typed_event::<ChunkLoad>(resource, handler, priority, blocking).await;
+            register_typed_event::<ChunkLoad>(resource, handler, priority, blocking);
         }
         EventType::ChunkSaveEvent => {
-            register_typed_event::<ChunkSave>(resource, handler, priority, blocking).await;
+            register_typed_event::<ChunkSave>(resource, handler, priority, blocking);
         }
         EventType::ChunkSendEvent => {
-            register_typed_event::<ChunkSend>(resource, handler, priority, blocking).await;
+            register_typed_event::<ChunkSend>(resource, handler, priority, blocking);
         }
         EventType::WeatherChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::weather_change::WeatherChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::ThunderChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::weather_change::ThunderChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::WorldLoadEvent => {
             register_typed_event::<crate::plugin::api::events::world::world_load::WorldLoadEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::WorldUnloadEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::world::world_load::WorldUnloadEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::world::world_load::WorldUnloadEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::AsyncStructureGenerateEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::async_structure_generate::AsyncStructureGenerateEvent,
             >(resource, handler, priority, blocking)
-            .await;
+            ;
         }
         EventType::AsyncStructureSpawnEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::async_structure_spawn::AsyncStructureSpawnEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::ChunkPopulateEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::chunk_populate::ChunkPopulateEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::ChunkUnloadEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::world::chunk_unload::ChunkUnloadEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::world::chunk_unload::ChunkUnloadEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::EntitiesLoadEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::entities_load::EntitiesLoadEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::EntitiesUnloadEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::entities_unload::EntitiesUnloadEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::GenericGameEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::world::generic_game::GenericGameEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::world::generic_game::GenericGameEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::LootGenerateEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::loot_generate::LootGenerateEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::PortalCreateEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::portal_create::PortalCreateEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::StructureGrowEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::structure_grow::StructureGrowEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::TimeSkipEvent => {
             register_typed_event::<crate::plugin::api::events::world::time_skip::TimeSkipEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::WorldInitEvent => {
             register_typed_event::<crate::plugin::api::events::world::world_init::WorldInitEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::WorldSaveEvent => {
             register_typed_event::<crate::plugin::api::events::world::world_save::WorldSaveEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::LightningStrikeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::world::lightning_strike::LightningStrikeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         _ => {
             tracing::error!("non-world event should not be routed to register_world_event");
@@ -1241,7 +1103,7 @@ async fn register_world_event(
 }
 
 #[allow(clippy::too_many_lines)]
-async fn register_block_event(
+fn register_block_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -1256,256 +1118,217 @@ async fn register_block_event(
 
     match event_type {
         EventType::BlockRedstoneEvent => {
-            register_typed_event::<BlockRedstoneEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<BlockRedstoneEvent>(resource, handler, priority, blocking);
         }
         EventType::BlockBreakEvent => {
-            register_typed_event::<BlockBreakEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<BlockBreakEvent>(resource, handler, priority, blocking);
         }
         EventType::BlockBurnEvent => {
-            register_typed_event::<BlockBurnEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<BlockBurnEvent>(resource, handler, priority, blocking);
         }
         EventType::BlockCanBuildEvent => {
-            register_typed_event::<BlockCanBuildEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<BlockCanBuildEvent>(resource, handler, priority, blocking);
         }
         EventType::BlockGrowEvent => {
-            register_typed_event::<BlockGrowEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<BlockGrowEvent>(resource, handler, priority, blocking);
         }
         EventType::BlockPlaceEvent => {
-            register_typed_event::<BlockPlaceEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<BlockPlaceEvent>(resource, handler, priority, blocking);
         }
         EventType::BlockDamageEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::block::block_damage::BlockDamageEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::block::block_damage::BlockDamageEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::BlockIgniteEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::block::block_ignite::BlockIgniteEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::block::block_ignite::BlockIgniteEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::BlockFromToEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_from_to::BlockFromToEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockFormEvent => {
             register_typed_event::<crate::plugin::api::events::block::block_form::BlockFormEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::BlockFadeEvent => {
             register_typed_event::<crate::plugin::api::events::block::block_fade::BlockFadeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::BlockDispenseEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_dispense::BlockDispenseEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockExplodeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_explode::BlockExplodeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockPhysicsEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_physics::BlockPhysicsEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockPistonExtendEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_piston::BlockPistonExtendEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockPistonRetractEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_piston::BlockPistonRetractEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::NotePlayEvent => {
             register_typed_event::<crate::plugin::api::events::block::note_play::NotePlayEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::SignChangeEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::block::sign_change::SignChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::block::sign_change::SignChangeEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::SpongeAbsorbEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::sponge_absorb::SpongeAbsorbEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::TntPrimeEvent => {
             register_typed_event::<crate::plugin::api::events::block::tnt_prime::TNTPrimeEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::BellResonateEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::bell_resonate::BellResonateEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BellRingEvent => {
             register_typed_event::<crate::plugin::api::events::block::bell_ring::BellRingEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::BlockBrushEvent => {
             register_typed_event::<crate::plugin::api::events::block::block_brush::BlockBrushEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::BlockCookEvent => {
             register_typed_event::<crate::plugin::api::events::block::block_cook::BlockCookEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::BlockDamageAbortEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_damage_abort::BlockDamageAbortEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockDispenseArmorEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_dispense_armor::BlockDispenseArmorEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockDispenseLootEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_dispense_loot::BlockDispenseLootEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockDropItemEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_drop_item::BlockDropItemEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockExpEvent => {
             register_typed_event::<crate::plugin::api::events::block::block_exp::BlockExpEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::BlockFertilizeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_fertilize::BlockFertilizeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockMultiPlaceEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_multi_place::BlockMultiPlaceEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockReceiveGameEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_receive_game::BlockReceiveGameEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockShearEntityEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::block_shear_entity::BlockShearEntityEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::BlockSpreadEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::block::block_spread::BlockSpreadEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::block::block_spread::BlockSpreadEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::BrewingStartEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::brewing_start::BrewingStartEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::CampfireStartEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::campfire_start::CampfireStartEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::CauldronLevelChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::cauldron_level_change::CauldronLevelChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::CrafterCraftEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::crafter_craft::CrafterCraftEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::EntityBlockFormEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::entity_block_form::EntityBlockFormEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::FluidLevelChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::fluid_level_change::FluidLevelChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::InventoryBlockStartEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::inventory_block_start::InventoryBlockStartEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::LeavesDecayEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::block::leaves_decay::LeavesDecayEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::block::leaves_decay::LeavesDecayEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::MoistureChangeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::moisture_change::MoistureChangeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         EventType::SculkBloomEvent => {
-            register_typed_event::<
-                crate::plugin::api::events::block::sculk_bloom::SculkBloomEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            register_typed_event::<crate::plugin::api::events::block::sculk_bloom::SculkBloomEvent>(
+                resource, handler, priority, blocking,
+            );
         }
         EventType::VaultDisplayItemEvent => {
             register_typed_event::<
                 crate::plugin::api::events::block::vault_display_item::VaultDisplayItemEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
 
         _ => {
@@ -1514,7 +1337,7 @@ async fn register_block_event(
     }
 }
 
-async fn register_raid_event(
+fn register_raid_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -1528,16 +1351,16 @@ async fn register_raid_event(
 
     match event_type {
         EventType::RaidFinishEvent => {
-            register_typed_event::<RaidFinishEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<RaidFinishEvent>(resource, handler, priority, blocking);
         }
         EventType::RaidSpawnWaveEvent => {
-            register_typed_event::<RaidSpawnWaveEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<RaidSpawnWaveEvent>(resource, handler, priority, blocking);
         }
         EventType::RaidStopEvent => {
-            register_typed_event::<RaidStopEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<RaidStopEvent>(resource, handler, priority, blocking);
         }
         EventType::RaidTriggerEvent => {
-            register_typed_event::<RaidTriggerEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<RaidTriggerEvent>(resource, handler, priority, blocking);
         }
         _ => {
             tracing::error!("non-raid event should not be routed to register_raid_event");
@@ -1545,7 +1368,7 @@ async fn register_raid_event(
     }
 }
 
-async fn register_server_event(
+fn register_server_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -1564,38 +1387,33 @@ async fn register_server_event(
 
     match event_type {
         EventType::PacketReceivedEvent => {
-            register_typed_event::<PacketReceivedEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<PacketReceivedEvent>(resource, handler, priority, blocking);
         }
         EventType::PacketSentEvent => {
-            register_typed_event::<PacketSentEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<PacketSentEvent>(resource, handler, priority, blocking);
         }
         EventType::ServerCommandEvent => {
-            register_typed_event::<ServerCommandEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<ServerCommandEvent>(resource, handler, priority, blocking);
         }
         EventType::ServerListPingEvent => {
-            register_typed_event::<ServerListPingEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<ServerListPingEvent>(resource, handler, priority, blocking);
         }
         EventType::ServerBroadcastEvent => {
-            register_typed_event::<ServerBroadcastEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<ServerBroadcastEvent>(resource, handler, priority, blocking);
         }
         EventType::ServerLoadEvent => {
-            register_typed_event::<ServerLoadEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<ServerLoadEvent>(resource, handler, priority, blocking);
         }
         EventType::ServerTickEndEvent => {
-            register_typed_event::<ServerTickEndEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<ServerTickEndEvent>(resource, handler, priority, blocking);
         }
         EventType::ServerTickStartEvent => {
-            register_typed_event::<ServerTickStartEvent>(resource, handler, priority, blocking)
-                .await;
+            register_typed_event::<ServerTickStartEvent>(resource, handler, priority, blocking);
         }
         EventType::MapInitializeEvent => {
             register_typed_event::<
                 crate::plugin::api::events::server::map_initialize::MapInitializeEvent,
-            >(resource, handler, priority, blocking)
-            .await;
+            >(resource, handler, priority, blocking);
         }
         _ => {
             tracing::error!("non-server event should not be routed to register_server_event");
@@ -1603,7 +1421,7 @@ async fn register_server_event(
     }
 }
 
-async fn register_hanging_event(
+fn register_hanging_event(
     resource: &ContextResource,
     handler: &Arc<WasmPluginEventHandler>,
     priority: crate::plugin::EventPriority,
@@ -1617,16 +1435,15 @@ async fn register_hanging_event(
 
     match event_type {
         EventType::HangingBreakEvent => {
-            register_typed_event::<HangingBreakEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<HangingBreakEvent>(resource, handler, priority, blocking);
         }
         EventType::HangingBreakByEntityEvent => {
             register_typed_event::<HangingBreakByEntityEvent>(
                 resource, handler, priority, blocking,
-            )
-            .await;
+            );
         }
         EventType::HangingPlaceEvent => {
-            register_typed_event::<HangingPlaceEvent>(resource, handler, priority, blocking).await;
+            register_typed_event::<HangingPlaceEvent>(resource, handler, priority, blocking);
         }
         _ => {
             tracing::error!("non-hanging event should not be routed to register_hanging_event");
@@ -1703,12 +1520,12 @@ impl pumpkin::plugin::context::HostContext for PluginHostState {
             | EventType::ServerTickEndEvent
             | EventType::ServerTickStartEvent
             | EventType::MapInitializeEvent) => {
-                register_server_event(resource, &handler, priority, blocking, event_type).await;
+                register_server_event(resource, &handler, priority, blocking, event_type);
             }
             event_type @ (EventType::HangingBreakEvent
             | EventType::HangingBreakByEntityEvent
             | EventType::HangingPlaceEvent) => {
-                register_hanging_event(resource, &handler, priority, blocking, event_type).await;
+                register_hanging_event(resource, &handler, priority, blocking, event_type);
             }
             event_type @ (EventType::SpawnChangeEvent
             | EventType::ChunkLoadEvent
@@ -1732,7 +1549,7 @@ impl pumpkin::plugin::context::HostContext for PluginHostState {
             | EventType::WorldInitEvent
             | EventType::WorldSaveEvent
             | EventType::LightningStrikeEvent) => {
-                register_world_event(resource, &handler, priority, blocking, event_type).await;
+                register_world_event(resource, &handler, priority, blocking, event_type);
             }
             event_type @ (EventType::EntityDamageEvent
             | EventType::EntityDeathEvent
@@ -1811,7 +1628,7 @@ impl pumpkin::plugin::context::HostContext for PluginHostState {
             | EventType::SpawnerSpawnEvent
             | EventType::TrialSpawnerSpawnEvent
             | EventType::VillagerReputationChangeEvent) => {
-                register_entity_event(resource, &handler, priority, blocking, event_type).await;
+                register_entity_event(resource, &handler, priority, blocking, event_type);
             }
             event_type @ (EventType::BlockRedstoneEvent
             | EventType::BlockBreakEvent
@@ -1858,7 +1675,7 @@ impl pumpkin::plugin::context::HostContext for PluginHostState {
             | EventType::MoistureChangeEvent
             | EventType::SculkBloomEvent
             | EventType::VaultDisplayItemEvent) => {
-                register_block_event(resource, &handler, priority, blocking, event_type).await;
+                register_block_event(resource, &handler, priority, blocking, event_type);
             }
             event_type @ (EventType::InventoryOpenEvent
             | EventType::InventoryDragEvent
@@ -1881,11 +1698,10 @@ impl pumpkin::plugin::context::HostContext for PluginHostState {
             | EventType::PrepareSmithingEvent
             | EventType::SmithItemEvent
             | EventType::TradeSelectEvent) => {
-                register_inventory_event(resource, &handler, priority, blocking, event_type).await;
+                register_inventory_event(resource, &handler, priority, blocking, event_type);
             }
             event_type @ (EventType::PrepareItemEnchantEvent | EventType::EnchantItemEvent) => {
-                register_enchantment_event(resource, &handler, priority, blocking, event_type)
-                    .await;
+                register_enchantment_event(resource, &handler, priority, blocking, event_type);
             }
             event_type @ (EventType::VehicleBlockCollisionEvent
             | EventType::VehicleCollisionEvent
@@ -1897,16 +1713,16 @@ impl pumpkin::plugin::context::HostContext for PluginHostState {
             | EventType::VehicleExitEvent
             | EventType::VehicleMoveEvent
             | EventType::VehicleUpdateEvent) => {
-                register_vehicle_event(resource, &handler, priority, blocking, event_type).await;
+                register_vehicle_event(resource, &handler, priority, blocking, event_type);
             }
             event_type @ (EventType::RaidFinishEvent
             | EventType::RaidSpawnWaveEvent
             | EventType::RaidStopEvent
             | EventType::RaidTriggerEvent) => {
-                register_raid_event(resource, &handler, priority, blocking, event_type).await;
+                register_raid_event(resource, &handler, priority, blocking, event_type);
             }
             event_type => {
-                register_player_event(resource, &handler, priority, blocking, event_type).await;
+                register_player_event(resource, &handler, priority, blocking, event_type);
             }
         }
 
diff --git a/crates/pumpkin/src/plugin/mod.rs b/crates/pumpkin/src/plugin/mod.rs
index accfaab79..e6c1ac53e 100644
--- a/crates/pumpkin/src/plugin/mod.rs
+++ b/crates/pumpkin/src/plugin/mod.rs
@@ -1,3 +1,4 @@
+use arc_swap::ArcSwap;
 use futures::future::join_all;
 use loader::{LoaderError, PluginLoader, native::NativePluginLoader};
 use notify::{EventKind, RecursiveMode, Watcher, event::ModifyKind};
@@ -101,15 +102,15 @@ pub trait EventHandler<E: Payload>: Send + Sync {
 /// A struct representing a typed event handler.
 ///
 /// This struct holds a reference to an event handler, its priority, and whether it is blocking.
-struct TypedEventHandler<E, H>
+pub struct TypedEventHandler<E, H>
 where
     E: Payload + Send + Sync + 'static,
     H: EventHandler<E> + Send + Sync,
 {
-    handler: Arc<H>,
-    priority: EventPriority,
-    blocking: bool,
-    _phantom: std::marker::PhantomData<E>,
+    pub handler: Arc<H>,
+    pub priority: EventPriority,
+    pub blocking: bool,
+    pub _phantom: std::marker::PhantomData<E>,
 }
 
 impl<E, H> DynEventHandler for TypedEventHandler<E, H>
@@ -158,7 +159,7 @@ where
 
 /// A type alias for a map of event handlers, where the key is a static string
 /// and the value is a vector of dynamic event handlers.
-type HandlerMap = HashMap<&'static str, Vec<Box<dyn DynEventHandler>>>;
+pub type HandlerMap = HashMap<&'static str, Vec<Arc<dyn DynEventHandler>>>;
 
 /// Plugin loading state
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -172,7 +173,7 @@ pub enum PluginState {
 pub struct PluginManager {
     plugins: RwLock<Vec<LoadedPlugin>>,
     loaders: RwLock<Vec<Arc<dyn PluginLoader>>>,
-    handlers: Arc<RwLock<HandlerMap>>,
+    handlers: Arc<ArcSwap<HandlerMap>>,
     unloaded_files: RwLock<HashSet<PathBuf>>,
     services: Arc<RwLock<HashMap<String, Arc<dyn Payload>>>>,
     // Plugin state tracking
@@ -227,7 +228,7 @@ impl PluginManager {
                 Arc::new(NativePluginLoader),
                 Arc::new(WasmPluginLoader),
             ]),
-            handlers: Arc::new(RwLock::new(HashMap::new())),
+            handlers: Arc::new(ArcSwap::from_pointee(HashMap::new())),
             unloaded_files: RwLock::new(HashSet::new()),
             services: Arc::new(RwLock::new(HashMap::new())),
             plugin_states: RwLock::new(HashMap::new()),
@@ -1090,23 +1091,26 @@ impl PluginManager {
     }
 
     /// Register an event handler
-    pub async fn register<E, H>(&self, handler: Arc<H>, priority: EventPriority, blocking: bool)
+    pub fn register<E, H>(&self, handler: Arc<H>, priority: EventPriority, blocking: bool)
     where
         E: Payload + Send + Sync + 'static,
         H: EventHandler<E> + 'static,
     {
-        let mut handlers = self.handlers.write().await;
-        let typed_handler = TypedEventHandler {
+        let typed_handler = Arc::new(TypedEventHandler {
             handler,
             priority,
             blocking,
             _phantom: std::marker::PhantomData,
-        };
+        });
 
-        handlers
-            .entry(E::get_name_static())
-            .or_default()
-            .push(Box::new(typed_handler));
+        self.handlers.rcu(|handlers| {
+            let mut new_handlers = (**handlers).clone();
+            new_handlers
+                .entry(E::get_name_static())
+                .or_default()
+                .push(typed_handler.clone());
+            Arc::new(new_handlers)
+        });
     }
 
     /// Fire an event to all registered handlers
@@ -1115,12 +1119,12 @@ impl PluginManager {
         server: &Arc<Server>,
         event: &mut E,
     ) {
-        let handlers_lock = self.handlers.read().await;
-        if handlers_lock.is_empty() {
+        let handlers_map = self.handlers.load();
+        if handlers_map.is_empty() {
             return;
         }
 
-        let Some(handlers) = handlers_lock.get(&E::get_name_static()) else {
+        let Some(handlers) = handlers_map.get(E::get_name_static()) else {
             return;
         };