Fixed liked track sorting

.github/workflows/release.yml

@@ -10,6 +10,7 @@ permissions:
 
 env:
   CARGO_TERM_COLOR: always
+  CARGO_NET_RETRY: 10
 
 jobs:
   build:
@@ -43,8 +44,11 @@ jobs:
       - name: Show Rust version
         run: rustc --version && cargo --version
 
+      - name: Fetch locked dependencies
+        run: cargo fetch --locked
+
       - name: Build
-        run: cargo build --release --locked
+        run: cargo build --release --locked --offline
 
       - name: Package
         shell: bash

AGENTS.md

@@ -29,7 +29,7 @@ Preserve these architectural invariants:
 
 ## Toolchain and checks
 
-The crate uses Rust edition 2024 and Rust 1.88 or newer.
+The crate uses Rust edition 2024 and Rust 1.97 or newer.
 
 Run the checks relevant to every code change:
 

Cargo.lock

@@ -1084,7 +1084,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccc2776f0c61eca1ca32528f85548abd1a4be8fb53d1b21c013e4f18da1e7090"
 dependencies = [
  "data-encoding",
- "syn 2.0.119",
+ "syn 1.0.109",
 ]
 
 [[package]]
@@ -1188,7 +1188,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1345,7 +1345,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1456,7 +1456,7 @@ dependencies = [
 [[package]]
 name = "federation-net"
 version = "0.1.0"
-source = "git+https://gt.hexor.cy/ab/frid.git#a9012351dcdbdf8dbaa1f5dd71e498b4bc678d99"
+source = "git+https://gt.hexor.cy/ab/frid.git?rev=a9012351dcdbdf8dbaa1f5dd71e498b4bc678d99#a9012351dcdbdf8dbaa1f5dd71e498b4bc678d99"
 dependencies = [
  "blake3",
  "data-encoding",
@@ -1567,7 +1567,7 @@ dependencies = [
 
 [[package]]
 name = "furumi_tui"
-version = "0.1.6"
+version = "0.1.8"
 dependencies = [
  "anyhow",
  "blake3",
@@ -2990,7 +2990,7 @@ dependencies = [
 [[package]]
 name = "music-dht"
 version = "0.1.0"
-source = "git+https://gt.hexor.cy/ab/frid.git#a9012351dcdbdf8dbaa1f5dd71e498b4bc678d99"
+source = "git+https://gt.hexor.cy/ab/frid.git?rev=a9012351dcdbdf8dbaa1f5dd71e498b4bc678d99#a9012351dcdbdf8dbaa1f5dd71e498b4bc678d99"
 dependencies = [
  "async-trait",
  "blake3",
@@ -3315,7 +3315,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3390,7 +3390,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
 dependencies = [
- "proc-macro-crate 3.5.0",
+ "proc-macro-crate",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
@@ -4028,16 +4028,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
 dependencies = [
  "once_cell",
- "toml_edit 0.19.15",
+ "toml_edit",
-]
-
-[[package]]
-name = "proc-macro-crate"
-version = "3.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
-dependencies = [
- "toml_edit 0.25.13+spec-1.1.0",
 ]
 
 [[package]]
@@ -4491,7 +4482,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4549,7 +4540,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4641,7 +4632,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b55fb86dfd3a2f5f76ea78310a88f96c4ea21a3031f8d212443d56123fd0521"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5289,7 +5280,7 @@ dependencies = [
  "getrandom 0.4.3",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5618,18 +5609,6 @@ dependencies = [
  "winnow 0.5.40",
 ]
 
-[[package]]
-name = "toml_edit"
-version = "0.25.13+spec-1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6975367e4d2ef766d86af01ffad14b622fecc8d4357a998fbc4deb6e9bacaf9b"
-dependencies = [
- "indexmap",
- "toml_datetime 1.1.1+spec-1.1.0",
- "toml_parser",
- "winnow 1.0.4",
-]
-
 [[package]]
 name = "toml_parser"
 version = "1.1.2+spec-1.1.0"
@@ -6157,7 +6136,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -6533,9 +6512,6 @@ name = "winnow"
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81"
-dependencies = [
- "memchr",
-]
 
 [[package]]
 name = "wit-bindgen"
@@ -6678,7 +6654,7 @@ version = "3.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7131497b0f887e8061b430c530240063d33bf9455fa34438f388a245da69e0a5"
 dependencies = [
- "proc-macro-crate 1.3.1",
+ "proc-macro-crate",
  "proc-macro2",
  "quote",
  "regex",
@@ -6832,7 +6808,7 @@ version = "3.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37c24dc0bed72f5f90d1f8bb5b07228cbf63b3c6e9f82d82559d4bae666e7ed9"
 dependencies = [
- "proc-macro-crate 1.3.1",
+ "proc-macro-crate",
  "proc-macro2",
  "quote",
  "syn 1.0.109",

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "furumi_tui"
-version = "0.1.6"
+version = "0.1.8"
 edition = "2024"
-rust-version = "1.88"
+rust-version = "1.97"
 description = "A federated P2P player for personal music libraries"
 license = "WTFPL"
 
@@ -21,7 +21,7 @@ image = { version = "0.25.10", default-features = false, features = ["jpeg", "pn
 lofty = "0.22"
 # P2P federation: library index in a shared DHT + audio streaming between
 # peers (same protocol as furumi-fd).
-music-dht = { git = "https://gt.hexor.cy/ab/frid.git" }
+music-dht = { git = "https://gt.hexor.cy/ab/frid.git", rev = "a9012351dcdbdf8dbaa1f5dd71e498b4bc678d99" }
 ratatui = "0.30.1"
 rhai = { version = "1", features = ["sync"] }
 rodio = { version = "0.22.2", default-features = false, features = ["playback", "mp3", "flac", "vorbis", "wav", "symphonia-aac", "symphonia-isomp4", "symphonia-alac"] }

README.md

@@ -71,8 +71,25 @@ without rebuilding the player.
 
 ## Install
 
-Download a prebuilt archive from the project releases, or build Furumi from
+### macOS
-source with Rust 1.97 or newer:
+
+On Apple Silicon Macs, install Furumi from the Homebrew tap:
+
+```bash
+brew install house-of-vanity/tap/furumi
+```
+
+Run it with:
+
+```bash
+furumi
+```
+
+### Linux, Windows, and other platforms
+
+Download a prebuilt archive from the
+[GitHub releases](https://github.com/house-of-vanity/furumi_tui/releases), or
+build Furumi from source with Rust 1.97 or newer:
 
 ```bash
 cargo build --release --locked

src/app/action.rs

@@ -48,6 +48,7 @@ pub enum Action {
     NewPlaylist,
     ToggleHelp,
     ToggleViewMode,
+    CycleSourceMode,
     OpenLibraryFilters,
     OpenCommandLine,
     OpenSearch,
@@ -128,9 +129,10 @@ impl Action {
             | Action::GoToTab(_)
             | Action::GoToRelease
             | Action::ToggleViewMode => Category::Navigation,
-            Action::EditSelected | Action::DeleteSelected | Action::OpenLibraryFilters => {
+            Action::EditSelected
-                Category::Library
+            | Action::DeleteSelected
-            }
+            | Action::CycleSourceMode
+            | Action::OpenLibraryFilters => Category::Library,
             Action::OpenSearch | Action::OpenCommandLine => Category::Search,
             Action::ToggleHelp | Action::Quit => Category::System,
         }
@@ -197,6 +199,7 @@ impl Action {
             Action::NewPlaylist => "Create a playlist".into(),
             Action::ToggleHelp => "Show / hide keybindings".into(),
             Action::ToggleViewMode => "Toggle tiles / table view".into(),
+            Action::CycleSourceMode => "Cycle source mode: Local / My / Global".into(),
             Action::OpenLibraryFilters => "Library filters…".into(),
             Action::OpenCommandLine => "Command line (:help for commands)".into(),
             Action::OpenSearch => "Search artists, releases, tracks".into(),

src/app/mod.rs

@@ -425,14 +425,21 @@ fn apply_playback_state_to_ui(
     wire: &crate::devices::PlaybackStateWire,
     library: Option<&Library>,
 ) {
-    state.player.queue = wire
+    let queue: Vec<_> = wire
         .queue
         .iter()
         .map(|track| playback_track_to_ui(track, library))
         .collect();
-    state.player.queue_pos = wire
+    let queue_pos = queue
-        .queue_pos
+        .iter()
-        .min(state.player.queue.len().saturating_sub(1));
+        .take(wire.queue_pos)
+        .filter(|track| update::track_allowed_by_source_mode(state, track))
+        .count();
+    state.player.queue = queue
+        .into_iter()
+        .filter(|track| update::track_allowed_by_source_mode(state, track))
+        .collect();
+    state.player.queue_pos = queue_pos.min(state.player.queue.len().saturating_sub(1));
     state.player.playing = wire.playing && !state.player.queue.is_empty();
     state.player.paused = wire.paused;
     state.device_playback.local_idle_since_ms = if state.player.playing && !state.player.paused {
@@ -1291,6 +1298,24 @@ fn perform_effect(state: &mut AppState, runtime: &mut Runtime, effect: Effect) {
         }
         Effect::SetOptions => {}
         Effect::PlaybackQueueChanged => {}
+        Effect::SourceModeChanged => {
+            runtime.library_network_refresh_at = None;
+            if let Ok(mut cursors) = runtime.library_network_cursors.lock() {
+                cursors.clear();
+            }
+            if let Ok(mut done) = runtime.library_network_done.lock() {
+                done.clear();
+            }
+            if let Ok(mut attempted) = runtime.library_network_art_attempted.lock() {
+                attempted.clear();
+            }
+            save_app_settings(state);
+            reset_artist_pagination(state);
+            refresh_artists(state, runtime);
+            if let Some(effect) = update::apply_library_filter_change(state) {
+                perform_effect(state, runtime, effect);
+            }
+        }
         Effect::EnqueueRelease { id, next } => {
             let library = Arc::clone(&runtime.library);
             let tx = runtime.event_tx.clone();
@@ -3410,10 +3435,13 @@ fn handle_app_event(state: &mut AppState, runtime: &mut Runtime, event: AppEvent
             });
         }
         AppEvent::EnqueueTracks { tracks, next } => {
-            let count = tracks.len();
+            let previous_len = state.player.queue.len();
             update::enqueue_tracks(state, tracks, next);
+            let count = state.player.queue.len().saturating_sub(previous_len);
             record_control_playback_state(state, runtime, false);
-            state.status_message = Some(if next {
+            state.status_message = Some(if count == 0 {
+                "no tracks available in the current source mode".to_string()
+            } else if next {
                 format!("{count} tracks queued next")
             } else {
                 format!("{count} tracks queued")

src/app/popup.rs

@@ -404,45 +404,26 @@ fn handle_connected_devices(
 fn handle_library_filters(
     state: &mut AppState,
     runtime: &mut Runtime,
-    cursor: usize,
+    _cursor: usize,
     key: KeyEvent,
 ) {
-    let max_cursor = crate::config::settings::LibrarySourceMode::ALL.len();
+    let cursor = 0;
-    let cursor = cursor.min(max_cursor);
     match key.code {
         KeyCode::Esc | KeyCode::Char('q') => {}
         KeyCode::Up | KeyCode::Char('k') => {
-            state.popup = Some(Popup::LibraryFilters {
+            state.popup = Some(Popup::LibraryFilters { cursor: 0 });
-                cursor: cursor.saturating_sub(1),
-            });
         }
         KeyCode::Down | KeyCode::Char('j') => {
-            state.popup = Some(Popup::LibraryFilters {
+            state.popup = Some(Popup::LibraryFilters { cursor: 0 });
-                cursor: (cursor + 1).min(max_cursor),
-            });
         }
         KeyCode::Enter | KeyCode::Char(' ') => {
-            if cursor == 0 {
+            state.global.filters.hide_featured_only = !state.global.filters.hide_featured_only;
-                state.global.filters.hide_featured_only = !state.global.filters.hide_featured_only;
-            } else if let Some(mode) =
-                crate::config::settings::LibrarySourceMode::ALL.get(cursor - 1)
-            {
-                state.global.filters.source_mode = *mode;
-            }
-            runtime.library_network_refresh_at = None;
-            if let Ok(mut cursors) = runtime.library_network_cursors.lock() {
-                cursors.clear();
-            }
-            if let Ok(mut done) = runtime.library_network_done.lock() {
-                done.clear();
-            }
-            if let Ok(mut attempted) = runtime.library_network_art_attempted.lock() {
-                attempted.clear();
-            }
             super::save_app_settings(state);
             super::reset_artist_pagination(state);
             super::refresh_artists(state, runtime);
-            super::update::apply_library_filter_change(state);
+            if let Some(effect) = super::update::apply_library_filter_change(state) {
+                super::perform_effect(state, runtime, effect);
+            }
         }
         _ => state.popup = Some(Popup::LibraryFilters { cursor }),
     }

src/app/update.rs

@@ -48,6 +48,8 @@ pub enum Effect {
     },
     /// Queue/options changed without a direct audio engine action.
     PlaybackQueueChanged,
+    /// Persist and apply a Local / My / Global source-mode change.
+    SourceModeChanged,
     /// Persist the federation settings and start/stop the node.
     FedApplySettings,
     /// Force an immediate library publish into the DHT.
@@ -239,6 +241,18 @@ pub fn update(state: &mut AppState, action: Action) -> Option<Effect> {
             }
             None
         }
+        Action::CycleSourceMode => {
+            if matches!(state.active_tab, Tab::Global | Tab::Playlists | Tab::Queue) {
+                state.global.filters.source_mode = state.global.filters.source_mode.next();
+                state.status_message = Some(format!(
+                    "source mode: {}",
+                    state.global.filters.source_mode.label()
+                ));
+                Some(Effect::SourceModeChanged)
+            } else {
+                None
+            }
+        }
         Action::OpenLibraryFilters => {
             if state.active_tab == Tab::Global {
                 state.popup = Some(super::state::Popup::LibraryFilters { cursor: 0 });
@@ -920,7 +934,7 @@ fn current_track_list_context(state: &AppState) -> Option<(TrackSelectionScope,
     }
 }
 
-fn current_track_list(state: &AppState) -> Option<(TrackSelectionScope, usize, &[TrackItem])> {
+fn current_track_list(state: &AppState) -> Option<(TrackSelectionScope, usize, Vec<&TrackItem>)> {
     match state.active_tab {
         Tab::Global => match state.global.stack.last()? {
             GlobalView::Artist { id, cursor } => match state.artist_views.get(id)? {
@@ -931,23 +945,25 @@ fn current_track_list(state: &AppState) -> Option<(TrackSelectionScope, usize, &
                         Some((
                             TrackSelectionScope::ArtistTop(*id),
                             *cursor,
-                            &detail.top_tracks,
+                            detail.top_tracks.iter().collect(),
                         ))
                     } else {
                         let featured = cursor.checked_sub(tracks + releases)?;
                         (featured < detail.featured_tracks.len()).then_some((
                             TrackSelectionScope::ArtistFeatured(*id),
                             featured,
-                            &detail.featured_tracks,
+                            detail.featured_tracks.iter().collect(),
                         ))
                     }
                 }
                 _ => None,
             },
             GlobalView::Release { id, cursor } => match state.release_views.get(id)? {
-                Loadable::Ready(detail) => {
+                Loadable::Ready(detail) => Some((
-                    Some((TrackSelectionScope::Release(*id), *cursor, &detail.tracks))
+                    TrackSelectionScope::Release(*id),
-                }
+                    *cursor,
+                    detail.tracks.iter().collect(),
+                )),
                 _ => None,
             },
             _ => None,
@@ -963,7 +979,7 @@ fn current_track_list(state: &AppState) -> Option<(TrackSelectionScope, usize, &
         Tab::Queue => Some((
             TrackSelectionScope::Queue,
             state.queue_tab.cursor,
-            &state.player.queue,
+            state.player.queue.iter().collect(),
         )),
         Tab::Federation | Tab::Logs => None,
     }
@@ -987,7 +1003,7 @@ pub fn selected_tracks(state: &AppState) -> Vec<TrackItem> {
         .unwrap_or_else(|| vec![cursor.min(tracks.len().saturating_sub(1))]);
     indices
         .into_iter()
-        .filter_map(|index| tracks.get(index).cloned())
+        .filter_map(|index| tracks.get(index).map(|track| (*track).clone()))
         .collect()
 }
 
@@ -1175,21 +1191,32 @@ pub fn selected_track(state: &AppState) -> Option<TrackItem> {
             let opened = state.playlists.opened.as_ref()?;
             playlist_tracks(state, opened.id)?
                 .get(opened.cursor)
-                .cloned()
+                .map(|track| (*track).clone())
         }
         Tab::Queue => state.player.queue.get(state.queue_tab.cursor).cloned(),
         Tab::Federation | Tab::Logs => None,
     }
 }
 
-/// Tracks backing an opened playlist, if loaded.
+/// Visible tracks backing an opened playlist. Local mode excludes pending
-pub fn playlist_tracks(state: &AppState, id: i64) -> Option<&Vec<TrackItem>> {
+/// federation entries so they cannot be selected or copied into playback.
+pub fn playlist_tracks(state: &AppState, id: i64) -> Option<Vec<&TrackItem>> {
     match state.playlist_views.get(&id)? {
-        Loadable::Ready(detail) => Some(&detail.tracks),
+        Loadable::Ready(detail) => Some(
+            detail
+                .tracks
+                .iter()
+                .filter(|track| track_allowed_by_source_mode(state, track))
+                .collect(),
+        ),
         _ => None,
     }
 }
 
+pub(crate) fn track_allowed_by_source_mode(state: &AppState, track: &TrackItem) -> bool {
+    state.global.filters.source_mode.includes_network() || !track.is_fed_pending()
+}
+
 /// A *release* under the cursor (artist-view tile/row or a search release).
 fn selected_release_id(state: &AppState) -> Option<i64> {
     if state.active_tab != Tab::Global {
@@ -1334,6 +1361,10 @@ pub(crate) fn track_artist_refs(track: &TrackItem) -> Vec<crate::library::models
 /// Insert tracks after the playing one (`next`) or at the end. Keeps the
 /// gapless prefetch index pointing at the same track if items shift.
 pub fn enqueue_tracks(state: &mut AppState, tracks: Vec<TrackItem>, next: bool) {
+    let tracks: Vec<_> = tracks
+        .into_iter()
+        .filter(|track| track_allowed_by_source_mode(state, track))
+        .collect();
     let player = &mut state.player;
     if tracks.is_empty() {
         return;
@@ -1790,7 +1821,7 @@ fn set_view_cursor(state: &mut AppState, value: usize) {
 /// Items in the playlists tab's current view (list or opened playlist).
 fn playlists_view_len(state: &AppState) -> usize {
     match &state.playlists.opened {
-        Some(opened) => playlist_tracks(state, opened.id).map_or(0, Vec::len),
+        Some(opened) => playlist_tracks(state, opened.id).map_or(0, |tracks| tracks.len()),
         None => match &state.playlists.list {
             Some(Loadable::Ready(list)) => list.len(),
             _ => 0,
@@ -1832,7 +1863,7 @@ fn current_view_len(state: &AppState) -> usize {
     }
 }
 
-pub(crate) fn apply_library_filter_change(state: &mut AppState) {
+pub(crate) fn apply_library_filter_change(state: &mut AppState) -> Option<Effect> {
     state.track_selection.clear();
     let len = current_view_len(state);
     if state.active_tab == Tab::Global {
@@ -1848,11 +1879,32 @@ pub(crate) fn apply_library_filter_change(state: &mut AppState) {
             };
             *cursor = (*cursor).min(len.saturating_sub(1));
         }
+    } else if state.active_tab == Tab::Playlists
+        && let Some(opened) = &mut state.playlists.opened
+    {
+        opened.cursor = opened.cursor.min(len.saturating_sub(1));
     }
 
     if state.global.filters.source_mode.includes_network() {
-        return;
+        return None;
     }
+    let remote_indices: Vec<_> = state
+        .player
+        .queue
+        .iter()
+        .enumerate()
+        .filter_map(|(index, track)| track.is_fed_pending().then_some(index))
+        .collect();
+    let queue_effect = if remote_indices.is_empty() {
+        None
+    } else {
+        let outcome = remove_queue_indices(state, &remote_indices);
+        Some(Effect::RemoveQueueIndices {
+            indices: remote_indices,
+            restart_paused: outcome.restart_paused,
+            stop: outcome.stop,
+        })
+    };
     let message = match state.global.stack.last() {
         Some(GlobalView::Artist { id, .. }) => match state.artist_views.get(id) {
             Some(Loadable::Ready(detail))
@@ -1885,6 +1937,7 @@ pub(crate) fn apply_library_filter_change(state: &mut AppState) {
     if let Some(message) = message {
         state.status_message = Some(message);
     }
+    queue_effect
 }
 
 fn jump_selection(state: &mut AppState, first: bool) {
@@ -1954,7 +2007,10 @@ fn jump_selection(state: &mut AppState, first: bool) {
 fn select_playlist(state: &mut AppState) -> Option<Effect> {
     match state.playlists.opened {
         Some(opened) => {
-            let tracks = playlist_tracks(state, opened.id)?.clone();
+            let tracks: Vec<_> = playlist_tracks(state, opened.id)?
+                .into_iter()
+                .cloned()
+                .collect();
             if tracks.is_empty() {
                 return None;
             }

src/app/update_tests.rs

@@ -41,6 +41,23 @@ fn test_track(id: i64) -> TrackItem {
     }
 }
 
+fn pending_fed_track(id: i64) -> TrackItem {
+    crate::federation::pending_track(&crate::federation::FedTrack {
+        item_id: format!("fed-{id}"),
+        owner: "peer".into(),
+        own: false,
+        title: format!("remote-{id}"),
+        artist_names: vec!["remote artist".into()],
+        featured_artist_names: vec![],
+        year: None,
+        duration_seconds: Some(1),
+        content_id: Some(format!("b3:{id:064x}")),
+        release_title: Some("remote release".into()),
+        track_number: None,
+        disc_number: None,
+    })
+}
+
 #[test]
 fn quit_needs_double_press() {
     let mut state = AppState::default();
@@ -115,6 +132,36 @@ fn library_filters_popup_opens_on_library_screens() {
     assert!(state.popup.is_none());
 }
 
+#[test]
+fn source_mode_cycles_on_library_playlists_and_queue_tabs() {
+    use crate::config::settings::LibrarySourceMode;
+
+    let mut state = AppState::default();
+    assert_eq!(
+        update(&mut state, Action::CycleSourceMode),
+        Some(Effect::SourceModeChanged)
+    );
+    assert_eq!(state.global.filters.source_mode, LibrarySourceMode::My);
+
+    state.active_tab = Tab::Playlists;
+    assert_eq!(
+        update(&mut state, Action::CycleSourceMode),
+        Some(Effect::SourceModeChanged)
+    );
+    assert_eq!(state.global.filters.source_mode, LibrarySourceMode::Global);
+
+    state.active_tab = Tab::Queue;
+    assert_eq!(
+        update(&mut state, Action::CycleSourceMode),
+        Some(Effect::SourceModeChanged)
+    );
+    assert_eq!(state.global.filters.source_mode, LibrarySourceMode::Local);
+
+    state.active_tab = Tab::Federation;
+    assert_eq!(update(&mut state, Action::CycleSourceMode), None);
+    assert_eq!(state.global.filters.source_mode, LibrarySourceMode::Local);
+}
+
 #[test]
 fn back_closes_help_first() {
     let mut state = AppState::default();
@@ -387,6 +434,118 @@ fn queue_tab_select_and_clear() {
     assert!(!state.player.playing);
 }
 
+#[test]
+fn local_mode_hides_pending_federation_tracks_from_playlists_and_playback() {
+    let mut state = AppState {
+        active_tab: Tab::Playlists,
+        ..AppState::default()
+    };
+    state.playlists.opened = Some(OpenedPlaylist { id: 7, cursor: 1 });
+    state.playlist_views.insert(
+        7,
+        Loadable::Ready(crate::library::models::PlaylistDetail {
+            id: 7,
+            title: "mixed".into(),
+            description: None,
+            tracks: vec![test_track(1), pending_fed_track(2), test_track(3)],
+        }),
+    );
+
+    assert_eq!(
+        playlist_tracks(&state, 7)
+            .unwrap()
+            .iter()
+            .map(|track| track.id)
+            .collect::<Vec<_>>(),
+        vec![1, 3]
+    );
+    assert_eq!(
+        update(&mut state, Action::Select),
+        Some(Effect::PlayCurrent)
+    );
+    assert_eq!(
+        state
+            .player
+            .queue
+            .iter()
+            .map(|track| track.id)
+            .collect::<Vec<_>>(),
+        vec![1, 3]
+    );
+    assert_eq!(state.player.queue_pos, 1);
+}
+
+#[test]
+fn network_modes_show_pending_federation_playlist_tracks() {
+    let mut state = AppState::default();
+    state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::My;
+    state.playlist_views.insert(
+        7,
+        Loadable::Ready(crate::library::models::PlaylistDetail {
+            id: 7,
+            title: "mixed".into(),
+            description: None,
+            tracks: vec![test_track(1), pending_fed_track(2)],
+        }),
+    );
+
+    assert_eq!(playlist_tracks(&state, 7).unwrap().len(), 2);
+}
+
+#[test]
+fn local_mode_rejects_async_federation_queue_additions() {
+    let mut state = AppState::default();
+
+    enqueue_tracks(
+        &mut state,
+        vec![test_track(1), pending_fed_track(2), test_track(3)],
+        false,
+    );
+
+    assert_eq!(
+        state
+            .player
+            .queue
+            .iter()
+            .map(|track| track.id)
+            .collect::<Vec<_>>(),
+        vec![1, 3]
+    );
+}
+
+#[test]
+fn switching_to_local_mode_removes_pending_federation_queue_tracks() {
+    let mut state = AppState::default();
+    state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::My;
+    state.player.queue = vec![test_track(1), pending_fed_track(2), test_track(3)];
+    state.player.queue_pos = 1;
+    state.player.current = Some(state.player.queue[1].clone());
+    state.player.playing = true;
+    state.global.filters.source_mode = crate::config::settings::LibrarySourceMode::Local;
+
+    let effect = apply_library_filter_change(&mut state);
+
+    assert!(matches!(
+        effect,
+        Some(Effect::RemoveQueueIndices {
+            indices,
+            restart_paused: Some(false),
+            stop: false,
+        }) if indices == vec![1]
+    ));
+    assert_eq!(
+        state
+            .player
+            .queue
+            .iter()
+            .map(|track| track.id)
+            .collect::<Vec<_>>(),
+        vec![1, 3]
+    );
+    assert_eq!(state.player.queue_pos, 1);
+    assert_eq!(state.player.current.as_ref().map(|track| track.id), Some(3));
+}
+
 #[test]
 fn current_track_info_uses_now_playing_track() {
     let mut state = AppState {

src/config/default_keymap.toml

@@ -225,6 +225,10 @@ command = "DeleteSelected"
 key_sequence = "v"
 command = "ToggleViewMode"
 
+[[keymaps]]
+key_sequence = "m"
+command = "CycleSourceMode"
+
 [[keymaps]]
 key_sequence = "f"
 command = "OpenLibraryFilters"

src/config/keymap.rs

@@ -426,6 +426,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn default_source_mode_key_resolves_on_content_tabs() {
+        let mut km = keymap_from(DEFAULT_KEYMAP);
+        for context in [
+            KeyContext::Library,
+            KeyContext::Playlists,
+            KeyContext::Queue,
+        ] {
+            assert_eq!(
+                km.resolve(key!(m), context),
+                KeyResolution::Action(Action::CycleSourceMode)
+            );
+        }
+    }
+
     #[test]
     fn default_shift_n_is_unbound() {
         let mut km = keymap_from(DEFAULT_KEYMAP);

src/config/settings.rs

@@ -11,12 +11,6 @@ pub enum LibrarySourceMode {
 }
 
 impl LibrarySourceMode {
-    pub const ALL: [LibrarySourceMode; 3] = [
-        LibrarySourceMode::Local,
-        LibrarySourceMode::My,
-        LibrarySourceMode::Global,
-    ];
-
     pub fn label(self) -> &'static str {
         match self {
             LibrarySourceMode::Local => "Local",
@@ -25,14 +19,6 @@ impl LibrarySourceMode {
         }
     }
 
-    pub fn description(self) -> &'static str {
-        match self {
-            LibrarySourceMode::Local => "only this device",
-            LibrarySourceMode::My => "this device + connected devices",
-            LibrarySourceMode::Global => "my devices + known federation peers",
-        }
-    }
-
     pub fn includes_network(self) -> bool {
         !matches!(self, LibrarySourceMode::Local)
     }
@@ -40,6 +26,14 @@ impl LibrarySourceMode {
     pub fn includes_global_peers(self) -> bool {
         matches!(self, LibrarySourceMode::Global)
     }
+
+    pub fn next(self) -> Self {
+        match self {
+            LibrarySourceMode::Local => LibrarySourceMode::My,
+            LibrarySourceMode::My => LibrarySourceMode::Global,
+            LibrarySourceMode::Global => LibrarySourceMode::Local,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -50,12 +44,6 @@ pub struct LibraryFilters {
     pub source_mode: LibrarySourceMode,
 }
 
-impl LibraryFilters {
-    pub fn is_active(&self) -> bool {
-        self.hide_featured_only || self.source_mode != LibrarySourceMode::Local
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct AppSettings {
     #[serde(default = "default_volume")]
@@ -140,7 +128,6 @@ hide_featured_only = true
 
         assert_eq!(settings.volume, 100);
         assert!(settings.library.hide_featured_only);
-        assert!(settings.library.is_active());
         assert_eq!(settings.library.source_mode, LibrarySourceMode::Local);
     }
 }

src/library/mod.rs

@@ -1201,7 +1201,11 @@ impl Library {
                         .get(&track.id)
                         .copied()
                         .unwrap_or_default();
-                    (liked_at, track.title.clone(), track)
+                    let stable_key = track
+                        .content_id
+                        .clone()
+                        .unwrap_or_else(|| format!("local:{:020}", track.id));
+                    (liked_at, stable_key, track)
                 })
                 .collect();
 
@@ -1218,11 +1222,11 @@ impl Library {
             })?;
             for row in fed_rows {
                 let (liked_at, fed) = row?;
-                entries.push((
+                let stable_key = fed
-                    liked_at,
+                    .content_id
-                    fed.title.clone(),
+                    .clone()
-                    crate::federation::pending_track(&fed),
+                    .unwrap_or_else(|| format!("fed:{}", fed.item_id));
-                ));
+                entries.push((liked_at, stable_key, crate::federation::pending_track(&fed)));
             }
             entries.sort_by(|left, right| right.0.cmp(&left.0).then_with(|| left.1.cmp(&right.1)));
             return Ok(PlaylistDetail {

src/ui/global.rs

@@ -383,15 +383,15 @@ fn draw_grid(frame: &mut Frame, area: Rect, state: &AppState) {
     let global = &state.global;
     let title = if global.total > 0 {
         format!(
-            " Library — {} artists · {} ",
+            " Library — {} artists · Mode: {} ",
             global.total,
             global.filters.source_mode.label()
         )
     } else {
-        format!(" Library · {} ", global.filters.source_mode.label())
+        format!(" Library · Mode: {} ", global.filters.source_mode.label())
     };
     let mut title_spans = vec![Span::styled(title, theme::tab_active_for(state))];
-    if global.filters.is_active() {
+    if global.filters.hide_featured_only {
         title_spans.push(Span::raw(" "));
         title_spans.push(Span::styled(" FILTERED ", theme::tab_active_for(state)));
     }

src/ui/mod.rs

@@ -247,8 +247,9 @@ fn draw_queue(frame: &mut Frame, area: Rect, state: &AppState) {
     let player = &state.player;
     let block = Block::bordered()
         .title(format!(
-            " Queue — {} tracks · enter: play · d: remove · shift-v: select · :clear ",
+            " Queue — {} tracks · Mode: {} · enter: play · d: remove · shift-v: select · :clear ",
-            player.queue.len()
+            player.queue.len(),
+            state.global.filters.source_mode.label()
         ))
         .title_style(theme::header_for(state))
         .border_style(theme::border_for(state));

src/ui/playlists.rs

@@ -38,7 +38,15 @@ fn centered_line(frame: &mut Frame, area: Rect, line: Line) {
 }
 
 fn draw_list(frame: &mut Frame, area: Rect, state: &AppState) {
-    let inner = bordered(frame, area, state, " Playlists ".to_string());
+    let inner = bordered(
+        frame,
+        area,
+        state,
+        format!(
+            " Playlists · Mode: {} ",
+            state.global.filters.source_mode.label()
+        ),
+    );
     let selected = state.playlists.selected;
 
     let list = match &state.playlists.list {
@@ -97,8 +105,15 @@ fn draw_list(frame: &mut Frame, area: Rect, state: &AppState) {
 fn draw_opened(frame: &mut Frame, area: Rect, state: &AppState, id: i64, cursor: usize) {
     let loadable = state.playlist_views.get(&id);
     let title = match loadable {
-        Some(Loadable::Ready(detail)) => format!(" Playlists ▸ {} ", detail.title),
+        Some(Loadable::Ready(detail)) => format!(
-        _ => " Playlists ▸ … ".to_string(),
+            " Playlists ▸ {} · Mode: {} ",
+            detail.title,
+            state.global.filters.source_mode.label()
+        ),
+        _ => format!(
+            " Playlists ▸ … · Mode: {} ",
+            state.global.filters.source_mode.label()
+        ),
     };
     let inner = bordered(frame, area, state, title);
 

src/ui/popup.rs

@@ -598,7 +598,7 @@ fn clip_cells(text: &str, max_width: usize) -> String {
 }
 
 fn draw_library_filters(frame: &mut Frame, state: &AppState, cursor: usize) {
-    let area = centered(frame.area(), 54, 9);
+    let area = centered(frame.area(), 44, 6);
     let block = Block::bordered()
         .title(" Library filters ")
         .title_style(theme::header_for(state))
@@ -608,7 +608,7 @@ fn draw_library_filters(frame: &mut Frame, state: &AppState, cursor: usize) {
     frame.render_widget(block, area);
 
     let [list_area, _, footer] = Layout::vertical([
-        Constraint::Length(4),
+        Constraint::Length(1),
         Constraint::Length(1),
         Constraint::Length(1),
     ])
@@ -624,18 +624,6 @@ fn draw_library_filters(frame: &mut Frame, state: &AppState, cursor: usize) {
         Span::styled(format!("{checked} "), theme::accent_for(state)),
         Span::raw("Hide featured only"),
     ]));
-    for mode in crate::config::settings::LibrarySourceMode::ALL {
-        let marker = if state.global.filters.source_mode == mode {
-            "(*)"
-        } else {
-            "( )"
-        };
-        rows.push(Line::from(vec![
-            Span::styled(format!("{marker} "), theme::accent_for(state)),
-            Span::raw(mode.label()),
-            Span::styled(format!("  {}", mode.description()), theme::dim()),
-        ]));
-    }
     for (index, line) in rows.into_iter().enumerate() {
         let row = Rect {
             y: list_area.y + index as u16,