Repository: hikari-py/hikari
Pull request #2365 (2025-05-15 18:50:14)

Do not try to stringify http message assuming it will be ascii
This isn't true for non-english messages that can be sent with special characters

### Summary
<!-- Small summary of the merge request -->

### Checklist
<!-- Make sure to tick all the following boxes by putting an `x` in between (like this `[x]`) -->
- [ ] I have run `nox` and all the pipelines have passed.
- [ ] I have made unittests according to the code I have added/modified/deleted.

### Related issues
<!--
To mention an issue use `#issue-id` and to mention a merge request use `!merge-request-id`
To close/fix an issue use `Close #issue-id` or `Fix #issue-id` (depending on the merge request)
-->



Patch:
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ea12eba7..d6801df5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -108,7 +108,7 @@ jobs:
           coverage report
 
       - name: Upload coverage to codecov
-        uses: codecov/codecov-action@ad3126e916f78f00edff4ed0317cf185271ccc2d # v5.4.2
+        uses: codecov/codecov-action@18283e04ce6e62d37312384ff67231eb8fd56d24 # v5.4.3
 
   linting:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 4728d153..63b0a061 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -22,9 +22,9 @@ jobs:
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@60168efe1c415ce0f5521ea06d5c2062adbeed1b # v3.28.17
+        uses: github/codeql-action/init@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3.28.18
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@60168efe1c415ce0f5521ea06d5c2062adbeed1b # v3.28.17
+        uses: github/codeql-action/analyze@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3.28.18
diff --git a/changes/2365.bugfix.md b/changes/2365.bugfix.md
new file mode 100644
index 00000000..f0e97bf9
--- /dev/null
+++ b/changes/2365.bugfix.md
@@ -0,0 +1,1 @@
+Fix error when attempting to stringify http request with a non-ascii character
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/changes/2369.feature.md b/changes/2369.feature.md
new file mode 100644
index 00000000..53a672c2
--- /dev/null
+++ b/changes/2369.feature.md
@@ -0,0 +1,1 @@
+Add `startup_window_delay` argument to `.run` and `.start` to customize the time in between startup windows for shards
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 b131eb66..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
@@ -693,7 +708,7 @@ def print_banner(
         ux.print_banner(banner, allow_color=allow_color, force_color=force_color, extra_args=extra_args)
 
     @typing_extensions.override
-    def run(
+    def run(  # noqa: PLR0912 - Too many branches
         self,
         *,
         activity: presences.Activity | None = None,
@@ -711,6 +726,7 @@ def run(
         status: presences.Status = presences.Status.ONLINE,
         shard_ids: typing.Sequence[int] | None = None,
         shard_count: int | None = None,
+        startup_window_delay: int = 5,
     ) -> None:
         """Start the application and block until it's finished running.
 
@@ -795,6 +811,8 @@ def run(
 
             Defaults to [`None`][] which results in the count being
             determined dynamically on startup.
+        startup_window_delay
+            The time in seconds to wait in between shard startup windows.
         status
             The initial status to show for the user presence on startup.
 
@@ -804,6 +822,8 @@ def run(
             If bot is already running.
         TypeError
             If `shard_ids` is passed without `shard_count`.
+        ValueError
+            If `startup_window_delay` is less than 5 seconds.
         """
         if self._closed_event:
             msg = "bot is already running"
@@ -813,6 +833,10 @@ def run(
             msg = "'shard_ids' must be passed with 'shard_count'"
             raise TypeError(msg)
 
+        if startup_window_delay < 5:
+            msg = "'startup_window_delay' must be at least 5 seconds"
+            raise ValueError(msg)
+
         loop = aio.get_or_make_loop()
 
         if asyncio_debug:
@@ -840,6 +864,7 @@ def run(
                         shard_ids=shard_ids,
                         shard_count=shard_count,
                         status=status,
+                        startup_window_delay=startup_window_delay,
                     )
                 )
 
@@ -880,6 +905,7 @@ async def start(
         shard_ids: typing.Sequence[int] | None = None,
         shard_count: int | None = None,
         status: presences.Status = presences.Status.ONLINE,
+        startup_window_delay: int = 5,
     ) -> None:
         """Start the bot, wait for all shards to become ready, and then return.
 
@@ -919,6 +945,8 @@ async def start(
 
             Defaults to [`None`][] which results in the count being
             determined dynamically on startup.
+        startup_window_delay
+            The time in seconds to wait in between shard startup windows.
         status
             The initial status to show for the user presence on startup.
 
@@ -926,6 +954,8 @@ async def start(
         ------
         TypeError
             If `shard_ids` is passed without `shard_count`.
+        ValueError
+            If `startup_window_delay` is less than 5 seconds.
         hikari.errors.ComponentStateConflictError
             If bot is already running.
         """
@@ -937,6 +967,10 @@ async def start(
             msg = "'shard_ids' must be passed with 'shard_count'"
             raise TypeError(msg)
 
+        if startup_window_delay < 5:
+            msg = "'startup_window_delay' must be at least 5 seconds"
+            raise ValueError(msg)
+
         _validate_activity(activity)
 
         start_time = time.monotonic()
@@ -951,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:
@@ -987,11 +1021,13 @@ async def start(
             shard_ids = shard_ids[max_concurrency:]
 
             if self._shards:
-                _LOGGER.info("the next startup window is in 5 seconds, please wait...")
+                _LOGGER.info("the next startup window is in %d seconds, please wait...", startup_window_delay)
 
                 try:
                     await aio.first_completed(
-                        self._closing_event.wait(), *(shard.join() for shard in self._shards.values()), timeout=5
+                        self._closing_event.wait(),
+                        *(shard.join() for shard in self._shards.values()),
+                        timeout=startup_window_delay,
                     )
 
                     if self._closing_event.is_set():
@@ -1022,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/rest.py b/hikari/impl/rest.py
index ce2232f9..1daf1193 100644
--- a/hikari/impl/rest.py
+++ b/hikari/impl/rest.py
@@ -482,7 +482,7 @@ def _stringify_http_message(headers: data_binding.Headers, body: bytes | None) -
 
     if body:
         string += "\n\n    "
-        string += body.decode("ascii")
+        string += body.decode()
 
     return string
 
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,
diff --git a/pyproject.toml b/pyproject.toml
index f5741f05..21e60a4a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -112,7 +112,7 @@ pytest = [
     { include-group = "coverage" },
 ]
 release = ["twine==6.1.0"]
-ruff = ["ruff==0.11.9"]
+ruff = ["ruff==0.11.10"]
 slotscheck = ["slotscheck==0.19.1"]
 towncrier = ["towncrier==24.8.0"]
 types = [
@@ -147,6 +147,7 @@ exclude_lines = [
     "^if __name__ == ['\"]__main__['\"]:$",
     "^\\s*\\.\\.\\.$",
     "^\\s*@abc.abstractmethod$",
+    "^\\s*@typing.overload$",
     "^\\s*if typing.TYPE_CHECKING:$",
     # Whatever is in inside `if not typing.TYPE_CHECKING:` is expected to be tested, but the branch will always run, making
     # coverage think that its only partial
diff --git a/uv.lock b/uv.lock
index 46ec1a3d..60850a34 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1128,7 +1128,7 @@ pytest = [
     { name = "pytest-randomly", specifier = "==3.16.0" },
 ]
 release = [{ name = "twine", specifier = "==6.1.0" }]
-ruff = [{ name = "ruff", specifier = "==0.11.9" }]
+ruff = [{ name = "ruff", specifier = "==0.11.10" }]
 slotscheck = [{ name = "slotscheck", specifier = "==0.19.1" }]
 towncrier = [{ name = "towncrier", specifier = "==24.8.0" }]
 types = [{ name = "pydub-stubs", specifier = "~=0.25.1.5" }]
@@ -2673,27 +2673,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.11.9"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f5/e7/e55dda1c92cdcf34b677ebef17486669800de01e887b7831a1b8fdf5cb08/ruff-0.11.9.tar.gz", hash = "sha256:ebd58d4f67a00afb3a30bf7d383e52d0e036e6195143c6db7019604a05335517", size = 4132134, upload-time = "2025-05-09T16:19:41.511Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fb/71/75dfb7194fe6502708e547941d41162574d1f579c4676a8eb645bf1a6842/ruff-0.11.9-py3-none-linux_armv6l.whl", hash = "sha256:a31a1d143a5e6f499d1fb480f8e1e780b4dfdd580f86e05e87b835d22c5c6f8c", size = 10335453, upload-time = "2025-05-09T16:18:58.2Z" },
-    { url = "https://files.pythonhosted.org/packages/74/fc/ad80c869b1732f53c4232bbf341f33c5075b2c0fb3e488983eb55964076a/ruff-0.11.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:66bc18ca783b97186a1f3100e91e492615767ae0a3be584e1266aa9051990722", size = 11072566, upload-time = "2025-05-09T16:19:01.432Z" },
-    { url = "https://files.pythonhosted.org/packages/87/0d/0ccececef8a0671dae155cbf7a1f90ea2dd1dba61405da60228bbe731d35/ruff-0.11.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:bd576cd06962825de8aece49f28707662ada6a1ff2db848d1348e12c580acbf1", size = 10435020, upload-time = "2025-05-09T16:19:03.897Z" },
-    { url = "https://files.pythonhosted.org/packages/52/01/e249e1da6ad722278094e183cbf22379a9bbe5f21a3e46cef24ccab76e22/ruff-0.11.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b1d18b4be8182cc6fddf859ce432cc9631556e9f371ada52f3eaefc10d878de", size = 10593935, upload-time = "2025-05-09T16:19:06.455Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/9a/40cf91f61e3003fe7bd43f1761882740e954506c5a0f9097b1cff861f04c/ruff-0.11.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0f3f46f759ac623e94824b1e5a687a0df5cd7f5b00718ff9c24f0a894a683be7", size = 10172971, upload-time = "2025-05-09T16:19:10.261Z" },
-    { url = "https://files.pythonhosted.org/packages/61/12/d395203de1e8717d7a2071b5a340422726d4736f44daf2290aad1085075f/ruff-0.11.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f34847eea11932d97b521450cf3e1d17863cfa5a94f21a056b93fb86f3f3dba2", size = 11748631, upload-time = "2025-05-09T16:19:12.307Z" },
-    { url = "https://files.pythonhosted.org/packages/66/d6/ef4d5eba77677eab511644c37c55a3bb8dcac1cdeb331123fe342c9a16c9/ruff-0.11.9-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:f33b15e00435773df97cddcd263578aa83af996b913721d86f47f4e0ee0ff271", size = 12409236, upload-time = "2025-05-09T16:19:15.006Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/8f/5a2c5fc6124dd925a5faf90e1089ee9036462118b619068e5b65f8ea03df/ruff-0.11.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7b27613a683b086f2aca8996f63cb3dd7bc49e6eccf590563221f7b43ded3f65", size = 11881436, upload-time = "2025-05-09T16:19:17.063Z" },
-    { url = "https://files.pythonhosted.org/packages/39/d1/9683f469ae0b99b95ef99a56cfe8c8373c14eba26bd5c622150959ce9f64/ruff-0.11.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e0d88756e63e8302e630cee3ce2ffb77859797cc84a830a24473939e6da3ca6", size = 13982759, upload-time = "2025-05-09T16:19:19.693Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/0b/c53a664f06e0faab596397867c6320c3816df479e888fe3af63bc3f89699/ruff-0.11.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:537c82c9829d7811e3aa680205f94c81a2958a122ac391c0eb60336ace741a70", size = 11541985, upload-time = "2025-05-09T16:19:21.831Z" },
-    { url = "https://files.pythonhosted.org/packages/23/a0/156c4d7e685f6526a636a60986ee4a3c09c8c4e2a49b9a08c9913f46c139/ruff-0.11.9-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:440ac6a7029f3dee7d46ab7de6f54b19e34c2b090bb4f2480d0a2d635228f381", size = 10465775, upload-time = "2025-05-09T16:19:24.401Z" },
-    { url = "https://files.pythonhosted.org/packages/43/d5/88b9a6534d9d4952c355e38eabc343df812f168a2c811dbce7d681aeb404/ruff-0.11.9-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:71c539bac63d0788a30227ed4d43b81353c89437d355fdc52e0cda4ce5651787", size = 10170957, upload-time = "2025-05-09T16:19:27.08Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/b8/2bd533bdaf469dc84b45815ab806784d561fab104d993a54e1852596d581/ruff-0.11.9-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c67117bc82457e4501473c5f5217d49d9222a360794bfb63968e09e70f340abd", size = 11143307, upload-time = "2025-05-09T16:19:29.462Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/d9/43cfba291788459b9bfd4e09a0479aa94d05ab5021d381a502d61a807ec1/ruff-0.11.9-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e4b78454f97aa454586e8a5557facb40d683e74246c97372af3c2d76901d697b", size = 11603026, upload-time = "2025-05-09T16:19:31.569Z" },
-    { url = "https://files.pythonhosted.org/packages/22/e6/7ed70048e89b01d728ccc950557a17ecf8df4127b08a56944b9d0bae61bc/ruff-0.11.9-py3-none-win32.whl", hash = "sha256:7fe1bc950e7d7b42caaee2a8a3bc27410547cc032c9558ee2e0f6d3b209e845a", size = 10548627, upload-time = "2025-05-09T16:19:33.657Z" },
-    { url = "https://files.pythonhosted.org/packages/90/36/1da5d566271682ed10f436f732e5f75f926c17255c9c75cefb77d4bf8f10/ruff-0.11.9-py3-none-win_amd64.whl", hash = "sha256:52edaa4a6d70f8180343a5b7f030c7edd36ad180c9f4d224959c2d689962d964", size = 11634340, upload-time = "2025-05-09T16:19:35.815Z" },
-    { url = "https://files.pythonhosted.org/packages/40/f7/70aad26e5877c8f7ee5b161c4c9fa0100e63fc4c944dc6d97b9c7e871417/ruff-0.11.9-py3-none-win_arm64.whl", hash = "sha256:bcf42689c22f2e240f496d0c183ef2c6f7b35e809f12c1db58f75d9aa8d630ca", size = 10741080, upload-time = "2025-05-09T16:19:39.605Z" },
+version = "0.11.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/4c/4a3c5a97faaae6b428b336dcca81d03ad04779f8072c267ad2bd860126bf/ruff-0.11.10.tar.gz", hash = "sha256:d522fb204b4959909ecac47da02830daec102eeb100fb50ea9554818d47a5fa6", size = 4165632, upload-time = "2025-05-15T14:08:56.76Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/9f/596c628f8824a2ce4cd12b0f0b4c0629a62dfffc5d0f742c19a1d71be108/ruff-0.11.10-py3-none-linux_armv6l.whl", hash = "sha256:859a7bfa7bc8888abbea31ef8a2b411714e6a80f0d173c2a82f9041ed6b50f58", size = 10316243, upload-time = "2025-05-15T14:08:12.884Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/38/c1e0b77ab58b426f8c332c1d1d3432d9fc9a9ea622806e208220cb133c9e/ruff-0.11.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:968220a57e09ea5e4fd48ed1c646419961a0570727c7e069842edd018ee8afed", size = 11083636, upload-time = "2025-05-15T14:08:16.551Z" },
+    { url = "https://files.pythonhosted.org/packages/23/41/b75e15961d6047d7fe1b13886e56e8413be8467a4e1be0a07f3b303cd65a/ruff-0.11.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:1067245bad978e7aa7b22f67113ecc6eb241dca0d9b696144256c3a879663bca", size = 10441624, upload-time = "2025-05-15T14:08:19.032Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/2c/e396b6703f131406db1811ea3d746f29d91b41bbd43ad572fea30da1435d/ruff-0.11.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4854fd09c7aed5b1590e996a81aeff0c9ff51378b084eb5a0b9cd9518e6cff2", size = 10624358, upload-time = "2025-05-15T14:08:21.542Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/8c/ee6cca8bdaf0f9a3704796022851a33cd37d1340bceaf4f6e991eb164e2e/ruff-0.11.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8b4564e9f99168c0f9195a0fd5fa5928004b33b377137f978055e40008a082c5", size = 10176850, upload-time = "2025-05-15T14:08:23.682Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/ce/4e27e131a434321b3b7c66512c3ee7505b446eb1c8a80777c023f7e876e6/ruff-0.11.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5b6a9cc5b62c03cc1fea0044ed8576379dbaf751d5503d718c973d5418483641", size = 11759787, upload-time = "2025-05-15T14:08:25.733Z" },
+    { url = "https://files.pythonhosted.org/packages/58/de/1e2e77fc72adc7cf5b5123fd04a59ed329651d3eab9825674a9e640b100b/ruff-0.11.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:607ecbb6f03e44c9e0a93aedacb17b4eb4f3563d00e8b474298a201622677947", size = 12430479, upload-time = "2025-05-15T14:08:28.013Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ed/af0f2340f33b70d50121628ef175523cc4c37619e98d98748c85764c8d88/ruff-0.11.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7b3a522fa389402cd2137df9ddefe848f727250535c70dafa840badffb56b7a4", size = 11919760, upload-time = "2025-05-15T14:08:30.956Z" },
+    { url = "https://files.pythonhosted.org/packages/24/09/d7b3d3226d535cb89234390f418d10e00a157b6c4a06dfbe723e9322cb7d/ruff-0.11.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2f071b0deed7e9245d5820dac235cbdd4ef99d7b12ff04c330a241ad3534319f", size = 14041747, upload-time = "2025-05-15T14:08:33.297Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b3/a63b4e91850e3f47f78795e6630ee9266cb6963de8f0191600289c2bb8f4/ruff-0.11.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a60e3a0a617eafba1f2e4186d827759d65348fa53708ca547e384db28406a0b", size = 11550657, upload-time = "2025-05-15T14:08:35.639Z" },
+    { url = "https://files.pythonhosted.org/packages/46/63/a4f95c241d79402ccdbdb1d823d156c89fbb36ebfc4289dce092e6c0aa8f/ruff-0.11.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:da8ec977eaa4b7bf75470fb575bea2cb41a0e07c7ea9d5a0a97d13dbca697bf2", size = 10489671, upload-time = "2025-05-15T14:08:38.437Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/9b/c2238bfebf1e473495659c523d50b1685258b6345d5ab0b418ca3f010cd7/ruff-0.11.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ddf8967e08227d1bd95cc0851ef80d2ad9c7c0c5aab1eba31db49cf0a7b99523", size = 10160135, upload-time = "2025-05-15T14:08:41.247Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/ef/ba7251dd15206688dbfba7d413c0312e94df3b31b08f5d695580b755a899/ruff-0.11.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:5a94acf798a82db188f6f36575d80609072b032105d114b0f98661e1679c9125", size = 11170179, upload-time = "2025-05-15T14:08:43.762Z" },
+    { url = "https://files.pythonhosted.org/packages/73/9f/5c336717293203ba275dbfa2ea16e49b29a9fd9a0ea8b6febfc17e133577/ruff-0.11.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3afead355f1d16d95630df28d4ba17fb2cb9c8dfac8d21ced14984121f639bad", size = 11626021, upload-time = "2025-05-15T14:08:46.451Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/2b/162fa86d2639076667c9aa59196c020dc6d7023ac8f342416c2f5ec4bda0/ruff-0.11.10-py3-none-win32.whl", hash = "sha256:dc061a98d32a97211af7e7f3fa1d4ca2fcf919fb96c28f39551f35fc55bdbc19", size = 10494958, upload-time = "2025-05-15T14:08:49.601Z" },
+    { url = "https://files.pythonhosted.org/packages/24/f3/66643d8f32f50a4b0d09a4832b7d919145ee2b944d43e604fbd7c144d175/ruff-0.11.10-py3-none-win_amd64.whl", hash = "sha256:5cc725fbb4d25b0f185cb42df07ab6b76c4489b4bfb740a175f3a59c70e8a224", size = 11650285, upload-time = "2025-05-15T14:08:52.392Z" },
+    { url = "https://files.pythonhosted.org/packages/95/3a/2e8704d19f376c799748ff9cb041225c1d59f3e7711bc5596c8cfdc24925/ruff-0.11.10-py3-none-win_arm64.whl", hash = "sha256:ef69637b35fb8b210743926778d0e45e1bffa850a7c61e428c6b971549b5f5d1", size = 10765278, upload-time = "2025-05-15T14:08:54.56Z" },
 ]
 
 [[package]]


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 cbfd7b05..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()
@@ -604,6 +604,7 @@ def test_run(self, bot):
                 shard_ids=shard_ids,
                 shard_count=shard_count,
                 status=status,
+                startup_window_delay=15,
             )
 
         loop.run_until_complete.assert_has_calls(
@@ -619,6 +620,7 @@ def test_run(self, bot):
             shard_ids=shard_ids,
             shard_count=shard_count,
             status=status,
+            startup_window_delay=15,
         )
         handle_interrupts.assert_called_once_with(enabled=False, loop=loop, propagate_interrupts=False)
         handle_interrupts.return_value.assert_used_once()
@@ -681,6 +683,7 @@ def _mock_start_one_shard(*args, **kwargs):
                 idle_since="some idle since",
                 status="some status",
                 large_threshold=500,
+                startup_window_delay=10,
             )
 
         check_for_updates.assert_called_once_with(http_settings, proxy_settings)
@@ -691,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),
             ]
         )
 
@@ -727,7 +730,7 @@ def _mock_start_one_shard(*args, **kwargs):
                 # Shard 1
                 mock.call(closing_event_closing_wait, gather.return_value),
                 # Shard 2
-                mock.call(closing_event_closing_wait, shard1.join.return_value, timeout=5),
+                mock.call(closing_event_closing_wait, shard1.join.return_value, timeout=10),
                 mock.call(closing_event_closing_wait, gather.return_value),
             ]
         )