Eliminate code duplication with unified action functions

Create action functions for stop, volume, and seek operations and
use them consistently across keyboard handlers, mouse handlers, and
API handlers. This eliminates duplicate logic and ensures consistent
behavior across all input methods.

Also fixes stop command triggering auto-advance by setting the
skip_position_update flag to prevent the Playing→Stopped transition
from being interpreted as a natural track ending.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-player"
-version = "0.1.26"
+version = "0.1.33"
 edition = "2021"
 
 [dependencies]

src/api/mod.rs

@@ -50,22 +50,6 @@ impl ApiResponse {
             data: None,
         }
     }
-
-    pub fn success_with_data(data: serde_json::Value) -> Self {
-        Self {
-            success: true,
-            message: None,
-            data: Some(data),
-        }
-    }
-
-    pub fn error(message: String) -> Self {
-        Self {
-            success: false,
-            message: Some(message),
-            data: None,
-        }
-    }
 }
 
 /// Start the API server on a Unix socket

src/main.rs

@@ -19,9 +19,8 @@ use std::os::unix::net::UnixStream;
 use tracing_subscriber;
 
 // UI update intervals and thresholds
-const METADATA_UPDATE_INTERVAL: u32 = 20; // Update metadata every N iterations (~2 seconds)
 const POLL_DURATION_STOPPED_MS: u64 = 200; // 5 FPS when stopped
-const POLL_DURATION_ACTIVE_MS: u64 = 100; // 10 FPS when playing/paused
+const POLL_DURATION_ACTIVE_MS: u64 = 200; // 5 FPS when playing/paused - single batch poll
 const DOUBLE_CLICK_MS: u128 = 500; // Double-click detection threshold
 
 fn main() -> Result<()> {
@@ -226,7 +225,7 @@ fn action_play_selection(state: &mut AppState, player: &mut player::Player, skip
         player.play(path)?;
         // Explicitly resume playback in case MPV was paused
         player.resume()?;
-        player.update_metadata();
+        // Metadata will be fetched by periodic update once MPV has it ready
         tracing::info!("Playing: {:?} (playlist: {} tracks)", path, state.playlist.len());
     }
     if state.visual_mode {
@@ -254,7 +253,6 @@ fn action_toggle_play_pause(state: &mut AppState, player: &mut player::Player) -
                     if let Some(ref path) = state.current_file {
                         player.play(path)?;
                         player.resume()?;
-                        player.update_metadata();
                         tracing::info!("Restarting playback: {:?}", path);
                     }
                 }
@@ -264,14 +262,44 @@ fn action_toggle_play_pause(state: &mut AppState, player: &mut player::Player) -
     Ok(())
 }
 
-fn action_stop(state: &mut AppState, player: &mut player::Player) -> Result<()> {
+fn action_stop(state: &mut AppState, player: &mut player::Player, skip_position_update: &mut bool) -> Result<()> {
     player.stop()?;
     state.current_position = 0.0;
     state.current_duration = 0.0;
+    *skip_position_update = true; // Prevent auto-advance on manual stop
     tracing::info!("Stopped");
     Ok(())
 }
 
+fn action_volume_up(state: &mut AppState, player: &mut player::Player) -> Result<()> {
+    state.volume = (state.volume + 5).min(100);
+    player.set_volume(state.volume)?;
+    tracing::info!("Volume: {}%", state.volume);
+    Ok(())
+}
+
+fn action_volume_down(state: &mut AppState, player: &mut player::Player) -> Result<()> {
+    state.volume = (state.volume - 5).max(0);
+    player.set_volume(state.volume)?;
+    tracing::info!("Volume: {}%", state.volume);
+    Ok(())
+}
+
+fn action_volume_set(state: &mut AppState, player: &mut player::Player, volume: i64) -> Result<()> {
+    state.volume = volume.clamp(0, 100);
+    player.set_volume(state.volume)?;
+    tracing::info!("Volume: {}%", state.volume);
+    Ok(())
+}
+
+fn action_seek(player: &mut player::Player, seconds: f64) -> Result<()> {
+    if player.get_player_state() != Some(PlayerState::Stopped) {
+        player.seek(seconds)?;
+        tracing::info!("Seek {}s", seconds);
+    }
+    Ok(())
+}
+
 fn action_remove_from_playlist(state: &mut AppState, player: &mut player::Player) -> Result<()> {
     let was_playing_removed = state.playlist_index == state.selected_playlist_index;
     let was_playing = player.get_player_state() == Some(PlayerState::Playing);
@@ -287,7 +315,7 @@ fn action_remove_from_playlist(state: &mut AppState, player: &mut player::Player
             player.play(path)?;
             // Explicitly resume playback in case MPV was paused
             player.resume()?;
-            player.update_metadata();
+                // Metadata will be fetched by periodic update
         }
     }
     Ok(())
@@ -319,7 +347,7 @@ fn action_navigate_track(state: &mut AppState, player: &mut player::Player, dire
                     *skip_position_update = true; // Skip position update after track change
                     player.play(path)?;
                     player.resume()?;
-                    player.update_metadata();
+                    // Metadata will be fetched by periodic update
                     tracing::info!("{} track: {:?}", track_name, path);
                 }
             }
@@ -328,7 +356,7 @@ fn action_navigate_track(state: &mut AppState, player: &mut player::Player, dire
                 if let Some(ref path) = state.current_file {
                     *skip_position_update = true; // Skip position update after track change
                     player.play_paused(path)?;
-                    player.update_metadata();
+                    // Metadata will be fetched by periodic update
                     tracing::info!("{} track (paused): {:?}", track_name, path);
                 }
             }
@@ -351,6 +379,7 @@ fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player,
     state.playlist_index = state.selected_playlist_index;
     state.current_file = Some(state.playlist[state.playlist_index].clone());
 
+
     if preserve_pause {
         if let Some(player_state) = player.get_player_state() {
             match player_state {
@@ -359,7 +388,7 @@ fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player,
                         *skip_position_update = true; // Skip position update after track change
                         player.play(path)?;
                         player.resume()?;
-                        player.update_metadata();
+                        // Metadata will be fetched by periodic update
                         tracing::info!("Jumped to track: {:?}", path);
                     }
                 }
@@ -367,7 +396,7 @@ fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player,
                     if let Some(ref path) = state.current_file {
                         *skip_position_update = true; // Skip position update after track change
                         player.play_paused(path)?;
-                        player.update_metadata();
+                        // Metadata will be fetched by periodic update
                         tracing::info!("Jumped to track (paused): {:?}", path);
                     }
                 }
@@ -376,7 +405,7 @@ fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player,
                         *skip_position_update = true; // Skip position update after track change
                         player.play(path)?;
                         player.resume()?;
-                        player.update_metadata();
+                        // Metadata will be fetched by periodic update
                         tracing::info!("Started playing track: {:?}", path);
                     }
                 }
@@ -388,7 +417,7 @@ fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player,
             player.play(path)?;
             // Explicitly resume playback in case MPV was paused
             player.resume()?;
-            player.update_metadata();
+            // Metadata will be fetched by periodic update
             tracing::info!("Playing from playlist: {:?}", path);
         }
     }
@@ -416,7 +445,7 @@ fn handle_context_menu_action(menu_type: state::ContextMenuType, selected: usize
         }
         state::ContextMenuType::TitleBar => {
             match selected {
-                0 => action_stop(state, player)?,
+                0 => action_stop(state, player, skip_position_update)?,
                 1 => {
                     state.cycle_play_mode();
                     tracing::info!("Play mode: {:?}", state.play_mode);
@@ -438,7 +467,6 @@ fn run_app<B: ratatui::backend::Backend>(
     player: &mut player::Player,
     api_rx: std::sync::mpsc::Receiver<api::ApiCommand>,
 ) -> Result<()> {
-    let mut metadata_update_counter = 0u32;
     let mut last_position = 0.0f64;
     let mut needs_redraw = true;
     let mut skip_position_update = false;
@@ -455,26 +483,11 @@ fn run_app<B: ratatui::backend::Backend>(
             tracing::debug!("Processing API command: {:?}", cmd);
             match cmd {
                 api::ApiCommand::PlayPause => {
-                    if let Some(player_state) = player.get_player_state() {
+                    action_toggle_play_pause(state, player)?;
-                        match player_state {
-                            PlayerState::Stopped => {
-                                // Play current file or first in playlist
-                                if state.current_file.is_none() && !state.playlist.is_empty() {
-                                    state.current_file = Some(state.playlist[0].clone());
-                                }
-                                if let Some(ref file) = state.current_file {
-                                    player.play(file)?;
-                                }
-                            }
-                            PlayerState::Playing => player.pause()?,
-                            PlayerState::Paused => player.resume()?,
-                        }
                     state_changed = true;
                 }
-                }
                 api::ApiCommand::Stop => {
-                    player.stop()?;
+                    action_stop(state, player, &mut skip_position_update)?;
-                    state.current_file = None;
                     state_changed = true;
                 }
                 api::ApiCommand::Next => {
@@ -486,26 +499,23 @@ fn run_app<B: ratatui::backend::Backend>(
                     state_changed = true;
                 }
                 api::ApiCommand::VolumeUp => {
-                    state.volume = (state.volume + 5).min(100);
+                    action_volume_up(state, player)?;
-                    player.set_volume(state.volume)?;
                     state_changed = true;
                 }
                 api::ApiCommand::VolumeDown => {
-                    state.volume = (state.volume - 5).max(0);
+                    action_volume_down(state, player)?;
-                    player.set_volume(state.volume)?;
                     state_changed = true;
                 }
                 api::ApiCommand::VolumeSet { volume } => {
-                    state.volume = volume.clamp(0, 100);
+                    action_volume_set(state, player, volume)?;
-                    player.set_volume(state.volume)?;
                     state_changed = true;
                 }
                 api::ApiCommand::SeekForward { seconds } => {
-                    player.seek(seconds)?;
+                    action_seek(player, seconds)?;
                     state_changed = true;
                 }
                 api::ApiCommand::SeekBackward { seconds } => {
-                    player.seek(-seconds)?;
+                    action_seek(player, -seconds)?;
                     state_changed = true;
                 }
                 api::ApiCommand::GetStatus => {
@@ -529,8 +539,8 @@ fn run_app<B: ratatui::backend::Backend>(
             }
         }
 
-        // Always update properties to keep state synchronized with MPV
+        // Always update all properties in one batch to keep state synchronized with MPV
-        player.update_properties();
+        player.update_all_properties();
 
         // Only proceed if we can successfully query player state
         let Some(player_state) = player.get_player_state() else {
@@ -556,8 +566,10 @@ fn run_app<B: ratatui::backend::Backend>(
         // Check if track ended and play next
         // When MPV finishes playing a file, it goes to idle (Stopped state)
         // Detect Playing → Stopped transition = track ended, play next
+        // But skip this check if we just manually stopped (skip_position_update flag)
         if previous_player_state == Some(PlayerState::Playing)
             && player_state == PlayerState::Stopped
+            && !skip_position_update
         {
             let should_continue = state.play_next();
             // play_next() returns true if should continue playing, false if should stop
@@ -572,9 +584,6 @@ fn run_app<B: ratatui::backend::Backend>(
                     player.play(path)?;
                     player.resume()?;
                 }
-                // Update metadata immediately when track changes
-                player.update_metadata();
-                metadata_update_counter = 0;
                 // Auto-scroll playlist to show current track (only if user is not browsing playlist)
                 if !state.focus_playlist {
                     let playlist_visible_height = playlist_area.height.saturating_sub(2) as usize;
@@ -587,16 +596,8 @@ fn run_app<B: ratatui::backend::Backend>(
             state_changed = true;
         }
 
-        // Only update metadata and track playback when not stopped
+        // Only update playback position when not stopped
         if player_state != PlayerState::Stopped {
-            // Update metadata periodically to reduce IPC calls
-            metadata_update_counter += 1;
-            if metadata_update_counter >= METADATA_UPDATE_INTERVAL {
-                player.update_metadata();
-                metadata_update_counter = 0;
-                state_changed = true;
-            }
-
             // Update position and duration from player
             // Skip this iteration if we just started a new track to avoid stale MPV values
             if skip_position_update {
@@ -674,14 +675,29 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
                 state.show_refresh_confirm = false;
                 state.is_refreshing = true;
                 terminal.draw(|f| { let _ = ui::render(f, state, player); })?;  // Show "Refreshing library..." immediately
-                tracing::info!("Rescanning...");
+
                 let cache_dir = cache::get_cache_dir()?;
+
+                // Delete old cache files to ensure fresh scan
+                let _ = std::fs::remove_file(cache_dir.join("file_tree.json"));
+                let _ = std::fs::remove_file(cache_dir.join("metadata.json"));
+
+                // Perform fresh scan
                 let new_cache = scanner::scan_paths(&state.config.scan_paths.paths)?;
                 new_cache.save(&cache_dir)?;
+
+                // Replace old cache completely
                 state.cache = new_cache;
-                state.refresh_flattened_items();
+                state.refresh_flattened_items(); // This also cleans up playlist and expanded_dirs
+
+                // If current file was removed, stop playback
+                if state.current_file.is_none() {
+                    player.stop()?;
+                    state.current_position = 0.0;
+                    state.current_duration = 0.0;
+                }
+
                 state.is_refreshing = false;
-                tracing::info!("Rescan complete");
             }
             KeyCode::Char('n') | KeyCode::Char('N') | KeyCode::Esc => {
                 state.show_refresh_confirm = false;
@@ -892,7 +908,7 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
             }
         }
         (KeyCode::Char('s'), _) => {
-            action_stop(state, player)?;
+            action_stop(state, player, skip_position_update)?;
         }
         (KeyCode::Char('m'), _) => {
             state.cycle_play_mode();
@@ -906,28 +922,16 @@ fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<B>, st
             action_toggle_play_pause(state, player)?;
         }
         (KeyCode::Char('H'), KeyModifiers::SHIFT) => {
-            if player.get_player_state() != Some(PlayerState::Stopped) {
+            action_seek(player, -10.0)?;
-                player.seek(-10.0)?;
-                tracing::info!("Seek backward 10s");
-            }
         }
         (KeyCode::Char('L'), KeyModifiers::SHIFT) => {
-            if player.get_player_state() != Some(PlayerState::Stopped) {
+            action_seek(player, 10.0)?;
-                player.seek(10.0)?;
-                tracing::info!("Seek forward 10s");
-            }
         }
         (KeyCode::Char('+'), _) | (KeyCode::Char('='), _) => {
-            let new_volume = (state.volume + 5).min(100);
+            action_volume_up(state, player)?;
-            state.volume = new_volume;
-            player.set_volume(new_volume)?;
-            tracing::info!("Volume: {}%", new_volume);
         }
         (KeyCode::Char('-'), _) => {
-            let new_volume = (state.volume - 5).max(0);
+            action_volume_down(state, player)?;
-            state.volume = new_volume;
-            player.set_volume(new_volume)?;
-            tracing::info!("Volume: {}%", new_volume);
         }
         (KeyCode::Char('r'), _) => {
             state.show_refresh_confirm = true;
@@ -1030,10 +1034,7 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                 && y < title_bar_area.y + title_bar_area.height
             {
                 // Scroll on title bar = decrease volume
-                let new_volume = (state.volume - 5).max(0);
+                action_volume_down(state, player)?;
-                state.volume = new_volume;
-                player.set_volume(new_volume)?;
-                tracing::info!("Volume: {}%", new_volume);
             } else if x >= playlist_area.x
                 && x < playlist_area.x + playlist_area.width
                 && y >= playlist_area.y
@@ -1056,10 +1057,7 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                 && y < title_bar_area.y + title_bar_area.height
             {
                 // Scroll on title bar = increase volume
-                let new_volume = (state.volume + 5).min(100);
+                action_volume_up(state, player)?;
-                state.volume = new_volume;
-                player.set_volume(new_volume)?;
-                tracing::info!("Volume: {}%", new_volume);
             } else if x >= playlist_area.x
                 && x < playlist_area.x + playlist_area.width
                 && y >= playlist_area.y
@@ -1097,15 +1095,55 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                     _ => {}
                 }
             }
+            // Check if click is on the panel title border (to switch focus)
+            // The visible area is whichever one is not Rect::default()
+            else if (file_panel_area.width > 0 && y == file_panel_area.y) ||
+                    (playlist_area.width > 0 && y == playlist_area.y) {
+                // Click is on the top border line where "Files | Playlist" is shown
+                // Get the actual visible area (not the default one)
+                let area = if file_panel_area.width > 0 { file_panel_area } else { playlist_area };
+
+                // Build title text to calculate positions
+                let playlist_text = if !state.playlist.is_empty() {
+                    format!("Playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
+                } else {
+                    "Playlist (empty)".to_string()
+                };
+
+                // Title is left-aligned by default in ratatui, starts after left border
+                // Border character takes 1 position, then title starts
+                let title_start_x = area.x + 1;
+
+                // Calculate where "Files" and "Playlist" text are
+                let files_start = title_start_x;
+                let files_end = files_start + 5; // "Files" is 5 chars
+                let separator_start = files_end;
+                let separator_end = separator_start + 3; // " | " is 3 chars
+                let playlist_start = separator_end;
+                let playlist_end = playlist_start + playlist_text.len() as u16;
+
+                match button {
+                    MouseButton::Left => {
+                        if x >= files_start && x < files_end {
+                            // Clicked on "Files" - switch to file panel
+                            state.focus_playlist = false;
+                        } else if x >= playlist_start && x < playlist_end {
+                            // Clicked on "Playlist" - switch to playlist
+                            state.focus_playlist = true;
+                        }
+                    }
+                    _ => {}
+                }
+            }
             // Check if click is within file panel area
             else if x >= file_panel_area.x
                 && x < file_panel_area.x + file_panel_area.width
                 && y >= file_panel_area.y
                 && y < file_panel_area.y + file_panel_area.height
             {
-                // Calculate which item was clicked (accounting for borders and scroll offset)
+                // Calculate which item was clicked (accounting for scroll offset and outer border)
-                // Border takes 1 line at top, so subtract 1 from y position
+                // Outer border takes 1 line at top, content starts at file_panel_area.y + 1
-                let relative_y = (y - file_panel_area.y).saturating_sub(1);
+                let relative_y = y.saturating_sub(file_panel_area.y + 1);
                 let clicked_index = state.scroll_offset + relative_y as usize;
 
                 // Set selection to clicked item if valid
@@ -1164,8 +1202,9 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                 && y >= playlist_area.y
                 && y < playlist_area.y + playlist_area.height
             {
-                // Calculate which track was clicked (accounting for borders)
+                // Calculate which track was clicked (accounting for outer border)
-                let relative_y = (y - playlist_area.y).saturating_sub(1);
+                // Outer border takes 1 line at top, content starts at playlist_area.y + 1
+                let relative_y = y.saturating_sub(playlist_area.y + 1);
                 let clicked_track = relative_y as usize;
 
                 // Add scroll offset to get actual index

src/player/mod.rs

@@ -119,84 +119,75 @@ impl Player {
         Ok(())
     }
 
-    fn get_property(&mut self, property: &str) -> Option<Value> {
+    fn get_properties_batch(&mut self, properties: &[&str]) -> std::collections::HashMap<String, Value> {
-        // Try to connect - if respawning or connection fails, return None
+        let mut results = std::collections::HashMap::new();
-        if let Err(e) = self.connect() {
-            tracing::debug!("Failed to connect for property '{}': {}", property, e);
-            return None;
-        }
 
-        let cmd = json!({
+        // Try to connect
-            "command": ["get_property", property],
+        if self.connect().is_err() {
-            "request_id": 1
+            return results;
-        });
+        }
 
         if let Some(ref mut socket) = self.socket {
+            // Send all property requests at once with unique request_ids
+            for (idx, property) in properties.iter().enumerate() {
+                let cmd = json!({
+                    "command": ["get_property", property],
+                    "request_id": idx + 1
+                });
                 let msg = format!("{}\n", cmd);
-
+                if socket.write_all(msg.as_bytes()).is_err() {
-            // Write command
+                    return results;
-            if let Err(e) = socket.write_all(msg.as_bytes()) {
+                }
-                tracing::warn!("Failed to write get_property command for '{}': {}", property, e);
-                self.socket = None;
-                return None;
             }
 
-            // Try to read response with timeout
+            // Read all responses
+            // IMPORTANT: Socket is non-blocking, need to set blocking mode for read
             socket.set_nonblocking(false).ok();
-            socket.set_read_timeout(Some(Duration::from_millis(100))).ok();
 
             let cloned_socket = match socket.try_clone() {
                 Ok(s) => s,
-                Err(e) => {
+                Err(_) => {
-                    tracing::warn!("Failed to clone socket for '{}': {}", property, e);
                     socket.set_nonblocking(true).ok();
-                    return None;
+                    return results;
                 }
             };
 
-            // Set timeout on cloned socket too (clone doesn't copy settings)
             cloned_socket.set_nonblocking(false).ok();
-            cloned_socket.set_read_timeout(Some(Duration::from_millis(100))).ok();
 
             let mut reader = BufReader::new(cloned_socket);
+
+            // Read responses - stop if we timeout or hit an error
+            for _ in 0..properties.len() {
                 let mut response = String::new();
-            if let Err(e) = reader.read_line(&mut response) {
+                if reader.read_line(&mut response).is_err() {
-                tracing::debug!("Failed to read response for '{}': {}", property, e);
+                    // Timeout or error - stop reading
-                socket.set_nonblocking(true).ok();
+                    break;
-                return None;
                 }
 
-            socket.set_nonblocking(true).ok();
+                // Parse response
-
+                if let Ok(parsed) = serde_json::from_str::<Value>(&response) {
-            // Parse and validate response
+                    // Check for success
-            let parsed: Value = match serde_json::from_str(&response) {
-                Ok(v) => v,
-                Err(e) => {
-                    tracing::warn!("Failed to parse JSON response for '{}': {} (response: {})", property, e, response.trim());
-                    return None;
-                }
-            };
-
-            // Check for errors in response
-            // MPV returns {"error": "success"} when there's NO error
                     if let Some(error) = parsed.get("error").and_then(|e| e.as_str()) {
-                if error != "success" {
+                        if error == "success" {
-                    tracing::debug!("MPV returned error for '{}': {}", property, error);
+                            // Get request_id to match with property
-                    return None;
-                }
-            }
-
-            // Validate request_id matches (should be 1)
                             if let Some(req_id) = parsed.get("request_id").and_then(|id| id.as_i64()) {
-                if req_id != 1 {
+                                let idx = (req_id - 1) as usize;
-                    tracing::warn!("Request ID mismatch for '{}': expected 1, got {}", property, req_id);
+                                if idx < properties.len() {
+                                    if let Some(data) = parsed.get("data") {
+                                        results.insert(properties[idx].to_string(), data.clone());
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
 
-            return parsed.get("data").cloned();
+            // Restore non-blocking mode
+            socket.set_nonblocking(true).ok();
         }
 
-        None
+        results
     }
 
     pub fn play(&mut self, path: &Path) -> Result<()> {
@@ -242,84 +233,73 @@ impl Player {
         Ok(())
     }
 
-    pub fn update_properties(&mut self) {
+    pub fn update_all_properties(&mut self) {
-        // Update position
+        // Fetch ALL properties in one batch
-        if let Some(val) = self.get_property("time-pos") {
+        let results = self.get_properties_batch(&[
+            "time-pos",
+            "duration",
+            "metadata/by-key/artist",
+            "metadata/by-key/ARTIST",
+            "metadata/by-key/album",
+            "metadata/by-key/ALBUM",
+            "metadata/by-key/title",
+            "metadata/by-key/TITLE",
+            "media-title",
+            "audio-codec-name",
+            "audio-bitrate",
+            "audio-params/samplerate",
+            "demuxer-cache-duration",
+        ]);
+
+        // Position
+        if let Some(val) = results.get("time-pos") {
             if let Some(pos) = val.as_f64() {
                 self.position = pos;
             }
         }
 
-        // Update duration
+        // Duration
-        if let Some(val) = self.get_property("duration") {
+        if let Some(val) = results.get("duration") {
             if let Some(dur) = val.as_f64() {
                 self.duration = dur;
             }
         }
-    }
 
-    pub fn update_metadata(&mut self) {
+        // Artist - try lowercase first, then uppercase
-        // Try to get artist directly
+        self.artist = results.get("metadata/by-key/artist")
-        if let Some(val) = self.get_property("metadata/by-key/artist") {
+            .and_then(|v| v.as_str().map(|s| s.to_string()))
-            self.artist = val.as_str().map(|s| s.to_string());
+            .or_else(|| results.get("metadata/by-key/ARTIST")
-        }
+                .and_then(|v| v.as_str().map(|s| s.to_string())));
-        // Fallback to ARTIST (uppercase)
-        if self.artist.is_none() {
-            if let Some(val) = self.get_property("metadata/by-key/ARTIST") {
-                self.artist = val.as_str().map(|s| s.to_string());
-            }
-        }
 
-        // Try to get album directly
+        // Album - try lowercase first, then uppercase
-        if let Some(val) = self.get_property("metadata/by-key/album") {
+        self.album = results.get("metadata/by-key/album")
-            self.album = val.as_str().map(|s| s.to_string());
+            .and_then(|v| v.as_str().map(|s| s.to_string()))
-        }
+            .or_else(|| results.get("metadata/by-key/ALBUM")
-        // Fallback to ALBUM (uppercase)
+                .and_then(|v| v.as_str().map(|s| s.to_string())));
-        if self.album.is_none() {
-            if let Some(val) = self.get_property("metadata/by-key/ALBUM") {
-                self.album = val.as_str().map(|s| s.to_string());
-            }
-        }
 
-        // Try to get title directly
+        // Title - try lowercase, then uppercase, then media-title
-        if let Some(val) = self.get_property("metadata/by-key/title") {
+        self.media_title = results.get("metadata/by-key/title")
-            self.media_title = val.as_str().map(|s| s.to_string());
+            .and_then(|v| v.as_str().map(|s| s.to_string()))
-        }
+            .or_else(|| results.get("metadata/by-key/TITLE")
-        // Fallback to TITLE (uppercase)
+                .and_then(|v| v.as_str().map(|s| s.to_string())))
-        if self.media_title.is_none() {
+            .or_else(|| results.get("media-title")
-            if let Some(val) = self.get_property("metadata/by-key/TITLE") {
+                .and_then(|v| v.as_str().map(|s| s.to_string())));
-                self.media_title = val.as_str().map(|s| s.to_string());
-            }
-        }
 
-        // Final fallback to media-title if metadata doesn't have title
+        // Audio codec
-        if self.media_title.is_none() {
+        self.audio_codec = results.get("audio-codec-name")
-            if let Some(val) = self.get_property("media-title") {
+            .and_then(|v| v.as_str().map(|s| s.to_string()));
-                self.media_title = val.as_str().map(|s| s.to_string());
-            }
-        }
 
-        // Update audio codec
+        // Audio bitrate (convert from bps to kbps)
-        if let Some(val) = self.get_property("audio-codec-name") {
+        self.audio_bitrate = results.get("audio-bitrate")
-            self.audio_codec = val.as_str().map(|s| s.to_string());
+            .and_then(|v| v.as_f64().map(|b| b / 1000.0));
-        }
 
-        // Update audio bitrate (convert from bps to kbps)
+        // Sample rate
-        if let Some(val) = self.get_property("audio-bitrate") {
+        self.sample_rate = results.get("audio-params/samplerate")
-            self.audio_bitrate = val.as_f64().map(|b| b / 1000.0);
+            .and_then(|v| v.as_i64());
-        }
 
-        // Update sample rate
+        // Cache duration
-        if let Some(val) = self.get_property("audio-params/samplerate") {
+        self.cache_duration = results.get("demuxer-cache-duration")
-            self.sample_rate = val.as_i64();
+            .and_then(|v| v.as_f64());
-        }
-
-        // Update cache duration (how many seconds are buffered ahead)
-        if let Some(val) = self.get_property("demuxer-cache-duration") {
-            self.cache_duration = val.as_f64();
-        } else {
-            self.cache_duration = None;
-        }
     }
 
     pub fn get_position(&self) -> Option<f64> {
@@ -330,20 +310,14 @@ impl Player {
         Some(self.duration)
     }
 
-    pub fn is_idle(&mut self) -> Option<bool> {
-        self.get_property("idle-active")
-            .and_then(|v| v.as_bool())
-    }
-
-    pub fn is_paused(&mut self) -> Option<bool> {
-        self.get_property("pause")
-            .and_then(|v| v.as_bool())
-    }
-
     pub fn get_player_state(&mut self) -> Option<crate::state::PlayerState> {
         use crate::state::PlayerState;
-        let is_idle = self.is_idle()?;
+
-        let is_paused = self.is_paused()?;
+        // Batch fetch both properties at once
+        let results = self.get_properties_batch(&["idle-active", "pause"]);
+
+        let is_idle = results.get("idle-active").and_then(|v| v.as_bool())?;
+        let is_paused = results.get("pause").and_then(|v| v.as_bool())?;
 
         Some(if is_idle {
             PlayerState::Stopped

src/scanner/mod.rs

@@ -63,8 +63,11 @@ pub fn scan_directory(root_path: &Path) -> Result<FileTreeNode> {
         if entry.file_type().is_dir() {
             // Recursively scan subdirectories
             if let Ok(child_node) = scan_directory(path) {
+                // Only add directory if it contains media files or non-empty subdirectories
+                if !child_node.children.is_empty() {
                     node.children.push(child_node);
                 }
+            }
         } else if is_media_file(path) {
             // Add media file
             let file_name = path

src/state/mod.rs

@@ -587,8 +587,84 @@ impl AppState {
     }
 
     pub fn refresh_flattened_items(&mut self) {
-        // Keep current expanded state after rescan
+        // Clean up expanded_dirs - remove paths that no longer exist in new cache
+        self.cleanup_expanded_dirs();
+
+        // Rebuild view with cleaned expanded state
         self.rebuild_flattened_items();
+
+        // Clean up playlist - remove files that no longer exist in cache
+        self.cleanup_playlist();
+    }
+
+    fn cleanup_expanded_dirs(&mut self) {
+        // Build a set of valid directory paths from the cache
+        let mut valid_dirs = std::collections::HashSet::new();
+        fn collect_dirs(node: &crate::cache::FileTreeNode, dirs: &mut std::collections::HashSet<std::path::PathBuf>) {
+            if node.is_dir {
+                dirs.insert(node.path.clone());
+            }
+            for child in &node.children {
+                collect_dirs(child, dirs);
+            }
+        }
+        for root in &self.cache.file_tree {
+            collect_dirs(root, &mut valid_dirs);
+        }
+
+        // Remove invalid paths from expanded_dirs
+        let original_len = self.expanded_dirs.len();
+        self.expanded_dirs.retain(|path| valid_dirs.contains(path));
+
+        if self.expanded_dirs.len() < original_len {
+            tracing::info!("Cleaned up expanded_dirs: removed {} invalid paths", original_len - self.expanded_dirs.len());
+        }
+    }
+
+    fn cleanup_playlist(&mut self) {
+        // Build a set of valid paths from the cache for fast lookup
+        let mut valid_paths = std::collections::HashSet::new();
+        fn collect_paths(node: &crate::cache::FileTreeNode, paths: &mut std::collections::HashSet<std::path::PathBuf>) {
+            if !node.is_dir {
+                paths.insert(node.path.clone());
+            }
+            for child in &node.children {
+                collect_paths(child, paths);
+            }
+        }
+        for root in &self.cache.file_tree {
+            collect_paths(root, &mut valid_paths);
+        }
+
+        // Check if current file is invalid
+        let current_file_invalid = if let Some(ref current) = self.current_file {
+            !valid_paths.contains(current)
+        } else {
+            false
+        };
+
+        if current_file_invalid {
+            self.current_file = None;
+            tracing::info!("Current playing file was deleted, cleared current_file");
+        }
+
+        // Remove files from playlist that don't exist in cache
+        let original_len = self.playlist.len();
+        self.playlist.retain(|path| valid_paths.contains(path));
+
+        // Adjust indices if playlist was modified
+        if self.playlist.len() < original_len {
+            // Ensure playlist_index is valid
+            if self.playlist_index >= self.playlist.len() && !self.playlist.is_empty() {
+                self.playlist_index = self.playlist.len() - 1;
+            }
+            // Ensure selected_playlist_index is valid
+            if self.selected_playlist_index >= self.playlist.len() && !self.playlist.is_empty() {
+                self.selected_playlist_index = self.playlist.len() - 1;
+            }
+
+            tracing::info!("Cleaned up playlist: removed {} deleted files", original_len - self.playlist.len());
+        }
     }
 
     pub fn rebuild_flattened_items(&mut self) {

src/ui/mod.rs

@@ -28,24 +28,60 @@ pub fn render(frame: &mut Frame, state: &mut AppState, player: &mut Player) -> (
         ])
         .split(frame.area());
 
-    // Main content: left (files) | right (status + playlist)
+    // Always use tab mode - show only the focused panel
-    // Switch proportions based on focus: 80/20 for focused panel
+    let tab_mode = true;
-    let (left_percent, right_percent) = if state.focus_playlist {
+
-        (20, 80) // Playlist focused: small file panel, large playlist
+    // Build the title with focused panel in bold
+    let file_style = if !state.focus_playlist {
+        Style::default().fg(Theme::bright_foreground()).add_modifier(Modifier::BOLD)
     } else {
-        (80, 20) // File panel focused: large file panel, small playlist
+        Style::default().fg(Theme::bright_foreground())
     };
 
-    let content_chunks = Layout::default()
+    let playlist_style = if state.focus_playlist {
-        .direction(Direction::Horizontal)
+        Style::default().fg(Theme::bright_foreground()).add_modifier(Modifier::BOLD)
-        .constraints([Constraint::Percentage(left_percent), Constraint::Percentage(right_percent)])
+    } else {
-        .split(main_chunks[1]);
+        Style::default().fg(Theme::bright_foreground())
+    };
+
+    // Add playlist counter
+    let playlist_text = if !state.playlist.is_empty() {
+        format!("Playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
+    } else {
+        "Playlist (empty)".to_string()
+    };
+
+    let title = Line::from(vec![
+        Span::styled("Files", file_style),
+        Span::raw(" | "),
+        Span::styled(playlist_text, playlist_style),
+    ]);
+
+    // Create one border around the entire content area
+    let main_block = Block::default()
+        .borders(Borders::ALL)
+        .title(title)
+        .style(Theme::widget_border_style());
+
+    let inner_area = main_block.inner(main_chunks[1]);
 
     render_title_bar(frame, state, player, main_chunks[0]);
-    render_file_panel(frame, state, content_chunks[0]);
+    frame.render_widget(main_block, main_chunks[1]);
-    render_right_panel(frame, state, content_chunks[1]);
+
+    // Tab mode - show only focused panel
+    if state.focus_playlist {
+        render_right_panel(frame, state, inner_area, tab_mode);
+    } else {
+        render_file_panel(frame, state, inner_area, tab_mode);
+    }
+
     render_status_bar(frame, state, player, main_chunks[2]);
 
+    // Show refreshing popup if scanning
+    if state.is_refreshing {
+        render_info_popup(frame, "Refreshing library...");
+    }
+
     // Show confirmation popup if needed
     if state.show_refresh_confirm {
         render_confirm_popup(frame, "Refresh library?", "This may take a while");
@@ -57,7 +93,12 @@ pub fn render(frame: &mut Frame, state: &mut AppState, player: &mut Player) -> (
     }
 
     // Return title bar area, file panel area, and playlist area for mouse event handling
-    (main_chunks[0], content_chunks[0], content_chunks[1])
+    // Use main_chunks[1] (full area) so mouse coordinates align properly
+    if state.focus_playlist {
+        (main_chunks[0], Rect::default(), main_chunks[1])
+    } else {
+        (main_chunks[0], main_chunks[1], Rect::default())
+    }
 }
 
 fn highlight_search_matches<'a>(text: &str, query: &str, is_selected: bool) -> Vec<Span<'a>> {
@@ -115,9 +156,9 @@ fn highlight_search_matches<'a>(text: &str, query: &str, is_selected: bool) -> V
     spans
 }
 
-fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
+fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect, _tab_mode: bool) {
-    // Calculate visible height (subtract 2 for borders)
+    // Calculate visible height (no borders on individual panels now)
-    let visible_height = area.height.saturating_sub(2) as usize;
+    let visible_height = area.height as usize;
     // Store visible height for keyboard navigation scroll calculations
     state.file_panel_visible_height = visible_height;
 
@@ -233,14 +274,7 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
         items.push(more_item);
     }
 
-    let list = List::new(items)
+    let list = List::new(items);
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .title("files")
-                .style(Theme::widget_border_style())
-                .title_style(Theme::title_style()),
-        );
 
     let mut list_state = ListState::default();
     // Don't set selection to avoid automatic scrolling - we manage scroll manually
@@ -249,9 +283,9 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
     frame.render_stateful_widget(list, area, &mut list_state);
 }
 
-fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
+fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect, _tab_mode: bool) {
-    // Calculate visible height (subtract 2 for borders)
+    // Calculate visible height (no borders on individual panels now)
-    let visible_height = area.height.saturating_sub(2) as usize;
+    let visible_height = area.height as usize;
     // Store visible height for keyboard navigation scroll calculations
     state.playlist_visible_height = visible_height;
 
@@ -292,12 +326,17 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
             let is_selected = state.focus_playlist && idx == state.selected_playlist_index;
             let is_playing = idx == state.playlist_index;
 
+            // Add playing indicator arrow
+            let indicator = if is_playing { "▸ " } else { "  " };
+
             // Build line with search highlighting if searching
-            let line = if in_playlist_search && !playlist_search_query.is_empty() {
+            let mut line_spans = vec![Span::raw(indicator)];
-                Line::from(highlight_search_matches(&filename, &playlist_search_query, is_selected))
+            if in_playlist_search && !playlist_search_query.is_empty() {
+                line_spans.extend(highlight_search_matches(&filename, &playlist_search_query, is_selected));
             } else {
-                Line::from(filename)
+                line_spans.push(Span::raw(filename));
-            };
+            }
+            let line = Line::from(line_spans);
 
             let style = if is_selected && is_playing {
                 // Both selected and playing: selection bar with bold
@@ -335,20 +374,7 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
         playlist_items.push(more_item);
     }
 
-    let playlist_title = if !state.playlist.is_empty() {
+    let playlist_widget = List::new(playlist_items);
-        format!("playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
-    } else {
-        "playlist (empty)".to_string()
-    };
-
-    let playlist_widget = List::new(playlist_items)
-        .block(
-            Block::default()
-                .borders(Borders::ALL)
-                .title(playlist_title)
-                .style(Theme::widget_border_style())
-                .title_style(Theme::title_style()),
-        );
 
     let mut playlist_state = ListState::default();
     // Don't set selection to avoid automatic scrolling - we manage scroll manually
@@ -388,16 +414,7 @@ fn render_title_bar(frame: &mut Frame, state: &AppState, player: &mut Player, ar
     // Right side: Status • Progress • Volume • Search (if active)
     let mut right_spans = Vec::new();
 
-    if state.is_refreshing {
+    {
-        // Show only "Refreshing library..." when refreshing
-        right_spans.push(Span::styled(
-            "Refreshing library... ",
-            Style::default()
-                .fg(Theme::background())
-                .bg(background_color)
-                .add_modifier(Modifier::BOLD)
-        ));
-    } else {
         // Status (bold when playing)
         let status_text = match player_state {
             PlayerState::Stopped => "Stopped",
@@ -590,23 +607,9 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, player: &mut Player, a
 
 fn render_progress_bar(frame: &mut Frame, _state: &AppState, player: &mut Player, area: Rect, progress_percent: f64) {
     // Get metadata to display
-    let mut left_parts = Vec::new();
     let mut right_parts = Vec::new();
 
-    // Left side: Artist | Album | Title
+    // Right side: Bitrate | Codec | Sample rate (metrics that must always be visible)
-    if let Some(ref artist) = player.artist {
-        left_parts.push(artist.clone());
-    }
-
-    if let Some(ref album) = player.album {
-        left_parts.push(album.clone());
-    }
-
-    if let Some(ref title) = player.media_title {
-        left_parts.push(title.clone());
-    }
-
-    // Right side: Bitrate | Codec | Sample rate | Cache
     if let Some(bitrate) = player.audio_bitrate {
         right_parts.push(format!("{:.0} kbps", bitrate));
     }
@@ -619,21 +622,59 @@ fn render_progress_bar(frame: &mut Frame, _state: &AppState, player: &mut Player
         right_parts.push(format!("{} Hz", samplerate));
     }
 
-    // Build text parts
+    // Build right text
-    let left_text = if !left_parts.is_empty() {
-        format!(" {}", left_parts.join(" | "))
-    } else {
-        String::new()
-    };
-
     let right_text = if !right_parts.is_empty() {
         format!("{} ", right_parts.join(" | "))
     } else {
         String::new()
     };
 
-    // Calculate filled width based on progress
+    // Calculate available space
     let total_width = area.width as usize;
+    let right_text_len = right_text.chars().count();
+
+    // Reserve space: 1 char at start, gap between left and right
+    let available_for_left = total_width.saturating_sub(right_text_len).saturating_sub(2);
+
+    // Collect left side metadata
+    let mut left_fields = Vec::new();
+    if let Some(ref artist) = player.artist {
+        left_fields.push(("artist", artist.as_str()));
+    }
+    if let Some(ref album) = player.album {
+        left_fields.push(("album", album.as_str()));
+    }
+    if let Some(ref title) = player.media_title {
+        left_fields.push(("title", title.as_str()));
+    }
+
+    // Calculate space per field (divide available space among fields)
+    let left_text = if !left_fields.is_empty() {
+        let num_fields = left_fields.len();
+        let separator_space = (num_fields - 1) * 3; // " | " between fields
+        let available_for_fields = available_for_left.saturating_sub(separator_space);
+        let max_per_field = available_for_fields / num_fields;
+
+        // Truncate each field individually
+        let truncated_fields: Vec<String> = left_fields.iter().map(|(_name, value)| {
+            if value.chars().count() > max_per_field && max_per_field > 3 {
+                let mut s: String = value.chars().take(max_per_field - 3).collect();
+                s.push_str("...");
+                s
+            } else if value.chars().count() > max_per_field {
+                // Very tight space, just cut hard
+                value.chars().take(max_per_field).collect()
+            } else {
+                value.to_string()
+            }
+        }).collect();
+
+        format!(" {}", truncated_fields.join(" | "))
+    } else {
+        String::new()
+    };
+
+    // Calculate filled width based on progress
     let filled_width = (total_width as f64 * progress_percent) as usize;
 
     // Build the full line character by character with proper spacing
@@ -679,6 +720,42 @@ fn render_progress_bar(frame: &mut Frame, _state: &AppState, player: &mut Player
     frame.render_widget(progress_widget, area);
 }
 
+fn render_info_popup(frame: &mut Frame, message: &str) {
+    // Create centered popup area - smaller than confirm popup
+    let area = frame.area();
+    let popup_width = 40;
+    let popup_height = 3;
+
+    let popup_area = Rect {
+        x: (area.width.saturating_sub(popup_width)) / 2,
+        y: (area.height.saturating_sub(popup_height)) / 2,
+        width: popup_width.min(area.width),
+        height: popup_height.min(area.height),
+    };
+
+    // Use Clear widget to completely erase the background
+    frame.render_widget(Clear, popup_area);
+
+    // Render the popup block with solid background
+    let block = Block::default()
+        .borders(Borders::ALL)
+        .style(Style::default()
+            .bg(Theme::background())
+            .fg(Theme::bright_foreground()));
+
+    let inner = block.inner(popup_area);
+    frame.render_widget(block, popup_area);
+
+    // Render message centered
+    let message_widget = Paragraph::new(message)
+        .alignment(Alignment::Center)
+        .style(Style::default()
+            .fg(Theme::bright_foreground())
+            .bg(Theme::background()));
+
+    frame.render_widget(message_widget, inner);
+}
+
 fn render_confirm_popup(frame: &mut Frame, title: &str, message: &str) {
     // Create centered popup area
     let area = frame.area();

src/ui/theme.rs

@@ -47,10 +47,6 @@ impl Theme {
         Self::dim_foreground()
     }
 
-    pub fn border_title() -> Color {
-        Self::bright_foreground()
-    }
-
     pub fn highlight() -> Color {
         Self::normal_blue()
     }
@@ -68,12 +64,6 @@ impl Theme {
         Style::default().fg(Self::border()).bg(Self::background())
     }
 
-    pub fn title_style() -> Style {
-        Style::default()
-            .fg(Self::border_title())
-            .bg(Self::background())
-    }
-
     pub fn secondary() -> Style {
         Style::default()
             .fg(Self::secondary_text())