feat(enrichment): oximedia BPM/mood facts, mood search, and queue display (#863)

* feat(enrichment): oximedia BPM/mood facts, mood search, and queue UI

Run client-side oximedia analysis after CPU seed and persist BPM, mood JSON,
and searchable mood_tag facts. Add product mood groups (joy/sadness/dance/work/
romance) with Advanced Search filter on the local index, queue BPM/mood display,
migration 008 mood_tag index, and refreshed licenses for oximedia crates.

* fix(enrichment): keep mood_groups module comment in English

* feat(search): virtual mood groups, anger filter, and Advanced Search UX

Expand mood search via overlapping virtual groups (tag expansion only),
add anger/Злость group, skip album/artist shortcuts for track-only filters,
and simplify mood search UI (songs-only, hide type tabs). Fix CustomSelect
spurious scrollbar on short option lists.

* feat(analysis): unified track analysis plan and enqueue path

Add TrackAnalysisPlan (waveform, LUFS, enrichment) with a single
enqueue_track_analysis entry for all byte-backed triggers. Run enrichment
when cache is full but library facts are missing; route playback, cache,
and backfill through the planner. Fix browseTextSearch LocalSearchOpts tsc
gap and remove obsolete read_seed_bytes_if_needed helper.

* fix(analysis): wire playback dispatch, preload enrichment, and UI refresh

Route stream, gapless, preload, and local-file playback through analysis_dispatch
so BPM/mood enrichment runs when waveform/LUFS are already cached. Fix audio_preload
cache-hit and hot-cache paths, emit preload-cancelled for retry, and add
analysis:enrichment-updated plus content_cache_coverage key resolution.

* fix(audio): preload local files from disk and stop analysis retry loop

Seed hot/offline next tracks via LocalFilePlayback (512 MiB) instead of copying
into the RAM preload slot. Keep bytePreloadingId set after preload-ready so
progress ticks do not re-invoke audio_preload every second.

* fix(enrichment): clippy, album bpm filter routing, and queue mood display

Clippy-clean analysis_dispatch and engine imports; restrict track-derived album
routing to mood_group/mood_tag only so bpm is skipped on album queries. Log
enrichment plan errors with retry-all plan; filter queue mood labels to oximedia ids.

* fix(enrichment): simplify mood_tag backfill branch in plan_track_enrichment

Remove empty if-block; keep same behaviour when backfill fails and moods row exists.

* docs: CHANGELOG and credits for track enrichment PR #863

* docs(credits): track enrichment PR #863 contributor line

* chore(enrichment): clippy-clean plan branch and trim dead exports

Collapse mood_tag backfill if for clippy; remove unused moodGroupById and
OXIMEDIA_MOOD_LABELS re-exports; stop poll when server BPM is already known.

* fix(enrichment): close R2/S1–S3 limits and Song Info BPM fallback

Return TrackEnrichmentOutcome::Failed on oximedia errors so retries are not
masked as complete; extract mood Advanced Search SQL, unify top-3 mood tag
selection in mood_groups with TS invariant tests, and show measured BPM in
Song Info when tag BPM is missing or zero.

* fix(enrichment): restore offline coverage and show mood in Song Info

Add unit tests for offline download cancel/clear registry after the analysis
seed refactor dropped read_seed_bytes coverage; show localized mood labels in
Song Info when library enrichment facts exist.

* fix(enrichment): soft mood scoring and unblock offline cancel tests

Replace oximedia quadrant happy/excited mapping with valence/arousal
soft scores across all mood tags for display, storage, and backfill;
fix offline cancel unit tests that deadlocked by calling clear while
holding the global offline_cancel_flags mutex.

* fix(enrichment): dedupe joy cluster and cap mood display at two labels

Never show happy and excited together; pick one tag per V/A cluster,
tighten oximedia recalibration, and limit queue/Song Info to two moods
that pass a relative score floor.

* fix(enrichment): disable oximedia mood labels in UI and search tags

Oximedia 0.1.7 mood is a spectral energy heuristic, not independent mood
weights; valence correlates with loud/bright audio and false-labels metal
and lyrical tracks as happy. Hide queue/Song Info mood and stop writing
mood_tag facts until a reliable detector lands; keep V/A/moods JSON stored.

* fix(enrichment): disable oximedia mood analysis and add BPM advanced search

Stop planning, running, and storing oximedia mood facts; purge accumulated
mood rows via migration 009. Hide mood filters in Advanced Search, expose
BPM range filter with dual-storage resolution, and show a BPM column in song
results when that filter is active.

* feat(search): analysis BPM priority, source tooltip, and filter UX

Prefer analysis track_fact over file tags for BPM resolution; show source
in list tooltips. Validate BPM range on blur, add clear button, fix double tooltip.

* fix(enrichment): prefer analysis BPM in Song Info and queue tech row

Show measured track_fact BPM before file tags until analysis completes;
pick the highest-confidence analysis fact when several exist.

src-tauri/crates/psysonic-audio/src/preload_commands.rs

@@ -3,15 +3,115 @@
 //! (which constructs the gapless source chain) and `audio_play` (which
 //! starts playback). All three live in this audio submodule.
 
+use std::path::PathBuf;
 use std::sync::atomic::Ordering;
 use std::time::Duration;
 
+use serde::Serialize;
 use tauri::{AppHandle, Emitter, State};
 
+use super::analysis_dispatch::{
+    dispatch_track_analysis_bytes, prepare_playback_analysis, spawn_track_analysis_file,
+    TrackAnalysisOrigin,
+};
 use super::engine::{audio_http_client, AudioEngine};
 use super::helpers::{analysis_cache_track_id, same_playback_target};
 use super::state::PreloadedTrack;
 
+#[derive(Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct PreloadEventPayload {
+    url: String,
+    track_id: Option<String>,
+}
+
+async fn seed_preload_analysis_bytes(
+    app: &AppHandle,
+    state: &State<'_, AudioEngine>,
+    url: &str,
+    data: &[u8],
+    analysis_track_id: Option<&str>,
+    server_id: Option<&str>,
+) {
+    let Some(track_id) = analysis_cache_track_id(analysis_track_id, url) else {
+        return;
+    };
+    let (sid, high) = prepare_playback_analysis(
+        app,
+        state,
+        server_id,
+        &track_id,
+        // Next-track prefetch — never steal CPU from the audible track.
+        Some(false),
+    );
+    if let Err(e) = dispatch_track_analysis_bytes(
+        app,
+        TrackAnalysisOrigin::PrefetchOrCacheFile,
+        &sid,
+        &track_id,
+        data.to_vec(),
+        high,
+    )
+    .await
+    {
+        crate::app_eprintln!("[analysis] preload seed failed for {track_id}: {e}");
+    }
+}
+
+fn seed_preload_analysis_file(
+    app: &AppHandle,
+    state: &State<'_, AudioEngine>,
+    url: &str,
+    file_path: PathBuf,
+    analysis_track_id: Option<&str>,
+    server_id: Option<&str>,
+) {
+    let Some(track_id) = analysis_cache_track_id(analysis_track_id, url) else {
+        return;
+    };
+    let (sid, high) = prepare_playback_analysis(
+        app,
+        state,
+        server_id,
+        &track_id,
+        Some(false),
+    );
+    crate::app_deprintln!(
+        "[stream] audio_preload: local file analysis track_id={} path={}",
+        track_id,
+        file_path.display()
+    );
+    spawn_track_analysis_file(
+        app.clone(),
+        TrackAnalysisOrigin::LocalFilePlayback,
+        sid,
+        track_id,
+        file_path,
+        high,
+        None,
+    );
+}
+
+fn emit_preload_ready(app: &AppHandle, url: String, track_id: Option<String>) {
+    let _ = app.emit(
+        "audio:preload-ready",
+        PreloadEventPayload {
+            url,
+            track_id,
+        },
+    );
+}
+
+fn emit_preload_cancelled(app: &AppHandle, url: String, track_id: Option<String>) {
+    let _ = app.emit(
+        "audio:preload-cancelled",
+        PreloadEventPayload {
+            url,
+            track_id,
+        },
+    );
+}
+
 #[tauri::command]
 pub async fn audio_preload(
     url: String,
@@ -21,49 +121,96 @@ pub async fn audio_preload(
     app: AppHandle,
     state: State<'_, AudioEngine>,
 ) -> Result<(), String> {
+    let logical_trim = analysis_track_id
+        .as_ref()
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty());
+    let track_id_for_events = logical_trim.clone();
+
+    let is_local = url.starts_with("psysonic-local://");
+
+    // Hot/offline cache: playback reads from disk — seed analysis from the file
+    // (512 MiB cap) without copying into the RAM preload slot.
+    if is_local {
+        let path = PathBuf::from(url.strip_prefix("psysonic-local://").unwrap());
+        if !path.is_file() {
+            crate::app_deprintln!(
+                "[stream] audio_preload: local file missing path={}",
+                path.display()
+            );
+            emit_preload_cancelled(&app, url, track_id_for_events);
+            return Ok(());
+        }
+        seed_preload_analysis_file(
+            &app,
+            &state,
+            &url,
+            path,
+            logical_trim.as_deref(),
+            server_id.as_deref(),
+        );
+        emit_preload_ready(&app, url, track_id_for_events);
+        return Ok(());
+    }
+
+    // Remote URL — reuse in-memory bytes when a prior HTTP preload finished.
     {
-        let preloaded = state.preloaded.lock().unwrap();
-        if preloaded.as_ref().is_some_and(|p| same_playback_target(&p.url, &url)) {
-            let _ = app.emit("audio:preload-ready", url.clone());
+        let cached = {
+            let preloaded = state.preloaded.lock().unwrap();
+            preloaded
+                .as_ref()
+                .filter(|p| same_playback_target(&p.url, &url))
+                .map(|p| p.data.clone())
+        };
+        if let Some(data) = cached {
+            if !data.is_empty() {
+                seed_preload_analysis_bytes(
+                    &app,
+                    &state,
+                    &url,
+                    &data,
+                    logical_trim.as_deref(),
+                    server_id.as_deref(),
+                )
+                .await;
+            }
             return Ok(());
         }
     }
+
+    let _ = duration_hint; // kept in API for compatibility
+
     // Throttle: wait 8 s before starting the background download so it does not
     // compete with the decode + sink-feed work of the just-started current track.
     // If the user skips during the wait the generation counter changes and we abort.
     let gen_snapshot = state.generation.load(Ordering::Relaxed);
     tokio::time::sleep(Duration::from_secs(8)).await;
     if state.generation.load(Ordering::Relaxed) != gen_snapshot {
+        emit_preload_cancelled(&app, url, track_id_for_events);
         return Ok(());
     }
-    let data: Vec<u8> = if let Some(path) = url.strip_prefix("psysonic-local://") {
-        tokio::fs::read(path).await.map_err(|e| e.to_string())?
-    } else {
-        let response = audio_http_client(&state).get(&url).send().await.map_err(|e| e.to_string())?;
-        if !response.status().is_success() {
-            return Ok(());
-        }
-        response.bytes().await.map_err(|e| e.to_string())?.into()
-    };
-    let _ = duration_hint; // kept in API for compatibility
-    let logical_trim = analysis_track_id
-        .as_ref()
-        .map(|s| s.trim().to_string())
-        .filter(|s| !s.is_empty());
-    if let Some(track_id) = analysis_cache_track_id(logical_trim.as_deref(), &url) {
-        crate::app_deprintln!(
-            "[stream] audio_preload: bytes ready track_id={} size_mib={:.2} — invoking full-track analysis",
-            track_id,
-            data.len() as f64 / (1024.0 * 1024.0)
-        );
-        let high = crate::engine::analysis_track_id_is_current_playback(&state, &track_id);
-        let sid = server_id.clone().unwrap_or_default();
-        if let Err(e) = psysonic_analysis::analysis_runtime::submit_analysis_cpu_seed(app.clone(), sid, track_id.clone(), data.clone(), high).await {
-            crate::app_eprintln!("[analysis] preload seed failed for {}: {}", track_id, e);
-        }
+
+    let response = audio_http_client(&state).get(&url).send().await.map_err(|e| e.to_string())?;
+    if !response.status().is_success() {
+        emit_preload_cancelled(&app, url, track_id_for_events);
+        return Ok(());
     }
+    let data: Vec<u8> = response.bytes().await.map_err(|e| e.to_string())?.into();
+
+    if !data.is_empty() {
+        seed_preload_analysis_bytes(
+            &app,
+            &state,
+            &url,
+            &data,
+            logical_trim.as_deref(),
+            server_id.as_deref(),
+        )
+        .await;
+    }
+
     let url_for_emit = url.clone();
     *state.preloaded.lock().unwrap() = Some(PreloadedTrack { url, data });
-    let _ = app.emit("audio:preload-ready", url_for_emit);
+    emit_preload_ready(&app, url_for_emit, track_id_for_events);
     Ok(())
 }