fixed up the featured artist thing

src/routes/albums.rs

@@ -69,19 +69,32 @@ async fn get_album(
     let mbid = path.into_inner();
 
     // Try fetching as a release first
-    let mb_tracks = match state.mb_client.get_release_tracks(&mbid).await {
-        Ok(tracks) => tracks,
+    let (mb_tracks, _release_mbid) = match state.mb_client.get_release_tracks(&mbid).await {
+        Ok(tracks) => (tracks, mbid.clone()),
         Err(_) => {
             // Probably a release-group MBID. Browse releases for this group.
-            let release_mbid = resolve_release_from_group(&state, &mbid).await?;
-            state
+            let resolved = resolve_release_from_group(&state, &mbid).await?;
+            let tracks = state
                 .mb_client
-                .get_release_tracks(&release_mbid)
+                .get_release_tracks(&resolved)
                 .await
-                .map_err(|e| ApiError::Internal(format!("MusicBrainz error: {e}")))?
+                .map_err(|e| ApiError::Internal(format!("MusicBrainz error: {e}")))?;
+            (tracks, resolved)
         }
     };
 
+    // Get the album artist from the release's recording credits
+    let album_artist = if let Some(first_track) = mb_tracks.first() {
+        state
+            .mb_client
+            .get_recording(&first_track.recording_mbid)
+            .await
+            .ok()
+            .map(|r| r.artist)
+    } else {
+        None
+    };
+
     // Get all wanted items to check local status
     let all_wanted = queries::wanted::list(state.db.conn(), None, None).await?;
 
@@ -112,6 +125,7 @@ async fn get_album(
 
     Ok(HttpResponse::Ok().json(serde_json::json!({
         "mbid": mbid,
+        "artist": album_artist,
         "tracks": tracks,
     })))
 }

src/routes/artists.rs

@@ -376,14 +376,18 @@ pub async fn enrich_artist(
     .await;
     tracing::debug!(mbid = %mbid, has_photo = artist_photo.is_some(), has_bio = artist_bio.is_some(), has_banner = artist_banner.is_some(), "artist enrichment data");
 
-    // Fetch release groups and filter by allowed secondary types
+    // Fetch release groups and split into primary vs featured
     let all_release_groups = state
         .search
         .get_release_groups(&mbid)
         .await
         .map_err(|e| ApiError::Internal(e.to_string()))?;
     let allowed = state.config.read().await.allowed_secondary_types.clone();
-    let release_groups: Vec<_> = all_release_groups
+
+    let (primary_rgs, featured_rgs): (Vec<_>, Vec<_>) =
+        all_release_groups.into_iter().partition(|rg| !rg.featured);
+
+    let release_groups: Vec<_> = primary_rgs
         .into_iter()
         .filter(|rg| {
             if rg.secondary_types.is_empty() {
@@ -395,6 +399,31 @@ pub async fn enrich_artist(
         })
         .collect();
 
+    // Featured release groups — just pass through with type filtering
+    let featured_albums: Vec<FullAlbumInfo> = featured_rgs
+        .iter()
+        .filter(|rg| {
+            if rg.secondary_types.is_empty() {
+                true
+            } else {
+                rg.secondary_types.iter().all(|st| allowed.contains(st))
+            }
+        })
+        .map(|rg| FullAlbumInfo {
+            mbid: rg.first_release_id.clone().unwrap_or_else(|| rg.id.clone()),
+            title: rg.title.clone(),
+            release_type: rg.primary_type.clone(),
+            date: rg.first_release_date.clone(),
+            track_count: 0,
+            local_album_id: None,
+            watched_tracks: 0,
+            owned_tracks: 0,
+            downloaded_tracks: 0,
+            total_local_tracks: 0,
+            status: "featured".to_string(),
+        })
+        .collect();
+
     // Get all wanted items for this artist
     let all_wanted = queries::wanted::list(state.db.conn(), None, None).await?;
     let artist_wanted: Vec<_> = all_wanted
@@ -609,6 +638,7 @@ pub async fn enrich_artist(
     Ok(serde_json::json!({
         "artist": artist,
         "albums": albums,
+        "featured_albums": featured_albums,
         "artist_status": artist_status,
         "total_available_tracks": total_available_tracks,
         "total_watched_tracks": total_artist_watched,

src/routes/system.rs

@@ -58,7 +58,9 @@ async fn get_status(
     let work_queue = queries::work_queue::counts_all(conn).await.ok();
 
     // Scheduler state from DB
-    let scheduler_jobs = queries::scheduler_state::list_all(conn).await.unwrap_or_default();
+    let scheduler_jobs = queries::scheduler_state::list_all(conn)
+        .await
+        .unwrap_or_default();
     let scheduler_json: serde_json::Value = scheduler_jobs
         .iter()
         .map(|j| {
@@ -158,13 +160,8 @@ async fn trigger_organize(
         }
         for track in &tracks {
             let payload = serde_json::json!({"track_id": track.id});
-            queries::work_queue::enqueue(
-                conn,
-                WorkTaskType::Organize,
-                &payload.to_string(),
-                None,
-            )
-            .await?;
+            queries::work_queue::enqueue(conn, WorkTaskType::Organize, &payload.to_string(), None)
+                .await?;
             count += 1;
         }
         offset += 500;