refactor(backend): retire unused native bridge entry points

rust_backend/crates/core/src/cover.rs

@@ -5,7 +5,7 @@ use std::borrow::Cow;
 use std::io::Cursor;
 
 mod library;
-pub use library::{clear_library_thumbnail_cache, library_thumbnail};
+pub use library::library_thumbnail;
 
 pub const MAX_DOWNLOAD_BYTES: usize = 24 << 20;
 pub const LIBRARY_MAX_DIMENSION: i64 = 800;

rust_backend/crates/core/src/cover/library.rs

@@ -90,14 +90,6 @@ pub fn library_thumbnail(
     Ok(thumbnail)
 }
 
-pub fn clear_library_thumbnail_cache() {
-    if let Some(mutex) = CACHE.get()
-        && let Ok(mut cache) = mutex.try_lock()
-    {
-        *cache = Cache::default();
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

rust_backend/crates/core/src/isrc/cache.rs

@@ -1,5 +1,4 @@
 use crate::matching::uppercase;
-use serde::{Deserialize, Deserializer, Serialize};
 use std::collections::BTreeMap;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex, MutexGuard, TryLockError, Weak};
@@ -246,47 +245,6 @@ impl IndexCache {
     pub fn clear(&self) {
         self.indexes.lock().expect("ISRC cache lock").clear();
     }
-
-    pub fn prebuild(
-        &self,
-        directory: &str,
-        files: &dyn IndexFiles,
-        check: Check<'_>,
-    ) -> Result<(), String> {
-        if directory.is_empty() {
-            return Err("output directory is required".into());
-        }
-        self.index(directory, files, true, check).map(|_| ())
-    }
-
-    pub fn check_batch(
-        &self,
-        directory: &str,
-        tracks: &[TrackQuery],
-        files: &dyn IndexFiles,
-        check: Check<'_>,
-    ) -> Result<Vec<TrackExistence>, String> {
-        let index = self.index(directory, files, false, check)?;
-        let index = index.lock().expect("ISRC index lock");
-        tracks
-            .iter()
-            .map(|track| {
-                check()?;
-                // Go's batch API deliberately trusts the cache without stat calls.
-                let path = index
-                    .entries
-                    .get(&uppercase(&track.isrc))
-                    .filter(|_| !track.isrc.is_empty());
-                Ok(TrackExistence {
-                    isrc: track.isrc.clone(),
-                    exists: path.is_some(),
-                    file_path: path.cloned().unwrap_or_default(),
-                    track_name: track.track_name.clone(),
-                    artist_name: track.artist_name.clone(),
-                })
-            })
-            .collect()
-    }
 }
 
 fn wait_for_builder<'a>(
@@ -302,84 +260,3 @@ fn wait_for_builder<'a>(
         }
     }
 }
-
-#[derive(Clone, Debug, Default)]
-pub struct TrackQuery {
-    pub isrc: String,
-    pub track_name: String,
-    pub artist_name: String,
-}
-
-impl<'de> Deserialize<'de> for TrackQuery {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        struct Visitor;
-        impl<'de> serde::de::Visitor<'de> for Visitor {
-            type Value = TrackQuery;
-            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                formatter.write_str("a track object")
-            }
-            fn visit_map<M: serde::de::MapAccess<'de>>(
-                self,
-                mut map: M,
-            ) -> Result<TrackQuery, M::Error> {
-                let mut track = TrackQuery::default();
-                while let Some(key) = map.next_key::<String>()? {
-                    let field = if equal_field(&key, "isrc") {
-                        Some(&mut track.isrc)
-                    } else if equal_field(&key, "track_name") {
-                        Some(&mut track.track_name)
-                    } else if equal_field(&key, "artist_name") {
-                        Some(&mut track.artist_name)
-                    } else {
-                        None
-                    };
-                    if let Some(field) = field {
-                        if let Some(value) = map.next_value::<Option<String>>()? {
-                            *field = value;
-                        }
-                    } else {
-                        map.next_value::<serde::de::IgnoredAny>()?;
-                    }
-                }
-                Ok(track)
-            }
-        }
-        deserializer.deserialize_map(Visitor)
-    }
-}
-
-pub fn parse_tracks(json: &str) -> Result<Vec<TrackQuery>, String> {
-    // Go matches the snake_case JSON tags, folds field-name case, and ignores
-    // null string values without overwriting an earlier duplicate field.
-    serde_json::from_str::<Option<Vec<Option<TrackQuery>>>>(&crate::text::json_surrogates(json))
-        .map(|tracks| {
-            tracks
-                .unwrap_or_default()
-                .into_iter()
-                .map(Option::unwrap_or_default)
-                .collect()
-        })
-        .map_err(|error| format!("failed to parse tracks JSON: {error}"))
-}
-
-fn equal_field(value: &str, target: &str) -> bool {
-    value.eq_ignore_ascii_case(target)
-        || (value.chars().count() == target.len()
-            && value.chars().zip(target.chars()).all(|(actual, expected)| {
-                actual.eq_ignore_ascii_case(&expected)
-                    || (actual == 'ſ' && expected == 's')
-                    || (actual == 'K' && expected == 'k')
-            }))
-}
-
-#[derive(Debug, Serialize)]
-pub struct TrackExistence {
-    pub isrc: String,
-    pub exists: bool,
-    #[serde(skip_serializing_if = "String::is_empty")]
-    pub file_path: String,
-    #[serde(skip_serializing_if = "String::is_empty")]
-    pub track_name: String,
-    #[serde(skip_serializing_if = "String::is_empty")]
-    pub artist_name: String,
-}

rust_backend/crates/core/src/isrc/mod.rs

@@ -2,7 +2,7 @@
 
 mod cache;
 mod native_files;
-pub use cache::{FileStamp, IndexCache, IndexFiles, TrackExistence, TrackQuery, parse_tracks};
+pub use cache::{FileStamp, IndexCache, IndexFiles};
 pub use native_files::NativeFiles;
 
 use std::io::{Read, Seek, SeekFrom};

rust_backend/crates/core/src/metadata/musicbrainz/case_data.rs

@@ -1,4 +1,4 @@
-// Generated by rust_backend/tools/generate_case_data.go. DO NOT EDIT.
+// Generated by docs/internal/legacy-go/rust_backend/tools/generate_case_data.go. DO NOT EDIT.
 // Unicode 15.0.0, golang.org/x/text v0.41.0; see NOTICE.
 // Flags: cased=1, case-ignorable=2, word break=4, mid punctuation=8.
 #[rustfmt::skip]

rust_backend/crates/core/src/progress/mod.rs

@@ -240,10 +240,6 @@ impl ProgressRegistry {
         self.update(id, mark_downloading)
     }
 
-    pub fn set_total(&self, id: &str, total: i64) -> Result<(), ProgressError> {
-        self.update(id, |item| item.bytes_total = total)
-    }
-
     pub fn set_received(&self, id: &str, received: i64) -> Result<(), ProgressError> {
         self.update(id, |item| set_received(item, received))
     }
@@ -322,15 +318,6 @@ impl ProgressRegistry {
         Ok(())
     }
 
-    pub fn clear(&self) -> Result<(), ProgressError> {
-        let mut state = self.shared.state.lock().expect("progress state lock");
-        state.check()?;
-        state.items.clear();
-        state.removed.clear();
-        state.reset = state.next(&self.shared.changed);
-        Ok(())
-    }
-
     pub fn item(&self, id: &str) -> Result<String, ProgressError> {
         let state = self.shared.state.lock().expect("progress state lock");
         state.check()?;
@@ -361,12 +348,6 @@ impl ProgressRegistry {
         Ok(state.cached.clone())
     }
 
-    pub fn delta(&self, since: i64) -> Result<String, ProgressError> {
-        let state = self.shared.state.lock().expect("progress state lock");
-        state.check()?;
-        Ok(state.delta(since))
-    }
-
     pub fn subscribe(&self) -> Result<ProgressSubscription, ProgressError> {
         self.shared
             .state

rust_backend/crates/extensions/src/auth.rs

@@ -97,23 +97,6 @@ impl AuthRegistry {
         self.edit(id, |record| record.code = Zeroizing::new(code.to_owned()))
     }
 
-    pub fn set_tokens(
-        &self,
-        id: &str,
-        access: &str,
-        refresh: &str,
-        expires_in: i64,
-    ) -> Result<(), String> {
-        let expires = (expires_in > 0)
-            .then(|| self.now() + i128::from(expires_in.wrapping_mul(1_000_000_000)));
-        self.edit(id, |record| {
-            record.access_token = Zeroizing::new(access.to_owned());
-            record.refresh_token = Zeroizing::new(refresh.to_owned());
-            record.authenticated = !access.is_empty();
-            record.expires_at = expires;
-        })
-    }
-
     pub fn code(&self, id: &str) -> Option<String> {
         self.state
             .lock()
@@ -251,16 +234,6 @@ impl AuthRegistry {
         })
     }
 
-    pub fn all_pending(&self) -> Vec<PendingAuthRequest> {
-        self.state
-            .lock()
-            .expect("auth registry lock")
-            .pending
-            .values()
-            .cloned()
-            .collect()
-    }
-
     pub fn resolve_callback(&self, nonce: &str, consume: bool) -> Result<String, String> {
         let nonce = nonce.trim();
         if nonce.is_empty() {

rust_backend/crates/extensions/src/backend.rs

@@ -184,22 +184,6 @@ impl Backend {
         Arc::clone(&self.availability)
     }
 
-    pub fn get_app_version(&self) -> Result<String, String> {
-        let _operation = self.enter()?;
-        self.manager
-            .environment()
-            .get_app_version()
-            .map_err(|error| error.to_string())
-    }
-
-    pub fn set_app_version(&self, version: &str) -> Result<(), String> {
-        let _operation = self.enter()?;
-        self.manager
-            .environment()
-            .set_app_version(version)
-            .map_err(|error| error.to_string())
-    }
-
     pub fn get_extension_pending_auth_json(&self, id: &str) -> Result<String, String> {
         let _operation = self.enter()?;
         let id = id.trim();

rust_backend/crates/extensions/src/backend/cover.rs

@@ -391,13 +391,6 @@ impl Backend {
         Ok(output.display())
     }
 
-    pub fn clear_cover_memory_cache(&self) -> Result<(), String> {
-        let _operation = self.enter()?;
-        self.cover.clear();
-        spotiflac_core::cover::clear_library_thumbnail_cache();
-        Ok(())
-    }
-
     pub fn download_cover_to_file_sized(
         &self,
         url: &str,

rust_backend/crates/extensions/src/backend/downloads.rs

@@ -60,17 +60,6 @@ impl Backend {
             .unwrap_or_else(|error| native_error_response(&error).to_string()))
     }
 
-    pub fn download_with_extensions_json(
-        &self,
-        raw: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        let _operation = self.enter()?;
-        let request =
-            DownloadRequest::parse(raw).map_err(|error| format!("invalid request: {error}"))?;
-        self.download_request(request, check)
-    }
-
     fn download_request(
         &self,
         mut request: DownloadRequest,

rust_backend/crates/extensions/src/backend/library/scan.rs

@@ -75,21 +75,6 @@ impl Backend {
         Ok(())
     }
 
-    pub fn scan_library_folder(&self, folder: &str, check: Check<'_>) -> Result<Value, String> {
-        let mut tracks = Vec::new();
-        self.scan_library(
-            folder,
-            None,
-            true,
-            &mut |value| {
-                tracks.push(value);
-                Ok(())
-            },
-            check,
-        )?;
-        Ok(tracks.into())
-    }
-
     pub fn scan_library_folder_incremental(
         &self,
         folder: &str,

rust_backend/crates/extensions/src/backend/lyrics.rs

@@ -118,11 +118,6 @@ impl Backend {
         Ok(response)
     }
 
-    pub fn get_lyrics_providers_json(&self) -> Result<String, String> {
-        let _operation = self.enter()?;
-        serde_json::to_string(&self.lyrics.providers()).map_err(|error| error.to_string())
-    }
-
     pub fn set_lyrics_providers_json(&self, raw: &str) -> Result<(), String> {
         let _operation = self.enter()?;
         let providers = config::decode_providers(raw).map_err(|error| error.to_string())?;
@@ -136,11 +131,6 @@ impl Backend {
         serde_json::to_string(&config::available_providers()).map_err(|error| error.to_string())
     }
 
-    pub fn get_lyrics_fetch_options_json(&self) -> Result<String, String> {
-        let _operation = self.enter()?;
-        serde_json::to_string(&self.lyrics.options()).map_err(|error| error.to_string())
-    }
-
     pub fn set_lyrics_fetch_options_json(&self, raw: &str) -> Result<(), String> {
         let _operation = self.enter()?;
         let _settings = self.lyrics_settings.lock().expect("lyrics settings lock");

rust_backend/crates/extensions/src/backend/metadata.rs

@@ -2,7 +2,7 @@ use super::Backend;
 use serde::Serialize;
 use serde_json::{Value, json};
 use spotiflac_core::metadata::TrackMetadata;
-use spotiflac_providers::deezer::{self, MetadataLookup};
+use spotiflac_providers::deezer::MetadataLookup;
 use spotiflac_providers::musicbrainz::MusicBrainzOptions;
 use spotiflac_providers::resolver::{Check, ResolverError, ResolverOptions};
 use std::time::{Duration, Instant};
@@ -97,13 +97,6 @@ impl Backend {
             .map_err(|error| error.to_string())
     }
 
-    pub fn get_song_link_region(&self) -> Result<String, String> {
-        let _operation = self.enter()?;
-        self.availability
-            .region()
-            .map_err(|error| error.to_string())
-    }
-
     // The retired Settings track-ID cache is distinct from catalog caches.
     pub fn get_track_cache_size(&self) -> Result<u64, String> {
         let _operation = self.enter()?;
@@ -115,11 +108,6 @@ impl Backend {
         Ok(())
     }
 
-    pub fn parse_deezer_url(&self, url: &str) -> Result<(String, String), String> {
-        let _operation = self.enter()?;
-        deezer::parse_url(url).map_err(|error| error.to_string())
-    }
-
     pub fn search_deezer(
         &self,
         query: &str,
@@ -137,15 +125,6 @@ impl Backend {
         })
     }
 
-    pub fn get_deezer_metadata(
-        &self,
-        kind: &str,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| self.deezer_metadata(kind, id, check))
-    }
-
     pub(super) fn deezer_metadata(
         &self,
         kind: &str,
@@ -175,10 +154,6 @@ impl Backend {
         })
     }
 
-    pub fn search_deezer_by_isrc(&self, isrc: &str, check: &Check<'_>) -> Result<String, String> {
-        self.search_deezer_by_isrc_for_item_id(isrc, "", check)
-    }
-
     pub fn search_deezer_by_isrc_for_item_id(
         &self,
         isrc: &str,
@@ -246,69 +221,6 @@ impl Backend {
         })
     }
 
-    pub fn check_track_availability_json(
-        &self,
-        id: &str,
-        isrc: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            encode(&self.availability.check_track(id, isrc, check)?)
-        })
-    }
-
-    pub fn check_album_availability_json(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            encode(&self.availability.check_album(id, check)?)
-        })
-    }
-
-    pub fn check_availability_from_deezer_json(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            encode(&self.availability.check_from_deezer(id, check)?)
-        })
-    }
-
-    pub fn check_availability_by_platform_json(
-        &self,
-        platform: &str,
-        kind: &str,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            encode(
-                &self
-                    .availability
-                    .check_by_platform(platform, kind, id, check)?,
-            )
-        })
-    }
-
-    pub fn check_availability_from_url_json(
-        &self,
-        url: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            encode(&self.availability.check_from_url(url, check)?)
-        })
-    }
-
-    pub fn get_streaming_urls_json(&self, id: &str, check: &Check<'_>) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            encode(&self.availability.streaming_urls(id, check)?)
-        })
-    }
-
     pub fn get_deezer_id_from_spotify(
         &self,
         id: &str,
@@ -316,66 +228,6 @@ impl Backend {
     ) -> Result<String, String> {
         self.metadata_operation(30, check, |check| self.deezer_id_from_spotify(id, check))
     }
-
-    pub fn get_deezer_album_id_from_spotify(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            self.availability.deezer_album_id(id, check)
-        })
-    }
-
-    pub fn get_youtube_url_from_spotify(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            self.availability.youtube_url_from_spotify(id, check)
-        })
-    }
-
-    pub fn get_spotify_id_from_deezer_track(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            self.availability.platform_from_deezer(id, "spotify", check)
-        })
-    }
-
-    pub fn get_tidal_url_from_deezer_track(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            self.availability.platform_from_deezer(id, "tidal", check)
-        })
-    }
-
-    pub fn get_amazon_url_from_deezer_track(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            self.availability.platform_from_deezer(id, "amazon", check)
-        })
-    }
-
-    pub fn get_youtube_url_from_deezer_track(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        self.metadata_operation(30, check, |check| {
-            self.availability.platform_from_deezer(id, "youtube", check)
-        })
-    }
 }
 
 #[cfg(test)]

rust_backend/crates/extensions/src/backend/provider_metadata.rs

@@ -10,13 +10,6 @@ use std::time::Duration;
 mod value_tests;
 
 impl Backend {
-    pub fn enrich_track_json(&self, id: &str, track_json: &str) -> Result<String, String> {
-        let _operation = self.enter()?;
-        self.manager
-            .enrich_track_export(id, track_json)
-            .map_err(|error| error.to_string())
-    }
-
     pub fn handle_url_json(&self, url: &str) -> Result<String, String> {
         let _operation = self.enter()?;
         let id = self

rust_backend/crates/extensions/src/backend/reenrich.rs

@@ -11,24 +11,6 @@ use std::io::Write;
 use std::sync::Mutex;
 
 impl Backend {
-    /// Resolve proposed tags without reading audio, downloading covers or writing files.
-    pub fn preview_reenrich_file(
-        &self,
-        request_json: &str,
-        check: &Check<'_>,
-    ) -> Result<String, String> {
-        let _operation = self.enter()?;
-        let check = || {
-            self.check()?;
-            check()
-        };
-        check()?;
-        let request = self.resolve_reenrich_request(request_json, &check)?;
-        serde_json::to_string(&json!({"method":"preview","success":true,
-            "enriched_metadata":request.result_metadata()}))
-        .map_err(|error| error.to_string())
-    }
-
     /// Execute FLAC enrichment or return the existing native FFmpeg plan.
     /// Returned cover files belong to the caller, which removes them after use.
     pub fn reenrich_file(&self, request_json: &str, check: &Check<'_>) -> Result<String, String> {

rust_backend/crates/extensions/src/environment.rs

@@ -207,11 +207,6 @@ impl ExtensionEnvironment {
         Ok(self.store(id)?.set(StoreKind::Settings, key, value)?)
     }
 
-    pub fn remove_setting(&self, id: &str, key: &str) -> Result<(), EnvironmentError> {
-        let _operation = self.enter()?;
-        Ok(self.store(id)?.remove(StoreKind::Settings, key)?)
-    }
-
     pub fn set_allow_private_network(&self, allow: bool) -> Result<(), EnvironmentError> {
         let _operation = self.enter()?;
         self.network.set_allow_private_network(allow);
@@ -247,13 +242,6 @@ impl ExtensionEnvironment {
         Ok(self.app_version.get())
     }
 
-    pub fn set_app_version(&self, version: &str) -> Result<(), EnvironmentError> {
-        let _operation = self.enter()?;
-        self.app_version
-            .set(version)
-            .map_err(|error| EnvironmentError::Gate(error.to_string()))
-    }
-
     pub(crate) fn shared_app_version(&self) -> AppVersion {
         self.app_version.clone()
     }
@@ -622,17 +610,6 @@ impl ExtensionEnvironment {
         Ok(self.auth.pending(id.trim()))
     }
 
-    pub fn all_pending_auth(&self) -> Result<Vec<PendingAuthRequest>, EnvironmentError> {
-        let _operation = self.enter()?;
-        Ok(self.auth.all_pending())
-    }
-
-    pub fn clear_pending_auth(&self, id: &str) -> Result<(), EnvironmentError> {
-        let _operation = self.enter()?;
-        self.auth.clear_pending(id);
-        Ok(())
-    }
-
     pub fn resolve_callback_state(
         &self,
         state: &str,
@@ -648,24 +625,6 @@ impl ExtensionEnvironment {
         let _operation = self.enter()?;
         self.auth.set_code(id, code).map_err(EnvironmentError::Auth)
     }
-
-    pub fn set_auth_tokens(
-        &self,
-        id: &str,
-        access: &str,
-        refresh: &str,
-        expires_in: i64,
-    ) -> Result<(), EnvironmentError> {
-        let _operation = self.enter()?;
-        self.auth
-            .set_tokens(id, access, refresh, expires_in)
-            .map_err(EnvironmentError::Auth)
-    }
-
-    pub fn is_authenticated(&self, id: &str) -> Result<bool, EnvironmentError> {
-        let _operation = self.enter()?;
-        Ok(self.auth.authenticated(id))
-    }
 }
 
 fn network_timeout(value: Option<&Value>) -> Duration {

rust_backend/crates/extensions/src/environment/index.rs

@@ -1,5 +1,5 @@
 use super::{EnvironmentError, ExtensionEnvironment};
-use spotiflac_core::isrc::{IndexCache, IndexFiles, NativeFiles, parse_tracks};
+use spotiflac_core::isrc::{IndexCache, NativeFiles};
 use std::sync::atomic::Ordering;
 
 type Check<'a> = &'a (dyn Fn() -> Result<(), String> + Sync);
@@ -27,27 +27,6 @@ impl ExtensionEnvironment {
 
     /// Trusted native entry points share the SDK's index, while JavaScript uses
     /// a scoped IndexFiles adapter and revalidates native directory grants.
-    pub fn prebuild_isrc_index(
-        &self,
-        directory: &str,
-        check: Check<'_>,
-    ) -> Result<(), EnvironmentError> {
-        self.with_index(check, |cache, files, check| {
-            cache.prebuild(directory, files, check)
-        })
-    }
-
-    pub fn check_isrc_exists(
-        &self,
-        directory: &str,
-        isrc: &str,
-        check: Check<'_>,
-    ) -> Result<String, EnvironmentError> {
-        self.with_index(check, |cache, files, check| {
-            cache.check(directory, isrc, files, check)
-        })
-    }
-
     pub fn add_to_isrc_index(
         &self,
         directory: &str,
@@ -60,33 +39,9 @@ impl ExtensionEnvironment {
         })
     }
 
-    pub fn check_files_exist_parallel(
-        &self,
-        directory: &str,
-        tracks_json: &str,
-        check: Check<'_>,
-    ) -> Result<String, EnvironmentError> {
-        self.with_index(check, |cache, files, check| {
-            if tracks_json.len() > 8 * 1024 * 1024 {
-                return Err("tracks JSON exceeds 8 MiB limit".into());
-            }
-            let tracks = parse_tracks(tracks_json)?;
-            let results = cache.check_batch(directory, &tracks, files, check)?;
-            serde_json::to_string(&results).map_err(|error| error.to_string())
-        })
-    }
-
     pub fn invalidate_isrc_cache(&self, directory: &str) -> Result<(), EnvironmentError> {
         let _operation = self.enter()?;
         self.isrc.invalidate(directory);
         Ok(())
     }
-
-    pub fn check_file_exists(&self, path: &str) -> Result<bool, EnvironmentError> {
-        let _operation = self.enter()?;
-        NativeFiles
-            .stat(path)
-            .map(|stamp| stamp.is_some_and(|stamp| !stamp.directory && stamp.size > 0))
-            .map_err(EnvironmentError::Index)
-    }
 }

rust_backend/crates/extensions/src/ffmpeg.rs

@@ -56,12 +56,6 @@ impl CommandRegistry {
         Ok(state.commands.get(id).map(|entry| entry.command.clone()))
     }
 
-    pub fn pending_json(&self) -> Result<String, RegistryClosed> {
-        let mut state = self.state.lock().expect("FFmpeg state lock");
-        state.check()?;
-        Ok(state.pending(false))
-    }
-
     /// Claims each command at most once, even with multiple native pumps.
     /// A zero/negative timeout performs a nonblocking claim. Shutdown wakes waits.
     pub fn wait_pending_json(&self, timeout_ms: i64) -> Result<String, RegistryClosed> {
@@ -70,7 +64,7 @@ impl CommandRegistry {
         let mut state = self.state.lock().expect("FFmpeg state lock");
         loop {
             state.check()?;
-            let commands = state.pending(true);
+            let commands = state.claim_pending();
             let remaining = timeout.saturating_sub(started.elapsed());
             if commands != "[]" || remaining.is_zero() {
                 return Ok(commands);
@@ -185,7 +179,7 @@ impl State {
         }
     }
 
-    fn pending(&mut self, claim: bool) -> String {
+    fn claim_pending(&mut self) -> String {
         #[derive(Serialize)]
         struct PendingCommand<'a> {
             command_id: &'a str,
@@ -198,9 +192,7 @@ impl State {
             .values_mut()
             .filter(|entry| !entry.claimed && entry.result.is_none())
             .map(|entry| {
-                if claim {
-                    entry.claimed = true;
-                }
+                entry.claimed = true;
                 PendingCommand {
                     command_id: &entry.command.command_id,
                     extension_id: &entry.command.extension_id,

rust_backend/crates/extensions/src/manager.rs

@@ -590,12 +590,6 @@ impl ExtensionManager {
             .map_err(|e| error(e.to_string()))
     }
 
-    pub fn unload(&self, id: &str) -> Result<(), ManagerError> {
-        let _metadata = MetadataChange(&self.metadata_revision);
-        let _mutation = self.mutation.lock().expect("extension mutation lock");
-        self.unload_locked(id)
-    }
-
     fn unload_locked(&self, id: &str) -> Result<(), ManagerError> {
         self.check()?;
         let entry = self
@@ -612,23 +606,6 @@ impl ExtensionManager {
         Ok(())
     }
 
-    pub fn unload_all(&self) -> Result<(), ManagerError> {
-        let _metadata = MetadataChange(&self.metadata_revision);
-        let _mutation = self.mutation.lock().expect("extension mutation lock");
-        self.check()?;
-        let ids: Vec<_> = self
-            .entries
-            .lock()
-            .expect("extension manager lock")
-            .keys()
-            .cloned()
-            .collect();
-        for id in ids {
-            self.unload_locked(&id)?;
-        }
-        Ok(())
-    }
-
     pub fn remove(&self, id: &str) -> Result<(), ManagerError> {
         let _metadata = MetadataChange(&self.metadata_revision);
         let _mutation = self.mutation.lock().expect("extension mutation lock");

rust_backend/crates/extensions/src/manager/metadata.rs

@@ -32,16 +32,6 @@ impl ExtensionManager {
             .map_err(|failure| error(failure.to_string()))
     }
 
-    pub fn check_availability(
-        &self,
-        id: &str,
-        request: ProviderAvailabilityRequest,
-        timeout_ms: u64,
-    ) -> Result<String, ManagerError> {
-        let lease = self.item_lease(&request.item_id)?;
-        self.check_availability_with_lease(id, request, timeout_ms, lease)
-    }
-
     pub(crate) fn check_availability_with_lease(
         &self,
         id: &str,
@@ -70,52 +60,6 @@ impl ExtensionManager {
         )
     }
 
-    /// Best-effort enrichment preserves the original provider attribution.
-    /// Cancellation remains an error, allowing the download worker to stop.
-    pub fn enrich_track(
-        &self,
-        id: &str,
-        track_json: &str,
-        item_id: &str,
-        timeout_ms: u64,
-    ) -> Result<String, ManagerError> {
-        self.enrich_track_with_lease(
-            id,
-            track_json,
-            item_id,
-            timeout_ms,
-            self.item_lease(item_id)?,
-        )
-    }
-
-    pub(crate) fn enrich_track_export(
-        &self,
-        id: &str,
-        track_json: &str,
-    ) -> Result<String, ManagerError> {
-        self.check()?;
-        let Ok(entry) = self.get(id) else {
-            return Ok(track_json.into());
-        };
-        if !entry.manifest.has_type("metadata_provider") {
-            return Ok(track_json.into());
-        }
-        // This export unmarshals into a value struct, unlike the nullable
-        // provider argument used by the internal download API.
-        let input = if track_json.trim() == "null" {
-            "{}"
-        } else {
-            track_json
-        };
-        self.enrich_track(id, input, "", 30_000).map_err(|failure| {
-            if let Some(message) = failure.0.strip_prefix("invalid track: ") {
-                error(format!("failed to parse track: {message}"))
-            } else {
-                failure
-            }
-        })
-    }
-
     pub(crate) fn enrich_track_with_lease(
         &self,
         id: &str,

rust_backend/crates/extensions/src/repository.rs

@@ -258,12 +258,6 @@ impl ExtensionRepository {
         Ok(())
     }
 
-    pub fn clear_cache(&self) -> Result<(), RepositoryError> {
-        self.check()?;
-        self.clear_locked(&mut self.state.lock().expect("repository state lock"));
-        Ok(())
-    }
-
     fn clear_locked(&self, state: &mut State) {
         state.generation = state.generation.wrapping_add(1);
         state.cache = None;
@@ -420,13 +414,6 @@ impl ExtensionRepository {
         )
     }
 
-    pub fn categories(&self) -> Result<Vec<String>, RepositoryError> {
-        self.check()?;
-        Ok(["metadata", "download", "utility", "lyrics", "integration"]
-            .map(str::to_owned)
-            .to_vec())
-    }
-
     pub fn download(&self, id: &str, directory: &Path) -> Result<PathBuf, RepositoryError> {
         let _operation = self.enter()?;
         let generation = self.state.lock().expect("repository state lock").generation;

rust_backend/crates/extensions/src/runtime.rs

@@ -478,16 +478,6 @@ impl ExtensionRuntime {
 
     /// Read typed provider fields in the owning VM. Go's provider wrappers do
     /// not await a returned Promise; the provider object itself is parsed.
-    pub fn call_provider(
-        &self,
-        method: &str,
-        arguments: &str,
-        lease: Option<Arc<RequestLease>>,
-        timeout_ms: u64,
-    ) -> Result<String, ExtensionError> {
-        self.call_provider_operation(method, arguments, lease, timeout_ms, String::new())
-    }
-
     pub(crate) fn call_provider_operation(
         &self,
         method: &str,
@@ -596,33 +586,6 @@ impl ExtensionRuntime {
         )
     }
 
-    /// The manager starts progress before resolution and completes it after
-    /// finalization. This call acquires another reference to the same item and
-    /// binds its identity to the queued command, never to mutable runtime state.
-    pub fn call_download_for_item(
-        &self,
-        method: &str,
-        arguments_json: &str,
-        item_id: &str,
-        resolution_timeout_ms: u64,
-    ) -> Result<String, ExtensionError> {
-        if self.control.is_closed() {
-            return Err(ExtensionError::Closed);
-        }
-        let lease = Arc::new(
-            self.downloads
-                .acquire(item_id)
-                .map_err(ExtensionError::Cancelled)?,
-        );
-        self.call_download_operation(
-            method,
-            arguments_json,
-            Some(lease),
-            resolution_timeout_ms,
-            item_id.trim().to_owned(),
-        )
-    }
-
     pub fn download_state(&self) -> Arc<spotiflac_core::downloads::DownloadState> {
         Arc::clone(&self.downloads)
     }

rust_backend/crates/mobile/src/cancellation.rs

@@ -59,18 +59,10 @@ impl CancellationRegistry {
         self.inner.cancel(&id).map_err(Into::into)
     }
 
-    pub fn cancel_active(&self) -> Result<Vec<String>, CancellationError> {
-        self.inner.cancel_active().map_err(Into::into)
-    }
-
     pub fn is_cancelled(&self, id: String) -> Result<bool, CancellationError> {
         self.inner.is_cancelled(&id).map_err(Into::into)
     }
 
-    pub fn reset_if_idle(&self, id: String) -> Result<(), CancellationError> {
-        self.inner.reset_if_idle(&id).map_err(Into::into)
-    }
-
     pub fn shutdown(&self) {
         self.inner.shutdown();
     }
@@ -87,14 +79,6 @@ impl RequestLease {
         self.inner.is_cancelled().map_err(Into::into)
     }
 
-    pub fn check_active(&self) -> Result<(), CancellationError> {
-        self.inner.check_active().map_err(Into::into)
-    }
-
-    pub fn wait_cancelled(&self, timeout_ms: i64) -> Result<bool, CancellationError> {
-        self.inner.wait_cancelled(timeout_ms).map_err(Into::into)
-    }
-
     pub fn release(&self) {
         self.inner.release();
     }

rust_backend/crates/mobile/src/extensions.rs

@@ -131,49 +131,6 @@ impl JsExtension {
             .map_err(Into::into)
     }
 
-    pub fn preflight_signed_session(
-        &self,
-        lease: Option<Arc<RequestLease>>,
-        timeout_ms: u64,
-    ) -> Result<bool, JsExtensionError> {
-        self.inner
-            .preflight_signed_session(lease.map(|lease| Arc::clone(&lease.inner)), timeout_ms)
-            .map_err(Into::into)
-    }
-
-    pub fn call_download(
-        &self,
-        method: String,
-        arguments_json: String,
-        lease: Option<Arc<RequestLease>>,
-        resolution_timeout_ms: u64,
-    ) -> Result<String, JsExtensionError> {
-        self.inner
-            .call_download(
-                &method,
-                &arguments_json,
-                lease.map(|lease| Arc::clone(&lease.inner)),
-                resolution_timeout_ms,
-            )
-            .map_err(Into::into)
-    }
-
-    pub fn take_verification_url(&self) -> String {
-        self.inner.take_verification_url()
-    }
-
-    pub fn call_download_for_item(
-        &self,
-        method: String,
-        arguments_json: String,
-        item_id: String,
-        resolution_timeout_ms: u64,
-    ) -> Result<String, JsExtensionError> {
-        self.inner
-            .call_download_for_item(&method, &arguments_json, &item_id, resolution_timeout_ms)
-            .map_err(Into::into)
-    }
-
     pub fn shutdown(&self) {
         self.inner.shutdown();
     }
@@ -220,48 +177,10 @@ impl ExtensionEnvironment {
         })
     }
 
-    pub fn load(
-        &self,
-        manifest_json: String,
-        source: String,
-        timeout_ms: u64,
-    ) -> Result<Arc<JsExtension>, JsExtensionError> {
-        let limits = RuntimeLimits {
-            timeout_ms: if timeout_ms == 0 { 30_000 } else { timeout_ms },
-            ..RuntimeLimits::default()
-        };
-        Ok(Arc::new(JsExtension {
-            inner: self.inner.load(&manifest_json, &source, limits)?,
-        }))
-    }
-
     pub fn settings(&self, extension_id: String) -> Result<String, JsExtensionError> {
         Ok(serde_json::Value::Object(self.inner.settings(&extension_id)?).to_string())
     }
 
-    pub fn set_setting(
-        &self,
-        extension_id: String,
-        key: String,
-        value_json: String,
-    ) -> Result<(), JsExtensionError> {
-        let value = serde_json::from_str(&value_json)
-            .map_err(|error| JsExtensionError::InvalidInput(error.to_string()))?;
-        self.inner
-            .set_setting(&extension_id, &key, value)
-            .map_err(Into::into)
-    }
-
-    pub fn remove_setting(
-        &self,
-        extension_id: String,
-        key: String,
-    ) -> Result<(), JsExtensionError> {
-        self.inner
-            .remove_setting(&extension_id, &key)
-            .map_err(Into::into)
-    }
-
     pub fn set_allow_private_network(&self, allow: bool) -> Result<(), JsExtensionError> {
         self.inner
             .set_allow_private_network(allow)
@@ -313,14 +232,6 @@ impl ExtensionEnvironment {
         }))
     }
 
-    pub fn pending_auth(&self, extension_id: String) -> Result<String, JsExtensionError> {
-        Ok(self
-            .inner
-            .pending_auth(&extension_id)?
-            .map(|pending| serde_json::to_string(&pending).expect("pending auth JSON"))
-            .unwrap_or_default())
-    }
-
     pub fn set_runtime_state(&self, raw: String) -> Result<(), JsExtensionError> {
         self.inner.set_runtime_state(&raw).map_err(Into::into)
     }
@@ -336,16 +247,6 @@ impl ExtensionEnvironment {
             .map_err(Into::into)
     }
 
-    pub fn all_pending_auth(&self) -> Result<String, JsExtensionError> {
-        Ok(serde_json::to_string(&self.inner.all_pending_auth()?).expect("pending auth JSON"))
-    }
-
-    pub fn clear_pending_auth(&self, extension_id: String) -> Result<(), JsExtensionError> {
-        self.inner
-            .clear_pending_auth(&extension_id)
-            .map_err(Into::into)
-    }
-
     pub fn resolve_callback_state(&self, state: String) -> Result<String, JsExtensionError> {
         self.inner
             .resolve_callback_state(&state, false)
@@ -369,26 +270,6 @@ impl ExtensionEnvironment {
             .map_err(Into::into)
     }
 
-    pub fn set_auth_tokens(
-        &self,
-        extension_id: String,
-        access_token: String,
-        refresh_token: String,
-        expires_in: i64,
-    ) -> Result<(), JsExtensionError> {
-        let access_token = zeroize::Zeroizing::new(access_token);
-        let refresh_token = zeroize::Zeroizing::new(refresh_token);
-        self.inner
-            .set_auth_tokens(&extension_id, &access_token, &refresh_token, expires_in)
-            .map_err(Into::into)
-    }
-
-    pub fn is_authenticated(&self, extension_id: String) -> Result<bool, JsExtensionError> {
-        self.inner
-            .is_authenticated(&extension_id)
-            .map_err(Into::into)
-    }
-
     pub fn shutdown(&self) {
         self.inner.shutdown();
     }

rust_backend/crates/mobile/src/ffmpeg.rs

@@ -22,10 +22,6 @@ pub struct FfmpegCommands {
 
 #[uniffi::export]
 impl FfmpegCommands {
-    pub fn pending(&self) -> Result<String, FfmpegError> {
-        self.inner.pending_json().map_err(Into::into)
-    }
-
     pub fn wait_pending(&self, timeout_ms: i64) -> Result<String, FfmpegError> {
         self.inner.wait_pending_json(timeout_ms).map_err(Into::into)
     }

rust_backend/crates/mobile/src/index.rs

@@ -1,69 +0,0 @@
-use crate::cancellation::RequestLease;
-use crate::extensions::{ExtensionEnvironment, JsExtensionError};
-use std::sync::Arc;
-
-fn check(lease: &Option<Arc<RequestLease>>) -> Result<(), String> {
-    lease.as_ref().map_or(Ok(()), |lease| {
-        lease
-            .inner
-            .check_active()
-            .map_err(|error| error.to_string())
-    })
-}
-
-#[uniffi::export]
-impl ExtensionEnvironment {
-    pub fn prebuild_isrc_index(
-        &self,
-        directory: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<(), JsExtensionError> {
-        self.inner
-            .prebuild_isrc_index(&directory, &|| check(&lease))
-            .map_err(Into::into)
-    }
-
-    pub fn check_isrc_exists(
-        &self,
-        directory: String,
-        isrc: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, JsExtensionError> {
-        self.inner
-            .check_isrc_exists(&directory, &isrc, &|| check(&lease))
-            .map_err(Into::into)
-    }
-
-    pub fn add_to_isrc_index(
-        &self,
-        directory: String,
-        isrc: String,
-        path: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<(), JsExtensionError> {
-        self.inner
-            .add_to_isrc_index(&directory, &isrc, &path, &|| check(&lease))
-            .map_err(Into::into)
-    }
-
-    pub fn check_files_exist_parallel(
-        &self,
-        directory: String,
-        tracks_json: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, JsExtensionError> {
-        self.inner
-            .check_files_exist_parallel(&directory, &tracks_json, &|| check(&lease))
-            .map_err(Into::into)
-    }
-
-    pub fn invalidate_isrc_cache(&self, directory: String) -> Result<(), JsExtensionError> {
-        self.inner
-            .invalidate_isrc_cache(&directory)
-            .map_err(Into::into)
-    }
-
-    pub fn check_file_exists(&self, path: String) -> Result<bool, JsExtensionError> {
-        self.inner.check_file_exists(&path).map_err(Into::into)
-    }
-}

rust_backend/crates/mobile/src/lib.rs

@@ -5,7 +5,6 @@ mod extensions;
 mod ffmpeg;
 mod filename;
 mod hires;
-mod index;
 mod library_metadata;
 mod logging;
 mod lyrics;

rust_backend/crates/mobile/src/lyrics.rs

@@ -79,12 +79,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn get_lyrics_providers_json(&self) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_lyrics_providers_json()
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn set_lyrics_providers_json(
         &self,
         providers_json: String,
@@ -100,12 +94,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn get_lyrics_fetch_options_json(&self) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_lyrics_fetch_options_json()
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn set_lyrics_fetch_options_json(
         &self,
         options_json: String,

rust_backend/crates/mobile/src/manager.rs

@@ -81,18 +81,6 @@ impl ExtensionManager {
         })
     }
 
-    pub fn get_app_version(&self) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_app_version()
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn set_app_version(&self, version: String) -> Result<(), ExtensionManagerError> {
-        self.inner
-            .set_app_version(&version)
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn install(&self, package_path: String) -> Result<String, ExtensionManagerError> {
         self.inner
             .install(Path::new(&package_path))
@@ -168,15 +156,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn download_with_extensions_json(
-        &self,
-        request_json: String,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .download_with_extensions_json(&request_json, &|| Ok(()))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn check_extension_health_json(
         &self,
         extension_id: String,
@@ -200,12 +179,6 @@ impl ExtensionManager {
             .map_err(Into::into)
     }
 
-    pub fn release_idle_download_runtimes(&self) -> Result<u64, ExtensionManagerError> {
-        self.inner
-            .release_idle_download_runtimes()
-            .map_err(Into::into)
-    }
-
     pub fn release_memory(&self, under_pressure: bool) -> Result<(), ExtensionManagerError> {
         self.inner
             .release_memory(under_pressure)
@@ -247,32 +220,6 @@ impl ExtensionManager {
             .map_err(Into::into)
     }
 
-    pub fn check_availability(
-        &self,
-        extension_id: String,
-        request_json: String,
-        timeout_ms: u64,
-    ) -> Result<String, ExtensionManagerError> {
-        let request = serde_json::from_str(&request_json).map_err(|error| {
-            ExtensionManagerError::Operation(format!("invalid availability request: {error}"))
-        })?;
-        self.inner
-            .check_availability(&extension_id, request, timeout_ms)
-            .map_err(Into::into)
-    }
-
-    pub fn enrich_track(
-        &self,
-        extension_id: String,
-        track_json: String,
-        item_id: String,
-        timeout_ms: u64,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .enrich_track(&extension_id, &track_json, &item_id, timeout_ms)
-            .map_err(Into::into)
-    }
-
     pub fn search_metadata_provider(
         &self,
         extension_id: String,
@@ -333,10 +280,6 @@ impl ExtensionManager {
             .map_err(Into::into)
     }
 
-    pub fn provider_ids(&self, kind: String) -> Result<Vec<String>, ExtensionManagerError> {
-        self.inner.provider_ids(&kind).map_err(Into::into)
-    }
-
     pub fn provider_call(
         &self,
         extension_id: String,
@@ -377,12 +320,6 @@ impl ExtensionManager {
         self.inner.provider_priorities().map_err(Into::into)
     }
 
-    pub fn fallback_allowed(&self, extension_id: String) -> Result<bool, ExtensionManagerError> {
-        self.inner
-            .fallback_allowed(&extension_id)
-            .map_err(Into::into)
-    }
-
     pub fn find_url_handler(&self, url: String) -> Result<Option<String>, ExtensionManagerError> {
         self.inner.find_url_handler(&url).map_err(Into::into)
     }
@@ -396,14 +333,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn unload(&self, extension_id: String) -> Result<(), ExtensionManagerError> {
-        self.inner.unload(&extension_id).map_err(Into::into)
-    }
-
-    pub fn unload_all(&self) -> Result<(), ExtensionManagerError> {
-        self.inner.unload_all().map_err(Into::into)
-    }
-
     pub fn remove(&self, extension_id: String) -> Result<(), ExtensionManagerError> {
         self.inner.remove(&extension_id).map_err(Into::into)
     }

rust_backend/crates/mobile/src/metadata.rs

@@ -2,12 +2,6 @@ use crate::cancellation::RequestLease;
 use crate::manager::{ExtensionManager, ExtensionManagerError};
 use std::sync::Arc;
 
-#[derive(uniffi::Record)]
-pub struct DeezerResource {
-    pub resource_type: String,
-    pub resource_id: String,
-}
-
 fn check(lease: &Option<Arc<RequestLease>>) -> Result<(), String> {
     lease.as_ref().map_or(Ok(()), |lease| {
         lease
@@ -21,16 +15,6 @@ fn check(lease: &Option<Arc<RequestLease>>) -> Result<(), String> {
 /// Run network operations on a native background thread and retain any lease.
 #[uniffi::export]
 impl ExtensionManager {
-    pub fn enrich_track_json(
-        &self,
-        extension_id: String,
-        track_json: String,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .enrich_track_json(&extension_id, &track_json)
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn handle_url_json(&self, url: String) -> Result<String, ExtensionManagerError> {
         self.inner
             .handle_url_json(&url)
@@ -118,18 +102,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn set_song_link_region(&self, region: String) -> Result<(), ExtensionManagerError> {
-        self.inner
-            .set_song_link_region(&region)
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_song_link_region(&self) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_song_link_region()
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn get_track_cache_size(&self) -> Result<u64, ExtensionManagerError> {
         self.inner
             .get_track_cache_size()
@@ -142,47 +114,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn parse_deezer_url(&self, url: String) -> Result<DeezerResource, ExtensionManagerError> {
-        let (resource_type, resource_id) = self
-            .inner
-            .parse_deezer_url(&url)
-            .map_err(ExtensionManagerError::Operation)?;
-        Ok(DeezerResource {
-            resource_type,
-            resource_id,
-        })
-    }
-
-    pub fn search_deezer(
-        &self,
-        query: String,
-        track_limit: i64,
-        artist_limit: i64,
-        filter: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .search_deezer(
-                &query,
-                track_limit as isize,
-                artist_limit as isize,
-                &filter,
-                &|| check(&lease),
-            )
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_deezer_metadata(
-        &self,
-        resource_type: String,
-        resource_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_deezer_metadata(&resource_type, &resource_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn get_deezer_extended_metadata(
         &self,
         track_id: String,
@@ -193,16 +124,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn search_deezer_by_isrc(
-        &self,
-        isrc: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .search_deezer_by_isrc(&isrc, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn search_deezer_by_isrc_for_item_id(
         &self,
         isrc: String,
@@ -236,151 +157,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn check_track_availability_json(
-        &self,
-        spotify_id: String,
-        isrc: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .check_track_availability_json(&spotify_id, &isrc, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn check_album_availability_json(
-        &self,
-        spotify_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .check_album_availability_json(&spotify_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn check_availability_from_deezer_json(
-        &self,
-        track_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .check_availability_from_deezer_json(&track_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn check_availability_by_platform_json(
-        &self,
-        platform: String,
-        resource_type: String,
-        resource_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .check_availability_by_platform_json(&platform, &resource_type, &resource_id, &|| {
-                check(&lease)
-            })
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn check_availability_from_url_json(
-        &self,
-        url: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .check_availability_from_url_json(&url, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_streaming_urls_json(
-        &self,
-        spotify_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_streaming_urls_json(&spotify_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_deezer_id_from_spotify(
-        &self,
-        spotify_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_deezer_id_from_spotify(&spotify_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_deezer_album_id_from_spotify(
-        &self,
-        spotify_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_deezer_album_id_from_spotify(&spotify_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_youtube_url_from_spotify(
-        &self,
-        spotify_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_youtube_url_from_spotify(&spotify_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_spotify_id_from_deezer_track(
-        &self,
-        track_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_spotify_id_from_deezer_track(&track_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_tidal_url_from_deezer_track(
-        &self,
-        track_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_tidal_url_from_deezer_track(&track_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_amazon_url_from_deezer_track(
-        &self,
-        track_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_amazon_url_from_deezer_track(&track_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn get_youtube_url_from_deezer_track(
-        &self,
-        track_id: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .get_youtube_url_from_deezer_track(&track_id, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
-    pub fn preview_reenrich_file(
-        &self,
-        request_json: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .preview_reenrich_file(&request_json, &|| check(&lease))
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn reenrich_file(
         &self,
         request_json: String,

rust_backend/crates/mobile/src/progress.rs

@@ -72,58 +72,6 @@ impl DownloadState {
         self.inner.progress.remove(&item_id).map_err(Into::into)
     }
 
-    pub fn clear_all_progress(&self) -> Result<(), DownloadProgressError> {
-        self.inner.progress.clear().map_err(Into::into)
-    }
-
-    pub fn set_preparing(
-        &self,
-        item_id: String,
-        stage: String,
-    ) -> Result<(), DownloadProgressError> {
-        self.inner
-            .progress
-            .preparing(&item_id, &stage)
-            .map_err(Into::into)
-    }
-
-    pub fn set_downloading(&self, item_id: String) -> Result<(), DownloadProgressError> {
-        self.inner
-            .progress
-            .downloading(&item_id)
-            .map_err(Into::into)
-    }
-
-    pub fn set_total(&self, item_id: String, total: i64) -> Result<(), DownloadProgressError> {
-        self.inner
-            .progress
-            .set_total(&item_id, total)
-            .map_err(Into::into)
-    }
-
-    pub fn set_received(
-        &self,
-        item_id: String,
-        received: i64,
-    ) -> Result<(), DownloadProgressError> {
-        self.inner
-            .progress
-            .set_received(&item_id, received)
-            .map_err(Into::into)
-    }
-
-    pub fn set_received_with_speed(
-        &self,
-        item_id: String,
-        received: i64,
-        speed: f64,
-    ) -> Result<(), DownloadProgressError> {
-        self.inner
-            .progress
-            .set_received_with_speed(&item_id, received, speed)
-            .map_err(Into::into)
-    }
-
     pub fn set_progress(
         &self,
         item_id: String,
@@ -137,26 +85,10 @@ impl DownloadState {
             .map_err(Into::into)
     }
 
-    pub fn set_finalizing(&self, item_id: String) -> Result<(), DownloadProgressError> {
-        self.inner.progress.finalizing(&item_id).map_err(Into::into)
-    }
-
-    pub fn complete_item(&self, item_id: String) -> Result<(), DownloadProgressError> {
-        self.inner.progress.complete(&item_id).map_err(Into::into)
-    }
-
-    pub fn item_progress(&self, item_id: String) -> Result<String, DownloadProgressError> {
-        self.inner.progress.item(&item_id).map_err(Into::into)
-    }
-
     pub fn all_progress(&self) -> Result<String, DownloadProgressError> {
         self.inner.progress.snapshot().map_err(Into::into)
     }
 
-    pub fn progress_delta(&self, since: i64) -> Result<String, DownloadProgressError> {
-        self.inner.progress.delta(since).map_err(Into::into)
-    }
-
     pub fn wait_progress_delta(
         &self,
         since: i64,

rust_backend/crates/mobile/src/repository.rs

@@ -54,22 +54,6 @@ impl ExtensionRepository {
         self.search_inner(force_refresh, "", "")
     }
 
-    pub fn search(
-        &self,
-        query: String,
-        category: String,
-    ) -> Result<String, ExtensionRepositoryError> {
-        self.search_inner(false, &query, &category)
-    }
-
-    pub fn categories(&self) -> Result<Vec<String>, ExtensionRepositoryError> {
-        self.inner.categories().map_err(Into::into)
-    }
-
-    pub fn clear_cache(&self) -> Result<(), ExtensionRepositoryError> {
-        self.inner.clear_cache().map_err(Into::into)
-    }
-
     pub fn download(
         &self,
         extension_id: String,

rust_backend/crates/mobile/src/tags.rs

@@ -93,17 +93,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn scan_library_folder(
-        &self,
-        folder: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .scan_library_folder(&folder, &|| check_lease(lease.as_deref()))
-            .map(|value| value.to_string())
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn scan_library_folder_incremental(
         &self,
         folder: String,
@@ -181,25 +170,6 @@ impl ExtensionManager {
             .map_err(ExtensionManagerError::Operation)
     }
 
-    pub fn save_cover_to_cache_with_hint_and_key(
-        &self,
-        audio_path: String,
-        hint: String,
-        cache_directory: String,
-        cache_key: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<String, ExtensionManagerError> {
-        self.inner
-            .save_cover_to_cache_with_hint_and_key(
-                &audio_path,
-                &hint,
-                &cache_directory,
-                &cache_key,
-                &|| check_lease(lease.as_deref()),
-            )
-            .map_err(ExtensionManagerError::Operation)
-    }
-
     pub fn download_cover_to_file_sized(
         &self,
         url: String,
@@ -280,22 +250,6 @@ impl ExtensionManager {
             })?;
         Ok(serde_json::json!({"success":true,"handled":handled}).to_string())
     }
-
-    /// Atomic audio tag editing on the root owner's granted file paths.
-    pub fn edit_audio_tags(
-        &self,
-        path: String,
-        format: String,
-        fields_json: String,
-        lease: Option<Arc<RequestLease>>,
-    ) -> Result<(), ExtensionManagerError> {
-        let check = || check_lease(lease.as_deref());
-        check().map_err(ExtensionManagerError::Operation)?;
-        let fields = decode_fields(&fields_json).map_err(ExtensionManagerError::Operation)?;
-        self.inner
-            .edit_audio_tags(&path, &format, &fields, &check)
-            .map_err(ExtensionManagerError::Operation)
-    }
 }
 
 fn decode_fields(json: &str) -> Result<BTreeMap<String, String>, String> {
@@ -308,23 +262,9 @@ fn decode_fields(json: &str) -> Result<BTreeMap<String, String>, String> {
         .collect())
 }
 
-/// Read only the tag fields. Native callers retain ownership of any platform
-/// descriptor referenced by `path` until this synchronous operation returns.
-#[uniffi::export]
-pub fn read_audio_tags(
-    path: String,
-    format: String,
-    lease: Option<Arc<RequestLease>>,
-) -> Result<String, AudioTagsError> {
-    let check = || check_lease(lease.as_deref());
-    check()?;
-    let mut file = open_audio_file(&path)?;
-    let metadata = tags::read_audio_tags(&mut file, &format, &check)?;
-    serde_json::to_string(&metadata).map_err(|error| error.to_string().into())
-}
-
 /// Complete application metadata. An empty hint is equivalent to the legacy
-/// ReadFileMetadata call. Native descriptor ownership matches read_audio_tags.
+/// ReadFileMetadata call. Native callers retain ownership of any platform
+/// descriptor referenced by `path` until this synchronous operation returns.
 #[uniffi::export]
 pub fn read_file_metadata(
     path: String,

rust_backend/crates/providers/src/deezer.rs

@@ -4,7 +4,6 @@ mod browse;
 mod cache;
 mod extended;
 mod search;
-pub use extended::parse_url;
 
 use crate::resolver::{Check, ResolverError, http::ResolverHttp};
 use serde::de::DeserializeOwned;

rust_backend/crates/providers/src/deezer/extended.rs

@@ -3,24 +3,9 @@ use spotiflac_core::metadata::{
     AlbumExtendedMetadata, TrackMetadata,
     deezer::{FullAlbum, Track},
 };
-use spotiflac_network::url::UrlParts;
 use std::sync::Arc;
-use std::time::Instant;
 
 impl DeezerClient {
-    pub fn get_track_isrc(&self, id: &str, check: &Check<'_>) -> Result<String, ResolverError> {
-        check().map_err(ResolverError::Cancelled)?;
-        if let Some(value) = self.cache.lock().unwrap().isrc.get(id).cloned() {
-            return Ok(value);
-        }
-        let track: Track =
-            self.get_json(&format!("https://api.deezer.com/2.0/track/{id}"), check)?;
-        let mut cache = self.cache.lock().unwrap();
-        cache.isrc.insert(id.into(), track.isrc.clone());
-        cache.cleanup(Instant::now());
-        Ok(track.isrc)
-    }
-
     pub fn get_track_album_id(&self, id: &str, check: &Check<'_>) -> Result<String, ResolverError> {
         match self.coalesced(&format!("track_album:{id}"), check, || {
             let track: Track =
@@ -108,47 +93,6 @@ impl DeezerClient {
     }
 }
 
-pub fn parse_url(input: &str) -> Result<(String, String), ResolverError> {
-    let input = input.trim();
-    if input.is_empty() {
-        return Err(ResolverError::Failed("empty URL".into()));
-    }
-    let parsed =
-        UrlParts::parse(input).ok_or_else(|| ResolverError::Failed("invalid Deezer URL".into()))?;
-    if parsed.port.is_some()
-        || !matches!(
-            parsed.hostname.as_str(),
-            "www.deezer.com" | "deezer.com" | "deezer.page.link"
-        )
-    {
-        return Err(ResolverError::Failed("not a Deezer URL".into()));
-    }
-    let mut path = parsed.path.as_slice();
-    while let Some(rest) = path.strip_prefix(b"/") {
-        path = rest;
-    }
-    while let Some(rest) = path.strip_suffix(b"/") {
-        path = rest;
-    }
-    let mut parts: Vec<_> = path.split(|byte| *byte == b'/').collect();
-    if parts.first().is_some_and(|part| part.len() == 2) {
-        parts.remove(0);
-    }
-    if parts.len() < 2 {
-        return Err(ResolverError::Failed("invalid Deezer URL format".into()));
-    }
-    match parts[0] {
-        b"track" | b"album" | b"artist" | b"playlist" => Ok((
-            String::from_utf8_lossy(parts[0]).into_owned(),
-            String::from_utf8_lossy(parts[1]).into_owned(),
-        )),
-        kind => Err(ResolverError::Failed(format!(
-            "unsupported Deezer resource type: {}",
-            String::from_utf8_lossy(kind)
-        ))),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

rust_backend/crates/providers/src/lyrics/cache.rs

@@ -111,13 +111,6 @@ impl LyricsCache {
         self.len() == 0
     }
 
-    pub fn clean_expired(&self, now: SystemTime) -> usize {
-        let mut state = self.inner.state.lock().expect("lyrics cache lock");
-        let before = state.entries.len();
-        state.entries.retain(|_, entry| now <= entry.expires_at);
-        before - state.entries.len()
-    }
-
     pub fn clear(&self) -> usize {
         let mut state = self.inner.state.lock().expect("lyrics cache lock");
         let count = state.entries.len();

rust_backend/crates/providers/src/resolver/availability.rs

@@ -1,7 +1,7 @@
 //! Application-facing track/album availability and platform-link contracts.
 
 mod cache;
-use super::{Check, Metadata, PlatformResolverService, ResolverError, urls};
+use super::{Check, Metadata, PlatformResolverService, ResolverError};
 pub use cache::AvailabilityService;
 use serde::{Deserialize, Serialize};
 use spotiflac_core::metadata::TrackMetadata;
@@ -204,17 +204,3 @@ fn album(
         deezer_url: url,
     })
 }
-
-fn by_platform(
-    resolver: &PlatformResolverService,
-    platform: &str,
-    kind: &str,
-    id: &str,
-    check: &Check<'_>,
-) -> Result<TrackAvailability, ResolverError> {
-    if id.is_empty() {
-        return Err(ResolverError::Failed(format!("{platform} ID is empty")));
-    }
-    let input = urls::from_id(platform, kind, id).map_err(ResolverError::Failed)?;
-    Ok(from_links("", &resolved_links(resolver, &input, check)?))
-}

rust_backend/crates/providers/src/resolver/availability/cache.rs

@@ -1,6 +1,6 @@
 use super::{
-    AlbumAvailability, TrackAvailability, album, by_platform, deezer_id_from_metadata, from_deezer,
-    from_links, resolved_links,
+    AlbumAvailability, TrackAvailability, album, deezer_id_from_metadata, from_deezer, from_links,
+    resolved_links,
 };
 use crate::deezer::MetadataLookup;
 use crate::lyrics::{LyricsError, builtin::TrackResolver};
@@ -156,44 +156,6 @@ impl AvailabilityService {
         self.with_raw(check, |resolver, check| from_deezer(resolver, id, check))
     }
 
-    pub fn check_by_platform(
-        &self,
-        platform: &str,
-        kind: &str,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<TrackAvailability, ResolverError> {
-        self.with_raw(check, |resolver, check| {
-            by_platform(resolver, platform, kind, id, check)
-        })
-    }
-
-    pub fn check_from_url(
-        &self,
-        url: &str,
-        check: &Check<'_>,
-    ) -> Result<TrackAvailability, ResolverError> {
-        self.with_raw(check, |resolver, check| {
-            Ok(from_links("", &resolved_links(resolver, url, check)?))
-        })
-    }
-
-    pub fn streaming_urls(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<BTreeMap<String, String>, ResolverError> {
-        let availability = self.check_track(id, "", check)?;
-        Ok([
-            ("tidal", availability.tidal_url),
-            ("amazon", availability.amazon_url),
-        ]
-        .into_iter()
-        .filter(|(_, value)| !value.is_empty())
-        .map(|(key, value)| (key.into(), value))
-        .collect())
-    }
-
     pub fn deezer_album_id(&self, id: &str, check: &Check<'_>) -> Result<String, ResolverError> {
         let album = self.check_album(id, check)?;
         if album.deezer && !album.deezer_id.is_empty() {
@@ -203,44 +165,6 @@ impl AvailabilityService {
         }
     }
 
-    pub fn youtube_url_from_spotify(
-        &self,
-        id: &str,
-        check: &Check<'_>,
-    ) -> Result<String, ResolverError> {
-        let track = self.check_track(id, "", check)?;
-        if track.youtube && !track.youtube_url.is_empty() {
-            Ok(track.youtube_url)
-        } else {
-            Err(ResolverError::Failed("track not found on YouTube".into()))
-        }
-    }
-
-    pub fn platform_from_deezer(
-        &self,
-        id: &str,
-        platform: &str,
-        check: &Check<'_>,
-    ) -> Result<String, ResolverError> {
-        let track = self.check_from_deezer(id, check)?;
-        let (value, name) = match platform {
-            "spotify" => (track.spotify_id, "Spotify"),
-            "tidal" => (track.tidal_url, "Tidal"),
-            "amazon" => (track.amazon_url, "Amazon Music"),
-            "youtube" => (track.youtube_url, "YouTube"),
-            _ => {
-                return Err(ResolverError::Failed(
-                    "unsupported availability platform".into(),
-                ));
-            }
-        };
-        if value.is_empty() {
-            Err(ResolverError::Failed(format!("track not found on {name}")))
-        } else {
-            Ok(value)
-        }
-    }
-
     fn with_raw<T>(
         &self,
         check: &Check<'_>,

rust_backend/crates/providers/src/resolver/urls.rs

@@ -138,41 +138,3 @@ pub fn path_escape(value: &str) -> String {
 pub fn query_escape(value: &str) -> String {
     escape(value, b"", true)
 }
-
-pub fn from_id(provider: &str, kind: &str, id: &str) -> Result<String, String> {
-    let provider = canonical(provider);
-    let id = id.trim();
-    if provider.is_empty() || id.is_empty() {
-        return Err("invalid platform or entity ID".into());
-    }
-    let kind = kind.trim().to_lowercase();
-    let kind = if kind == "song" { "track" } else { &kind };
-    if !matches!(kind, "track" | "album" | "artist") {
-        return Err(format!("unsupported entity type {kind:?}"));
-    }
-    let base = match provider {
-        "spotify" => "https://open.spotify.com",
-        "deezer" => "https://www.deezer.com",
-        "tidal" => "https://tidal.com/browse",
-        "qobuz" => "https://open.qobuz.com",
-        "amazonMusic" => {
-            return Ok(format!(
-                "https://music.amazon.com/{kind}s/{}",
-                path_escape(id)
-            ));
-        }
-        "youtube" | "youtubeMusic" => {
-            if kind != "track" {
-                return Err(format!("unsupported {provider} entity type {kind:?}"));
-            }
-            let host = if provider == "youtube" {
-                "www.youtube.com"
-            } else {
-                "music.youtube.com"
-            };
-            return Ok(format!("https://{host}/watch?v={}", query_escape(id)));
-        }
-        _ => return Err(format!("cannot build a direct {provider} URL from an ID")),
-    };
-    Ok(format!("{base}/{kind}/{}", path_escape(id)))
-}