Repository: hikari-py/hikari
Pull request #2368 (2025-05-17 20:50:34)

Greatly optimize event manager memory management
Instead of creating tasks that keep references to soon to be deleted objects (ie, payloads) we can optimize the lifetime of each of these objects and have them be marked for removal by the GC as soon as possible



Patch:
diff --git a/changes/2368.optimization.md b/changes/2368.optimization.md
new file mode 100644
index 00000000..b0db80a1
--- /dev/null
+++ b/changes/2368.optimization.md
@@ -0,0 +1,1 @@
+Greatly optimize event managers memory management by avoiding unnecessary tasks creations and reducing lifetime of objects
diff --git a/hikari/api/event_manager.py b/hikari/api/event_manager.py
index 302cfd31..b6e973fe 100644
--- a/hikari/api/event_manager.py
+++ b/hikari/api/event_manager.py
@@ -184,14 +184,29 @@ def consume_raw_event(
             If there is no consumer for the event.
         """
 
+    @typing.overload
+    def dispatch(self, event: base_events.Event, *, return_tasks: typing.Literal[False] = False) -> None: ...
+
+    @typing.overload
+    def dispatch(
+        self, event: base_events.Event, *, return_tasks: typing.Literal[True] = True
+    ) -> asyncio.Future[typing.Any]: ...
+
+    @typing.overload
+    def dispatch(
+        self, event: base_events.Event, *, return_tasks: bool = False
+    ) -> asyncio.Future[typing.Any] | None: ...
+
     @abc.abstractmethod
-    def dispatch(self, event: base_events.Event) -> asyncio.Future[typing.Any]:
+    def dispatch(self, event: base_events.Event, *, return_tasks: bool = False) -> asyncio.Future[typing.Any] | None:
         """Dispatch an event.
 
         Parameters
         ----------
         event
             The event to dispatch.
+        return_tasks
+            Whether to return an asyncio future to wait for the listeners to finish.
 
         Examples
         --------
diff --git a/hikari/impl/event_manager.py b/hikari/impl/event_manager.py
index 350064c4..2e3d64df 100644
--- a/hikari/impl/event_manager.py
+++ b/hikari/impl/event_manager.py
@@ -124,7 +124,7 @@ def _cache_enabled_for(self, components: config.CacheComponents, /) -> bool:
         return self._cache is not None and (self._cache.settings.components & components) == components
 
     @event_manager_base.filtered(shard_events.ShardReadyEvent, config.CacheComponents.ME)
-    async def on_ready(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_ready(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#ready for more info."""
         # TODO: cache unavailable guilds on startup, I didn't bother for the time being.
         event = self._event_factory.deserialize_ready_event(shard, payload)
@@ -132,31 +132,31 @@ async def on_ready(self, shard: gateway_shard.GatewayShard, payload: data_bindin
         if self._cache:
             self._cache.update_me(event.my_user)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(shard_events.ShardResumedEvent)
-    async def on_resumed(self, shard: gateway_shard.GatewayShard, _: data_binding.JSONObject) -> None:
+    def on_resumed(self, shard: gateway_shard.GatewayShard, _: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#resumed for more info."""
-        await self.dispatch(self._event_factory.deserialize_resumed_event(shard))
+        self.dispatch(self._event_factory.deserialize_resumed_event(shard))
 
     @event_manager_base.filtered(application_events.ApplicationCommandPermissionsUpdateEvent)
-    async def on_application_command_permissions_update(
+    def on_application_command_permissions_update(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
-        await self.dispatch(self._event_factory.deserialize_application_command_permission_update_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_application_command_permission_update_event(shard, payload))
 
     @event_manager_base.filtered(channel_events.GuildChannelCreateEvent, config.CacheComponents.GUILD_CHANNELS)
-    async def on_channel_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_channel_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#channel-create for more info."""
         event = self._event_factory.deserialize_guild_channel_create_event(shard, payload)
 
         if self._cache:
             self._cache.set_guild_channel(event.channel)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(channel_events.GuildChannelUpdateEvent, config.CacheComponents.GUILD_CHANNELS)
-    async def on_channel_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_channel_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#channel-update for more info."""
         old = self._cache.get_guild_channel(snowflakes.Snowflake(payload["id"])) if self._cache else None
         event = self._event_factory.deserialize_guild_channel_update_event(shard, payload, old_channel=old)
@@ -164,13 +164,13 @@ async def on_channel_update(self, shard: gateway_shard.GatewayShard, payload: da
         if self._cache:
             self._cache.update_guild_channel(event.channel)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(
         channel_events.GuildChannelDeleteEvent,
         config.CacheComponents.GUILD_CHANNELS | config.CacheComponents.GUILD_THREADS,
     )
-    async def on_channel_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_channel_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#channel-delete for more info."""
         event = self._event_factory.deserialize_guild_channel_delete_event(shard, payload)
 
@@ -178,19 +178,19 @@ async def on_channel_delete(self, shard: gateway_shard.GatewayShard, payload: da
             self._cache.delete_guild_channel(event.channel.id)
             self._cache.clear_threads_for_channel(event.guild_id, event.channel.id)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered((channel_events.GuildPinsUpdateEvent, channel_events.DMPinsUpdateEvent))
-    async def on_channel_pins_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_channel_pins_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#channel-pins-update for more info."""
         # TODO: we need a method for this specifically
-        await self.dispatch(self._event_factory.deserialize_channel_pins_update_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_channel_pins_update_event(shard, payload))
 
     @event_manager_base.filtered(
         (channel_events.GuildThreadAccessEvent, channel_events.GuildThreadCreateEvent),
         config.CacheComponents.GUILD_THREADS,
     )
-    async def on_thread_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_thread_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#thread-create for more info."""
         event: channel_events.GuildThreadAccessEvent | channel_events.GuildThreadCreateEvent
         if "newly_created" in payload:
@@ -202,10 +202,10 @@ async def on_thread_create(self, shard: gateway_shard.GatewayShard, payload: dat
         if self._cache:
             self._cache.set_thread(event.thread)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(channel_events.GuildThreadUpdateEvent, config.CacheComponents.GUILD_THREADS)
-    async def on_thread_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_thread_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#thread-update for more info."""
         old = self._cache.get_thread(snowflakes.Snowflake(payload["id"])) if self._cache else None
         event = self._event_factory.deserialize_guild_thread_update_event(shard, payload, old_thread=old)
@@ -213,20 +213,20 @@ async def on_thread_update(self, shard: gateway_shard.GatewayShard, payload: dat
         if self._cache:
             self._cache.update_thread(event.thread)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(channel_events.GuildThreadDeleteEvent, config.CacheComponents.GUILD_THREADS)
-    async def on_thread_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_thread_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#thread-delete for more info."""
         event = self._event_factory.deserialize_guild_thread_delete_event(shard, payload)
 
         if self._cache:
             self._cache.delete_thread(event.thread_id)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(channel_events.ThreadListSyncEvent, config.CacheComponents.GUILD_THREADS)
-    async def on_thread_list_sync(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_thread_list_sync(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#thread-list-sync for more info."""
         event = self._event_factory.deserialize_thread_list_sync_event(shard, payload)
 
@@ -241,12 +241,10 @@ async def on_thread_list_sync(self, shard: gateway_shard.GatewayShard, payload:
             for thread in event.threads.values():
                 self._cache.set_thread(thread)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(channel_events.ThreadMembersUpdateEvent, config.CacheComponents.GUILD_THREADS)
-    async def on_thread_members_update(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
+    def on_thread_members_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#thread-members-update for more info."""
         event = self._event_factory.deserialize_thread_members_update_event(shard, payload)
 
@@ -258,10 +256,10 @@ async def on_thread_members_update(
             if user_id in event.removed_member_ids:
                 self._cache.delete_thread(event.thread_id)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     # Internal granularity is preferred for GUILD_CREATE over decorator based filtering due to its large scope.
-    async def on_guild_create(  # noqa: C901, PLR0912, PLR0915 - Function too complex, too many branches and too long
+    def on_guild_create(  # noqa: C901, PLR0912, PLR0915 - Function too complex, too many branches and too long
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-create for more info."""
@@ -421,10 +419,10 @@ async def on_guild_create(  # noqa: C901, PLR0912, PLR0915 - Function too comple
             task.add_done_callback(self._guild_member_request_tasks.discard)
 
         if event:
-            await self.dispatch(event)
+            self.dispatch(event)
 
     # Internal granularity is preferred for GUILD_UPDATE over decorator based filtering due to its large scope.
-    async def on_guild_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-update for more info."""
         event: guild_events.GuildUpdateEvent | None
         if self._enabled_for_event(guild_events.GuildUpdateEvent):
@@ -475,7 +473,7 @@ async def on_guild_update(self, shard: gateway_shard.GatewayShard, payload: data
                     self._cache.set_role(role)
 
         if event:
-            await self.dispatch(event)
+            self.dispatch(event)
 
     @event_manager_base.filtered(
         (guild_events.GuildLeaveEvent, guild_events.GuildUnavailableEvent),
@@ -489,7 +487,7 @@ async def on_guild_update(self, shard: gateway_shard.GatewayShard, payload: data
         | config.CacheComponents.MEMBERS
         | config.CacheComponents.GUILD_THREADS,
     )
-    async def on_guild_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-delete for more info."""
         event: guild_events.GuildUnavailableEvent | guild_events.GuildLeaveEvent
         if payload.get("unavailable"):
@@ -516,20 +514,20 @@ async def on_guild_delete(self, shard: gateway_shard.GatewayShard, payload: data
 
             event = self._event_factory.deserialize_guild_leave_event(shard, payload, old_guild=old)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(guild_events.BanCreateEvent)
-    async def on_guild_ban_add(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_ban_add(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-ban-add for more info."""
-        await self.dispatch(self._event_factory.deserialize_guild_ban_add_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_guild_ban_add_event(shard, payload))
 
     @event_manager_base.filtered(guild_events.BanDeleteEvent)
-    async def on_guild_ban_remove(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_ban_remove(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-ban-remove for more info."""
-        await self.dispatch(self._event_factory.deserialize_guild_ban_remove_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_guild_ban_remove_event(shard, payload))
 
     @event_manager_base.filtered(guild_events.EmojisUpdateEvent, config.CacheComponents.EMOJIS)
-    async def on_guild_emojis_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_emojis_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-emojis-update for more info."""
         guild_id = snowflakes.Snowflake(payload["guild_id"])
         old = list(self._cache.clear_emojis_for_guild(guild_id).values()) if self._cache else None
@@ -540,12 +538,10 @@ async def on_guild_emojis_update(self, shard: gateway_shard.GatewayShard, payloa
             for emoji in event.emojis:
                 self._cache.set_emoji(emoji)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(guild_events.StickersUpdateEvent, config.CacheComponents.EMOJIS)
-    async def on_guild_stickers_update(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
+    def on_guild_stickers_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-stickers-update for more info."""
         guild_id = snowflakes.Snowflake(payload["guild_id"])
         old = list(self._cache.clear_stickers_for_guild(guild_id).values()) if self._cache else None
@@ -556,42 +552,42 @@ async def on_guild_stickers_update(
             for sticker in event.stickers:
                 self._cache.set_sticker(sticker)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(())  # An empty sequence here means that this method will always be skipped.
-    async def on_guild_integrations_update(self, _: gateway_shard.GatewayShard, __: data_binding.JSONObject) -> None:
+    def on_guild_integrations_update(self, _: gateway_shard.GatewayShard, __: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-integrations-update for more info."""
         # This is only here to stop this being logged or dispatched as an "unknown event".
         # This event is made redundant by INTEGRATION_CREATE/DELETE/UPDATE and is thus not parsed or dispatched.
         raise NotImplementedError
 
     @event_manager_base.filtered(guild_events.IntegrationCreateEvent)
-    async def on_integration_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_integration_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         event = self._event_factory.deserialize_integration_create_event(shard, payload)
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(guild_events.IntegrationUpdateEvent)
-    async def on_integration_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_integration_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         event = self._event_factory.deserialize_integration_update_event(shard, payload)
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(guild_events.IntegrationDeleteEvent)
-    async def on_integration_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_integration_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         event = self._event_factory.deserialize_integration_delete_event(shard, payload)
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(member_events.MemberCreateEvent, config.CacheComponents.MEMBERS)
-    async def on_guild_member_add(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_member_add(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-member-add for more info."""
         event = self._event_factory.deserialize_guild_member_add_event(shard, payload)
 
         if self._cache:
             self._cache.update_member(event.member)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(member_events.MemberDeleteEvent, config.CacheComponents.MEMBERS)
-    async def on_guild_member_remove(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_member_remove(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-member-remove for more info."""
         old: guilds.Member | None = None
         if self._cache:
@@ -600,10 +596,10 @@ async def on_guild_member_remove(self, shard: gateway_shard.GatewayShard, payloa
             )
 
         event = self._event_factory.deserialize_guild_member_remove_event(shard, payload, old_member=old)
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(member_events.MemberUpdateEvent, config.CacheComponents.MEMBERS)
-    async def on_guild_member_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_member_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-member-update for more info."""
         old: guilds.Member | None = None
         if self._cache:
@@ -616,10 +612,10 @@ async def on_guild_member_update(self, shard: gateway_shard.GatewayShard, payloa
         if self._cache:
             self._cache.update_member(event.member)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(shard_events.MemberChunkEvent, config.CacheComponents.MEMBERS)
-    async def on_guild_members_chunk(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_members_chunk(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-members-chunk for more info."""
         event = self._event_factory.deserialize_guild_member_chunk_event(shard, payload)
 
@@ -630,20 +626,20 @@ async def on_guild_members_chunk(self, shard: gateway_shard.GatewayShard, payloa
             for presence in event.presences.values():
                 self._cache.set_presence(presence)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(role_events.RoleCreateEvent, config.CacheComponents.ROLES)
-    async def on_guild_role_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_role_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-role-create for more info."""
         event = self._event_factory.deserialize_guild_role_create_event(shard, payload)
 
         if self._cache:
             self._cache.set_role(event.role)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(role_events.RoleUpdateEvent, config.CacheComponents.ROLES)
-    async def on_guild_role_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_role_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-role-update for more info."""
         old = self._cache.get_role(snowflakes.Snowflake(payload["role"]["id"])) if self._cache else None
         event = self._event_factory.deserialize_guild_role_update_event(shard, payload, old_role=old)
@@ -651,10 +647,10 @@ async def on_guild_role_update(self, shard: gateway_shard.GatewayShard, payload:
         if self._cache:
             self._cache.update_role(event.role)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(role_events.RoleDeleteEvent, config.CacheComponents.ROLES)
-    async def on_guild_role_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_guild_role_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-role-delete for more info."""
         old: guilds.Role | None = None
         if self._cache:
@@ -662,20 +658,20 @@ async def on_guild_role_delete(self, shard: gateway_shard.GatewayShard, payload:
 
         event = self._event_factory.deserialize_guild_role_delete_event(shard, payload, old_role=old)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(channel_events.InviteCreateEvent, config.CacheComponents.INVITES)
-    async def on_invite_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_invite_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#invite-create for more info."""
         event = self._event_factory.deserialize_invite_create_event(shard, payload)
 
         if self._cache:
             self._cache.set_invite(event.invite)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(channel_events.InviteDeleteEvent, config.CacheComponents.INVITES)
-    async def on_invite_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_invite_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#invite-delete for more info."""
         old: invites.InviteWithMetadata | None = None
         if self._cache:
@@ -683,24 +679,24 @@ async def on_invite_delete(self, shard: gateway_shard.GatewayShard, payload: dat
 
         event = self._event_factory.deserialize_invite_delete_event(shard, payload, old_invite=old)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(
         (message_events.GuildMessageCreateEvent, message_events.DMMessageCreateEvent), config.CacheComponents.MESSAGES
     )
-    async def on_message_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_message_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-create for more info."""
         event = self._event_factory.deserialize_message_create_event(shard, payload)
 
         if self._cache:
             self._cache.set_message(event.message)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(
         (message_events.GuildMessageUpdateEvent, message_events.DMMessageUpdateEvent), config.CacheComponents.MESSAGES
     )
-    async def on_message_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_message_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-update for more info."""
         old = self._cache.get_message(snowflakes.Snowflake(payload["id"])) if self._cache else None
         event = self._event_factory.deserialize_message_update_event(shard, payload, old_message=old)
@@ -708,12 +704,12 @@ async def on_message_update(self, shard: gateway_shard.GatewayShard, payload: da
         if self._cache:
             self._cache.update_message(event.message)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(
         (message_events.GuildMessageDeleteEvent, message_events.DMMessageDeleteEvent), config.CacheComponents.MESSAGES
     )
-    async def on_message_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_message_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-delete for more info."""
         if self._cache:
             message_id = snowflakes.Snowflake(payload["id"])
@@ -723,12 +719,12 @@ async def on_message_delete(self, shard: gateway_shard.GatewayShard, payload: da
 
         event = self._event_factory.deserialize_message_delete_event(shard, payload, old_message=old_message)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(
         (message_events.GuildMessageDeleteEvent, message_events.DMMessageDeleteEvent), config.CacheComponents.MESSAGES
     )
-    async def on_message_delete_bulk(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_message_delete_bulk(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-delete-bulk for more info."""
         old_messages = {}
 
@@ -739,46 +735,42 @@ async def on_message_delete_bulk(self, shard: gateway_shard.GatewayShard, payloa
                 if message := self._cache.delete_message(message_id):
                     old_messages[message_id] = message
 
-        await self.dispatch(
+        self.dispatch(
             self._event_factory.deserialize_guild_message_delete_bulk_event(shard, payload, old_messages=old_messages)
         )
 
     @event_manager_base.filtered((reaction_events.GuildReactionAddEvent, reaction_events.DMReactionAddEvent))
-    async def on_message_reaction_add(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
+    def on_message_reaction_add(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-reaction-add for more info."""
-        await self.dispatch(self._event_factory.deserialize_message_reaction_add_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_message_reaction_add_event(shard, payload))
 
     # TODO: this is unlikely but reaction cache?
 
     @event_manager_base.filtered((reaction_events.GuildReactionDeleteEvent, reaction_events.DMReactionDeleteEvent))
-    async def on_message_reaction_remove(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
+    def on_message_reaction_remove(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-reaction-remove for more info."""
-        await self.dispatch(self._event_factory.deserialize_message_reaction_remove_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_message_reaction_remove_event(shard, payload))
 
     @event_manager_base.filtered(
         (reaction_events.GuildReactionDeleteAllEvent, reaction_events.DMReactionDeleteAllEvent)
     )
-    async def on_message_reaction_remove_all(
+    def on_message_reaction_remove_all(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-reaction-remove-all for more info."""
-        await self.dispatch(self._event_factory.deserialize_message_reaction_remove_all_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_message_reaction_remove_all_event(shard, payload))
 
     @event_manager_base.filtered(
         (reaction_events.GuildReactionDeleteEmojiEvent, reaction_events.DMReactionDeleteEmojiEvent)
     )
-    async def on_message_reaction_remove_emoji(
+    def on_message_reaction_remove_emoji(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-reaction-remove-emoji for more info."""
-        await self.dispatch(self._event_factory.deserialize_message_reaction_remove_emoji_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_message_reaction_remove_emoji_event(shard, payload))
 
     @event_manager_base.filtered(guild_events.PresenceUpdateEvent, config.CacheComponents.PRESENCES)
-    async def on_presence_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_presence_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#presence-update for more info."""
         old: presences_.MemberPresence | None = None
 
@@ -795,15 +787,15 @@ async def on_presence_update(self, shard: gateway_shard.GatewayShard, payload: d
             self._cache.update_presence(event.presence)
 
         # TODO: update user here when partial_user is set self._cache.update_user(event.partial_user)
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered((typing_events.GuildTypingEvent, typing_events.DMTypingEvent))
-    async def on_typing_start(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_typing_start(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#typing-start for more info."""
-        await self.dispatch(self._event_factory.deserialize_typing_start_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_typing_start_event(shard, payload))
 
     @event_manager_base.filtered(user_events.OwnUserUpdateEvent, config.CacheComponents.ME)
-    async def on_user_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_user_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#user-update for more info."""
         old = self._cache.get_me() if self._cache else None
         event = self._event_factory.deserialize_own_user_update_event(shard, payload, old_user=old)
@@ -811,10 +803,10 @@ async def on_user_update(self, shard: gateway_shard.GatewayShard, payload: data_
         if self._cache:
             self._cache.update_me(event.user)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(voice_events.VoiceStateUpdateEvent, config.CacheComponents.VOICE_STATES)
-    async def on_voice_state_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_voice_state_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#voice-state-update for more info."""
         old: voices.VoiceState | None = None
         if self._cache:
@@ -829,17 +821,17 @@ async def on_voice_state_update(self, shard: gateway_shard.GatewayShard, payload
         elif self._cache:
             self._cache.update_voice_state(event.state)
 
-        await self.dispatch(event)
+        self.dispatch(event)
 
     @event_manager_base.filtered(voice_events.VoiceServerUpdateEvent)
-    async def on_voice_server_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_voice_server_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#voice-server-update for more info."""
-        await self.dispatch(self._event_factory.deserialize_voice_server_update_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_voice_server_update_event(shard, payload))
 
     @event_manager_base.filtered(channel_events.WebhookUpdateEvent)
-    async def on_webhooks_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_webhooks_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#webhooks-update for more info."""
-        await self.dispatch(self._event_factory.deserialize_webhook_update_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_webhook_update_event(shard, payload))
 
     @event_manager_base.filtered(
         (
@@ -849,123 +841,113 @@ async def on_webhooks_update(self, shard: gateway_shard.GatewayShard, payload: d
             interaction_events.ModalInteractionCreateEvent,
         )
     )
-    async def on_interaction_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_interaction_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#interaction-create for more info."""
-        await self.dispatch(self._event_factory.deserialize_interaction_create_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_interaction_create_event(shard, payload))
 
     @event_manager_base.filtered(scheduled_events.ScheduledEventCreateEvent)
-    async def on_guild_scheduled_event_create(
+    def on_guild_scheduled_event_create(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-create for more info."""
-        await self.dispatch(self._event_factory.deserialize_scheduled_event_create_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_scheduled_event_create_event(shard, payload))
 
     @event_manager_base.filtered(scheduled_events.ScheduledEventDeleteEvent)
-    async def on_guild_scheduled_event_delete(
+    def on_guild_scheduled_event_delete(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-delete for more info."""
-        await self.dispatch(self._event_factory.deserialize_scheduled_event_delete_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_scheduled_event_delete_event(shard, payload))
 
     @event_manager_base.filtered(scheduled_events.ScheduledEventUpdateEvent)
-    async def on_guild_scheduled_event_update(
+    def on_guild_scheduled_event_update(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-update for more info."""
-        await self.dispatch(self._event_factory.deserialize_scheduled_event_update_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_scheduled_event_update_event(shard, payload))
 
     @event_manager_base.filtered(scheduled_events.ScheduledEventUserAddEvent)
-    async def on_guild_scheduled_event_user_add(
+    def on_guild_scheduled_event_user_add(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-user-add for more info."""  # noqa: E501
-        await self.dispatch(self._event_factory.deserialize_scheduled_event_user_add_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_scheduled_event_user_add_event(shard, payload))
 
     @event_manager_base.filtered(scheduled_events.ScheduledEventUserRemoveEvent)
-    async def on_guild_scheduled_event_user_remove(
+    def on_guild_scheduled_event_user_remove(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-scheduled-event-user-remove for more info."""  # noqa: E501
-        await self.dispatch(self._event_factory.deserialize_scheduled_event_user_remove_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_scheduled_event_user_remove_event(shard, payload))
 
     @event_manager_base.filtered(guild_events.AuditLogEntryCreateEvent)
-    async def on_guild_audit_log_entry_create(
+    def on_guild_audit_log_entry_create(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#guild-audit-log-entry-create for more info."""
-        await self.dispatch(self._event_factory.deserialize_audit_log_entry_create_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_audit_log_entry_create_event(shard, payload))
 
     @event_manager_base.filtered(monetization_events.EntitlementCreateEvent)
-    async def on_entitlement_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_entitlement_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#entitlement-create for more info."""
-        await self.dispatch(self._event_factory.deserialize_entitlement_create_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_entitlement_create_event(shard, payload))
 
     @event_manager_base.filtered(monetization_events.EntitlementDeleteEvent)
-    async def on_entitlement_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_entitlement_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#entitlement-delete for more info."""
-        await self.dispatch(self._event_factory.deserialize_entitlement_delete_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_entitlement_delete_event(shard, payload))
 
     @event_manager_base.filtered(monetization_events.EntitlementUpdateEvent)
-    async def on_entitlement_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+    def on_entitlement_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#entitlement-update for more info."""
-        await self.dispatch(self._event_factory.deserialize_entitlement_update_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_entitlement_update_event(shard, payload))
 
     @event_manager_base.filtered(stage_events.StageInstanceCreateEvent)
-    async def on_stage_instance_create(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
-        await self.dispatch(self._event_factory.deserialize_stage_instance_create_event(shard, payload))
+    def on_stage_instance_create(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+        self.dispatch(self._event_factory.deserialize_stage_instance_create_event(shard, payload))
 
     @event_manager_base.filtered(stage_events.StageInstanceUpdateEvent)
-    async def on_stage_instance_update(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
-        await self.dispatch(self._event_factory.deserialize_stage_instance_update_event(shard, payload))
+    def on_stage_instance_update(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+        self.dispatch(self._event_factory.deserialize_stage_instance_update_event(shard, payload))
 
     @event_manager_base.filtered(stage_events.StageInstanceDeleteEvent)
-    async def on_stage_instance_delete(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
-        await self.dispatch(self._event_factory.deserialize_stage_instance_delete_event(shard, payload))
+    def on_stage_instance_delete(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
+        self.dispatch(self._event_factory.deserialize_stage_instance_delete_event(shard, payload))
 
     @event_manager_base.filtered(poll_events.PollVoteCreateEvent)
-    async def on_message_poll_vote_add(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
+    def on_message_poll_vote_add(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-poll-vote-add for more info."""
-        await self.dispatch(self._event_factory.deserialize_poll_vote_create_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_poll_vote_create_event(shard, payload))
 
     @event_manager_base.filtered(poll_events.PollVoteDeleteEvent)
-    async def on_message_poll_vote_remove(
-        self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
+    def on_message_poll_vote_remove(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         """See https://discord.com/developers/docs/topics/gateway-events#message-poll-vote-remove for more info."""
-        await self.dispatch(self._event_factory.deserialize_poll_vote_delete_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_poll_vote_delete_event(shard, payload))
 
     @event_manager_base.filtered(auto_mod_events.AutoModRuleCreateEvent)
-    async def on_auto_moderation_rule_create(
+    def on_auto_moderation_rule_create(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway#auto-moderation-rule-create for more info."""
-        await self.dispatch(self._event_factory.deserialize_auto_mod_rule_create_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_auto_mod_rule_create_event(shard, payload))
 
     @event_manager_base.filtered(auto_mod_events.AutoModRuleUpdateEvent)
-    async def on_auto_moderation_rule_update(
+    def on_auto_moderation_rule_update(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway#auto-moderation-rule-update for more info."""
-        await self.dispatch(self._event_factory.deserialize_auto_mod_rule_update_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_auto_mod_rule_update_event(shard, payload))
 
     @event_manager_base.filtered(auto_mod_events.AutoModRuleDeleteEvent)
-    async def on_auto_moderation_rule_delete(
+    def on_auto_moderation_rule_delete(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway#auto-moderation-rule-delete for more info."""
-        await self.dispatch(self._event_factory.deserialize_auto_mod_rule_delete_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_auto_mod_rule_delete_event(shard, payload))
 
     @event_manager_base.filtered(auto_mod_events.AutoModActionExecutionEvent)
-    async def on_auto_moderation_action_execution(
+    def on_auto_moderation_action_execution(
         self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
     ) -> None:
         """See https://discord.com/developers/docs/topics/gateway#auto-moderation-action-execution for more info."""
-        await self.dispatch(self._event_factory.deserialize_auto_mod_action_execution_event(shard, payload))
+        self.dispatch(self._event_factory.deserialize_auto_mod_action_execution_event(shard, payload))
diff --git a/hikari/impl/event_manager_base.py b/hikari/impl/event_manager_base.py
index cf75f634..721e72d0 100644
--- a/hikari/impl/event_manager_base.py
+++ b/hikari/impl/event_manager_base.py
@@ -42,7 +42,6 @@
 from hikari.api import event_manager as event_manager_
 from hikari.events import base_events
 from hikari.events import shard_events
-from hikari.internal import aio
 from hikari.internal import fast_protocol
 from hikari.internal import reflect
 from hikari.internal import typing_extensions
@@ -56,9 +55,7 @@
     from hikari.api import shard as gateway_shard
     from hikari.internal import data_binding
 
-    _ConsumerT = typing.Callable[
-        [gateway_shard.GatewayShard, data_binding.JSONObject], typing.Coroutine[typing.Any, typing.Any, None]
-    ]
+    _ConsumerT = typing.Callable[[gateway_shard.GatewayShard, data_binding.JSONObject], None]
     _ListenerMapT = dict[type[base_events.EventT], list[event_manager_.CallbackT[base_events.EventT]]]
     _WaiterT = tuple[
         typing.Optional[event_manager_.PredicateT[base_events.EventT]], "asyncio.Future[base_events.EventT]"
@@ -66,10 +63,7 @@
     _WaiterMapT = dict[type[base_events.EventT], set[_WaiterT[base_events.EventT]]]
 
     _EventManagerBaseT = typing.TypeVar("_EventManagerBaseT", bound="EventManagerBase")
-    _UnboundMethodT = typing.Callable[
-        [_EventManagerBaseT, gateway_shard.GatewayShard, data_binding.JSONObject],
-        typing.Coroutine[typing.Any, typing.Any, None],
-    ]
+    _UnboundMethodT = typing.Callable[[_EventManagerBaseT, gateway_shard.GatewayShard, data_binding.JSONObject], None]
 
 
 if sys.version_info >= (3, 10):
@@ -85,7 +79,7 @@
 class _FilteredMethodT(fast_protocol.FastProtocolChecking, typing.Protocol):
     __slots__: typing.Sequence[str] = ()
 
-    async def __call__(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject, /) -> None:
+    def __call__(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
         raise NotImplementedError
 
     @property
@@ -328,8 +322,8 @@ class EventManagerBase(event_manager_.EventManager):
 
     __slots__: typing.Sequence[str] = (
         "_consumers",
+        "_dispatched_tasks",
         "_event_factory",
-        "_handling_dispatch_tasks",
         "_intents",
         "_listeners",
         "_waiters",
@@ -347,7 +341,7 @@ def __init__(
         self._intents = intents
         self._listeners: _ListenerMapT[base_events.Event] = {}
         self._waiters: _WaiterMapT[base_events.Event] = {}
-        self._handling_dispatch_tasks: set[asyncio.Task[None]] = set()
+        self._dispatched_tasks: set[asyncio.Task[None]] = set()
 
         for name, member in inspect.getmembers(self):
             if name.startswith("on_"):
@@ -420,12 +414,28 @@ def consume_raw_event(
         if self._enabled_for_event(shard_events.ShardPayloadEvent):
             payload_event = self._event_factory.deserialize_shard_payload_event(shard, payload, name=event_name)
             self.dispatch(payload_event)
-        consumer = self._consumers[event_name.lower()]
 
-        task = asyncio.create_task(self._handle_dispatch(consumer, shard, payload), name=f"dispatch {event_name}")
+        consumer = self._consumers[event_name.lower()]
+        if not consumer.is_enabled:
+            name = consumer.callback.__name__
+            _LOGGER.log(
+                ux.TRACE, "Skipping raw dispatch for %s due to lack of any registered listeners or cache need", name
+            )
+            return
 
-        self._handling_dispatch_tasks.add(task)
-        task.add_done_callback(self._handling_dispatch_tasks.discard)
+        try:
+            consumer.callback(shard, payload)
+        except errors.UnrecognisedEntityError:
+            _LOGGER.debug("Event referenced an unrecognised entity, discarding")
+        except Exception as ex:  # noqa: BLE001 - Do not catch blind exception
+            asyncio.get_running_loop().call_exception_handler(
+                {
+                    "message": "Exception occurred in raw event dispatch conduit",
+                    "payload": payload,
+                    "exception": ex,
+                    "task": asyncio.current_task(),
+                }
+            )
 
     # Yes, this is not generic. The reason for this is MyPy complains about
     # using ABCs that are not concrete in generic types passed to functions.
@@ -536,12 +546,26 @@ def decorator(
 
         return decorator
 
+    @typing.overload
+    def dispatch(self, event: base_events.Event, *, return_tasks: typing.Literal[False] = False) -> None: ...
+
+    @typing.overload
+    def dispatch(
+        self, event: base_events.Event, *, return_tasks: typing.Literal[True] = True
+    ) -> asyncio.Future[typing.Any]: ...
+
+    @typing.overload
+    def dispatch(
+        self, event: base_events.Event, *, return_tasks: bool = False
+    ) -> asyncio.Future[typing.Any] | None: ...
+
     @typing_extensions.override
-    def dispatch(self, event: base_events.Event) -> asyncio.Future[typing.Any]:
-        tasks: list[typing.Coroutine[None, typing.Any, None]] = []
+    def dispatch(self, event: base_events.Event, *, return_tasks: bool = False) -> asyncio.Future[typing.Any] | None:
+        tasks: list[asyncio.Task[None]] = []
 
         for cls in event.dispatches():
-            tasks.extend(self._invoke_callback(c, event) for c in self._listeners.get(cls, ()))
+            if cls in self._listeners:
+                tasks.extend(asyncio.create_task(self._invoke_callback(c, event)) for c in self._listeners[cls])
 
             if cls not in self._waiters:
                 continue
@@ -565,10 +589,13 @@ def dispatch(self, event: base_events.Event) -> asyncio.Future[typing.Any]:
                 del self._waiters[cls]
                 self._increment_waiter_group_count(cls, -1)
 
-        if tasks:
+        if return_tasks:
             return asyncio.gather(*tasks)
 
-        return aio.completed_future()
+        self._dispatched_tasks.update(tasks)
+        for task in tasks:
+            task.add_done_callback(self._dispatched_tasks.remove)
+        return None
 
     @typing_extensions.override
     def stream(
@@ -610,33 +637,6 @@ async def wait_for(
 
             raise
 
-    async def _handle_dispatch(
-        self, consumer: _Consumer, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
-    ) -> None:
-        if not consumer.is_enabled:
-            name = consumer.callback.__name__
-            _LOGGER.log(
-                ux.TRACE, "Skipping raw dispatch for %s due to lack of any registered listeners or cache need", name
-            )
-            return
-
-        try:
-            await consumer.callback(shard, payload)
-        except asyncio.CancelledError:
-            # Skip cancelled errors, likely caused by the event loop being shut down.
-            pass
-        except errors.UnrecognisedEntityError:
-            _LOGGER.debug("Event referenced an unrecognised entity, discarding")
-        except Exception as ex:  # noqa: BLE001 - Do not catch blind exception
-            asyncio.get_running_loop().call_exception_handler(
-                {
-                    "message": "Exception occurred in raw event dispatch conduit",
-                    "payload": payload,
-                    "exception": ex,
-                    "task": asyncio.current_task(),
-                }
-            )
-
     async def _invoke_callback(
         self, callback: event_manager_.CallbackT[base_events.EventT], event: base_events.EventT
     ) -> None:
@@ -656,4 +656,4 @@ async def _invoke_callback(
 
                 log = _LOGGER.debug if self.get_listeners(type(exception_event), polymorphic=True) else _LOGGER.error
                 log("an exception occurred handling an event (%s)", type(event).__name__, exc_info=trio)
-                await self.dispatch(exception_event)
+                self.dispatch(exception_event)
diff --git a/hikari/impl/gateway_bot.py b/hikari/impl/gateway_bot.py
index 60c08210..1419d85e 100644
--- a/hikari/impl/gateway_bot.py
+++ b/hikari/impl/gateway_bot.py
@@ -481,7 +481,7 @@ async def close(self) -> None:
         _LOGGER.info("bot requested to shut down")
         self._closing_event.set()
 
-        await self._event_manager.dispatch(self._event_factory.deserialize_stopping_event())
+        await self._event_manager.dispatch(self._event_factory.deserialize_stopping_event(), return_tasks=True)
         _LOGGER.log(ux.TRACE, "StoppingEvent dispatch completed, now beginning termination")
 
         await _close_resource("voice handler", self._voice.close())
@@ -497,7 +497,7 @@ async def close(self) -> None:
         self._cache.clear()
         self._shards.clear()
 
-        await self._event_manager.dispatch(self._event_factory.deserialize_stopped_event())
+        await self._event_manager.dispatch(self._event_factory.deserialize_stopped_event(), return_tasks=True)
 
         self._closed_event.set()
         self._closed_event = None
@@ -505,13 +505,28 @@ async def close(self) -> None:
 
         _LOGGER.info("bot shut down successfully")
 
-    def dispatch(self, event: base_events.Event) -> asyncio.Future[typing.Any]:
+    @typing.overload
+    def dispatch(self, event: base_events.Event, *, return_tasks: typing.Literal[False] = False) -> None: ...
+
+    @typing.overload
+    def dispatch(
+        self, event: base_events.Event, *, return_tasks: typing.Literal[True] = True
+    ) -> asyncio.Future[typing.Any]: ...
+
+    @typing.overload
+    def dispatch(
+        self, event: base_events.Event, *, return_tasks: bool = False
+    ) -> asyncio.Future[typing.Any] | None: ...
+
+    def dispatch(self, event: base_events.Event, *, return_tasks: bool = False) -> asyncio.Future[typing.Any] | None:
         """Dispatch an event.
 
         Parameters
         ----------
         event
             The event to dispatch.
+        return_tasks
+            Whether to return an asyncio future to wait for the listeners to finish.
 
         Examples
         --------
@@ -588,7 +603,7 @@ async def on_everyone_mentioned(event):
         Unsubscribe : [`hikari.impl.gateway_bot.GatewayBot.unsubscribe`][].
         Wait_for : [`hikari.impl.gateway_bot.GatewayBot.wait_for`][].
         """
-        return self._event_manager.dispatch(event)
+        return self._event_manager.dispatch(event, return_tasks=return_tasks)
 
     def get_listeners(
         self, event_type: type[base_events.EventT], /, *, polymorphic: bool = True
@@ -970,7 +985,7 @@ async def start(
         self._rest.start()
         self._voice.start()
 
-        await self._event_manager.dispatch(self._event_factory.deserialize_starting_event())
+        await self._event_manager.dispatch(self._event_factory.deserialize_starting_event(), return_tasks=True)
         requirements = await self._rest.fetch_gateway_bot_info()
 
         if shard_count is None:
@@ -1043,7 +1058,7 @@ async def start(
 
             await aio.first_completed(self._closing_event.wait(), gather)
 
-        await self._event_manager.dispatch(self._event_factory.deserialize_started_event())
+        await self._event_manager.dispatch(self._event_factory.deserialize_started_event(), return_tasks=True)
 
         _LOGGER.info("started successfully in approx %.2f seconds", time.monotonic() - start_time)
 
diff --git a/hikari/impl/shard.py b/hikari/impl/shard.py
index 0f230b73..87439710 100644
--- a/hikari/impl/shard.py
+++ b/hikari/impl/shard.py
@@ -98,7 +98,7 @@
 # to get around (leaving 3 slots for it).
 _NON_PRIORITY_RATELIMIT: typing.Final[tuple[float, int]] = (60.0, 117)
 # Used to identify the end of a ZLIB payload
-_ZLIB_SUFFIX: typing.Final[bytes] = b"\x00\x00\xff\xff"
+_ZLIB_SYNC_FLUSH: typing.Final[bytes] = b"\x00\x00\xff\xff"
 # Close codes which don't invalidate the current session.
 _RECONNECTABLE_CLOSE_CODES: frozenset[errors.ShardCloseCode] = frozenset(
     (
@@ -191,6 +191,7 @@ async def send_close(self, *, code: int, message: bytes) -> None:
 
     async def receive_json(self) -> data_binding.JSONObject:
         pl = await self._receive_and_check()
+
         if self._logger.isEnabledFor(ux.TRACE):
             filtered = self._log_filterer(pl)
             self._logger.log(ux.TRACE, "received payload with size %s\n    %s", len(pl), filtered)
@@ -247,7 +248,7 @@ async def _receive_and_check_zlib(self) -> bytes:
         message = await self._ws.receive()
 
         if message.type == aiohttp.WSMsgType.BINARY:
-            if message.data.endswith(_ZLIB_SUFFIX):
+            if message.data.endswith(_ZLIB_SYNC_FLUSH):
                 # Hot and fast path: we already have the full message
                 # in a single frame
                 return self._zlib.decompress(message.data)
@@ -256,7 +257,7 @@ async def _receive_and_check_zlib(self) -> bytes:
             # the whole message. Only then do we create a buffer
             buff = bytearray(message.data)
 
-            while not buff.endswith(_ZLIB_SUFFIX):
+            while not buff.endswith(_ZLIB_SYNC_FLUSH):
                 message = await self._ws.receive()
 
                 if message.type == aiohttp.WSMsgType.BINARY:
@@ -933,7 +934,9 @@ async def _keep_alive(self) -> None:  # noqa: PLR0912, PLR0915
                 if not self._handshake_event.is_set():
                     continue
 
-                await self._event_manager.dispatch(self._event_factory.deserialize_connected_event(self))
+                await self._event_manager.dispatch(
+                    self._event_factory.deserialize_connected_event(self), return_tasks=True
+                )
                 await aio.first_completed(*lifetime_tasks)
 
                 # Since nothing went wrong, we can reset the backoff and try again
@@ -1003,7 +1006,9 @@ async def _keep_alive(self) -> None:  # noqa: PLR0912, PLR0915
 
                     if self._handshake_event.is_set():
                         # We dispatched the connected event, so we can dispatch the disconnected one too
-                        await self._event_manager.dispatch(self._event_factory.deserialize_disconnected_event(self))
+                        await self._event_manager.dispatch(
+                            self._event_factory.deserialize_disconnected_event(self), return_tasks=True
+                        )
 
     def _serialize_and_store_presence_payload(
         self,


Test patch:
diff --git a/tests/hikari/impl/test_event_manager.py b/tests/hikari/impl/test_event_manager.py
index 023fdc60..0aeac397 100644
--- a/tests/hikari/impl/test_event_manager.py
+++ b/tests/hikari/impl/test_event_manager.py
@@ -75,7 +75,7 @@ async def test__request_guild_members(shard):
 
     await event_manager._request_guild_members(shard, 123, include_presences=True, nonce="okokok")
 
-    shard.request_guild_members.assert_awaited_once_with(123, include_presences=True, nonce="okokok")
+    shard.request_guild_members.assert_called_once_with(123, include_presences=True, nonce="okokok")
 
 
 @pytest.mark.asyncio
@@ -84,7 +84,7 @@ async def test__request_guild_members_handles_state_conflict_error(shard):
 
     await event_manager._request_guild_members(shard, 123, include_presences=True, nonce="okokok")
 
-    shard.request_guild_members.assert_awaited_once_with(123, include_presences=True, nonce="okokok")
+    shard.request_guild_members.assert_called_once_with(123, include_presences=True, nonce="okokok")
 
 
 class TestEventManagerImpl:
@@ -102,7 +102,7 @@ def event_manager_impl(self, entity_factory, event_factory):
             entity_factory, event_factory, intents.Intents.ALL, cache=mock.Mock(settings=config.CacheSettings())
         )
 
-        obj.dispatch = mock.AsyncMock()
+        obj.dispatch = mock.Mock()
         return obj
 
     @pytest.fixture
@@ -111,79 +111,72 @@ def stateless_event_manager_impl(self, event_factory, entity_factory):
             entity_factory, event_factory, intents.Intents.ALL, cache=None
         )
 
-        obj.dispatch = mock.AsyncMock()
+        obj.dispatch = mock.Mock()
         return obj
 
-    @pytest.mark.asyncio
-    async def test_on_ready_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_ready_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock(my_user=mock.Mock())
 
         event_factory.deserialize_ready_event.return_value = event
 
-        await event_manager_impl.on_ready(shard, payload)
+        event_manager_impl.on_ready(shard, payload)
 
         event_manager_impl._cache.update_me.assert_called_once_with(event.my_user)
         event_factory.deserialize_ready_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_ready_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_ready_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_ready(shard, payload)
+        stateless_event_manager_impl.on_ready(shard, payload)
 
         event_factory.deserialize_ready_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_ready_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_resumed(self, event_manager_impl, shard, event_factory):
+    def test_on_resumed(self, event_manager_impl, shard, event_factory):
         payload = {}
 
-        await event_manager_impl.on_resumed(shard, payload)
+        event_manager_impl.on_resumed(shard, payload)
 
         event_factory.deserialize_resumed_event.assert_called_once_with(shard)
-        event_manager_impl.dispatch.assert_awaited_once_with(event_factory.deserialize_resumed_event.return_value)
+        event_manager_impl.dispatch.assert_called_once_with(event_factory.deserialize_resumed_event.return_value)
 
-    @pytest.mark.asyncio
-    async def test_on_application_command_permissions_update(self, event_manager_impl, shard, event_factory):
+    def test_on_application_command_permissions_update(self, event_manager_impl, shard, event_factory):
         payload = {}
 
-        await event_manager_impl.on_application_command_permissions_update(shard, payload)
+        event_manager_impl.on_application_command_permissions_update(shard, payload)
 
         event_factory.deserialize_application_command_permission_update_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_application_command_permission_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_channel_create_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_channel_create_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock(channel=mock.Mock(channels.GuildChannel))
 
         event_factory.deserialize_guild_channel_create_event.return_value = event
 
-        await event_manager_impl.on_channel_create(shard, payload)
+        event_manager_impl.on_channel_create(shard, payload)
 
         event_manager_impl._cache.set_guild_channel.assert_called_once_with(event.channel)
         event_factory.deserialize_guild_channel_create_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_channel_create_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_channel_create_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_channel_create(shard, payload)
+        stateless_event_manager_impl.on_channel_create(shard, payload)
 
         event_factory.deserialize_guild_channel_create_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_channel_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_channel_update_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_channel_update_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"id": 123}
         old_channel = object()
         event = mock.Mock(channel=mock.Mock(channels.GuildChannel))
@@ -191,111 +184,102 @@ async def test_on_channel_update_stateful(self, event_manager_impl, shard, event
         event_factory.deserialize_guild_channel_update_event.return_value = event
         event_manager_impl._cache.get_guild_channel.return_value = old_channel
 
-        await event_manager_impl.on_channel_update(shard, payload)
+        event_manager_impl.on_channel_update(shard, payload)
 
         event_manager_impl._cache.get_guild_channel.assert_called_once_with(123)
         event_manager_impl._cache.update_guild_channel.assert_called_once_with(event.channel)
         event_factory.deserialize_guild_channel_update_event.assert_called_once_with(
             shard, payload, old_channel=old_channel
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_channel_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_channel_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"id": 123}
 
-        await stateless_event_manager_impl.on_channel_update(shard, payload)
+        stateless_event_manager_impl.on_channel_update(shard, payload)
 
         event_factory.deserialize_guild_channel_update_event.assert_called_once_with(shard, payload, old_channel=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_channel_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_channel_delete_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_channel_delete_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock(channel=mock.Mock(id=123))
 
         event_factory.deserialize_guild_channel_delete_event.return_value = event
 
-        await event_manager_impl.on_channel_delete(shard, payload)
+        event_manager_impl.on_channel_delete(shard, payload)
 
         event_manager_impl._cache.delete_guild_channel.assert_called_once_with(123)
         event_factory.deserialize_guild_channel_delete_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_channel_delete_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_channel_delete_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_channel_delete(shard, payload)
+        stateless_event_manager_impl.on_channel_delete(shard, payload)
 
         event_factory.deserialize_guild_channel_delete_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_channel_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_channel_pins_update(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_channel_pins_update(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_channel_pins_update(shard, payload)
+        stateless_event_manager_impl.on_channel_pins_update(shard, payload)
 
         event_factory.deserialize_channel_pins_update_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_channel_pins_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_thread_create_when_create_stateful(
+    def test_on_thread_create_when_create_stateful(
         self, event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         mock_payload = {"id": "123321", "newly_created": True}
-        await event_manager_impl.on_thread_create(shard, mock_payload)
+        event_manager_impl.on_thread_create(shard, mock_payload)
 
         event = event_factory.deserialize_guild_thread_create_event.return_value
         event_manager_impl._cache.set_thread.assert_called_once_with(event.thread)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
         event_factory.deserialize_guild_thread_create_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_create_stateless(
+    def test_on_thread_create_stateless(
         self, stateless_event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         mock_payload = {"id": "123321", "newly_created": True}
-        await stateless_event_manager_impl.on_thread_create(shard, mock_payload)
+        stateless_event_manager_impl.on_thread_create(shard, mock_payload)
 
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_thread_create_event.return_value
         )
         event_factory.deserialize_guild_thread_create_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_create_for_access_stateful(
+    def test_on_thread_create_for_access_stateful(
         self, event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         mock_payload = {"id": "123321"}
-        await event_manager_impl.on_thread_create(shard, mock_payload)
+        event_manager_impl.on_thread_create(shard, mock_payload)
 
         event = event_factory.deserialize_guild_thread_access_event.return_value
         event_manager_impl._cache.set_thread.assert_called_once_with(event.thread)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
         event_factory.deserialize_guild_thread_access_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_create_for_access_stateless(
+    def test_on_thread_create_for_access_stateless(
         self, stateless_event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         mock_payload = {"id": "123321"}
-        await stateless_event_manager_impl.on_thread_create(shard, mock_payload)
+        stateless_event_manager_impl.on_thread_create(shard, mock_payload)
 
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_thread_access_event.return_value
         )
         event_factory.deserialize_guild_thread_access_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_update_stateful(
+    def test_on_thread_update_stateful(
         self, event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         payload = {"id": 123}
@@ -305,54 +289,50 @@ async def test_on_thread_update_stateful(
         event_factory.deserialize_guild_thread_update_event.return_value = event
         event_manager_impl._cache.get_thread.return_value = old_thread
 
-        await event_manager_impl.on_thread_update(shard, payload)
+        event_manager_impl.on_thread_update(shard, payload)
 
         event_manager_impl._cache.get_thread.assert_called_once_with(123)
         event_manager_impl._cache.update_thread.assert_called_once_with(event.thread)
         event_factory.deserialize_guild_thread_update_event.assert_called_once_with(
             shard, payload, old_thread=old_thread
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_update_stateless(
+    def test_on_thread_update_stateless(
         self, stateless_event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         payload = {"id": 123}
 
-        await stateless_event_manager_impl.on_thread_update(shard, payload)
+        stateless_event_manager_impl.on_thread_update(shard, payload)
 
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_thread_update_event.return_value
         )
         event_factory.deserialize_guild_thread_update_event.assert_called_once_with(shard, payload, old_thread=None)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_delete_stateful(
+    def test_on_thread_delete_stateful(
         self, event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         mock_payload = mock.Mock()
-        await event_manager_impl.on_thread_delete(shard, mock_payload)
+        event_manager_impl.on_thread_delete(shard, mock_payload)
 
         event = event_factory.deserialize_guild_thread_delete_event.return_value
         event_manager_impl._cache.delete_thread.assert_called_once_with(event.thread_id)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
         event_factory.deserialize_guild_thread_delete_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_delete_stateless(
+    def test_on_thread_delete_stateless(
         self, stateless_event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         mock_payload = mock.Mock()
-        await stateless_event_manager_impl.on_thread_delete(shard, mock_payload)
+        stateless_event_manager_impl.on_thread_delete(shard, mock_payload)
 
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_thread_delete_event.return_value
         )
         event_factory.deserialize_guild_thread_delete_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_list_sync_stateful_when_channel_ids(
+    def test_on_thread_list_sync_stateful_when_channel_ids(
         self, event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         event = event_factory.deserialize_thread_list_sync_event.return_value
@@ -360,18 +340,17 @@ async def test_on_thread_list_sync_stateful_when_channel_ids(
         event.threads = {1: "thread1"}
 
         mock_payload = mock.Mock()
-        await event_manager_impl.on_thread_list_sync(shard, mock_payload)
+        event_manager_impl.on_thread_list_sync(shard, mock_payload)
 
         assert event_manager_impl._cache.clear_threads_for_channel.call_count == 2
         event_manager_impl._cache.clear_threads_for_channel.assert_has_calls(
             [mock.call(event.guild_id, "1"), mock.call(event.guild_id, "2")]
         )
         event_manager_impl._cache.set_thread("thread1")
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
         event_factory.deserialize_thread_list_sync_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_list_sync_stateful_when_not_channel_ids(
+    def test_on_thread_list_sync_stateful_when_not_channel_ids(
         self, event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         event = event_factory.deserialize_thread_list_sync_event.return_value
@@ -379,75 +358,68 @@ async def test_on_thread_list_sync_stateful_when_not_channel_ids(
         event.threads = {1: "thread1"}
 
         mock_payload = mock.Mock()
-        await event_manager_impl.on_thread_list_sync(shard, mock_payload)
+        event_manager_impl.on_thread_list_sync(shard, mock_payload)
 
         event_manager_impl._cache.clear_threads_for_guild.assert_called_once_with(event.guild_id)
         event_manager_impl._cache.set_thread("thread1")
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
         event_factory.deserialize_thread_list_sync_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_list_sync_stateless(
+    def test_on_thread_list_sync_stateless(
         self, stateless_event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         mock_payload = mock.Mock()
-        await stateless_event_manager_impl.on_thread_list_sync(shard, mock_payload)
+        stateless_event_manager_impl.on_thread_list_sync(shard, mock_payload)
 
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_thread_list_sync_event.return_value
         )
         event_factory.deserialize_thread_list_sync_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_members_update_stateful_when_id_in_removed(
+    def test_on_thread_members_update_stateful_when_id_in_removed(
         self, event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         event = event_factory.deserialize_thread_members_update_event.return_value
         event.removed_member_ids = [1, 2, 3]
         event.shard.get_user_id.return_value = 1
         mock_payload = mock.Mock()
-        await event_manager_impl.on_thread_members_update(shard, mock_payload)
+        event_manager_impl.on_thread_members_update(shard, mock_payload)
 
         event_manager_impl._cache.delete_thread.assert_called_once_with(event.thread_id)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
         event_factory.deserialize_thread_members_update_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_members_update_stateful_when_id_not_in_removed(
+    def test_on_thread_members_update_stateful_when_id_not_in_removed(
         self, event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         event = event_factory.deserialize_thread_members_update_event.return_value
         event.removed_member_ids = [1, 2, 3]
         event.shard.get_user_id.return_value = 69
         mock_payload = mock.Mock()
-        await event_manager_impl.on_thread_members_update(shard, mock_payload)
+        event_manager_impl.on_thread_members_update(shard, mock_payload)
 
         event_manager_impl._cache.delete_thread.assert_not_called()
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
         event_factory.deserialize_thread_members_update_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_thread_members_update_stateless(
+    def test_on_thread_members_update_stateless(
         self, stateless_event_manager_impl: event_manager.EventManagerImpl, shard: mock.Mock, event_factory: mock.Mock
     ):
         mock_payload = mock.Mock()
-        await stateless_event_manager_impl.on_thread_members_update(shard, mock_payload)
+        stateless_event_manager_impl.on_thread_members_update(shard, mock_payload)
 
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_thread_members_update_event.return_value
         )
         event_factory.deserialize_thread_members_update_event.assert_called_once_with(shard, mock_payload)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_create_when_unavailable_guild(
-        self, event_manager_impl, shard, event_factory, entity_factory
-    ):
+    def test_on_guild_create_when_unavailable_guild(self, event_manager_impl, shard, event_factory, entity_factory):
         payload = {"unavailable": True}
         event_manager_impl._cache_enabled_for = mock.Mock(return_value=True)
         event_manager_impl._enabled_for_event = mock.Mock(return_value=True)
 
         with mock.patch.object(event_manager, "_request_guild_members") as request_guild_members:
-            await event_manager_impl.on_guild_create(shard, payload)
+            event_manager_impl.on_guild_create(shard, payload)
 
         event_manager_impl._enabled_for_event.assert_not_called()
         event_factory.deserialize_guild_available_event.assert_not_called()
@@ -483,7 +455,7 @@ async def test_on_guild_create_when_dispatching_and_not_caching(
         event_manager_impl._enabled_for_event = mock.Mock(return_value=True)
 
         with mock.patch.object(event_manager, "_request_guild_members") as request_guild_members:
-            await event_manager_impl.on_guild_create(shard, payload)
+            event_manager_impl.on_guild_create(shard, payload)
 
         if include_unavailable:
             event_manager_impl._enabled_for_event.assert_called_once_with(guild_events.GuildAvailableEvent)
@@ -513,11 +485,10 @@ async def test_on_guild_create_when_dispatching_and_not_caching(
         event_manager_impl._cache.set_voice_state.assert_not_called()
         request_guild_members.assert_not_called()
 
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
     @pytest.mark.parametrize("include_unavailable", [True, False])
-    @pytest.mark.asyncio
-    async def test_on_guild_create_when_not_dispatching_and_not_caching(
+    def test_on_guild_create_when_not_dispatching_and_not_caching(
         self, event_manager_impl, shard, event_factory, entity_factory, include_unavailable
     ):
         payload = {"unavailable": False} if include_unavailable else {}
@@ -526,7 +497,7 @@ async def test_on_guild_create_when_not_dispatching_and_not_caching(
         event_manager_impl._enabled_for_event = mock.Mock(return_value=False)
 
         with mock.patch.object(event_manager, "_request_guild_members") as request_guild_members:
-            await event_manager_impl.on_guild_create(shard, payload)
+            event_manager_impl.on_guild_create(shard, payload)
 
         if include_unavailable:
             event_manager_impl._enabled_for_event.assert_called_once_with(guild_events.GuildAvailableEvent)
@@ -563,8 +534,7 @@ async def test_on_guild_create_when_not_dispatching_and_not_caching(
     @pytest.mark.parametrize(
         ("include_unavailable", "only_my_member"), [(True, True), (True, False), (False, True), (False, False)]
     )
-    @pytest.mark.asyncio
-    async def test_on_guild_create_when_not_dispatching_and_caching(
+    def test_on_guild_create_when_not_dispatching_and_caching(
         self, event_manager_impl, shard, event_factory, entity_factory, include_unavailable, only_my_member
     ):
         payload = {"unavailable": False} if include_unavailable else {}
@@ -584,7 +554,7 @@ async def test_on_guild_create_when_not_dispatching_and_caching(
         gateway_guild.threads.return_value = {1: "thread1", 2: "thread2"}
 
         with mock.patch.object(event_manager, "_request_guild_members") as request_guild_members:
-            await event_manager_impl.on_guild_create(shard, payload)
+            event_manager_impl.on_guild_create(shard, payload)
 
         if include_unavailable:
             event_manager_impl._enabled_for_event.assert_called_once_with(guild_events.GuildAvailableEvent)
@@ -623,8 +593,7 @@ async def test_on_guild_create_when_not_dispatching_and_caching(
         event_manager_impl.dispatch.assert_not_called()
 
     @pytest.mark.parametrize("include_unavailable", [True, False])
-    @pytest.mark.asyncio
-    async def test_on_guild_create_when_stateless(
+    def test_on_guild_create_when_stateless(
         self, stateless_event_manager_impl, shard, event_factory, entity_factory, include_unavailable
     ):
         payload = {"id": 123}
@@ -636,7 +605,7 @@ async def test_on_guild_create_when_stateless(
         stateless_event_manager_impl._enabled_for_event = mock.Mock(return_value=False)
 
         with mock.patch.object(event_manager, "_request_guild_members") as request_guild_members:
-            await stateless_event_manager_impl.on_guild_create(shard, payload)
+            stateless_event_manager_impl.on_guild_create(shard, payload)
 
         if include_unavailable:
             stateless_event_manager_impl._enabled_for_event.assert_called_once_with(guild_events.GuildAvailableEvent)
@@ -649,8 +618,7 @@ async def test_on_guild_create_when_stateless(
 
         stateless_event_manager_impl.dispatch.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_on_guild_create_when_members_declared_and_member_cache_enabled_but_only_my_member_not_enabled(
+    def test_on_guild_create_when_members_declared_and_member_cache_enabled_but_only_my_member_not_enabled(
         self, event_manager_impl, shard, event_factory, entity_factory
     ):
         def cache_enabled_for_members_only(component):
@@ -669,15 +637,14 @@ def cache_enabled_for_members_only(component):
         with mock.patch.object(asyncio, "create_task") as create_task:
             with mock.patch.object(event_manager, "_fixed_size_nonce", return_value="abc"):
                 with mock.patch.object(event_manager, "_request_guild_members", new=mock_request_guild_members):
-                    await event_manager_impl.on_guild_create(shard, {"id": 456, "large": False})
+                    event_manager_impl.on_guild_create(shard, {"id": 456, "large": False})
 
         mock_request_guild_members.assert_called_once_with(shard, 456, include_presences=False, nonce="123.abc")
         create_task.assert_called_once_with(
             mock_request_guild_members.return_value, name="123:456 guild create members request"
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_create_when_members_declared_and_member_cache_but_only_my_member_enabled(
+    def test_on_guild_create_when_members_declared_and_member_cache_but_only_my_member_enabled(
         self, event_manager_impl, shard, event_factory, entity_factory
     ):
         def cache_enabled_for_members_only(component):
@@ -697,13 +664,12 @@ def cache_enabled_for_members_only(component):
         with mock.patch.object(asyncio, "create_task") as create_task:
             with mock.patch.object(event_manager, "_fixed_size_nonce", return_value="abc"):
                 with mock.patch.object(event_manager, "_request_guild_members", new=mock_request_guild_members):
-                    await event_manager_impl.on_guild_create(shard, {"id": 456, "large": False})
+                    event_manager_impl.on_guild_create(shard, {"id": 456, "large": False})
 
         mock_request_guild_members.assert_not_called()
         create_task.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_on_guild_create_when_members_declared_and_enabled_for_member_chunk_event(
+    def test_on_guild_create_when_members_declared_and_enabled_for_member_chunk_event(
         self, stateless_event_manager_impl, shard, event_factory, entity_factory
     ):
         shard.id = 123
@@ -719,20 +685,19 @@ async def test_on_guild_create_when_members_declared_and_enabled_for_member_chun
         with mock.patch.object(asyncio, "create_task") as create_task:
             with mock.patch.object(event_manager, "_fixed_size_nonce", return_value="abc"):
                 with mock.patch.object(event_manager, "_request_guild_members", new=mock_request_guild_members):
-                    await stateless_event_manager_impl.on_guild_create(shard, {"large": True})
+                    stateless_event_manager_impl.on_guild_create(shard, {"large": True})
 
         mock_request_guild_members.assert_called_once_with(shard, 456, include_presences=False, nonce="123.abc")
         create_task.assert_called_once_with(
             mock_request_guild_members.return_value, name="123:456 guild create members request"
         )
         assert mock_event.chunk_nonce == "123.abc"
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(mock_event)
+        stateless_event_manager_impl.dispatch.assert_called_once_with(mock_event)
 
     @pytest.mark.parametrize("cache_enabled", [True, False])
     @pytest.mark.parametrize("large", [True, False])
     @pytest.mark.parametrize("enabled_for_event", [True, False])
-    @pytest.mark.asyncio
-    async def test_on_guild_create_when_chunk_members_disabled(
+    def test_on_guild_create_when_chunk_members_disabled(
         self, stateless_event_manager_impl, shard, large, cache_enabled, enabled_for_event
     ):
         shard.id = 123
@@ -742,29 +707,23 @@ async def test_on_guild_create_when_chunk_members_disabled(
         stateless_event_manager_impl._auto_chunk_members = False
 
         with mock.patch.object(event_manager, "_request_guild_members") as request_guild_members:
-            await stateless_event_manager_impl.on_guild_create(shard, {"id": 456, "large": large})
+            stateless_event_manager_impl.on_guild_create(shard, {"id": 456, "large": large})
 
         request_guild_members.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_on_guild_update_when_stateless(
-        self, stateless_event_manager_impl, shard, event_factory, entity_factory
-    ):
+    def test_on_guild_update_when_stateless(self, stateless_event_manager_impl, shard, event_factory, entity_factory):
         stateless_event_manager_impl._intents = intents.Intents.NONE
         stateless_event_manager_impl._cache_enabled_for = mock.Mock(return_value=True)
         stateless_event_manager_impl._enabled_for_event = mock.Mock(return_value=False)
 
-        await stateless_event_manager_impl.on_guild_update(shard, {})
+        stateless_event_manager_impl.on_guild_update(shard, {})
 
         stateless_event_manager_impl._enabled_for_event.assert_called_once_with(guild_events.GuildUpdateEvent)
         event_factory.deserialize_guild_update_event.assert_not_called()
 
         stateless_event_manager_impl.dispatch.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_on_guild_update_stateful_and_dispatching(
-        self, event_manager_impl, shard, event_factory, entity_factory
-    ):
+    def test_on_guild_update_stateful_and_dispatching(self, event_manager_impl, shard, event_factory, entity_factory):
         payload = {"id": 123}
         old_guild = object()
         mock_role = object()
@@ -778,7 +737,7 @@ async def test_on_guild_update_stateful_and_dispatching(
         event_factory.deserialize_guild_update_event.return_value = event
         event_manager_impl._cache.get_guild.return_value = old_guild
 
-        await event_manager_impl.on_guild_update(shard, payload)
+        event_manager_impl.on_guild_update(shard, payload)
 
         event_manager_impl._enabled_for_event.assert_called_once_with(guild_events.GuildUpdateEvent)
         event_manager_impl._cache.get_guild.assert_called_once_with(123)
@@ -791,11 +750,10 @@ async def test_on_guild_update_stateful_and_dispatching(
         event_manager_impl._cache.set_sticker.assert_called_once_with(mock_sticker)
         entity_factory.deserialize_gateway_guild.assert_not_called()
         event_factory.deserialize_guild_update_event.assert_called_once_with(shard, payload, old_guild=old_guild)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
         shard.get_user_id.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_on_guild_update_all_cache_components_and_not_dispatching(
+    def test_on_guild_update_all_cache_components_and_not_dispatching(
         self, event_manager_impl, shard, event_factory, entity_factory
     ):
         payload = {"id": 123}
@@ -809,7 +767,7 @@ async def test_on_guild_update_all_cache_components_and_not_dispatching(
         guild_definition.roles.return_value = {1: mock_role}
         guild_definition.stickers.return_value = {4: mock_sticker}
 
-        await event_manager_impl.on_guild_update(shard, payload)
+        event_manager_impl.on_guild_update(shard, payload)
 
         entity_factory.deserialize_gateway_guild.assert_called_once_with(
             {"id": 123}, user_id=shard.get_user_id.return_value
@@ -829,8 +787,7 @@ async def test_on_guild_update_all_cache_components_and_not_dispatching(
         guild_definition.roles.assert_called_once_with()
         guild_definition.guild.assert_called_once_with()
 
-    @pytest.mark.asyncio
-    async def test_on_guild_update_no_cache_components_and_not_dispatching(
+    def test_on_guild_update_no_cache_components_and_not_dispatching(
         self, event_manager_impl, shard, event_factory, entity_factory
     ):
         payload = {"id": 123}
@@ -838,7 +795,7 @@ async def test_on_guild_update_no_cache_components_and_not_dispatching(
         event_manager_impl._enabled_for_event = mock.Mock(return_value=False)
         guild_definition = entity_factory.deserialize_gateway_guild.return_value
 
-        await event_manager_impl.on_guild_update(shard, payload)
+        event_manager_impl.on_guild_update(shard, payload)
 
         entity_factory.deserialize_gateway_guild.assert_called_once_with(
             {"id": 123}, user_id=shard.get_user_id.return_value
@@ -858,31 +815,29 @@ async def test_on_guild_update_no_cache_components_and_not_dispatching(
         guild_definition.guild.assert_not_called()
         shard.get_user_id.assert_called_once_with()
 
-    @pytest.mark.asyncio
-    async def test_on_guild_update_stateless_and_dispatching(
+    def test_on_guild_update_stateless_and_dispatching(
         self, stateless_event_manager_impl, shard, event_factory, entity_factory
     ):
         payload = {"id": 123}
         stateless_event_manager_impl._enabled_for_event = mock.Mock(return_value=True)
 
-        await stateless_event_manager_impl.on_guild_update(shard, payload)
+        stateless_event_manager_impl.on_guild_update(shard, payload)
 
         stateless_event_manager_impl._enabled_for_event.assert_called_once_with(guild_events.GuildUpdateEvent)
         shard.get_user_id.deserialize_gateway_guild.assert_not_called()
         shard.user_id.assert_not_called()
         event_factory.deserialize_guild_update_event.assert_called_once_with(shard, payload, old_guild=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_delete_stateful_when_available(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_delete_stateful_when_available(self, event_manager_impl, shard, event_factory):
         payload = {"unavailable": False, "id": "123"}
         event = mock.Mock(guild_id=123)
 
         event_factory.deserialize_guild_leave_event.return_value = event
 
-        await event_manager_impl.on_guild_delete(shard, payload)
+        event_manager_impl.on_guild_delete(shard, payload)
 
         event_manager_impl._cache.delete_guild.assert_called_once_with(123)
         event_manager_impl._cache.clear_voice_states_for_guild.assert_called_once_with(123)
@@ -897,69 +852,63 @@ async def test_on_guild_delete_stateful_when_available(self, event_manager_impl,
         event_factory.deserialize_guild_leave_event.assert_called_once_with(
             shard, payload, old_guild=event_manager_impl._cache.delete_guild.return_value
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_delete_stateful_when_unavailable(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_delete_stateful_when_unavailable(self, event_manager_impl, shard, event_factory):
         payload = {"unavailable": True, "id": "123"}
         event = mock.Mock(guild_id=123)
 
         event_factory.deserialize_guild_unavailable_event.return_value = event
 
-        await event_manager_impl.on_guild_delete(shard, payload)
+        event_manager_impl.on_guild_delete(shard, payload)
 
         event_manager_impl._cache.set_guild_availability.assert_called_once_with(event.guild_id, False)
         event_factory.deserialize_guild_unavailable_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_delete_stateless_when_available(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_delete_stateless_when_available(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"unavailable": False, "id": "123"}
 
-        await stateless_event_manager_impl.on_guild_delete(shard, payload)
+        stateless_event_manager_impl.on_guild_delete(shard, payload)
 
         event_factory.deserialize_guild_leave_event.assert_called_once_with(shard, payload, old_guild=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_leave_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_delete_stateless_when_unavailable(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_delete_stateless_when_unavailable(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"unavailable": True}
 
-        await stateless_event_manager_impl.on_guild_delete(shard, payload)
+        stateless_event_manager_impl.on_guild_delete(shard, payload)
 
         event_factory.deserialize_guild_unavailable_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_unavailable_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_ban_add(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_ban_add(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_guild_ban_add_event.return_value = event
 
-        await event_manager_impl.on_guild_ban_add(shard, payload)
+        event_manager_impl.on_guild_ban_add(shard, payload)
 
         event_factory.deserialize_guild_ban_add_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_ban_remove(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_ban_remove(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_guild_ban_remove_event.return_value = event
 
-        await event_manager_impl.on_guild_ban_remove(shard, payload)
+        event_manager_impl.on_guild_ban_remove(shard, payload)
 
         event_factory.deserialize_guild_ban_remove_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_emojis_update_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_emojis_update_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"guild_id": 123}
         old_emojis = {"Test": 123}
         mock_emoji = object()
@@ -968,26 +917,24 @@ async def test_on_guild_emojis_update_stateful(self, event_manager_impl, shard,
         event_factory.deserialize_guild_emojis_update_event.return_value = event
         event_manager_impl._cache.clear_emojis_for_guild.return_value = old_emojis
 
-        await event_manager_impl.on_guild_emojis_update(shard, payload)
+        event_manager_impl.on_guild_emojis_update(shard, payload)
 
         event_manager_impl._cache.clear_emojis_for_guild.assert_called_once_with(123)
         event_manager_impl._cache.set_emoji.assert_called_once_with(mock_emoji)
         event_factory.deserialize_guild_emojis_update_event.assert_called_once_with(shard, payload, old_emojis=[123])
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_emojis_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_emojis_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"guild_id": 123}
 
-        await stateless_event_manager_impl.on_guild_emojis_update(shard, payload)
+        stateless_event_manager_impl.on_guild_emojis_update(shard, payload)
 
         event_factory.deserialize_guild_emojis_update_event.assert_called_once_with(shard, payload, old_emojis=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_emojis_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_stickers_update_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_stickers_update_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"guild_id": 720}
         old_stickers = {700: 123}
         mock_sticker = object()
@@ -996,120 +943,110 @@ async def test_on_guild_stickers_update_stateful(self, event_manager_impl, shard
         event_factory.deserialize_guild_stickers_update_event.return_value = event
         event_manager_impl._cache.clear_stickers_for_guild.return_value = old_stickers
 
-        await event_manager_impl.on_guild_stickers_update(shard, payload)
+        event_manager_impl.on_guild_stickers_update(shard, payload)
 
         event_manager_impl._cache.clear_stickers_for_guild.assert_called_once_with(720)
         event_manager_impl._cache.set_sticker.assert_called_once_with(mock_sticker)
         event_factory.deserialize_guild_stickers_update_event.assert_called_once_with(
             shard, payload, old_stickers=[123]
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_stickers_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_stickers_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"guild_id": 123}
 
-        await stateless_event_manager_impl.on_guild_stickers_update(shard, payload)
+        stateless_event_manager_impl.on_guild_stickers_update(shard, payload)
 
         event_factory.deserialize_guild_stickers_update_event.assert_called_once_with(shard, payload, old_stickers=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_stickers_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_integrations_update(self, event_manager_impl, shard):
+    def test_on_guild_integrations_update(self, event_manager_impl, shard):
         with pytest.raises(NotImplementedError):
-            await event_manager_impl.on_guild_integrations_update(shard, {})
+            event_manager_impl.on_guild_integrations_update(shard, {})
 
         event_manager_impl.dispatch.assert_not_called()
 
-    @pytest.mark.asyncio
-    async def test_on_integration_create(self, event_manager_impl, shard, event_factory):
+    def test_on_integration_create(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_integration_create_event.return_value = event
 
-        await event_manager_impl.on_integration_create(shard, payload)
+        event_manager_impl.on_integration_create(shard, payload)
 
         event_factory.deserialize_integration_create_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_integration_delete(self, event_manager_impl, shard, event_factory):
+    def test_on_integration_delete(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_integration_delete_event.return_value = event
 
-        await event_manager_impl.on_integration_delete(shard, payload)
+        event_manager_impl.on_integration_delete(shard, payload)
 
         event_factory.deserialize_integration_delete_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_integration_update(self, event_manager_impl, shard, event_factory):
+    def test_on_integration_update(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_integration_update_event.return_value = event
 
-        await event_manager_impl.on_integration_update(shard, payload)
+        event_manager_impl.on_integration_update(shard, payload)
 
         event_factory.deserialize_integration_update_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_member_add_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_member_add_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock(user=object(), member=object())
 
         event_factory.deserialize_guild_member_add_event.return_value = event
 
-        await event_manager_impl.on_guild_member_add(shard, payload)
+        event_manager_impl.on_guild_member_add(shard, payload)
 
         event_manager_impl._cache.update_member.assert_called_once_with(event.member)
         event_factory.deserialize_guild_member_add_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_member_add_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_member_add_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_guild_member_add(shard, payload)
+        stateless_event_manager_impl.on_guild_member_add(shard, payload)
 
         event_factory.deserialize_guild_member_add_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_member_add_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_member_remove_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_member_remove_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"guild_id": "456", "user": {"id": "123"}}
 
-        await event_manager_impl.on_guild_member_remove(shard, payload)
+        event_manager_impl.on_guild_member_remove(shard, payload)
 
         event_manager_impl._cache.delete_member.assert_called_once_with(456, 123)
         event_factory.deserialize_guild_member_remove_event.assert_called_once_with(
             shard, payload, old_member=event_manager_impl._cache.delete_member.return_value
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_member_remove_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_member_remove_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_member_remove_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_guild_member_remove(shard, payload)
+        stateless_event_manager_impl.on_guild_member_remove(shard, payload)
 
         event_factory.deserialize_guild_member_remove_event.assert_called_once_with(shard, payload, old_member=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_member_remove_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_member_update_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_member_update_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"user": {"id": 123}, "guild_id": 456}
         old_member = object()
         event = mock.Mock(member=mock.Mock())
@@ -1117,76 +1054,70 @@ async def test_on_guild_member_update_stateful(self, event_manager_impl, shard,
         event_factory.deserialize_guild_member_update_event.return_value = event
         event_manager_impl._cache.get_member.return_value = old_member
 
-        await event_manager_impl.on_guild_member_update(shard, payload)
+        event_manager_impl.on_guild_member_update(shard, payload)
 
         event_manager_impl._cache.get_member.assert_called_once_with(456, 123)
         event_manager_impl._cache.update_member.assert_called_once_with(event.member)
         event_factory.deserialize_guild_member_update_event.assert_called_once_with(
             shard, payload, old_member=old_member
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_member_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_member_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"user": {"id": 123}, "guild_id": 456}
 
-        await stateless_event_manager_impl.on_guild_member_update(shard, payload)
+        stateless_event_manager_impl.on_guild_member_update(shard, payload)
 
         event_factory.deserialize_guild_member_update_event.assert_called_once_with(shard, payload, old_member=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_member_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_members_chunk_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_members_chunk_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock(members={"TestMember": 123}, presences={"TestPresences": 456})
         event_factory.deserialize_guild_member_chunk_event.return_value = event
 
-        await event_manager_impl.on_guild_members_chunk(shard, payload)
+        event_manager_impl.on_guild_members_chunk(shard, payload)
 
         event_manager_impl._cache.set_member.assert_called_once_with(123)
         event_manager_impl._cache.set_presence.assert_called_once_with(456)
         event_factory.deserialize_guild_member_chunk_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_members_chunk_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_members_chunk_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_guild_members_chunk(shard, payload)
+        stateless_event_manager_impl.on_guild_members_chunk(shard, payload)
 
         event_factory.deserialize_guild_member_chunk_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_member_chunk_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_role_create_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_role_create_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock(role=object())
 
         event_factory.deserialize_guild_role_create_event.return_value = event
 
-        await event_manager_impl.on_guild_role_create(shard, payload)
+        event_manager_impl.on_guild_role_create(shard, payload)
 
         event_manager_impl._cache.set_role.assert_called_once_with(event.role)
         event_factory.deserialize_guild_role_create_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_role_create_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_role_create_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_guild_role_create(shard, payload)
+        stateless_event_manager_impl.on_guild_role_create(shard, payload)
 
         event_factory.deserialize_guild_role_create_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_role_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_role_update_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_role_update_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"role": {"id": 123}}
         old_role = object()
         event = mock.Mock(role=mock.Mock())
@@ -1194,122 +1125,112 @@ async def test_on_guild_role_update_stateful(self, event_manager_impl, shard, ev
         event_factory.deserialize_guild_role_update_event.return_value = event
         event_manager_impl._cache.get_role.return_value = old_role
 
-        await event_manager_impl.on_guild_role_update(shard, payload)
+        event_manager_impl.on_guild_role_update(shard, payload)
 
         event_manager_impl._cache.get_role.assert_called_once_with(123)
         event_manager_impl._cache.update_role.assert_called_once_with(event.role)
         event_factory.deserialize_guild_role_update_event.assert_called_once_with(shard, payload, old_role=old_role)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_guild_role_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_role_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"role": {"id": 123}}
 
-        await stateless_event_manager_impl.on_guild_role_update(shard, payload)
+        stateless_event_manager_impl.on_guild_role_update(shard, payload)
 
         event_factory.deserialize_guild_role_update_event.assert_called_once_with(shard, payload, old_role=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_role_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_role_delete_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_guild_role_delete_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"role_id": "123"}
 
-        await event_manager_impl.on_guild_role_delete(shard, payload)
+        event_manager_impl.on_guild_role_delete(shard, payload)
 
         event_manager_impl._cache.delete_role.assert_called_once_with(123)
         event_factory.deserialize_guild_role_delete_event.assert_called_once_with(
             shard, payload, old_role=event_manager_impl._cache.delete_role.return_value
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_role_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_role_delete_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_guild_role_delete_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_guild_role_delete(shard, payload)
+        stateless_event_manager_impl.on_guild_role_delete(shard, payload)
 
         event_factory.deserialize_guild_role_delete_event.assert_called_once_with(shard, payload, old_role=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_role_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_invite_create_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_invite_create_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock(invite="qwerty")
 
         event_factory.deserialize_invite_create_event.return_value = event
 
-        await event_manager_impl.on_invite_create(shard, payload)
+        event_manager_impl.on_invite_create(shard, payload)
 
         event_manager_impl._cache.set_invite.assert_called_once_with("qwerty")
         event_factory.deserialize_invite_create_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_invite_create_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_invite_create_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_invite_create(shard, payload)
+        stateless_event_manager_impl.on_invite_create(shard, payload)
 
         event_factory.deserialize_invite_create_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_invite_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_invite_delete_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_invite_delete_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"code": "qwerty"}
 
-        await event_manager_impl.on_invite_delete(shard, payload)
+        event_manager_impl.on_invite_delete(shard, payload)
 
         event_manager_impl._cache.delete_invite.assert_called_once_with("qwerty")
         event_factory.deserialize_invite_delete_event.assert_called_once_with(
             shard, payload, old_invite=event_manager_impl._cache.delete_invite.return_value
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(event_factory.deserialize_invite_delete_event.return_value)
+        event_manager_impl.dispatch.assert_called_once_with(event_factory.deserialize_invite_delete_event.return_value)
 
-    @pytest.mark.asyncio
-    async def test_on_invite_delete_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_invite_delete_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_invite_delete(shard, payload)
+        stateless_event_manager_impl.on_invite_delete(shard, payload)
 
         event_factory.deserialize_invite_delete_event.assert_called_once_with(shard, payload, old_invite=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_invite_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_message_create_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_message_create_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock(message=object())
 
         event_factory.deserialize_message_create_event.return_value = event
 
-        await event_manager_impl.on_message_create(shard, payload)
+        event_manager_impl.on_message_create(shard, payload)
 
         event_manager_impl._cache.set_message.assert_called_once_with(event.message)
         event_factory.deserialize_message_create_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_message_create_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_message_create_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_message_create(shard, payload)
+        stateless_event_manager_impl.on_message_create(shard, payload)
 
         event_factory.deserialize_message_create_event.assert_called_once_with(shard, payload)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_message_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_message_update_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_message_update_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"id": 123}
         old_message = object()
         event = mock.Mock(message=mock.Mock())
@@ -1317,58 +1238,52 @@ async def test_on_message_update_stateful(self, event_manager_impl, shard, event
         event_factory.deserialize_message_update_event.return_value = event
         event_manager_impl._cache.get_message.return_value = old_message
 
-        await event_manager_impl.on_message_update(shard, payload)
+        event_manager_impl.on_message_update(shard, payload)
 
         event_manager_impl._cache.get_message.assert_called_once_with(123)
         event_manager_impl._cache.update_message.assert_called_once_with(event.message)
         event_factory.deserialize_message_update_event.assert_called_once_with(shard, payload, old_message=old_message)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_message_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_message_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"id": 123}
 
-        await stateless_event_manager_impl.on_message_update(shard, payload)
+        stateless_event_manager_impl.on_message_update(shard, payload)
 
         event_factory.deserialize_message_update_event.assert_called_once_with(shard, payload, old_message=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_message_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_message_delete_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_message_delete_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"id": 123}
 
-        await event_manager_impl.on_message_delete(shard, payload)
+        event_manager_impl.on_message_delete(shard, payload)
 
         event_manager_impl._cache.delete_message.assert_called_once_with(123)
         event_factory.deserialize_message_delete_event.assert_called_once_with(
             shard, payload, old_message=event_manager_impl._cache.delete_message.return_value
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(
-            event_factory.deserialize_message_delete_event.return_value
-        )
+        event_manager_impl.dispatch.assert_called_once_with(event_factory.deserialize_message_delete_event.return_value)
 
-    @pytest.mark.asyncio
-    async def test_on_message_delete_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_message_delete_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_message_delete(shard, payload)
+        stateless_event_manager_impl.on_message_delete(shard, payload)
 
         event_factory.deserialize_message_delete_event.assert_called_once_with(shard, payload, old_message=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_message_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_message_delete_bulk_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_message_delete_bulk_stateful(self, event_manager_impl, shard, event_factory):
         payload = {"ids": [123, 456, 789, 987]}
         message1 = object()
         message2 = object()
         message3 = object()
         event_manager_impl._cache.delete_message.side_effect = [message1, message2, message3, None]
 
-        await event_manager_impl.on_message_delete_bulk(shard, payload)
+        event_manager_impl.on_message_delete_bulk(shard, payload)
 
         event_manager_impl._cache.delete_message.assert_has_calls(
             [mock.call(123), mock.call(456), mock.call(789), mock.call(987)]
@@ -1376,73 +1291,67 @@ async def test_on_message_delete_bulk_stateful(self, event_manager_impl, shard,
         event_factory.deserialize_guild_message_delete_bulk_event.assert_called_once_with(
             shard, payload, old_messages={123: message1, 456: message2, 789: message3}
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_message_delete_bulk_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_message_delete_bulk_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_message_delete_bulk_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_message_delete_bulk(shard, payload)
+        stateless_event_manager_impl.on_message_delete_bulk(shard, payload)
 
         event_factory.deserialize_guild_message_delete_bulk_event.assert_called_once_with(
             shard, payload, old_messages={}
         )
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_guild_message_delete_bulk_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_message_reaction_add(self, event_manager_impl, shard, event_factory):
+    def test_on_message_reaction_add(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_message_reaction_add_event.return_value = event
 
-        await event_manager_impl.on_message_reaction_add(shard, payload)
+        event_manager_impl.on_message_reaction_add(shard, payload)
 
         event_factory.deserialize_message_reaction_add_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_message_reaction_remove(self, event_manager_impl, shard, event_factory):
+    def test_on_message_reaction_remove(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_message_reaction_remove_event.return_value = event
 
-        await event_manager_impl.on_message_reaction_remove(shard, payload)
+        event_manager_impl.on_message_reaction_remove(shard, payload)
 
         event_factory.deserialize_message_reaction_remove_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_message_reaction_remove_all(self, event_manager_impl, shard, event_factory):
+    def test_on_message_reaction_remove_all(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_message_reaction_remove_all_event.return_value = event
 
-        await event_manager_impl.on_message_reaction_remove_all(shard, payload)
+        event_manager_impl.on_message_reaction_remove_all(shard, payload)
 
         event_factory.deserialize_message_reaction_remove_all_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_message_reaction_remove_emoji(self, event_manager_impl, shard, event_factory):
+    def test_on_message_reaction_remove_emoji(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_message_reaction_remove_emoji_event.return_value = event
 
-        await event_manager_impl.on_message_reaction_remove_emoji(shard, payload)
+        event_manager_impl.on_message_reaction_remove_emoji(shard, payload)
 
         event_factory.deserialize_message_reaction_remove_emoji_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_presence_update_stateful_update(self, event_manager_impl, shard, event_factory):
+    def test_on_presence_update_stateful_update(self, event_manager_impl, shard, event_factory):
         payload = {"user": {"id": 123}, "guild_id": 456}
         old_presence = object()
         event = mock.Mock(presence=mock.Mock(visible_status=presences.Status.ONLINE))
@@ -1450,17 +1359,16 @@ async def test_on_presence_update_stateful_update(self, event_manager_impl, shar
         event_factory.deserialize_presence_update_event.return_value = event
         event_manager_impl._cache.get_presence.return_value = old_presence
 
-        await event_manager_impl.on_presence_update(shard, payload)
+        event_manager_impl.on_presence_update(shard, payload)
 
         event_manager_impl._cache.get_presence.assert_called_once_with(456, 123)
         event_manager_impl._cache.update_presence.assert_called_once_with(event.presence)
         event_factory.deserialize_presence_update_event.assert_called_once_with(
             shard, payload, old_presence=old_presence
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_presence_update_stateful_delete(self, event_manager_impl, shard, event_factory):
+    def test_on_presence_update_stateful_delete(self, event_manager_impl, shard, event_factory):
         payload = {"user": {"id": 123}, "guild_id": 456}
         old_presence = object()
         event = mock.Mock(presence=mock.Mock(visible_status=presences.Status.OFFLINE))
@@ -1468,7 +1376,7 @@ async def test_on_presence_update_stateful_delete(self, event_manager_impl, shar
         event_factory.deserialize_presence_update_event.return_value = event
         event_manager_impl._cache.get_presence.return_value = old_presence
 
-        await event_manager_impl.on_presence_update(shard, payload)
+        event_manager_impl.on_presence_update(shard, payload)
 
         event_manager_impl._cache.get_presence.assert_called_once_with(456, 123)
         event_manager_impl._cache.delete_presence.assert_called_once_with(
@@ -1477,33 +1385,30 @@ async def test_on_presence_update_stateful_delete(self, event_manager_impl, shar
         event_factory.deserialize_presence_update_event.assert_called_once_with(
             shard, payload, old_presence=old_presence
         )
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_presence_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_presence_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"user": {"id": 123}, "guild_id": 456}
 
-        await stateless_event_manager_impl.on_presence_update(shard, payload)
+        stateless_event_manager_impl.on_presence_update(shard, payload)
 
         event_factory.deserialize_presence_update_event.assert_called_once_with(shard, payload, old_presence=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_presence_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_typing_start(self, event_manager_impl, shard, event_factory):
+    def test_on_typing_start(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_typing_start_event.return_value = event
 
-        await event_manager_impl.on_typing_start(shard, payload)
+        event_manager_impl.on_typing_start(shard, payload)
 
         event_factory.deserialize_typing_start_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_user_update_stateful(self, event_manager_impl, shard, event_factory):
+    def test_on_user_update_stateful(self, event_manager_impl, shard, event_factory):
         payload = {}
         old_user = object()
         event = mock.Mock(user=mock.Mock())
@@ -1511,25 +1416,23 @@ async def test_on_user_update_stateful(self, event_manager_impl, shard, event_fa
         event_factory.deserialize_own_user_update_event.return_value = event
         event_manager_impl._cache.get_me.return_value = old_user
 
-        await event_manager_impl.on_user_update(shard, payload)
+        event_manager_impl.on_user_update(shard, payload)
 
         event_manager_impl._cache.update_me.assert_called_once_with(event.user)
         event_factory.deserialize_own_user_update_event.assert_called_once_with(shard, payload, old_user=old_user)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_user_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_user_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {}
 
-        await stateless_event_manager_impl.on_user_update(shard, payload)
+        stateless_event_manager_impl.on_user_update(shard, payload)
 
         event_factory.deserialize_own_user_update_event.assert_called_once_with(shard, payload, old_user=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_own_user_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_voice_state_update_stateful_update(self, event_manager_impl, shard, event_factory):
+    def test_on_voice_state_update_stateful_update(self, event_manager_impl, shard, event_factory):
         payload = {"user_id": 123, "guild_id": 456}
         old_state = object()
         event = mock.Mock(state=mock.Mock(channel_id=123))
@@ -1537,15 +1440,14 @@ async def test_on_voice_state_update_stateful_update(self, event_manager_impl, s
         event_factory.deserialize_voice_state_update_event.return_value = event
         event_manager_impl._cache.get_voice_state.return_value = old_state
 
-        await event_manager_impl.on_voice_state_update(shard, payload)
+        event_manager_impl.on_voice_state_update(shard, payload)
 
         event_manager_impl._cache.get_voice_state.assert_called_once_with(456, 123)
         event_manager_impl._cache.update_voice_state.assert_called_once_with(event.state)
         event_factory.deserialize_voice_state_update_event.assert_called_once_with(shard, payload, old_state=old_state)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_voice_state_update_stateful_delete(self, event_manager_impl, shard, event_factory):
+    def test_on_voice_state_update_stateful_delete(self, event_manager_impl, shard, event_factory):
         payload = {"user_id": 123, "guild_id": 456}
         old_state = object()
         event = mock.Mock(state=mock.Mock(channel_id=None))
@@ -1553,61 +1455,56 @@ async def test_on_voice_state_update_stateful_delete(self, event_manager_impl, s
         event_factory.deserialize_voice_state_update_event.return_value = event
         event_manager_impl._cache.get_voice_state.return_value = old_state
 
-        await event_manager_impl.on_voice_state_update(shard, payload)
+        event_manager_impl.on_voice_state_update(shard, payload)
 
         event_manager_impl._cache.get_voice_state.assert_called_once_with(456, 123)
         event_manager_impl._cache.delete_voice_state.assert_called_once_with(event.state.guild_id, event.state.user_id)
         event_factory.deserialize_voice_state_update_event.assert_called_once_with(shard, payload, old_state=old_state)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_voice_state_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
+    def test_on_voice_state_update_stateless(self, stateless_event_manager_impl, shard, event_factory):
         payload = {"user_id": 123, "guild_id": 456}
 
-        await stateless_event_manager_impl.on_voice_state_update(shard, payload)
+        stateless_event_manager_impl.on_voice_state_update(shard, payload)
 
         event_factory.deserialize_voice_state_update_event.assert_called_once_with(shard, payload, old_state=None)
-        stateless_event_manager_impl.dispatch.assert_awaited_once_with(
+        stateless_event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_voice_state_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_voice_server_update(self, event_manager_impl, shard, event_factory):
+    def test_on_voice_server_update(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_voice_server_update_event.return_value = event
 
-        await event_manager_impl.on_voice_server_update(shard, payload)
+        event_manager_impl.on_voice_server_update(shard, payload)
 
         event_factory.deserialize_voice_server_update_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_webhooks_update(self, event_manager_impl, shard, event_factory):
+    def test_on_webhooks_update(self, event_manager_impl, shard, event_factory):
         payload = {}
         event = mock.Mock()
 
         event_factory.deserialize_webhook_update_event.return_value = event
 
-        await event_manager_impl.on_webhooks_update(shard, payload)
+        event_manager_impl.on_webhooks_update(shard, payload)
 
         event_factory.deserialize_webhook_update_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(event)
+        event_manager_impl.dispatch.assert_called_once_with(event)
 
-    @pytest.mark.asyncio
-    async def test_on_interaction_create(self, event_manager_impl, shard, event_factory):
+    def test_on_interaction_create(self, event_manager_impl, shard, event_factory):
         payload = {"id": "123"}
 
-        await event_manager_impl.on_interaction_create(shard, payload)
+        event_manager_impl.on_interaction_create(shard, payload)
 
         event_factory.deserialize_interaction_create_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_interaction_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_scheduled_event_create(
+    def test_on_guild_scheduled_event_create(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1615,15 +1512,14 @@ async def test_on_guild_scheduled_event_create(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_guild_scheduled_event_create(shard, mock_payload)
+        event_manager_impl.on_guild_scheduled_event_create(shard, mock_payload)
 
         event_factory.deserialize_scheduled_event_create_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_scheduled_event_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_scheduled_event_delete(
+    def test_on_guild_scheduled_event_delete(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1631,15 +1527,14 @@ async def test_on_guild_scheduled_event_delete(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_guild_scheduled_event_delete(shard, mock_payload)
+        event_manager_impl.on_guild_scheduled_event_delete(shard, mock_payload)
 
         event_factory.deserialize_scheduled_event_delete_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_scheduled_event_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_scheduled_event_update(
+    def test_on_guild_scheduled_event_update(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1647,15 +1542,14 @@ async def test_on_guild_scheduled_event_update(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_guild_scheduled_event_update(shard, mock_payload)
+        event_manager_impl.on_guild_scheduled_event_update(shard, mock_payload)
 
         event_factory.deserialize_scheduled_event_update_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_scheduled_event_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_scheduled_event_user_add(
+    def test_on_guild_scheduled_event_user_add(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1663,15 +1557,14 @@ async def test_on_guild_scheduled_event_user_add(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_guild_scheduled_event_user_add(shard, mock_payload)
+        event_manager_impl.on_guild_scheduled_event_user_add(shard, mock_payload)
 
         event_factory.deserialize_scheduled_event_user_add_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_scheduled_event_user_add_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_scheduled_event_user_remove(
+    def test_on_guild_scheduled_event_user_remove(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1679,15 +1572,14 @@ async def test_on_guild_scheduled_event_user_remove(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_guild_scheduled_event_user_remove(shard, mock_payload)
+        event_manager_impl.on_guild_scheduled_event_user_remove(shard, mock_payload)
 
         event_factory.deserialize_scheduled_event_user_remove_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_scheduled_event_user_remove_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_guild_audit_log_entry_create(
+    def test_on_guild_audit_log_entry_create(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1695,15 +1587,14 @@ async def test_on_guild_audit_log_entry_create(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_guild_audit_log_entry_create(shard, mock_payload)
+        event_manager_impl.on_guild_audit_log_entry_create(shard, mock_payload)
 
         event_factory.deserialize_audit_log_entry_create_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_audit_log_entry_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_stage_instance_create(
+    def test_on_stage_instance_create(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1718,15 +1609,14 @@ async def test_on_stage_instance_create(
             "discoverable_disabled": False,
         }
 
-        await event_manager_impl.on_stage_instance_create(shard, payload)
+        event_manager_impl.on_stage_instance_create(shard, payload)
 
         event_factory.deserialize_stage_instance_create_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_stage_instance_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_stage_instance_update(
+    def test_on_stage_instance_update(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1741,15 +1631,14 @@ async def test_on_stage_instance_update(
             "discoverable_disabled": False,
         }
 
-        await event_manager_impl.on_stage_instance_update(shard, payload)
+        event_manager_impl.on_stage_instance_update(shard, payload)
 
         event_factory.deserialize_stage_instance_update_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_stage_instance_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_stage_instance_delete(
+    def test_on_stage_instance_delete(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1764,15 +1653,14 @@ async def test_on_stage_instance_delete(
             "discoverable_disabled": False,
         }
 
-        await event_manager_impl.on_stage_instance_delete(shard, payload)
+        event_manager_impl.on_stage_instance_delete(shard, payload)
 
         event_factory.deserialize_stage_instance_delete_event.assert_called_once_with(shard, payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_stage_instance_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_message_poll_vote_create(
+    def test_on_message_poll_vote_create(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1780,15 +1668,14 @@ async def test_on_message_poll_vote_create(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_message_poll_vote_add(shard, mock_payload)
+        event_manager_impl.on_message_poll_vote_add(shard, mock_payload)
 
         event_factory.deserialize_poll_vote_create_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_poll_vote_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_message_poll_vote_delete(
+    def test_on_message_poll_vote_delete(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1796,15 +1683,14 @@ async def test_on_message_poll_vote_delete(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_message_poll_vote_remove(shard, mock_payload)
+        event_manager_impl.on_message_poll_vote_remove(shard, mock_payload)
 
         event_factory.deserialize_poll_vote_delete_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_poll_vote_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_auto_moderation_rule_create(
+    def test_on_auto_moderation_rule_create(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1812,15 +1698,14 @@ async def test_on_auto_moderation_rule_create(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_auto_moderation_rule_create(shard, mock_payload)
+        event_manager_impl.on_auto_moderation_rule_create(shard, mock_payload)
 
         event_factory.deserialize_auto_mod_rule_create_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_auto_mod_rule_create_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_auto_moderation_rule_update(
+    def test_on_auto_moderation_rule_update(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1828,15 +1713,14 @@ async def test_on_auto_moderation_rule_update(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_auto_moderation_rule_update(shard, mock_payload)
+        event_manager_impl.on_auto_moderation_rule_update(shard, mock_payload)
 
         event_factory.deserialize_auto_mod_rule_update_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_auto_mod_rule_update_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_auto_moderation_rule_delete(
+    def test_on_auto_moderation_rule_delete(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1844,15 +1728,14 @@ async def test_on_auto_moderation_rule_delete(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_auto_moderation_rule_delete(shard, mock_payload)
+        event_manager_impl.on_auto_moderation_rule_delete(shard, mock_payload)
 
         event_factory.deserialize_auto_mod_rule_delete_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_auto_mod_rule_delete_event.return_value
         )
 
-    @pytest.mark.asyncio
-    async def test_on_auto_moderation_action_execution(
+    def test_on_auto_moderation_action_execution(
         self,
         event_manager_impl: event_manager.EventManagerImpl,
         shard: mock.Mock,
@@ -1860,9 +1743,9 @@ async def test_on_auto_moderation_action_execution(
     ):
         mock_payload = mock.Mock()
 
-        await event_manager_impl.on_auto_moderation_action_execution(shard, mock_payload)
+        event_manager_impl.on_auto_moderation_action_execution(shard, mock_payload)
 
         event_factory.deserialize_auto_mod_action_execution_event.assert_called_once_with(shard, mock_payload)
-        event_manager_impl.dispatch.assert_awaited_once_with(
+        event_manager_impl.dispatch.assert_called_once_with(
             event_factory.deserialize_auto_mod_action_execution_event.return_value
         )
diff --git a/tests/hikari/impl/test_event_manager_base.py b/tests/hikari/impl/test_event_manager_base.py
index 4b9ad569..7b9e661c 100644
--- a/tests/hikari/impl/test_event_manager_base.py
+++ b/tests/hikari/impl/test_event_manager_base.py
@@ -481,13 +481,11 @@ async def test_consume_raw_event_when_KeyError(self, event_manager):
         event_manager._enabled_for_event = mock.Mock(return_value=True)
         mock_payload = {"id": "3123123123"}
         mock_shard = mock.Mock(id=123)
-        event_manager._handle_dispatch = mock.Mock()
         event_manager.dispatch = mock.Mock()
 
         with pytest.raises(LookupError):
             event_manager.consume_raw_event("UNEXISTING_EVENT", mock_shard, mock_payload)
 
-        event_manager._handle_dispatch.assert_not_called()
         event_manager.dispatch.assert_called_once_with(
             event_manager._event_factory.deserialize_shard_payload_event.return_value
         )
@@ -499,20 +497,15 @@ async def test_consume_raw_event_when_KeyError(self, event_manager):
     @pytest.mark.asyncio
     async def test_consume_raw_event_when_found(self, event_manager):
         event_manager._enabled_for_event = mock.Mock(return_value=True)
-        event_manager._handle_dispatch = mock.Mock()
         event_manager.dispatch = mock.Mock()
-        on_existing_event = object()
+        on_existing_event = mock.Mock(is_enabled=True, callback=mock.Mock(__name__="testing"))
         event_manager._consumers = {"existing_event": on_existing_event}
         shard = object()
         payload = {"berp": "baz"}
 
-        with mock.patch("asyncio.create_task") as create_task:
-            event_manager.consume_raw_event("EXISTING_EVENT", shard, payload)
+        event_manager.consume_raw_event("EXISTING_EVENT", shard, payload)
 
-        event_manager._handle_dispatch.assert_called_once_with(on_existing_event, shard, {"berp": "baz"})
-        create_task.assert_called_once_with(
-            event_manager._handle_dispatch(on_existing_event, shard, {"berp": "baz"}), name="dispatch EXISTING_EVENT"
-        )
+        on_existing_event.callback.assert_called_once_with(shard, payload)
         event_manager.dispatch.assert_called_once_with(
             event_manager._event_factory.deserialize_shard_payload_event.return_value
         )
@@ -522,64 +515,50 @@ async def test_consume_raw_event_when_found(self, event_manager):
         event_manager._enabled_for_event.assert_called_once_with(shard_events.ShardPayloadEvent)
 
     @pytest.mark.asyncio
-    async def test_consume_raw_event_skips_raw_dispatch_when_not_enabled(self, event_manager):
-        event_manager._enabled_for_event = mock.Mock(return_value=False)
-        event_manager._handle_dispatch = mock.Mock()
+    async def test_consume_raw_event_skips_consumer_callback_when_not_enabled(self, event_manager):
+        event_manager._enabled_for_event = mock.Mock(return_value=True)
         event_manager.dispatch = mock.Mock()
-        on_existing_event = object()
+        on_existing_event = mock.Mock(is_enabled=False, callback=mock.Mock(__name__="testing"))
         event_manager._consumers = {"existing_event": on_existing_event}
         shard = object()
         payload = {"berp": "baz"}
 
-        with mock.patch("asyncio.create_task") as create_task:
-            event_manager.consume_raw_event("EXISTING_EVENT", shard, payload)
+        event_manager.consume_raw_event("EXISTING_EVENT", shard, payload)
 
-        event_manager._handle_dispatch.assert_called_once_with(on_existing_event, shard, {"berp": "baz"})
-        create_task.assert_called_once_with(
-            event_manager._handle_dispatch(on_existing_event, shard, {"berp": "baz"}), name="dispatch EXISTING_EVENT"
+        on_existing_event.callback.assert_not_called()
+        event_manager.dispatch.assert_called_once_with(
+            event_manager._event_factory.deserialize_shard_payload_event.return_value
+        )
+        event_manager._event_factory.deserialize_shard_payload_event.assert_called_once_with(
+            shard, payload, name="EXISTING_EVENT"
         )
-        event_manager.dispatch.assert_not_called()
-        event_manager._event_factory.deserialize_shard_payload_event.vassert_not_called()
         event_manager._enabled_for_event.assert_called_once_with(shard_events.ShardPayloadEvent)
 
     @pytest.mark.asyncio
-    async def test_handle_dispatch_invokes_callback(self, event_manager):
-        event_manager._enabled_for_consumer = mock.Mock(return_value=True)
-        consumer = mock.AsyncMock()
-        error_handler = mock.MagicMock()
-        event_loop = asyncio.get_running_loop()
-        event_loop.set_exception_handler(error_handler)
-        shard = object()
-        pl = {"foo": "bar"}
-
-        await event_manager._handle_dispatch(consumer, shard, pl)
-
-        consumer.callback.assert_awaited_once_with(shard, pl)
-        error_handler.assert_not_called()
-
-    @pytest.mark.asyncio
-    async def test_handle_dispatch_ignores_cancelled_errors(self, event_manager):
-        event_manager._enabled_for_consumer = mock.Mock(return_value=True)
-        consumer = mock.AsyncMock(side_effect=asyncio.CancelledError)
-        error_handler = mock.MagicMock()
-        event_loop = asyncio.get_running_loop()
-        event_loop.set_exception_handler(error_handler)
+    async def test_consume_raw_event_skips_raw_dispatch_when_not_enabled(self, event_manager):
+        event_manager._enabled_for_event = mock.Mock(return_value=False)
+        event_manager.dispatch = mock.Mock()
+        on_existing_event = mock.Mock(is_enabled=False, callback=mock.Mock(__name__="testing"))
+        event_manager._consumers = {"existing_event": on_existing_event}
         shard = object()
-        pl = {"lorem": "ipsum"}
+        payload = {"berp": "baz"}
 
-        await event_manager._handle_dispatch(consumer, shard, pl)
+        event_manager.consume_raw_event("EXISTING_EVENT", shard, payload)
 
-        error_handler.assert_not_called()
+        event_manager.dispatch.assert_not_called()
+        event_manager._event_factory.deserialize_shard_payload_event.assert_not_called()
+        event_manager._enabled_for_event.assert_called_once_with(shard_events.ShardPayloadEvent)
 
     @pytest.mark.asyncio
-    async def test_handle_dispatch_handles_exceptions(self, event_manager):
+    async def test_consume_raw_event_handles_exceptions(self, event_manager):
         mock_task = mock.Mock()
         # On Python 3.12+ Asyncio uses this to get the task's context if set to call the
         # error handler in. We want to avoid for this test for simplicity.
         mock_task.get_context.return_value = None
-        event_manager._enabled_for_consumer = mock.Mock(return_value=True)
         exc = Exception("aaaa!")
-        consumer = mock.Mock(callback=mock.AsyncMock(side_effect=exc))
+        consumer = mock.Mock(callback=mock.Mock(__name__="testing", side_effect=exc))
+        event_manager._consumers = {"existing_event": consumer}
+
         error_handler = mock.MagicMock()
         event_loop = asyncio.get_running_loop()
         event_loop.set_exception_handler(error_handler)
@@ -587,7 +566,7 @@ async def test_handle_dispatch_handles_exceptions(self, event_manager):
         pl = {"i like": "cats"}
 
         with mock.patch.object(asyncio, "current_task", return_value=mock_task):
-            await event_manager._handle_dispatch(consumer, shard, pl)
+            event_manager.consume_raw_event("EXISTING_EVENT", shard, pl)
 
         error_handler.assert_called_once_with(
             event_loop,
@@ -599,20 +578,6 @@ async def test_handle_dispatch_handles_exceptions(self, event_manager):
             },
         )
 
-    @pytest.mark.asyncio
-    async def test_handle_dispatch_invokes_when_consumer_not_enabled(self, event_manager):
-        consumer = mock.Mock(callback=mock.AsyncMock(__name__="ok"), is_enabled=False)
-        error_handler = mock.MagicMock()
-        event_loop = asyncio.get_running_loop()
-        event_loop.set_exception_handler(error_handler)
-        shard = object()
-        pl = {"foo": "bar"}
-
-        await event_manager._handle_dispatch(consumer, shard, pl)
-
-        consumer.callback.assert_not_called()
-        error_handler.assert_not_called()
-
     def test_subscribe_when_class_call(self, event_manager):
         class Foo:
             async def __call__(self) -> None: ...
diff --git a/tests/hikari/impl/test_gateway_bot.py b/tests/hikari/impl/test_gateway_bot.py
index 13601498..a9afd390 100644
--- a/tests/hikari/impl/test_gateway_bot.py
+++ b/tests/hikari/impl/test_gateway_bot.py
@@ -443,19 +443,19 @@ def assert_awaited_once(self):
         assert bot._shards == {}
         cache.clear.assert_called_once_with()
 
-        event_manager.dispatch.assert_has_calls(
+        event_manager.dispatch.assert_has_awaits(
             [
-                mock.call(event_factory.deserialize_stopping_event.return_value),
-                mock.call(event_factory.deserialize_stopped_event.return_value),
+                mock.call(event_factory.deserialize_stopping_event.return_value, return_tasks=True),
+                mock.call(event_factory.deserialize_stopped_event.return_value, return_tasks=True),
             ]
         )
 
     def test_dispatch(self, bot, event_manager):
-        event = object()
+        event = mock.Mock()
 
-        assert bot.dispatch(event) is event_manager.dispatch.return_value
+        assert bot.dispatch(event, return_tasks=True) is event_manager.dispatch.return_value
 
-        event_manager.dispatch.assert_called_once_with(event)
+        event_manager.dispatch.assert_called_once_with(event, return_tasks=True)
 
     def test_get_listeners(self, bot, event_manager):
         event = object()
@@ -694,8 +694,8 @@ def _mock_start_one_shard(*args, **kwargs):
         assert event_manager.dispatch.call_count == 2
         event_manager.dispatch.assert_has_awaits(
             [
-                mock.call(event_factory.deserialize_starting_event.return_value),
-                mock.call(event_factory.deserialize_started_event.return_value),
+                mock.call(event_factory.deserialize_starting_event.return_value, return_tasks=True),
+                mock.call(event_factory.deserialize_started_event.return_value, return_tasks=True),
             ]
         )