cleanup

src/tui/mod.rs

@@ -13,7 +13,8 @@
 use std::io::{self, Stdout};
 use std::time::Duration;
 
-use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers};
+use crossterm::event::{Event, EventStream, KeyCode, KeyEvent, KeyModifiers};
+use futures::StreamExt;
 use crossterm::execute;
 use crossterm::terminal::{
     EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
@@ -250,7 +251,7 @@ fn render(frame: &mut Frame, state: &AppState) {
 /// ```text
 /// loop:
 ///   1. drain UIEvents (non-blocking try_recv)
-///   2. poll keyboard for up to 16 ms  (<- spawn_blocking keeps async runtime free)
+///   2. poll keyboard for up to 16 ms via EventStream (async, no blocking thread)
 ///   3. handle key event -> Option<LoopControl>
 ///   4. render frame (scroll updated inside draw closure)
 ///   5. act on LoopControl: send message or break
@@ -265,24 +266,21 @@ pub async fn run(
     install_panic_hook();
     let mut terminal = init_terminal()?;
     let mut state = AppState::new();
+    let mut event_stream = EventStream::new();
 
     loop {
         // 1. Drain pending UI events.
         drain_ui_events(&mut event_rx, &mut state);
 
-        // 2. Poll keyboard without blocking the async runtime.
-        let key_event: Option<KeyEvent> = tokio::task::spawn_blocking(|| {
-            if event::poll(Duration::from_millis(16)).unwrap_or(false) {
-                match event::read() {
-                    Ok(Event::Key(k)) => Some(k),
-                    _ => None,
-                }
-            } else {
-                None
-            }
-        })
-        .await
-        .unwrap_or(None);
+        // 2. Poll keyboard for up to 16 ms.  EventStream integrates with the
+        //    Tokio runtime via futures::Stream, so no blocking thread is needed.
+        //    Timeout expiry, stream end, non-key events, and I/O errors all map
+        //    to None -- the frame is rendered regardless.
+        let key_event: Option<KeyEvent> =
+            match tokio::time::timeout(Duration::from_millis(16), event_stream.next()).await {
+                Ok(Some(Ok(Event::Key(k)))) => Some(k),
+                _ => None,
+            };
 
         // 3. Handle key.
         let control = handle_key(key_event, &mut state);