fix: update ListenContext and timer event handling for consistency.

Author: Splode

src-tauri/src/themes/watcher.rs

@@ -73,13 +73,7 @@ fn debounce_loop(
     app_data_dir: &Path,
     app: &AppHandle,
 ) {
-    loop {
-        // Block until at least one event arrives.
-        let first = match rx.recv() {
-            Ok(evt) => evt,
-            Err(_) => break, // channel closed — watcher was dropped
-        };
-
+    while let Ok(first) = rx.recv() {
         // Log and ignore watcher errors.
         if let Err(e) = first {
             eprintln!("[themes/watcher] watch error: {e}");

src-tauri/src/timer/mod.rs

@@ -96,12 +96,14 @@ impl TimerController {
                 listen_events(
                     app,
                     event_rx,
-                    seq_thread,
-                    settings_thread,
-                    shared_thread,
-                    engine_thread,
-                    tray_thread,
-                    db,
+                    ListenContext {
+                        sequence: seq_thread,
+                        settings: settings_thread,
+                        shared: shared_thread,
+                        engine: engine_thread,
+                        tray: tray_thread,
+                        db,
+                    },
                 );
             })
             .expect("failed to spawn timer event listener");
@@ -213,16 +215,21 @@ impl TimerController {
 // Background event listener thread
 // ---------------------------------------------------------------------------
 
-fn listen_events(
-    app: AppHandle,
-    event_rx: std::sync::mpsc::Receiver<TimerEvent>,
+struct ListenContext {
     sequence: Arc<Mutex<SequenceState>>,
     settings: Arc<Mutex<Settings>>,
     shared: Arc<Mutex<TimerShared>>,
     engine: EngineHandle,
     tray: Arc<TrayState>,
     db: DbState,
+}
+
+fn listen_events(
+    app: AppHandle,
+    event_rx: std::sync::mpsc::Receiver<TimerEvent>,
+    ctx: ListenContext,
 ) {
+    let ListenContext { sequence, settings, shared, engine, tray, db } = ctx;
     // Track last tray progress to throttle redraws to ≥ 1% delta.
     let mut last_tray_progress: f32 = -1.0;
     // Active session row ID for recording (None = not started yet).

src-tauri/src/tray/mod.rs

@@ -214,12 +214,13 @@ pub fn render_tray_icon_rgba(
 ) -> Vec<u8> {
     let mut pixmap = Pixmap::new(SIZE, SIZE).expect("pixmap alloc");
 
-    let mut paint = Paint::default();
-    paint.anti_alias = true;
+    let mut paint = Paint { anti_alias: true, ..Default::default() };
 
-    let mut stroke = Stroke::default();
-    stroke.width = STROKE_WIDTH;
-    stroke.line_cap = tiny_skia::LineCap::Round;
+    let stroke = Stroke {
+        width: STROKE_WIDTH,
+        line_cap: tiny_skia::LineCap::Round,
+        ..Default::default()
+    };
 
     // Track ring: full circle at low opacity — defines the circular shape.
     {

src-tauri/src/websocket/mod.rs

@@ -141,7 +141,7 @@ async fn handle_socket(socket: WebSocket, state: ServerState) {
                 Ok(s) => s,
                 Err(_) => continue,
             };
-            if sender.send(Message::Text(json.into())).await.is_err() {
+            if sender.send(Message::Text(json)).await.is_err() {
                 break;
             }
         }
@@ -178,21 +178,18 @@ async fn handle_client_message(
         return;
     };
 
-    match msg.get("type").and_then(|t| t.as_str()) {
-        Some("getState") => {
-            if let Some(timer) = app.try_state::<TimerController>() {
-                let snapshot = timer.get_snapshot();
-                let response = serde_json::json!({
-                    "type": "state",
-                    "payload": snapshot,
-                });
-                // Note: we can't send directly here without the sender;
-                // the client will receive state via the next broadcast.
-                // For an immediate reply, broadcast it.
-                let _ = app.emit("timer:state-query", response);
-            }
+    if let Some("getState") = msg.get("type").and_then(|t| t.as_str()) {
+        if let Some(timer) = app.try_state::<TimerController>() {
+            let snapshot = timer.get_snapshot();
+            let response = serde_json::json!({
+                "type": "state",
+                "payload": snapshot,
+            });
+            // Note: we can't send directly here without the sender;
+            // the client will receive state via the next broadcast.
+            // For an immediate reply, broadcast it.
+            let _ = app.emit("timer:state-query", response);
         }
-        _ => {}
     }
 }