refactor: improve EventBus to prevent deadlocks and remove unused events

- Change BoxedHandler from Box to Arc to enable cloning
- Clone handlers before releasing lock in publish() to prevent deadlocks
- Remove unused domain events (TypingStarted, ChallengeCompleted, StageCompleted, SessionCompleted, ScoreCalculated, ErrorOccurred)
- Consolidate remaining events into unified DomainEvent enum
- Remove unused ui_events.rs module

This fixes deadlocks that occurred when EventBus handlers tried to
acquire locks while publish() was holding the subscribers lock.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: unhappychoice

src/domain/events/domain_events.rs

@@ -1,91 +1,19 @@
 use super::Event;
-use crate::domain::models::chunk::CodeChunk;
-use crate::domain::models::rank::Rank;
 use std::any::Any;
-use std::time::Instant;
 
+// Unified domain event enum for pattern matching
 #[derive(Debug, Clone)]
-pub struct TypingStarted {
-    pub challenge_id: i64,
-    pub timestamp: Instant,
+pub enum DomainEvent {
+    KeyPressed { key: char, position: usize },
+    StageStarted { start_time: std::time::Instant },
+    StagePaused,
+    StageResumed,
+    StageFinalized,
+    StageSkipped,
+    ChallengeLoaded { text: String, source_path: String },
 }
 
-impl Event for TypingStarted {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct KeyPressed {
-    pub key: char,
-    pub timestamp: Instant,
-}
-
-impl Event for KeyPressed {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct ChallengeCompleted {
-    pub challenge_id: i64,
-    pub timestamp: Instant,
-}
-
-impl Event for ChallengeCompleted {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct StageCompleted {
-    pub stage_id: i64,
-    pub chunk: CodeChunk,
-    pub timestamp: Instant,
-}
-
-impl Event for StageCompleted {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct SessionCompleted {
-    pub session_id: i64,
-    pub timestamp: Instant,
-}
-
-impl Event for SessionCompleted {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct ScoreCalculated {
-    pub score: f64,
-    pub accuracy: f64,
-    pub wpm: f64,
-    pub rank: Rank,
-}
-
-impl Event for ScoreCalculated {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct ErrorOccurred {
-    pub message: String,
-    pub timestamp: Instant,
-}
-
-impl Event for ErrorOccurred {
+impl Event for DomainEvent {
     fn as_any(&self) -> &dyn Any {
         self
     }

src/domain/events/mod.rs

@@ -3,7 +3,6 @@ use std::collections::HashMap;
 use std::sync::{Arc, RwLock};
 
 pub mod domain_events;
-pub mod ui_events;
 
 pub trait Event: Send + Sync + 'static {
     fn as_any(&self) -> &dyn Any;
@@ -13,7 +12,7 @@ pub trait EventHandler<E: Event>: Send + Sync {
     fn handle(&self, event: &E);
 }
 
-type BoxedHandler = Box<dyn Fn(&dyn Event) + Send + Sync>;
+type BoxedHandler = Arc<dyn Fn(&dyn Event) + Send + Sync>;
 
 pub struct EventBus {
     subscribers: Arc<RwLock<HashMap<TypeId, Vec<BoxedHandler>>>>,
@@ -28,12 +27,19 @@ impl EventBus {
 
     pub fn publish<E: Event>(&self, event: E) {
         let type_id = TypeId::of::<E>();
-        let subscribers = self.subscribers.read().unwrap();
 
-        if let Some(handlers) = subscribers.get(&type_id) {
-            for handler in handlers {
-                handler(&event);
-            }
+        // Clone Arc<handlers> while holding the lock, then release it before calling them
+        let handlers: Vec<BoxedHandler> = {
+            let subscribers = self.subscribers.read().unwrap();
+            let h = subscribers.get(&type_id)
+                .map(|h| h.clone())
+                .unwrap_or_default();
+            h
+        }; // Lock is released here
+
+        // Call handlers without holding the lock
+        for handler in handlers.iter() {
+            handler(&event);
         }
     }
 
@@ -44,7 +50,7 @@ impl EventBus {
         let type_id = TypeId::of::<E>();
         let mut subscribers = self.subscribers.write().unwrap();
 
-        let boxed_handler: BoxedHandler = Box::new(move |event: &dyn Event| {
+        let boxed_handler: BoxedHandler = Arc::new(move |event: &dyn Event| {
             if let Some(concrete_event) = event.as_any().downcast_ref::<E>() {
                 handler(concrete_event);
             }

src/domain/events/ui_events.rs

@@ -1,6 +1,5 @@
 pub mod ascii_art_coverage_tests;
 pub mod comment_processing_tests;
-pub mod event_flow_tests;
 pub mod indent_treesitter_tests;
 pub mod languages;
 pub mod missing_ascii_art_test;