Add Swoole-specific optimizations to events Dispatcher

- Add listenersCache for prepared listeners (avoids creating new closures
  on every dispatch in long-running processes)
- Use Context for deferred events state (coroutine-safe, prevents race
  conditions when multiple coroutines defer events simultaneously)
- Invalidate listenersCache in listen(), setupWildcardListen(), forget()

Author: binaryfire

src/events/src/Dispatcher.php

@@ -6,6 +6,7 @@
 
 use Closure;
 use Exception;
+use Hypervel\Context\Context;
 use Hypervel\Container\Container;
 use Hypervel\Contracts\Broadcasting\Factory as BroadcastFactory;
 use Hypervel\Contracts\Broadcasting\ShouldBroadcast;
@@ -58,6 +59,13 @@ class Dispatcher implements DispatcherContract
      */
     protected array $wildcardsCache = [];
 
+    /**
+     * The cached prepared listeners.
+     *
+     * @var array<string, array<Closure>>
+     */
+    protected array $listenersCache = [];
+
     /**
      * The queue resolver instance.
      *
@@ -72,23 +80,6 @@ class Dispatcher implements DispatcherContract
      */
     protected $transactionManagerResolver;
 
-    /**
-     * The currently deferred events.
-     */
-    protected array $deferredEvents = [];
-
-    /**
-     * Indicates if events should be deferred.
-     */
-    protected bool $deferringEvents = false;
-
-    /**
-     * The specific events to defer (null means defer all events).
-     *
-     * @var null|string[]
-     */
-    protected ?array $eventsToDefer = null;
-
     /**
      * Create a new event dispatcher instance.
      */
@@ -131,6 +122,8 @@ public function listen(QueuedClosure|Closure|array|string $events, QueuedClosure
                 $this->listeners[$event][] = $listener;
             }
         }
+
+        $this->listenersCache = [];
     }
 
     /**
@@ -141,6 +134,7 @@ protected function setupWildcardListen(string $event, Closure|string|array $list
         $this->wildcards[$event][] = $listener;
 
         $this->wildcardsCache = [];
+        $this->listenersCache = [];
     }
 
     /**
@@ -243,7 +237,12 @@ public function dispatch(string|object $event, mixed $payload = [], bool $halt =
         ];
 
         if ($this->shouldDeferEvent($parsedEvent)) {
-            $this->deferredEvents[] = func_get_args();
+            Context::override('__events.deferred_events', function (?array $events) use ($event, $payload, $halt) {
+                $events = $events ?? [];
+                $events[] = [$event, $payload, $halt];
+
+                return $events;
+            });
 
             return null;
         }
@@ -345,14 +344,20 @@ protected function broadcastEvent(ShouldBroadcast $event): void
      */
     public function getListeners(string $eventName): array
     {
+        if (isset($this->listenersCache[$eventName])) {
+            return $this->listenersCache[$eventName];
+        }
+
         $listeners = array_merge(
             $this->prepareListeners($eventName),
             $this->wildcardsCache[$eventName] ?? $this->getWildcardListeners($eventName)
         );
 
-        return class_exists($eventName, false)
+        $listeners = class_exists($eventName, false)
             ? $this->addInterfaceListeners($eventName, $listeners)
             : $listeners;
+
+        return $this->listenersCache[$eventName] = $listeners;
     }
 
     /**
@@ -657,6 +662,8 @@ public function forget(string $event): void
                 unset($this->wildcardsCache[$key]);
             }
         }
+
+        $this->listenersCache = [];
     }
 
     /**
@@ -720,29 +727,29 @@ public function setTransactionManagerResolver(callable $resolver): static
      */
     public function defer(callable $callback, ?array $events = null): mixed
     {
-        $wasDeferring = $this->deferringEvents;
-        $previousDeferredEvents = $this->deferredEvents;
-        $previousEventsToDefer = $this->eventsToDefer;
+        $wasDeferring = Context::get('__events.deferring', false);
+        $previousDeferredEvents = Context::get('__events.deferred_events', []);
+        $previousEventsToDefer = Context::get('__events.events_to_defer', null);
 
-        $this->deferringEvents = true;
-        $this->deferredEvents = [];
-        $this->eventsToDefer = $events;
+        Context::set('__events.deferring', true);
+        Context::set('__events.deferred_events', []);
+        Context::set('__events.events_to_defer', $events);
 
         try {
             $result = $callback();
 
-            $this->deferringEvents = false;
+            Context::set('__events.deferring', false);
 
             /* @phpstan-ignore foreach.emptyArray (callback may add deferred events) */
-            foreach ($this->deferredEvents as $args) {
+            foreach (Context::get('__events.deferred_events', []) as $args) {
                 $this->dispatch(...$args);
             }
 
             return $result;
         } finally {
-            $this->deferringEvents = $wasDeferring;
-            $this->deferredEvents = $previousDeferredEvents;
-            $this->eventsToDefer = $previousEventsToDefer;
+            Context::set('__events.deferring', $wasDeferring);
+            Context::set('__events.deferred_events', $previousDeferredEvents);
+            Context::set('__events.events_to_defer', $previousEventsToDefer);
         }
     }
 
@@ -751,7 +758,17 @@ public function defer(callable $callback, ?array $events = null): mixed
      */
     protected function shouldDeferEvent(string $event): bool
     {
-        return $this->deferringEvents && ($this->eventsToDefer === null || in_array($event, $this->eventsToDefer));
+        if (! Context::get('__events.deferring', false)) {
+            return false;
+        }
+
+        $eventsToDefer = Context::get('__events.events_to_defer', null);
+
+        if ($eventsToDefer === null) {
+            return true;
+        }
+
+        return in_array($event, $eventsToDefer);
     }
 
     /**