feat(tui): tabbed browsing — browse several users at once

Replace the single browse view with BrowseTabs (one tab per user),
mirroring the chat-room tabs. Browsing a new user (from search results
or a chat room's member list) opens or focuses their tab; Tab/Shift-Tab
switch between open users, 'w' closes the active tab, Esc hides the
popup while keeping the tabs. A tab bar shows the open users when more
than one is open, and each tab polls/loads independently. Re-browsing a
timed-out user retries. BrowseTabs is unit-tested.

soulseek-rs/src/models/app_state.rs

@@ -1,4 +1,4 @@
-use crate::models::{BrowseState, FileDisplayData, RoomsState};
+use crate::models::{BrowseTabs, FileDisplayData, RoomsState};
 use ratatui::{layout::Rect, widgets::TableState};
 use soulseek_rs::{DownloadStatus, types::Download};
 use std::sync::atomic::AtomicBool;
@@ -94,8 +94,8 @@ pub struct AppState {
     /// Incoming private messages received while the inbox was closed.
     pub unread_messages: usize,
 
-    // Browse a user's shared files
-    pub browse: Option<BrowseState>,
+    // Browse users' shared files (one tab per user)
+    pub browse: BrowseTabs,
     pub show_browse: bool,
     pub browse_table_state: TableState,
 
@@ -151,7 +151,7 @@ impl AppState {
             show_messages: false,
             unread_messages: 0,
 
-            browse: None,
+            browse: BrowseTabs::new(),
             show_browse: false,
             browse_table_state: TableState::default(),
 

soulseek-rs/src/models/browse.rs

@@ -319,6 +319,82 @@ impl BrowseState {
     }
 }
 
+/// A set of open browse views (tabs), one per user, like the chat-room tabs.
+#[derive(Default)]
+pub struct BrowseTabs {
+    pub tabs: Vec<BrowseState>,
+    pub active: usize,
+}
+
+impl BrowseTabs {
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            tabs: Vec::new(),
+            active: 0,
+        }
+    }
+
+    #[must_use]
+    pub const fn is_empty(&self) -> bool {
+        self.tabs.is_empty()
+    }
+
+    #[must_use]
+    pub fn active_tab(&self) -> Option<&BrowseState> {
+        self.tabs.get(self.active)
+    }
+
+    #[must_use]
+    pub fn active_tab_mut(&mut self) -> Option<&mut BrowseState> {
+        self.tabs.get_mut(self.active)
+    }
+
+    /// Focus the tab for `username`, or open a fresh loading one. Returns
+    /// `true` if the caller should (re)issue a browse request — i.e. the tab is
+    /// new or was retried after a timeout.
+    pub fn open(&mut self, username: &str) -> bool {
+        if let Some(idx) = self.tabs.iter().position(|t| t.username == username)
+        {
+            self.active = idx;
+            // Re-request only if the previous attempt gave up.
+            if self.tabs[idx].status == BrowseStatus::TimedOut {
+                self.tabs[idx] = BrowseState::loading(username.to_string());
+                true
+            } else {
+                false
+            }
+        } else {
+            self.tabs.push(BrowseState::loading(username.to_string()));
+            self.active = self.tabs.len() - 1;
+            true
+        }
+    }
+
+    /// Close the active tab, returning `false` when no tabs remain.
+    pub fn close_active(&mut self) -> bool {
+        if self.active < self.tabs.len() {
+            self.tabs.remove(self.active);
+        }
+        if self.active >= self.tabs.len() {
+            self.active = self.tabs.len().saturating_sub(1);
+        }
+        !self.tabs.is_empty()
+    }
+
+    pub const fn next_tab(&mut self) {
+        if !self.tabs.is_empty() {
+            self.active = (self.active + 1) % self.tabs.len();
+        }
+    }
+
+    pub const fn prev_tab(&mut self) {
+        if !self.tabs.is_empty() {
+            self.active = (self.active + self.tabs.len() - 1) % self.tabs.len();
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -427,6 +503,48 @@ mod tests {
         assert_eq!(all.len(), 3);
     }
 
+    #[test]
+    fn browse_tabs_open_focus_close_and_cycle() {
+        let mut tabs = BrowseTabs::new();
+        assert!(tabs.is_empty());
+
+        // New users open new tabs and request a browse.
+        assert!(tabs.open("alice"));
+        assert!(tabs.open("bob"));
+        assert_eq!(tabs.tabs.len(), 2);
+        assert_eq!(tabs.active, 1);
+        assert_eq!(tabs.active_tab().unwrap().username, "bob");
+
+        // Re-opening a live tab just focuses it (no new request).
+        assert!(!tabs.open("alice"));
+        assert_eq!(tabs.active, 0);
+        assert_eq!(tabs.tabs.len(), 2);
+
+        // Cycling wraps.
+        tabs.next_tab();
+        assert_eq!(tabs.active, 1);
+        tabs.next_tab();
+        assert_eq!(tabs.active, 0);
+        tabs.prev_tab();
+        assert_eq!(tabs.active, 1);
+
+        // Closing the active tab returns whether any remain.
+        assert!(tabs.close_active());
+        assert_eq!(tabs.tabs.len(), 1);
+        assert!(!tabs.close_active());
+        assert!(tabs.is_empty());
+    }
+
+    #[test]
+    fn browse_tabs_reopen_after_timeout_requests_again() {
+        let mut tabs = BrowseTabs::new();
+        tabs.open("alice");
+        tabs.active_tab_mut().unwrap().status = BrowseStatus::TimedOut;
+        // Re-opening a timed-out tab retries (returns true) and resets it.
+        assert!(tabs.open("alice"));
+        assert_eq!(tabs.active_tab().unwrap().status, BrowseStatus::Loading);
+    }
+
     #[test]
     fn browse_state_load_auto_expands_top_level() {
         let mut state = BrowseState::loading("bob".to_string());

soulseek-rs/src/models/mod.rs

@@ -7,6 +7,8 @@ pub use app_state::{
     AppState, ChatMessage, CommandBarMode, DownloadEntry, FocusedPane,
     MessageDirection, SearchEntry, SearchStatus,
 };
-pub use browse::{BrowseState, BrowseStatus, files_under, find_node};
+pub use browse::{
+    BrowseState, BrowseStatus, BrowseTabs, files_under, find_node,
+};
 pub use file_display_data::FileDisplayData;
 pub use rooms::{RoomLine, RoomsState, RoomsView};