PLAYER: Added generated playlists feature

Cargo.lock

@@ -1418,7 +1418,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "furumusic"
-version = "0.2.1"
+version = "0.2.10"
 dependencies = [
  "anyhow",
  "async-trait",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "furumusic"
-version = "0.2.1"
+version = "0.2.10"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 

src/admin/mod.rs

@@ -282,6 +282,32 @@ impl App for AdminApp {
                 },
                 "admin_v2_jobs",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/jobs/metadata_backfill/run-options",
+                cot::router::method::post({
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    move |session: Session,
+                          db: Database,
+                          json: Json<v2::MetadataBackfillRunRequest>| {
+                        let pool = Arc::clone(&pool);
+                        let pool_config = Arc::clone(&pool_config);
+                        async move {
+                            let pg_pool = pool
+                                .get_or_init(|| async {
+                                    sqlx::postgres::PgPoolOptions::new()
+                                        .max_connections(5)
+                                        .connect(&pool_config.database_url)
+                                        .await
+                                        .expect("admin pool")
+                                })
+                                .await;
+                            v2::run_metadata_backfill(session, db, pg_pool, json).await
+                        }
+                    }
+                }),
+                "admin_v2_metadata_backfill_run_options",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/jobs/{name}/run",
                 cot::router::method::post({

src/admin/v2.rs

@@ -9,7 +9,7 @@ use cot::response::IntoResponse;
 use cot::session::Session;
 use cot::{Body, Template};
 use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use sqlx::{PgPool, Postgres, QueryBuilder};
 
 use super::BUILD_INFO;
@@ -17,7 +17,7 @@ use crate::agent;
 use crate::auth::{self, AuthenticatedUser, Role};
 use crate::config::{AppConfig, ConfigEntry, ConfigSources};
 use crate::i18n::{I18n, Translations};
-use crate::scheduler::{JobRegistry, ScheduledJob};
+use crate::scheduler::{self, JobRegistry, JobRun, ScheduledJob};
 
 #[derive(Debug, Template)]
 #[template(path = "admin/v2.html")]
@@ -61,6 +61,24 @@ pub(super) struct BulkLibraryRequest {
     filter: Option<LibraryFilter>,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct MetadataBackfillRunRequest {
+    #[serde(default = "default_true")]
+    audio_bitrate: bool,
+    #[serde(default = "default_true")]
+    audio_sample_rate: bool,
+    #[serde(default = "default_true")]
+    audio_bit_depth: bool,
+    #[serde(default = "default_true")]
+    duration_seconds: bool,
+    #[serde(default = "default_true")]
+    local_genres: bool,
+    #[serde(default = "default_true")]
+    lastfm_tags: bool,
+    #[serde(default)]
+    overwrite: bool,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct UpdateLibraryItemRequest {
     kind: String,
@@ -68,7 +86,13 @@ pub(super) struct UpdateLibraryItemRequest {
     title: String,
     hidden: bool,
     release_type: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_optional_stringish")]
     year: Option<String>,
+    release_id: Option<i64>,
+    #[serde(default, deserialize_with = "deserialize_optional_stringish")]
+    track_number: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_optional_stringish")]
+    disc_number: Option<String>,
     artist_ids: Option<Vec<i64>>,
 }
 
@@ -155,6 +179,14 @@ struct TagDto {
     kind: String,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct MetadataTagDto {
+    name: String,
+    source: String,
+    weight: f64,
+    updated_at: String,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 struct ReviewPageDto {
     items: Vec<ReviewDto>,
@@ -385,10 +417,15 @@ struct LibraryItemDetailDto {
     hidden: bool,
     release_type: Option<String>,
     year: Option<i32>,
+    release_id: Option<i64>,
+    track_number: Option<i32>,
+    disc_number: Option<i32>,
     current_image_url: Option<String>,
     selected_artist_ids: Vec<i64>,
     artists: Vec<ArtistOptionDto>,
+    releases: Vec<ReleaseOptionDto>,
     available_covers: Vec<AvailableCoverDto>,
+    metadata_tags: Vec<MetadataTagDto>,
 }
 
 #[derive(Debug, Serialize, JsonSchema)]
@@ -397,6 +434,13 @@ struct ArtistOptionDto {
     name: String,
 }
 
+#[derive(Debug, Serialize, JsonSchema)]
+struct ReleaseOptionDto {
+    id: i64,
+    title: String,
+    subtitle: String,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 struct AvailableCoverDto {
     media_file_id: i64,
@@ -872,6 +916,68 @@ pub async fn run_job(
     }
 }
 
+pub async fn run_metadata_backfill(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    Json(body): Json<MetadataBackfillRunRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+
+    let options = crate::jobs::metadata_backfill::MetadataBackfillOptions {
+        audio_bitrate: body.audio_bitrate,
+        audio_sample_rate: body.audio_sample_rate,
+        audio_bit_depth: body.audio_bit_depth,
+        duration_seconds: body.duration_seconds,
+        local_genres: body.local_genres,
+        lastfm_tags: body.lastfm_tags,
+        overwrite: body.overwrite,
+    };
+    if !options.any_field() {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "select at least one metadata field",
+        ));
+    }
+
+    let mut run = JobRun::create_running(&db, "metadata_backfill", "manual")
+        .await
+        .map_err(|e| cot::Error::internal(format!("failed to create job run: {e}")))?;
+    let run_id = run.id_val();
+    let (live_config, _) = AppConfig::load_with_db(&db).await;
+    let db_for_task = db.clone();
+    let pool_for_task = pool.clone();
+
+    tokio::spawn(async move {
+        let start = std::time::Instant::now();
+        let ctx = scheduler::JobContext {
+            config: std::sync::Arc::new(live_config),
+            db: db_for_task.clone(),
+            pool: pool_for_task.clone(),
+            run_id,
+            registry: std::sync::Arc::new(JobRegistry::new()),
+        };
+        let mut log = scheduler::JobLog::with_live_flush(pool_for_task.clone(), run_id);
+        let result =
+            crate::jobs::metadata_backfill::run_with_options(&ctx, &mut log, options).await;
+        let duration_ms = start.elapsed().as_millis() as i64;
+        match result {
+            Ok(()) => {
+                let _ = run.set_completed(&db_for_task, duration_ms, &log.output()).await;
+            }
+            Err(err) => {
+                let _ = run
+                    .set_failed(&db_for_task, duration_ms, &log.output(), &err.to_string())
+                    .await;
+            }
+        }
+    });
+
+    Json(JobRunStartedDto { ok: true, run_id }).into_response()
+}
+
 pub async fn toggle_job(
     session: Session,
     db: Database,
@@ -1050,6 +1156,40 @@ pub async fn update_library_item(
             .execute(pool)
             .await
         }
+        "tracks" => {
+            let release_id = body.release_id.unwrap_or(0);
+            if release_id <= 0 {
+                return Ok(json_error(StatusCode::BAD_REQUEST, "release is required"));
+            }
+            let release_exists: Option<i64> =
+                sqlx::query_scalar("SELECT id FROM furumusic__release WHERE id = $1")
+                    .bind(release_id)
+                    .fetch_optional(pool)
+                    .await
+                    .map_err(|e| cot::Error::internal(e.to_string()))?;
+            if release_exists.is_none() {
+                return Ok(json_error(StatusCode::NOT_FOUND, "release not found"));
+            }
+            let year = parse_optional_admin_i32(body.year.as_deref(), 0, 3000);
+            let track_number = parse_optional_admin_i32(body.track_number.as_deref(), 1, 9999);
+            let disc_number = parse_optional_admin_i32(body.disc_number.as_deref(), 1, 999);
+            sqlx::query(
+                "UPDATE furumusic__track \
+                 SET title = $1, title_sort = $2, release_id = $3, track_number = $4, disc_number = $5, year = $6, is_hidden = $7, updated_at = $8 \
+                 WHERE id = $9",
+            )
+            .bind(title)
+            .bind(normalize_name(title))
+            .bind(release_id)
+            .bind(track_number)
+            .bind(disc_number)
+            .bind(year)
+            .bind(body.hidden)
+            .bind(&now)
+            .bind(body.id)
+            .execute(pool)
+            .await
+        }
         "playlists" => {
             sqlx::query(
                 "UPDATE furumusic__playlist \
@@ -1071,25 +1211,44 @@ pub async fn update_library_item(
     if affected == 0 {
         return Ok(json_error(StatusCode::NOT_FOUND, "library item not found"));
     }
-    if kind == "releases" {
+    if kind == "releases" || kind == "tracks" {
         if let Some(mut artist_ids) = body.artist_ids {
             let mut seen_artist_ids = HashSet::new();
             artist_ids.retain(|id| *id > 0 && seen_artist_ids.insert(*id));
-            sqlx::query("DELETE FROM furumusic__release_artist WHERE release_id = $1")
-                .bind(body.id)
-                .execute(pool)
-                .await
-                .map_err(|e| cot::Error::internal(e.to_string()))?;
-            for (position, artist_id) in artist_ids.iter().enumerate() {
-                sqlx::query(
-                    "INSERT INTO furumusic__release_artist (release_id, artist_id, position) VALUES ($1, $2, $3)",
-                )
-                .bind(body.id)
-                .bind(*artist_id)
-                .bind(position as i32)
-                .execute(pool)
-                .await
-                .map_err(|e| cot::Error::internal(e.to_string()))?;
+            if kind == "releases" {
+                sqlx::query("DELETE FROM furumusic__release_artist WHERE release_id = $1")
+                    .bind(body.id)
+                    .execute(pool)
+                    .await
+                    .map_err(|e| cot::Error::internal(e.to_string()))?;
+                for (position, artist_id) in artist_ids.iter().enumerate() {
+                    sqlx::query(
+                        "INSERT INTO furumusic__release_artist (release_id, artist_id, position) VALUES ($1, $2, $3)",
+                    )
+                    .bind(body.id)
+                    .bind(*artist_id)
+                    .bind(position as i32)
+                    .execute(pool)
+                    .await
+                    .map_err(|e| cot::Error::internal(e.to_string()))?;
+                }
+            } else {
+                sqlx::query("DELETE FROM furumusic__track_artist WHERE track_id = $1 AND role = 'main'")
+                    .bind(body.id)
+                    .execute(pool)
+                    .await
+                    .map_err(|e| cot::Error::internal(e.to_string()))?;
+                for (position, artist_id) in artist_ids.iter().enumerate() {
+                    sqlx::query(
+                        "INSERT INTO furumusic__track_artist (track_id, artist_id, role, position) VALUES ($1, $2, 'main', $3)",
+                    )
+                    .bind(body.id)
+                    .bind(*artist_id)
+                    .bind(position as i32)
+                    .execute(pool)
+                    .await
+                    .map_err(|e| cot::Error::internal(e.to_string()))?;
+                }
             }
         }
     }
@@ -1781,6 +1940,7 @@ async fn load_library_page(pool: &PgPool, query: LibraryQuery) -> anyhow::Result
     let total = count_library(pool, &kind, search_pattern.clone()).await?;
     let rows = match kind.as_str() {
         "releases" => load_release_items(pool, search_pattern.clone(), limit, offset).await?,
+        "tracks" => load_track_items(pool, search_pattern.clone(), limit, offset).await?,
         "playlists" => load_playlist_items(pool, search_pattern.clone(), limit, offset).await?,
         _ => load_artist_items(pool, search_pattern.clone(), limit, offset).await?,
     };
@@ -1808,7 +1968,7 @@ async fn fetch_library_item(
         "releases" => {
             sqlx::query_as::<_, LibraryItemRow>(
                 "SELECT r.id, r.title::text AS title, \
-                        CONCAT(r.release_type::text, COALESCE(' · ' || r.year::text, '')) AS subtitle, \
+                        (COALESCE(NULLIF(STRING_AGG(DISTINCT a.name::text, ', '), ''), 'Unknown artist') || COALESCE(' / ' || r.year::text, '')) AS subtitle, \
                         r.is_hidden, COUNT(DISTINCT t.id)::bigint AS primary_count, \
                         COUNT(DISTINCT ra.artist_id)::bigint AS secondary_count, \
                         COUNT(DISTINCT ph.id)::bigint AS tertiary_count, \
@@ -1816,6 +1976,7 @@ async fn fetch_library_item(
                  FROM furumusic__release r \
                  LEFT JOIN furumusic__track t ON t.release_id = r.id \
                  LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
+                 LEFT JOIN furumusic__artist a ON a.id = ra.artist_id \
                  LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
                  WHERE r.id = $1 \
                  GROUP BY r.id",
@@ -1841,6 +2002,26 @@ async fn fetch_library_item(
             .fetch_optional(pool)
             .await?
         }
+        "tracks" => {
+            sqlx::query_as::<_, LibraryItemRow>(
+                "SELECT t.id, t.title::text AS title, \
+                        CONCAT(r.title::text, COALESCE(' / #' || t.track_number::text, '')) AS subtitle, \
+                        t.is_hidden, COUNT(DISTINCT ta.artist_id)::bigint AS primary_count, \
+                        COUNT(DISTINCT ph.id)::bigint AS secondary_count, \
+                        COUNT(DISTINCT pt.playlist_id)::bigint AS tertiary_count, \
+                        t.updated_at::text AS updated_at \
+                 FROM furumusic__track t \
+                 JOIN furumusic__release r ON r.id = t.release_id \
+                 LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+                 LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
+                 LEFT JOIN furumusic__playlist_track pt ON pt.track_id = t.id \
+                 WHERE t.id = $1 \
+                 GROUP BY t.id, r.title",
+            )
+            .bind(id)
+            .fetch_optional(pool)
+            .await?
+        }
         _ => {
             sqlx::query_as::<_, LibraryItemRow>(
                 "SELECT a.id, a.name::text AS title, NULL::text AS subtitle, a.is_hidden, \
@@ -1874,10 +2055,15 @@ async fn load_library_item_detail(
         hidden: item.is_hidden.unwrap_or(false),
         release_type: None,
         year: None,
+        release_id: None,
+        track_number: None,
+        disc_number: None,
         current_image_url: None,
         selected_artist_ids: Vec::new(),
         artists: Vec::new(),
+        releases: Vec::new(),
         available_covers: Vec::new(),
+        metadata_tags: load_metadata_tags(pool, kind, item.id).await?,
         item,
     };
 
@@ -1917,12 +2103,128 @@ async fn load_library_item_detail(
             .collect();
             detail.artists = load_artist_options(pool).await?;
         }
+        "tracks" => {
+            let row: Option<(i64, Option<i32>, Option<i32>, Option<i32>)> = sqlx::query_as(
+                "SELECT release_id, track_number, disc_number, year FROM furumusic__track WHERE id = $1",
+            )
+            .bind(detail.item.id)
+            .fetch_optional(pool)
+            .await?;
+            if let Some((release_id, track_number, disc_number, year)) = row {
+                detail.release_id = Some(release_id);
+                detail.track_number = track_number;
+                detail.disc_number = disc_number;
+                detail.year = year;
+            }
+            detail.selected_artist_ids = sqlx::query_as::<_, IdRow>(
+                "SELECT artist_id AS id FROM furumusic__track_artist WHERE track_id = $1 AND role = 'main' ORDER BY position, artist_id",
+            )
+            .bind(detail.item.id)
+            .fetch_all(pool)
+            .await?
+            .into_iter()
+            .map(|row| row.id)
+            .collect();
+            detail.artists = load_artist_options(pool).await?;
+            detail.releases = load_release_options(pool).await?;
+        }
         _ => {}
     }
 
     Ok(detail)
 }
 
+async fn load_metadata_tags(
+    pool: &PgPool,
+    kind: &str,
+    id: i64,
+) -> anyhow::Result<Vec<MetadataTagDto>> {
+    let entity_kind = match kind {
+        "artists" => "artist",
+        "releases" => "release",
+        "tracks" => "track",
+        _ => return Ok(Vec::new()),
+    };
+    let rows = sqlx::query_as::<_, (String, String, f64, String)>(
+        r#"SELECT name, source, weight, updated_at
+           FROM (
+               SELECT g.name::text AS name,
+                      egt.source::text AS source,
+                      egt.weight,
+                      egt.updated_at::text AS updated_at
+                 FROM furumusic__entity_genre_tag egt
+                 JOIN furumusic__genre g ON g.id = egt.genre_id
+                WHERE egt.entity_kind = $1 AND egt.entity_id = $2
+               UNION ALL
+               SELECT g.name::text AS name,
+                      'track_genre'::text AS source,
+                      1.0::double precision AS weight,
+                      ''::text AS updated_at
+                 FROM furumusic__track_genre tg
+                 JOIN furumusic__genre g ON g.id = tg.genre_id
+                WHERE $1 = 'track'
+                  AND tg.track_id = $2
+                  AND NOT EXISTS (
+                      SELECT 1
+                        FROM furumusic__entity_genre_tag egt
+                       WHERE egt.entity_kind = 'track'
+                         AND egt.entity_id = tg.track_id
+                         AND egt.genre_id = tg.genre_id
+                  )
+               UNION ALL
+               SELECT g.name::text AS name,
+                      ('release_' || egt.source)::text AS source,
+                      egt.weight,
+                      egt.updated_at::text AS updated_at
+                 FROM furumusic__track t
+                 JOIN furumusic__entity_genre_tag egt
+                   ON egt.entity_kind = 'release'
+                  AND egt.entity_id = t.release_id
+                 JOIN furumusic__genre g ON g.id = egt.genre_id
+                WHERE $1 = 'track'
+                  AND t.id = $2
+                  AND NOT EXISTS (
+                      SELECT 1
+                        FROM furumusic__entity_genre_tag direct_egt
+                       WHERE direct_egt.entity_kind = 'track'
+                         AND direct_egt.entity_id = t.id
+                         AND direct_egt.genre_id = egt.genre_id
+                  )
+                  AND NOT EXISTS (
+                      SELECT 1
+                        FROM furumusic__track_genre tg
+                       WHERE tg.track_id = t.id
+                         AND tg.genre_id = egt.genre_id
+                  )
+           ) tags
+           ORDER BY CASE source
+                        WHEN 'lastfm' THEN 0
+                        WHEN 'release_lastfm' THEN 1
+                        WHEN 'review' THEN 2
+                        WHEN 'release_review' THEN 3
+                        WHEN 'file' THEN 4
+                        WHEN 'release_file' THEN 5
+                        WHEN 'track_genre' THEN 6
+                        ELSE 7
+                    END,
+                    weight DESC,
+                    name ASC"#,
+    )
+    .bind(entity_kind)
+    .bind(id)
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(name, source, weight, updated_at)| MetadataTagDto {
+            name,
+            source,
+            weight,
+            updated_at,
+        })
+        .collect())
+}
+
 async fn load_artist_options(pool: &PgPool) -> anyhow::Result<Vec<ArtistOptionDto>> {
     let rows = sqlx::query_as::<_, (i64, String)>(
         "SELECT id, name::text FROM furumusic__artist ORDER BY name ASC",
@@ -1935,6 +2237,28 @@ async fn load_artist_options(pool: &PgPool) -> anyhow::Result<Vec<ArtistOptionDt
         .collect())
 }
 
+async fn load_release_options(pool: &PgPool) -> anyhow::Result<Vec<ReleaseOptionDto>> {
+    let rows = sqlx::query_as::<_, (i64, String, Option<String>)>(
+        "SELECT r.id, r.title::text AS title, \
+                (COALESCE(NULLIF(STRING_AGG(DISTINCT a.name::text, ', '), ''), 'Unknown artist') || COALESCE(' / ' || r.year::text, '')) AS subtitle \
+         FROM furumusic__release r \
+         LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
+         LEFT JOIN furumusic__artist a ON a.id = ra.artist_id \
+         GROUP BY r.id \
+         ORDER BY r.title_sort ASC, r.year NULLS LAST, r.id ASC",
+    )
+    .fetch_all(pool)
+    .await?;
+    Ok(rows
+        .into_iter()
+        .map(|(id, title, subtitle)| ReleaseOptionDto {
+            id,
+            title,
+            subtitle: subtitle.unwrap_or_default(),
+        })
+        .collect())
+}
+
 async fn artist_available_covers(
     pool: &PgPool,
     artist_id: i64,
@@ -1974,6 +2298,13 @@ async fn library_ids_by_filter(
              LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
              LEFT JOIN furumusic__artist a ON a.id = ra.artist_id WHERE 1=1",
         ),
+        "tracks" => QueryBuilder::<Postgres>::new(
+            "SELECT DISTINCT t.id \
+             FROM furumusic__track t \
+             JOIN furumusic__release r ON r.id = t.release_id \
+             LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+             LEFT JOIN furumusic__artist a ON a.id = ta.artist_id WHERE 1=1",
+        ),
         "playlists" => QueryBuilder::<Postgres>::new(
             "SELECT DISTINCT p.id \
              FROM furumusic__playlist p \
@@ -2030,6 +2361,14 @@ async fn set_library_visibility(
             .bind(ids)
             .execute(pool)
             .await,
+            "tracks" => sqlx::query(
+                "UPDATE furumusic__track SET is_hidden = $1, updated_at = $2 WHERE id = ANY($3)",
+            )
+            .bind(hidden)
+            .bind(&now)
+            .bind(ids)
+            .execute(pool)
+            .await,
             _ => sqlx::query(
                 "UPDATE furumusic__artist SET is_hidden = $1, updated_at = $2 WHERE id = ANY($3)",
             )
@@ -2046,6 +2385,7 @@ async fn set_library_visibility(
 async fn delete_library_items(pool: &PgPool, kind: &str, ids: &[i64]) -> cot::Result<u64> {
     match kind {
         "releases" => delete_releases(pool, ids).await,
+        "tracks" => delete_tracks(pool, ids).await,
         "playlists" => delete_playlists(pool, ids).await,
         _ => delete_artists(pool, ids).await,
     }
@@ -2132,6 +2472,40 @@ async fn delete_releases(pool: &PgPool, ids: &[i64]) -> cot::Result<u64> {
     Ok(result.rows_affected())
 }
 
+async fn delete_tracks(pool: &PgPool, ids: &[i64]) -> cot::Result<u64> {
+    sqlx::query("DELETE FROM furumusic__playlist_track WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__user_liked_track WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__play_history WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__track_genre WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    sqlx::query("DELETE FROM furumusic__track_artist WHERE track_id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    let result = sqlx::query("DELETE FROM furumusic__track WHERE id = ANY($1)")
+        .bind(ids)
+        .execute(pool)
+        .await
+        .map_err(|e| cot::Error::internal(e.to_string()))?;
+    Ok(result.rows_affected())
+}
+
 async fn delete_playlists(pool: &PgPool, ids: &[i64]) -> cot::Result<u64> {
     sqlx::query("DELETE FROM furumusic__playlist_track WHERE playlist_id = ANY($1)")
         .bind(ids)
@@ -2163,6 +2537,13 @@ async fn count_library(
              LEFT JOIN furumusic__release_artist ra ON ra.release_id = r.id \
              LEFT JOIN furumusic__artist a ON a.id = ra.artist_id WHERE 1=1",
         ),
+        "tracks" => QueryBuilder::<Postgres>::new(
+            "SELECT COUNT(DISTINCT t.id) AS count \
+             FROM furumusic__track t \
+             JOIN furumusic__release r ON r.id = t.release_id \
+             LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+             LEFT JOIN furumusic__artist a ON a.id = ta.artist_id WHERE 1=1",
+        ),
         "playlists" => QueryBuilder::<Postgres>::new(
             "SELECT COUNT(DISTINCT p.id) AS count \
              FROM furumusic__playlist p \
@@ -2203,6 +2584,15 @@ fn push_library_search_filter(
             qb.push_bind(pattern);
             qb.push(")");
         }
+        "tracks" => {
+            qb.push(" AND (t.title ILIKE ");
+            qb.push_bind(pattern.clone());
+            qb.push(" OR r.title ILIKE ");
+            qb.push_bind(pattern.clone());
+            qb.push(" OR a.name ILIKE ");
+            qb.push_bind(pattern);
+            qb.push(")");
+        }
         _ => {
             qb.push(" AND a.name ILIKE ");
             qb.push_bind(pattern);
@@ -2250,7 +2640,7 @@ async fn load_release_items(
 ) -> anyhow::Result<Vec<LibraryItemRow>> {
     let mut qb = QueryBuilder::<Postgres>::new(
         "SELECT r.id, r.title::text AS title, \
-                CONCAT(r.release_type::text, COALESCE(' · ' || r.year::text, '')) AS subtitle, \
+                (COALESCE(NULLIF(STRING_AGG(DISTINCT a.name::text, ', '), ''), 'Unknown artist') || COALESCE(' / ' || r.year::text, '')) AS subtitle, \
                 r.is_hidden, COUNT(DISTINCT t.id)::bigint AS primary_count, \
                 COUNT(DISTINCT ra.artist_id)::bigint AS secondary_count, \
                 COUNT(DISTINCT ph.id)::bigint AS tertiary_count, \
@@ -2279,6 +2669,46 @@ async fn load_release_items(
         .await?)
 }
 
+async fn load_track_items(
+    pool: &PgPool,
+    search_pattern: Option<String>,
+    limit: i64,
+    offset: i64,
+) -> anyhow::Result<Vec<LibraryItemRow>> {
+    let mut qb = QueryBuilder::<Postgres>::new(
+        "SELECT t.id, t.title::text AS title, \
+                CONCAT(r.title::text, COALESCE(' / #' || t.track_number::text, '')) AS subtitle, \
+                t.is_hidden, COUNT(DISTINCT ta.artist_id)::bigint AS primary_count, \
+                COUNT(DISTINCT ph.id)::bigint AS secondary_count, \
+                COUNT(DISTINCT pt.playlist_id)::bigint AS tertiary_count, \
+                t.updated_at::text AS updated_at \
+         FROM furumusic__track t \
+         JOIN furumusic__release r ON r.id = t.release_id \
+         LEFT JOIN furumusic__track_artist ta ON ta.track_id = t.id \
+         LEFT JOIN furumusic__artist a ON a.id = ta.artist_id \
+         LEFT JOIN furumusic__play_history ph ON ph.track_id = t.id \
+         LEFT JOIN furumusic__playlist_track pt ON pt.track_id = t.id \
+         WHERE 1=1",
+    );
+    if let Some(pattern) = search_pattern {
+        qb.push(" AND (t.title ILIKE ");
+        qb.push_bind(pattern.clone());
+        qb.push(" OR r.title ILIKE ");
+        qb.push_bind(pattern.clone());
+        qb.push(" OR a.name ILIKE ");
+        qb.push_bind(pattern);
+        qb.push(")");
+    }
+    qb.push(" GROUP BY t.id, r.title ORDER BY r.title ASC, t.disc_number NULLS FIRST, t.track_number NULLS FIRST, t.title ASC LIMIT ");
+    qb.push_bind(limit);
+    qb.push(" OFFSET ");
+    qb.push_bind(offset);
+    Ok(qb
+        .build_query_as::<LibraryItemRow>()
+        .fetch_all(pool)
+        .await?)
+}
+
 async fn load_playlist_items(
     pool: &PgPool,
     search_pattern: Option<String>,
@@ -2324,6 +2754,11 @@ fn library_item_dto(kind: &str, row: LibraryItemRow) -> LibraryItemDto {
             tag(format!("{} artists", row.secondary_count), "relation"),
             tag(format!("{} plays", row.tertiary_count), "plays"),
         ],
+        "tracks" => vec![
+            tag(format!("{} artists", row.primary_count), "relation"),
+            tag(format!("{} plays", row.secondary_count), "plays"),
+            tag(format!("{} playlists", row.tertiary_count), "count"),
+        ],
         "playlists" => vec![
             tag(format!("{} tracks", row.primary_count), "count"),
             tag(
@@ -2401,6 +2836,10 @@ fn tag(label: impl Into<String>, kind: impl Into<String>) -> TagDto {
     }
 }
 
+fn default_true() -> bool {
+    true
+}
+
 fn optional_job_time(value: &str) -> Option<String> {
     if value.is_empty() {
         None
@@ -2410,9 +2849,12 @@ fn optional_job_time(value: &str) -> Option<String> {
 }
 
 fn normalize_library_kind(kind: Option<&str>) -> String {
-    match kind {
-        Some("releases") => "releases",
-        Some("playlists") => "playlists",
+    let kind = kind.unwrap_or_default().trim().to_ascii_lowercase();
+    match kind.as_str() {
+        "release" | "releases" => "releases",
+        "track" | "tracks" => "tracks",
+        "playlist" | "playlists" => "playlists",
+        "artist" | "artists" => "artists",
         _ => "artists",
     }
     .to_owned()
@@ -2437,6 +2879,34 @@ fn normalize_name(value: &str) -> String {
     value.trim().to_lowercase()
 }
 
+fn parse_optional_admin_i32(value: Option<&str>, min: i32, max: i32) -> Option<i32> {
+    let value = value?.trim();
+    if value.is_empty() {
+        return None;
+    }
+    value
+        .parse::<i32>()
+        .ok()
+        .map(|parsed| parsed.clamp(min, max))
+}
+
+fn deserialize_optional_stringish<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let Some(value) = Option::<serde_json::Value>::deserialize(deserializer)? else {
+        return Ok(None);
+    };
+    match value {
+        serde_json::Value::Null => Ok(None),
+        serde_json::Value::String(value) => Ok(Some(value)),
+        serde_json::Value::Number(value) => Ok(Some(value.to_string())),
+        other => Err(serde::de::Error::custom(format!(
+            "expected string, number, or null, got {other}"
+        ))),
+    }
+}
+
 fn now_string() -> String {
     chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string()
 }

src/admin/views.rs

@@ -1402,6 +1402,8 @@ pub struct MetadataBackfillForm {
     audio_sample_rate: Option<String>,
     audio_bit_depth: Option<String>,
     duration_seconds: Option<String>,
+    local_genres: Option<String>,
+    lastfm_tags: Option<String>,
     mode: Option<String>,
 }
 
@@ -1468,6 +1470,8 @@ pub async fn metadata_backfill_run(
         audio_sample_rate: data.audio_sample_rate.is_some(),
         audio_bit_depth: data.audio_bit_depth.is_some(),
         duration_seconds: data.duration_seconds.is_some(),
+        local_genres: data.local_genres.is_some(),
+        lastfm_tags: data.lastfm_tags.is_some(),
         overwrite: data.mode.as_deref() == Some("overwrite"),
     };
 

src/agent/cover_art.rs

@@ -370,7 +370,8 @@ pub async fn save_cover_to_storage(
     }
 
     let ext = extension_for_mime(&cover.mime_type);
-    let filename = format!("cover.{ext}");
+    let hash_prefix: String = hash.chars().take(12).collect();
+    let filename = format!("cover-{hash_prefix}.{ext}");
 
     let artist_dir = sanitize_dir_name(artist_name);
     let album_dir = sanitize_dir_name(release_title);

src/i18n/phrases.rs

@@ -338,10 +338,19 @@ translations! {
     player_lastfm_connected: "Connected as {user}"             , "Подключён: {user}";
     player_lastfm_reconnect: "Reconnect Last.fm"               , "Переподключить Last.fm";
     player_lastfm_not_configured: "Last.fm is not configured"  , "Last.fm не настроен";
+    player_lastfm_status_connect: "connect account"            , "подключить аккаунт";
+    player_lastfm_status_connected: "connected"                , "подключён";
+    player_lastfm_status_reconnect: "reconnect account"        , "переподключить аккаунт";
+    player_lastfm_status_not_configured: "not configured"      , "не настроен";
     player_lastfm_disconnect_confirm: "Disconnect Last.fm account {user}?" , "Отвязать аккаунт Last.fm {user}?";
     player_lastfm_connect_failed: "Could not open Last.fm connection" , "Не удалось открыть подключение Last.fm";
     player_lastfm_disconnect_failed: "Could not disconnect Last.fm" , "Не удалось отвязать Last.fm";
     player_play:             "Play"                            , "Играть";
+    player_listen:           "Listen"                          , "Слушать";
+    player_listen_artist:    "Listen to artist"                , "Слушать артиста";
+    player_start_radio:      "Start radio"                     , "Запустить радио";
+    player_radio_failed:     "Could not start radio"           , "Не удалось запустить радио";
+    player_played_at:        "Played"                          , "Прослушано";
     player_like:             "Like"                            , "Лайк";
     player_add_to_queue:     "Add to queue"                    , "Добавить в очередь";
     player_add_to_end_queue: "Add to end of queue"             , "Добавить в конец очереди";

src/jobs/inbox_process.rs

@@ -878,6 +878,26 @@ pub async fn finalize_approved(
         .await;
     }
 
+    let approved_genre = normalized
+        .genre
+        .as_deref()
+        .or_else(|| context.get("raw_genre").and_then(|v| v.as_str()))
+        .map(str::trim)
+        .filter(|value| !value.is_empty());
+    if let Some(genre) = approved_genre {
+        if let Err(err) =
+            crate::jobs::metadata_backfill::save_approved_track_genres(pool, track.id_val(), genre)
+                .await
+        {
+            tracing::warn!(
+                track_id = track.id_val(),
+                genre,
+                error = %err,
+                "failed to save approved track genre metadata"
+            );
+        }
+    }
+
     // Cover art: if the release has no cover yet, try to find one
     if release.cover_file_id.is_none() {
         let source_folder = Path::new(input_path_str).parent().unwrap_or(Path::new("."));

src/music/mod.rs

@@ -1815,6 +1815,56 @@ pub mod db_migrations {
             &[Operation::custom(create_artwork_lookup_state).build()];
     }
 
+    // -- M0035: Weighted metadata tags for tracks, releases, and artists ----
+
+    #[cot::db::migrations::migration_op]
+    async fn create_entity_genre_tags(
+        ctx: migrations::MigrationContext<'_>,
+    ) -> cot::db::Result<()> {
+        ctx.db
+            .raw(
+                "CREATE TABLE IF NOT EXISTS furumusic__entity_genre_tag (
+                    id BIGSERIAL PRIMARY KEY,
+                    entity_kind VARCHAR(32) NOT NULL,
+                    entity_id BIGINT NOT NULL,
+                    genre_id BIGINT NOT NULL,
+                    source VARCHAR(32) NOT NULL,
+                    weight DOUBLE PRECISION NOT NULL DEFAULT 1,
+                    updated_at VARCHAR(32) NOT NULL,
+                    UNIQUE(entity_kind, entity_id, genre_id, source)
+                )",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_entity_genre_tag_entity
+                   ON furumusic__entity_genre_tag (entity_kind, entity_id, source)",
+            )
+            .await?;
+        ctx.db
+            .raw(
+                "CREATE INDEX IF NOT EXISTS idx_entity_genre_tag_genre
+                   ON furumusic__entity_genre_tag (genre_id, entity_kind)",
+            )
+            .await?;
+        Ok(())
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct M0035CreateEntityGenreTags;
+
+    impl migrations::Migration for M0035CreateEntityGenreTags {
+        const APP_NAME: &'static str = "furumusic";
+        const MIGRATION_NAME: &'static str = "m_0035_create_entity_genre_tags";
+        const DEPENDENCIES: &'static [migrations::MigrationDependency] =
+            &[migrations::MigrationDependency::migration(
+                "furumusic",
+                "m_0034_create_artwork_lookup_state",
+            )];
+        const OPERATIONS: &'static [Operation] =
+            &[Operation::custom(create_entity_genre_tags).build()];
+    }
+
     pub const MIGRATIONS: &[&SyncDynMigration] = &[
         &M0006CreateMediaFile,
         &M0007CreateArtist,
@@ -1840,5 +1890,6 @@ pub mod db_migrations {
         &M0032CreateLastfmTrackPopularity,
         &M0033CreateLastfmScrobbling,
         &M0034CreateArtworkLookupState,
+        &M0035CreateEntityGenreTags,
     ];
 }

src/player/dto.rs

@@ -36,17 +36,18 @@ pub(super) struct ArtistDetail {
     pub(super) image_url: Option<String>,
     pub(super) total_track_count: i64,
     pub(super) total_play_count: i64,
+    pub(super) top_tracks: Vec<TrackItem>,
     pub(super) releases: Vec<ReleaseCard>,
     pub(super) featured_tracks: Vec<ArtistAppearanceTrack>,
 }
 
-#[derive(Debug, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, JsonSchema)]
 pub(super) struct ArtistRef {
     pub(super) id: i64,
     pub(super) name: String,
 }
 
-#[derive(Debug, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Serialize, JsonSchema)]
 pub(super) struct TrackItem {
     pub(super) id: i64,
     pub(super) title: String,
@@ -137,6 +138,143 @@ pub(super) struct PlaybackStateDto {
     pub(super) volume: f64,
 }
 
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct DeviceHeartbeatRequest {
+    pub(super) device_id: String,
+    pub(super) user_agent: Option<String>,
+    pub(super) current_jam_id: Option<String>,
+    pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct DeviceSelectRequest {
+    pub(super) device_id: String,
+    pub(super) current_device_id: Option<String>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct DeviceCommandRequest {
+    pub(super) target_device_id: Option<String>,
+    pub(super) jam_id: Option<String>,
+    pub(super) command: String,
+    #[serde(default)]
+    pub(super) payload: serde_json::Value,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerDeviceDto {
+    pub(super) id: String,
+    pub(super) name: String,
+    pub(super) kind: String,
+    pub(super) is_current: bool,
+    pub(super) is_active: bool,
+    pub(super) last_seen_ms: i64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerJamDto {
+    pub(super) id: String,
+    pub(super) name: String,
+    pub(super) host_user_id: i64,
+    pub(super) host_name: String,
+    pub(super) is_owner: bool,
+    pub(super) is_member: bool,
+    pub(super) is_pending: bool,
+    pub(super) is_active: bool,
+    pub(super) member_count: i64,
+    pub(super) host_last_seen_ms: i64,
+    pub(super) host_device_online: bool,
+    pub(super) members: Vec<PlayerJamMemberDto>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerJamMemberDto {
+    pub(super) user_id: i64,
+    pub(super) name: String,
+    pub(super) is_joined: bool,
+    pub(super) is_current_user: bool,
+    pub(super) last_seen_ms: i64,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct PlayerJamCreateRequest {
+    pub(super) device_id: String,
+    #[serde(default)]
+    pub(super) invitee_user_ids: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct PlayerJamInviteRequest {
+    pub(super) jam_id: String,
+    pub(super) device_id: String,
+    #[serde(default)]
+    pub(super) invitee_user_ids: Vec<i64>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct PlayerJamJoinRequest {
+    pub(super) jam_id: String,
+    pub(super) device_id: String,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct PlayerJamLeaveRequest {
+    pub(super) jam_id: String,
+    pub(super) device_id: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerJamUserDto {
+    pub(super) id: i64,
+    pub(super) username: String,
+    pub(super) display_name: Option<String>,
+    pub(super) email: Option<String>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerDeviceCommandDto {
+    pub(super) id: String,
+    pub(super) command: String,
+    pub(super) payload: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub(super) struct PlayerDevicePlaybackStateDto {
+    pub(super) track: Option<serde_json::Value>,
+    #[serde(default)]
+    pub(super) tracks: Vec<serde_json::Value>,
+    pub(super) index: i32,
+    pub(super) position_seconds: f64,
+    pub(super) duration_seconds: f64,
+    pub(super) paused: bool,
+    pub(super) shuffle: bool,
+    pub(super) repeat_mode: String,
+    pub(super) volume: f64,
+    #[serde(default)]
+    pub(super) updated_at_ms: i64,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerDevicesResponse {
+    pub(super) device_id: String,
+    pub(super) active_device_id: Option<String>,
+    pub(super) devices: Vec<PlayerDeviceDto>,
+    pub(super) jams: Vec<PlayerJamDto>,
+    pub(super) current_jam_id: Option<String>,
+    pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct PlayerDevicePollResponse {
+    pub(super) device_id: String,
+    pub(super) active_device_id: Option<String>,
+    pub(super) devices: Vec<PlayerDeviceDto>,
+    pub(super) jams: Vec<PlayerJamDto>,
+    pub(super) current_jam_id: Option<String>,
+    pub(super) commands: Vec<PlayerDeviceCommandDto>,
+    pub(super) playback_state: Option<PlayerDevicePlaybackStateDto>,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct PlaylistDetail {
     pub(super) id: i64,
@@ -167,6 +305,7 @@ pub(super) struct UserStats {
 
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct UserProfile {
+    pub(super) id: i64,
     pub(super) name: String,
     pub(super) role: String,
     pub(super) stats: UserStats,
@@ -207,12 +346,125 @@ pub(super) struct AgentQueueStatus {
     pub(super) processing_count: i64,
 }
 
+#[derive(Debug, Clone, Serialize, JsonSchema)]
+pub(super) struct UserUploadTrack {
+    pub(super) track: TrackItem,
+    pub(super) media_file_id: i64,
+    pub(super) is_hidden: bool,
+    pub(super) release_is_hidden: bool,
+    pub(super) release_type: String,
+    pub(super) year: Option<i32>,
+    pub(super) uploaded_at: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadRelease {
+    pub(super) id: i64,
+    pub(super) title: String,
+    pub(super) release_type: String,
+    pub(super) year: Option<i32>,
+    pub(super) is_hidden: bool,
+    pub(super) artists: Vec<ArtistRef>,
+    pub(super) tracks: Vec<UserUploadTrack>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadReviewFields {
+    pub(super) title: String,
+    pub(super) artist: String,
+    pub(super) album: String,
+    pub(super) year: String,
+    pub(super) track_number: String,
+    pub(super) genre: String,
+    pub(super) featured_artists: Vec<String>,
+    pub(super) release_type: String,
+    pub(super) notes: String,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadReviewItem {
+    pub(super) id: i64,
+    pub(super) status: String,
+    pub(super) filename: String,
+    pub(super) created_at: String,
+    pub(super) updated_at: String,
+    pub(super) error_message: Option<String>,
+    pub(super) fields: UserUploadReviewFields,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadQueueItem {
+    pub(super) id: i64,
+    pub(super) status: String,
+    pub(super) filename: String,
+    pub(super) created_at: String,
+    pub(super) updated_at: String,
+    pub(super) error_message: Option<String>,
+}
+
+#[derive(Debug, Serialize, JsonSchema)]
+pub(super) struct UserUploadsPage {
+    pub(super) tracks: Vec<UserUploadTrack>,
+    pub(super) releases: Vec<UserUploadRelease>,
+    pub(super) pending: Vec<UserUploadReviewItem>,
+    pub(super) queued: Vec<UserUploadQueueItem>,
+    pub(super) pending_total: i64,
+    pub(super) queued_total: i64,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct UserUploadTrackUpdateRequest {
+    pub(super) title: Option<String>,
+    pub(super) artist_names: Option<Vec<String>>,
+    pub(super) featured_artist_names: Option<Vec<String>>,
+    pub(super) release_title: Option<String>,
+    pub(super) release_type: Option<String>,
+    pub(super) release_year: Option<String>,
+    pub(super) track_number: Option<String>,
+    pub(super) disc_number: Option<String>,
+    pub(super) is_hidden: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct UserUploadReleaseUpdateRequest {
+    pub(super) title: Option<String>,
+    pub(super) artist_names: Option<Vec<String>>,
+    pub(super) release_type: Option<String>,
+    pub(super) year: Option<String>,
+    pub(super) is_hidden: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct UserUploadBulkTrackUpdateRequest {
+    pub(super) track_ids: Vec<i64>,
+    pub(super) artist_names: Option<Vec<String>>,
+    pub(super) featured_artist_names: Option<Vec<String>>,
+    pub(super) release_title: Option<String>,
+    pub(super) release_type: Option<String>,
+    pub(super) release_year: Option<String>,
+    pub(super) is_hidden: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, JsonSchema)]
+pub(super) struct UserUploadReviewUpdateRequest {
+    pub(super) title: Option<String>,
+    pub(super) artist: Option<String>,
+    pub(super) album: Option<String>,
+    pub(super) year: Option<String>,
+    pub(super) track_number: Option<String>,
+    pub(super) genre: Option<String>,
+    pub(super) featured_artists: Option<Vec<String>>,
+    pub(super) release_type: Option<String>,
+    pub(super) notes: Option<String>,
+}
+
 #[derive(Debug, Serialize, JsonSchema)]
 pub(super) struct PlayHistoryItem {
     pub(super) id: i64,
     pub(super) track_id: i64,
     pub(super) track_title: String,
     pub(super) release_title: Option<String>,
+    pub(super) track: TrackItem,
     pub(super) played_at: String,
     pub(super) duration_listened: Option<i32>,
     pub(super) completed: bool,

src/player/queries.rs

@@ -19,6 +19,11 @@ pub(super) struct TracksByIdsRequest {
     pub(super) ids: Vec<i64>,
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct UserUploadsQuery {
+    pub(super) limit: Option<i32>,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct CreatePlaylistRequest {
     pub(super) title: String,
@@ -56,12 +61,24 @@ pub(super) struct PathStringId {
     pub(super) id: String,
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct PathRadioSeed {
+    pub(super) kind: String,
+    pub(super) id: i64,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct SearchQuery {
     pub(super) q: String,
     pub(super) limit: Option<i32>,
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct JamUserSearchQuery {
+    pub(super) q: Option<String>,
+    pub(super) limit: Option<i32>,
+}
+
 #[derive(Debug, Deserialize)]
 pub(super) struct PathTrackId {
     pub(super) track_id: i64,

src/player/rows.rs

@@ -12,6 +12,14 @@ pub(super) struct CountRow {
     pub(super) count: i64,
 }
 
+#[derive(sqlx::FromRow)]
+pub(super) struct PlayerJamUserRow {
+    pub(super) id: i64,
+    pub(super) username: String,
+    pub(super) display_name: Option<String>,
+    pub(super) email: Option<String>,
+}
+
 #[derive(sqlx::FromRow)]
 pub(super) struct ReleaseRow {
     pub(super) id: i64,
@@ -28,30 +36,6 @@ pub(super) struct ArtistBriefRow {
     pub(super) name: String,
 }
 
-#[derive(sqlx::FromRow)]
-pub(super) struct TrackRow {
-    pub(super) id: i64,
-    pub(super) title: String,
-    pub(super) track_number: Option<i32>,
-    pub(super) disc_number: Option<i32>,
-    pub(super) duration_seconds: f64,
-    pub(super) cover_file_id: Option<i64>,
-    pub(super) release_cover_file_id: Option<i64>,
-    pub(super) release_id: i64,
-    pub(super) release_title: String,
-    pub(super) release_year: Option<i32>,
-    pub(super) uploader_name: String,
-    pub(super) audio_format: Option<String>,
-    pub(super) audio_bitrate: Option<i32>,
-    pub(super) audio_sample_rate: Option<i32>,
-    pub(super) audio_bit_depth: Option<i32>,
-    pub(super) file_size_bytes: Option<i64>,
-    pub(super) lastfm_listeners: Option<i64>,
-    pub(super) lastfm_playcount: Option<i64>,
-    pub(super) lastfm_rating: Option<f64>,
-    pub(super) lastfm_updated_at: Option<String>,
-}
-
 #[derive(sqlx::FromRow)]
 pub(super) struct TrackArtistRow {
     pub(super) track_id: i64,
@@ -60,6 +44,13 @@ pub(super) struct TrackArtistRow {
     pub(super) role: String,
 }
 
+#[derive(sqlx::FromRow)]
+pub(super) struct ReleaseArtistRefRow {
+    pub(super) release_id: i64,
+    pub(super) artist_id: i64,
+    pub(super) artist_name: String,
+}
+
 #[derive(sqlx::FromRow)]
 pub(super) struct MediaFileRow {
     pub(super) file_path: String,
@@ -124,6 +115,70 @@ pub(super) struct PlaylistTrackRow {
     pub(super) lastfm_updated_at: Option<String>,
 }
 
+#[derive(sqlx::FromRow)]
+pub(super) struct UploadedTrackRow {
+    pub(super) id: i64,
+    pub(super) title: String,
+    pub(super) track_number: Option<i32>,
+    pub(super) disc_number: Option<i32>,
+    pub(super) duration_seconds: f64,
+    pub(super) cover_file_id: Option<i64>,
+    pub(super) release_cover_file_id: Option<i64>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
+    pub(super) release_type: String,
+    pub(super) release_year: Option<i32>,
+    pub(super) release_is_hidden: bool,
+    pub(super) uploader_name: String,
+    pub(super) audio_format: Option<String>,
+    pub(super) audio_bitrate: Option<i32>,
+    pub(super) audio_sample_rate: Option<i32>,
+    pub(super) audio_bit_depth: Option<i32>,
+    pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
+    pub(super) media_file_id: i64,
+    pub(super) is_hidden: bool,
+    pub(super) year: Option<i32>,
+    pub(super) uploaded_at: String,
+}
+
+#[derive(sqlx::FromRow)]
+pub(super) struct UserUploadQueueRow {
+    pub(super) id: i64,
+    pub(super) status: String,
+    pub(super) input_path: Option<String>,
+    pub(super) created_at: String,
+    pub(super) updated_at: String,
+    pub(super) error_message: Option<String>,
+}
+
+#[derive(sqlx::FromRow)]
+pub(super) struct UserUploadReviewRow {
+    pub(super) id: i64,
+    pub(super) status: String,
+    pub(super) input_path: Option<String>,
+    pub(super) result_json: Option<String>,
+    pub(super) context_json: Option<String>,
+    pub(super) created_at: String,
+    pub(super) updated_at: String,
+    pub(super) error_message: Option<String>,
+}
+
+#[derive(sqlx::FromRow)]
+pub(super) struct UploadTrackEditRow {
+    pub(super) release_id: i64,
+    pub(super) title: String,
+    pub(super) track_number: Option<i32>,
+    pub(super) disc_number: Option<i32>,
+    pub(super) is_hidden: bool,
+    pub(super) release_title: String,
+    pub(super) release_type: String,
+    pub(super) release_year: Option<i32>,
+}
+
 #[derive(sqlx::FromRow)]
 pub(super) struct AppearanceTrackRow {
     pub(super) id: i64,
@@ -197,14 +252,31 @@ pub(super) struct ReleaseUploaderRow {
 }
 
 #[derive(sqlx::FromRow)]
-pub(super) struct PlayHistoryRow {
-    pub(super) id: i64,
-    pub(super) track_id: i64,
-    pub(super) track_title: String,
-    pub(super) release_title: Option<String>,
+pub(super) struct PlayHistoryTrackRow {
+    pub(super) history_id: i64,
     pub(super) played_at: String,
     pub(super) duration_listened: Option<i32>,
     pub(super) completed: bool,
+    pub(super) id: i64,
+    pub(super) title: String,
+    pub(super) track_number: Option<i32>,
+    pub(super) disc_number: Option<i32>,
+    pub(super) duration_seconds: f64,
+    pub(super) cover_file_id: Option<i64>,
+    pub(super) release_cover_file_id: Option<i64>,
+    pub(super) release_id: i64,
+    pub(super) release_title: String,
+    pub(super) release_year: Option<i32>,
+    pub(super) uploader_name: String,
+    pub(super) audio_format: Option<String>,
+    pub(super) audio_bitrate: Option<i32>,
+    pub(super) audio_sample_rate: Option<i32>,
+    pub(super) audio_bit_depth: Option<i32>,
+    pub(super) file_size_bytes: Option<i64>,
+    pub(super) lastfm_listeners: Option<i64>,
+    pub(super) lastfm_playcount: Option<i64>,
+    pub(super) lastfm_rating: Option<f64>,
+    pub(super) lastfm_updated_at: Option<String>,
 }
 
 #[derive(sqlx::FromRow)]

templates/admin/job_detail.html

@@ -46,6 +46,12 @@
         <label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
             <input type="checkbox" name="duration_seconds" checked> duration_seconds
         </label>
+        <label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
+            <input type="checkbox" name="local_genres" checked> local genres from files
+        </label>
+        <label style="display:inline-flex; gap:.35rem; align-items:center; margin-right:1rem; margin-bottom:.4rem;">
+            <input type="checkbox" name="lastfm_tags" checked> Last.fm tags
+        </label>
     </fieldset>
     <div style="display:flex; gap:1rem; align-items:center; margin-bottom:.9rem;">
         <label style="display:inline-flex; gap:.35rem; align-items:center;">

templates/admin/v2.html

@@ -486,6 +486,13 @@ tbody tr:hover {
 .tag.plays,
 .tag.followers { background: rgba(185, 140, 255, 0.18); color: #d8c2ff; }
 .tag.visibility { background: rgba(29, 185, 84, 0.16); color: #8ef0b2; }
+.tag.metadata-lastfm { background: rgba(90, 167, 255, 0.18); color: #c7e0ff; }
+.tag.metadata-file { background: rgba(29, 185, 84, 0.16); color: #9af0b8; }
+.tag.metadata-review { background: rgba(241, 184, 75, 0.18); color: #ffe1a6; }
+.tag.metadata-track-genre { background: rgba(255, 255, 255, 0.1); color: #d2d2d2; }
+.tag.metadata-release-lastfm { background: rgba(90, 167, 255, 0.12); color: #b7d6ff; border: 1px solid rgba(90, 167, 255, 0.22); }
+.tag.metadata-release-file { background: rgba(29, 185, 84, 0.1); color: #a7eabd; border: 1px solid rgba(29, 185, 84, 0.2); }
+.tag.metadata-release-review { background: rgba(241, 184, 75, 0.12); color: #ffe1a6; border: 1px solid rgba(241, 184, 75, 0.22); }
 
 .jobs-grid {
     display: grid;
@@ -494,6 +501,45 @@ tbody tr:hover {
     padding: 12px;
 }
 
+.metadata-backfill-options {
+    display: grid;
+    gap: 8px;
+    margin-bottom: 12px;
+    padding: 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+}
+
+.metadata-backfill-options .option-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 8px;
+}
+
+.metadata-backfill-options label {
+    display: inline-flex;
+    align-items: center;
+    gap: 7px;
+    min-height: 26px;
+    color: var(--text-secondary);
+    font-size: 12px;
+    font-weight: 700;
+}
+
+.metadata-backfill-options input {
+    width: auto;
+    min-height: auto;
+}
+
+.metadata-backfill-options .mode-row {
+    display: flex;
+    gap: 14px;
+    flex-wrap: wrap;
+    padding-top: 4px;
+    border-top: 1px solid rgba(255, 255, 255, 0.06);
+}
+
 .jobs-page {
     display: grid;
     grid-template-columns: minmax(720px, 1fr) 380px;
@@ -524,31 +570,37 @@ tbody tr:hover {
     table-layout: fixed;
 }
 
-.jobs-page .jobs-list-panel .panel-head,
-.jobs-page .jobs-list-panel .action-strip {
+.jobs-page .jobs-list-panel .panel-head {
     flex-shrink: 0;
 }
 
-.jobs-page .jobs-list-panel .action-strip {
-    border-top: 1px solid var(--border-color);
-    border-bottom: 0;
-}
-
-.job-table .job-column { width: 28%; }
-.job-table .state-column { width: 13%; }
-.job-table .schedule-column { width: 20%; }
-.job-table .runs-column { width: 29%; }
+.job-table .job-column { width: 32%; }
+.job-table .state-column { width: 12%; }
+.job-table .schedule-column { width: 22%; }
+.job-table .runs-column { width: 24%; }
 .job-table .actions-column { width: 10%; }
 
+.job-table .toolbar {
+    flex-wrap: nowrap;
+    justify-content: flex-end;
+}
+
 .inline-runs {
     display: flex;
-    flex-wrap: wrap;
+    flex-wrap: nowrap;
     gap: 5px;
+    max-width: 100%;
+    overflow: hidden;
 }
 
 .run-chip {
     gap: 5px;
-    max-width: 128px;
+    max-width: 70px;
+    height: 20px;
+    padding: 0 7px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
 }
 
 .task-form {
@@ -557,6 +609,76 @@ tbody tr:hover {
     grid-column: 2;
     grid-row: 1 / span 2;
     align-self: start;
+    display: flex;
+    flex-direction: column;
+    max-height: calc(100vh - 100px);
+    overflow: hidden;
+}
+
+.task-form-body {
+    min-height: 0;
+    overflow: auto;
+    padding: 12px;
+}
+
+.job-detail-description {
+    margin-bottom: 10px;
+    color: var(--text-secondary);
+    font-size: 12px;
+    line-height: 1.45;
+}
+
+.job-facts {
+    display: grid;
+    gap: 8px;
+    margin-bottom: 12px;
+}
+
+.job-fact {
+    display: grid;
+    grid-template-columns: 58px minmax(0, 1fr);
+    gap: 8px;
+    align-items: center;
+    min-height: 28px;
+    padding: 6px 8px;
+    border: 1px solid var(--border-color);
+    border-radius: 7px;
+    background: var(--bg-primary);
+}
+
+.job-fact span:first-child {
+    color: var(--text-subdued);
+    font-size: 10px;
+    font-weight: 850;
+    text-transform: uppercase;
+}
+
+.job-fact span:last-child {
+    min-width: 0;
+    color: var(--text-secondary);
+    font-size: 12px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.job-param-note {
+    margin: -2px 0 10px;
+    color: var(--text-subdued);
+    font-size: 11px;
+}
+
+.job-run-pager {
+    min-height: 34px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    padding: 8px 0 0;
+}
+
+.job-run-pager .toolbar {
+    flex-wrap: nowrap;
 }
 
 .run-log-panel {
@@ -941,6 +1063,44 @@ tbody tr:hover {
     margin-bottom: 8px;
 }
 
+.run-log-output.is-following {
+    border-color: rgba(29, 185, 84, 0.36);
+}
+
+.metadata-tags {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+    max-height: 112px;
+    overflow: auto;
+    padding: 8px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+}
+
+.metadata-tags .tag {
+    height: auto;
+    min-height: 24px;
+    gap: 5px;
+    padding: 4px 8px;
+}
+
+.metadata-tags small {
+    font-size: 9px;
+    font-weight: 800;
+    opacity: 0.72;
+    text-transform: uppercase;
+}
+
+.metadata-empty {
+    min-height: 34px;
+    padding: 8px 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: var(--bg-primary);
+}
+
 .artist-picker {
     position: relative;
 }
@@ -975,6 +1135,16 @@ tbody tr:hover {
     cursor: pointer;
 }
 
+.artist-result small {
+    display: block;
+    margin-top: 2px;
+    color: var(--text-subdued);
+    font-size: 11px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
 .artist-result:hover,
 .artist-result:focus {
     background: var(--bg-hover);
@@ -1325,7 +1495,7 @@ tbody tr:hover {
                                 </tr>
                             </thead>
                             <tbody>
-                                <template x-for="job in pagedJobs()" :key="job.name">
+                                <template x-for="job in jobs" :key="job.name">
                                     <tr :class="{active: activeJob && activeJob.name === job.name}" @click="selectJob(job.name)">
                                         <td>
                                             <div class="primary-line" x-text="job.name"></div>
@@ -1338,7 +1508,7 @@ tbody tr:hover {
                                         </td>
                                         <td>
                                             <div class="inline-runs">
-                                                <template x-for="run in (job.recent_runs || []).slice(0, 5)" :key="run.id">
+                                                <template x-for="run in (job.recent_runs || []).slice(0, 3)" :key="run.id">
                                                     <button class="badge run-chip" :class="run.status" @click.stop="loadRunDetail(run)" :title="runTitle(run)">
                                                         <span x-text="runChipLabel(run)"></span>
                                                     </button>
@@ -1347,10 +1517,10 @@ tbody tr:hover {
                                         </td>
                                         <td>
                                             <div class="toolbar">
-                                                <button class="icon-btn" @click.stop="runJob(job)" :disabled="job.launching" title="Run now">
+                                                <button class="icon-btn" type="button" @click.stop="runJob(job)" :disabled="Boolean(job.launching)" title="Run now">
                                                     <i data-lucide="play"></i>
                                                 </button>
-                                                <button class="icon-btn" @click.stop="toggleJob(job)" :title="job.enabled ? 'Disable' : 'Enable'">
+                                                <button class="icon-btn" type="button" @click.stop="toggleJob(job)" :title="job.enabled ? 'Disable' : 'Enable'">
                                                     <i :data-lucide="job.enabled ? 'pause' : 'power'"></i>
                                                 </button>
                                             </div>
@@ -1360,18 +1530,6 @@ tbody tr:hover {
                             </tbody>
                         </table>
                     </div>
-                    <div class="action-strip">
-                        <span class="selection-summary" x-text="jobsRangeText()"></span>
-                        <div class="toolbar">
-                            <select class="search" style="width:92px" x-model.number="jobsPerPage" @change="jobsPage = 0">
-                                <option value="8">8</option>
-                                <option value="12">12</option>
-                                <option value="20">20</option>
-                            </select>
-                            <button class="btn" @click="pageJobs(-1)" :disabled="jobsPage === 0">Previous</button>
-                            <button class="btn" @click="pageJobs(1)" :disabled="(jobsPage + 1) * jobsPerPage >= jobs.length">Next</button>
-                        </div>
-                    </div>
                 </section>
 
                 <section class="panel task-form">
@@ -1381,25 +1539,45 @@ tbody tr:hover {
                             <span x-text="activeJob ? activeJob.health : 'Select a task'"></span>
                         </div>
                     </div>
-                    <div style="padding:14px" x-show="activeJob">
-                        <div class="field">
-                            <label>Description</label>
-                            <textarea readonly x-text="activeJob?.description || ''"></textarea>
+                    <div class="task-form-body" x-show="activeJob">
+                        <div class="job-detail-description" x-text="activeJob?.description || ''"></div>
+                        <div class="job-facts">
+                            <div class="job-fact">
+                                <span>Cron</span>
+                                <span :title="activeJob?.cron_expression || ''" x-text="cronLabel(activeJob)"></span>
+                            </div>
+                            <div class="job-fact">
+                                <span>Next</span>
+                                <span x-text="relativeDate(activeJob?.next_run_at)"></span>
+                            </div>
+                            <div class="job-fact">
+                                <span>Last</span>
+                                <span x-text="relativeDate(activeJob?.last_run_at)"></span>
+                            </div>
                         </div>
-                        <div class="field">
-                            <label>Cron</label>
-                            <input readonly :value="activeJob?.cron_expression || ''" />
+                        <div class="metadata-backfill-options" x-show="isMetadataBackfillJob(activeJob)">
+                            <div class="option-grid">
+                                <label><input type="checkbox" x-model="metadataBackfillOptions.audio_bitrate" /> audio_bitrate</label>
+                                <label><input type="checkbox" x-model="metadataBackfillOptions.audio_sample_rate" /> audio_sample_rate</label>
+                                <label><input type="checkbox" x-model="metadataBackfillOptions.audio_bit_depth" /> audio_bit_depth</label>
+                                <label><input type="checkbox" x-model="metadataBackfillOptions.duration_seconds" /> duration_seconds</label>
+                                <label><input type="checkbox" x-model="metadataBackfillOptions.local_genres" /> local genres from files</label>
+                                <label><input type="checkbox" x-model="metadataBackfillOptions.lastfm_tags" /> Last.fm tags</label>
+                            </div>
+                            <div class="mode-row">
+                                <label><input type="radio" value="fill_missing" x-model="metadataBackfillOptions.mode" /> Fill missing only</label>
+                                <label><input type="radio" value="overwrite" x-model="metadataBackfillOptions.mode" /> Overwrite existing values</label>
+                            </div>
                         </div>
-                        <div class="field">
-                            <label>Next / Last</label>
-                            <input readonly :value="relativeDate(activeJob?.next_run_at) + ' / ' + relativeDate(activeJob?.last_run_at)" />
+                        <div class="job-param-note" x-show="activeJob && !jobHasParameterForm(activeJob)">
+                            This task has no manual parameters.
                         </div>
                         <div class="toolbar" style="margin-bottom:12px">
-                            <button class="btn primary" @click="runJob(activeJob)">
+                            <button class="btn primary" type="button" @click="runJob(activeJob)">
                                 <i data-lucide="play"></i>
-                                Run now
+                                <span x-text="isMetadataBackfillJob(activeJob) ? 'Run with options' : 'Run now'"></span>
                             </button>
-                            <button class="btn" @click="toggleJob(activeJob)">
+                            <button class="btn" type="button" @click="toggleJob(activeJob)">
                                 <i data-lucide="power"></i>
                                 Toggle
                             </button>
@@ -1407,7 +1585,7 @@ tbody tr:hover {
                         <div class="field">
                             <label>Recent Runs</label>
                             <div class="runs">
-                                <template x-for="run in visibleRuns()" :key="run.id">
+                                <template x-for="run in pagedVisibleRuns()" :key="run.id">
                                     <div class="run-row" @click="loadRunDetail(run)">
                                         <span class="badge" :class="run.status" x-text="run.status"></span>
                                         <span x-text="'#' + run.id"></span>
@@ -1415,6 +1593,14 @@ tbody tr:hover {
                                         <span x-text="duration(run.duration_ms)"></span>
                                     </div>
                                 </template>
+                                <div class="empty" x-show="visibleRuns().length === 0">No runs for this task yet</div>
+                            </div>
+                            <div class="job-run-pager" x-show="visibleRuns().length > recentRunsPerPage">
+                                <span class="selection-summary" x-text="recentRunsRangeText()"></span>
+                                <div class="toolbar">
+                                    <button class="btn" type="button" @click="pageRecentRuns(-1)" :disabled="recentRunsPage === 0">Previous</button>
+                                    <button class="btn" type="button" @click="pageRecentRuns(1)" :disabled="(recentRunsPage + 1) * recentRunsPerPage >= visibleRuns().length">Next</button>
+                                </div>
                             </div>
                         </div>
                     </div>
@@ -1430,10 +1616,14 @@ tbody tr:hover {
                         <div class="toolbar" x-show="activeRunDetail">
                             <span class="badge" :class="activeRunDetail?.run?.status" x-text="activeRunDetail?.run?.status"></span>
                             <span class="selection-summary" x-text="duration(activeRunDetail?.run?.duration_ms)"></span>
+                            <button class="btn" type="button" x-show="!runLogAutoScroll" @click="enableRunLogFollow()">
+                                <i data-lucide="chevrons-down"></i>
+                                Follow
+                            </button>
                         </div>
                     </div>
                     <div class="run-log-body">
-                        <pre class="run-log-output" x-show="activeRunDetail" x-text="activeRunDetail?.log_output || activeRunDetail?.run?.log_excerpt || 'No log output captured for this run.'"></pre>
+                        <pre class="run-log-output" :class="{'is-following': runLogAutoScroll}" x-ref="runLogOutput" x-show="activeRunDetail" @scroll.passive="handleRunLogScroll()" x-text="activeRunDetail?.log_output || activeRunDetail?.run?.log_excerpt || 'No log output captured for this run.'"></pre>
                         <div class="empty" x-show="!activeRunDetail">No run selected</div>
                     </div>
                 </section>
@@ -1452,6 +1642,7 @@ tbody tr:hover {
                             <div class="segmented">
                                 <button class="seg-btn" :class="{active: libraryKind === 'artists'}" @click="openLibrary('artists')">Artists</button>
                                 <button class="seg-btn" :class="{active: libraryKind === 'releases'}" @click="openLibrary('releases')">Releases</button>
+                                <button class="seg-btn" :class="{active: libraryKind === 'tracks'}" @click="openLibrary('tracks')">Tracks</button>
                                 <button class="seg-btn" :class="{active: libraryKind === 'playlists'}" @click="openLibrary('playlists')">Playlists</button>
                             </div>
                             <input class="search" placeholder="Search library" x-model="librarySearch" @input.debounce.350ms="loadLibrary()" />
@@ -1923,7 +2114,7 @@ tbody tr:hover {
                 <div class="empty" x-show="editorLoading">Loading editor...</div>
                 <div x-show="!editorLoading">
                     <div class="field">
-                        <label x-text="isArtistEditor() ? 'Artist name' : 'Title'"></label>
+                        <label x-text="isArtistEditor() ? 'Artist name' : (isReleaseEditor() ? 'Release title' : (isTrackEditor() ? 'Track title' : 'Title'))"></label>
                         <input x-model="editorDraft.title" />
                     </div>
 
@@ -1947,8 +2138,43 @@ tbody tr:hover {
                         </div>
                     </div>
 
-                    <div class="field" x-show="isReleaseEditor()">
-                        <label>Release artists</label>
+                    <div class="editor-grid" x-show="isTrackEditor()">
+                        <div class="field">
+                            <label>Track #</label>
+                            <input type="number" min="1" max="9999" x-model="editorDraft.track_number" />
+                        </div>
+                        <div class="field">
+                            <label>Disc #</label>
+                            <input type="number" min="1" max="999" x-model="editorDraft.disc_number" />
+                        </div>
+                        <div class="field">
+                            <label>Year</label>
+                            <input type="number" min="0" max="3000" x-model="editorDraft.year" />
+                        </div>
+                    </div>
+
+                    <div class="field" x-show="isTrackEditor()">
+                        <label>Release</label>
+                        <div class="artist-tags">
+                            <span class="tag relation" x-show="selectedEditorRelease()" x-text="selectedEditorReleaseLabel()"></span>
+                            <span class="muted" x-show="!selectedEditorRelease()">No release selected</span>
+                        </div>
+                        <div class="artist-picker">
+                            <input class="search" placeholder="Search release to move track" x-model="editorReleaseToAdd" @keydown.enter.prevent="selectEditorRelease()" @keydown.escape="editorReleaseToAdd = ''" />
+                            <div class="artist-results" x-show="editorReleaseSearchOpen()" x-transition>
+                                <template x-for="release in filteredEditorReleases()" :key="release.id">
+                                    <button class="artist-result" type="button" @click="selectEditorRelease(release)">
+                                        <span x-text="release.title"></span>
+                                        <small x-text="release.subtitle"></small>
+                                    </button>
+                                </template>
+                                <div class="artist-result muted" x-show="filteredEditorReleases().length === 0">No matching releases</div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="field" x-show="isReleaseEditor() || isTrackEditor()">
+                        <label x-text="isTrackEditor() ? 'Track artists' : 'Release artists'"></label>
                         <div class="artist-tags">
                             <template x-for="artist in selectedEditorArtists()" :key="artist.id">
                                 <span class="tag relation">
@@ -1969,6 +2195,22 @@ tbody tr:hover {
                         </div>
                     </div>
 
+                    <div class="field" x-show="canShowMetadataTags()">
+                        <label>Metadata genres and tags</label>
+                        <div class="metadata-tags" x-show="metadataTags().length">
+                            <template x-for="tag in metadataTags()" :key="`${tag.source}:${tag.name}`">
+                                <span class="tag" :class="metadataTagClass(tag)" :title="metadataTagTitle(tag)">
+                                    <span x-text="tag.name"></span>
+                                    <small x-text="metadataTagSourceLabel(tag)"></small>
+                                    <small x-show="metadataTagScore(tag)" x-text="metadataTagScore(tag)"></small>
+                                </span>
+                            </template>
+                        </div>
+                        <div class="metadata-empty muted" x-show="!metadataTags().length">
+                            No metadata genres or tags saved yet
+                        </div>
+                    </div>
+
                     <div class="field">
                         <label>Visibility</label>
                         <select class="search" style="width:100%" x-model="editorDraft.hidden">
@@ -2083,10 +2325,23 @@ function adminV2() {
         ],
         jobs: [],
         recentRuns: [],
+        activeJobRuns: [],
+        activeJobRunsName: null,
         activeJobName: null,
         activeRunDetail: null,
-        jobsPage: 0,
-        jobsPerPage: 12,
+        recentRunsPage: 0,
+        recentRunsPerPage: 8,
+        runLogAutoScroll: true,
+        runLogRefreshing: false,
+        metadataBackfillOptions: {
+            audio_bitrate: true,
+            audio_sample_rate: true,
+            audio_bit_depth: true,
+            duration_seconds: true,
+            local_genres: true,
+            lastfm_tags: true,
+            mode: 'fill_missing'
+        },
         libraryKind: 'artists',
         librarySearch: '',
         library: { items: [], total: 0, limit: 40, offset: 0 },
@@ -2099,8 +2354,9 @@ function adminV2() {
         editorImageUploading: false,
         editorImageFile: null,
         editorArtistToAdd: '',
+        editorReleaseToAdd: '',
         editorDetail: null,
-        editorDraft: { title: '', hidden: 'false', release_type: 'album', year: '', artist_ids: [] },
+        editorDraft: { title: '', hidden: 'false', release_type: 'album', year: '', release_id: null, track_number: '', disc_number: '', artist_ids: [] },
         settings: { values: {}, sources: {}, lastfm_api_key_configured: false, lastfm_shared_secret_configured: false, lastfm_scrobbling_configured: false },
         settingsDraft: {
             auth_password_enabled: false,
@@ -2139,7 +2395,7 @@ function adminV2() {
                 this.applyRouteFromHash();
                 this.activateCurrentView(false);
             });
-            this.poller = setInterval(() => this.poll(), 6000);
+            this.poller = setInterval(() => this.poll(), 4000);
             this.icons();
         },
 
@@ -2180,7 +2436,15 @@ function adminV2() {
 
         async poll() {
             if (this.loading) return;
-            await Promise.allSettled([this.loadJobs(false), this.loadReviews(false)]);
+            if (this.activeView === 'jobs') {
+                await Promise.allSettled([
+                    this.loadJobs(false),
+                    this.activeJobName ? this.loadRunsForJob(this.activeJobName, false) : Promise.resolve(),
+                    this.refreshActiveRunDetail()
+                ]);
+            } else {
+                await Promise.allSettled([this.loadJobs(false), this.loadReviews(false)]);
+            }
         },
 
         applyRouteFromHash() {
@@ -2194,9 +2458,17 @@ function adminV2() {
                 this.reviewFilter.status = nextStatus;
             } else if (view === 'jobs') {
                 this.activeView = 'jobs';
-                if (parts[1]) this.activeJobName = decodeURIComponent(parts[1]);
+                if (parts[1]) {
+                    const nextJobName = decodeURIComponent(parts[1]);
+                    if (this.activeJobName !== nextJobName) {
+                        this.activeJobRuns = [];
+                        this.activeJobRunsName = nextJobName;
+                        this.recentRunsPage = 0;
+                    }
+                    this.activeJobName = nextJobName;
+                }
             } else if (view === 'library') {
-                const nextKind = ['artists', 'releases', 'playlists'].includes(parts[1]) ? parts[1] : 'artists';
+                const nextKind = ['artists', 'releases', 'tracks', 'playlists'].includes(parts[1]) ? parts[1] : 'artists';
                 if (this.libraryKind !== nextKind) this.clearLibrarySelection();
                 this.activeView = 'library';
                 this.libraryKind = nextKind;
@@ -2248,7 +2520,14 @@ function adminV2() {
 
         openJobs(name = this.activeJobName) {
             this.activeView = 'jobs';
-            if (name) this.activeJobName = name;
+            if (name && this.activeJobName !== name) {
+                this.activeJobRuns = [];
+                this.activeJobRunsName = name;
+                this.recentRunsPage = 0;
+                this.activeJobName = name;
+            } else if (name) {
+                this.activeJobName = name;
+            }
             this.setRoute(this.activeJobName ? `#jobs/${encodeURIComponent(this.activeJobName)}` : '#jobs');
             this.loadJobs();
             if (this.activeJobName) this.loadRunsForJob(this.activeJobName);
@@ -2256,7 +2535,7 @@ function adminV2() {
 
         openLibrary(kind = this.libraryKind) {
             this.activeView = 'library';
-            const nextKind = ['artists', 'releases', 'playlists'].includes(kind) ? kind : 'artists';
+            const nextKind = ['artists', 'releases', 'tracks', 'playlists'].includes(kind) ? kind : 'artists';
             if (this.libraryKind !== nextKind) this.clearLibrarySelection();
             this.libraryKind = nextKind;
             this.setRoute(`#library/${this.libraryKind}`);
@@ -2289,7 +2568,6 @@ function adminV2() {
             try {
                 this.jobs = await this.request(`${this.apiBase}/jobs`);
                 if (!this.activeJobName && this.jobs.length) this.activeJobName = this.jobs[0].name;
-                if (this.jobsPage * this.jobsPerPage >= this.jobs.length) this.jobsPage = 0;
             } catch (error) {
                 if (showErrors) this.showToast(error.message);
             } finally {
@@ -2531,13 +2809,22 @@ function adminV2() {
         },
 
         async runJob(job) {
+            if (!job) return;
+            if (job.launching) return;
             job.launching = true;
             try {
-                const result = await this.request(`${this.apiBase}/jobs/${encodeURIComponent(job.name)}/run`, { method: 'POST' });
+                const result = this.isMetadataBackfillJob(job)
+                    ? await this.request(`${this.apiBase}/jobs/metadata_backfill/run-options`, {
+                        method: 'POST',
+                        body: JSON.stringify(this.metadataBackfillPayload())
+                    })
+                    : await this.request(`${this.apiBase}/jobs/${encodeURIComponent(job.name)}/run`, { method: 'POST' });
                 this.showToast(`Run #${result.run_id} started`);
                 this.activeJobName = job.name;
+                this.recentRunsPage = 0;
                 await this.loadJobs(false);
                 await this.loadRunsForJob(job.name);
+                await this.loadRunDetail({ id: result.run_id, job_name: job.name }, { silent: true });
             } catch (error) {
                 this.showToast(error.message);
             } finally {
@@ -2546,6 +2833,27 @@ function adminV2() {
             }
         },
 
+        isMetadataBackfillJob(job) {
+            return job && job.name === 'metadata_backfill';
+        },
+
+        jobHasParameterForm(job) {
+            return this.isMetadataBackfillJob(job);
+        },
+
+        metadataBackfillPayload() {
+            const options = this.metadataBackfillOptions || {};
+            return {
+                audio_bitrate: Boolean(options.audio_bitrate),
+                audio_sample_rate: Boolean(options.audio_sample_rate),
+                audio_bit_depth: Boolean(options.audio_bit_depth),
+                duration_seconds: Boolean(options.duration_seconds),
+                local_genres: Boolean(options.local_genres),
+                lastfm_tags: Boolean(options.lastfm_tags),
+                overwrite: options.mode === 'overwrite'
+            };
+        },
+
         async toggleJob(job) {
             try {
                 const result = await this.request(`${this.apiBase}/jobs/${encodeURIComponent(job.name)}/toggle`, { method: 'POST' });
@@ -2561,34 +2869,111 @@ function adminV2() {
             this.setRoute(`#jobs/${encodeURIComponent(name)}`);
             this.activeReview = null;
             this.activeRunDetail = null;
+            this.activeJobRuns = [];
+            this.activeJobRunsName = name;
+            this.recentRunsPage = 0;
+            this.runLogAutoScroll = true;
             await this.loadRunsForJob(name);
         },
 
-        async loadRunsForJob(name) {
+        async loadRunsForJob(name, showErrors = true) {
             try {
                 const data = await this.request(`${this.apiBase}/jobs/${encodeURIComponent(name)}/runs`);
+                const runs = data.runs || [];
                 const job = this.jobs.find(item => item.name === name);
-                if (job) job.recent_runs = data.runs;
+                if (job) job.recent_runs = runs;
+                if (this.activeJobName === name) {
+                    this.activeJobRuns = runs;
+                    this.activeJobRunsName = name;
+                    const maxPage = Math.max(0, Math.ceil(runs.length / this.recentRunsPerPage) - 1);
+                    this.recentRunsPage = Math.min(this.recentRunsPage, maxPage);
+                }
             } catch (error) {
-                this.showToast(error.message);
+                if (showErrors) this.showToast(error.message);
             }
         },
 
-        async loadRunDetail(run) {
+        async loadRunDetail(run, options = {}) {
+            if (!run) return;
             this.activeReview = null;
+            const previousJobName = this.activeJobName;
+            const preserveScroll = Boolean(options.preserveScroll);
+            const sameRun = this.activeRunDetail && Number(this.activeRunDetail.run.id) === Number(run.id);
+            const shouldFollow = !preserveScroll || !sameRun || this.runLogAutoScroll || this.isRunLogAtBottom();
             try {
                 this.activeRunDetail = await this.request(`${this.apiBase}/jobs/${encodeURIComponent(run.job_name)}/runs/${run.id}`);
                 this.activeJobName = run.job_name;
+                if (previousJobName !== run.job_name) this.recentRunsPage = 0;
+                if (!preserveScroll || !sameRun) this.runLogAutoScroll = true;
+                this.$nextTick(() => {
+                    if (shouldFollow) this.scrollRunLogToBottom(true);
+                });
             } catch (error) {
-                this.showToast(error.message);
+                if (!options.silent) this.showToast(error.message);
             }
         },
 
+        async refreshActiveRunDetail() {
+            if (this.runLogRefreshing || !this.activeRunDetail || this.activeView !== 'jobs') return;
+            this.runLogRefreshing = true;
+            try {
+                await this.loadRunDetail(this.activeRunDetail.run, { preserveScroll: true, silent: true });
+            } finally {
+                this.runLogRefreshing = false;
+            }
+        },
+
+        handleRunLogScroll() {
+            this.runLogAutoScroll = this.isRunLogAtBottom();
+        },
+
+        isRunLogAtBottom() {
+            const el = this.$refs.runLogOutput;
+            if (!el) return true;
+            return el.scrollHeight - el.scrollTop - el.clientHeight < 28;
+        },
+
+        scrollRunLogToBottom(force = false) {
+            const el = this.$refs.runLogOutput;
+            if (!el) return;
+            if (force || this.runLogAutoScroll) {
+                el.scrollTop = el.scrollHeight;
+                this.runLogAutoScroll = true;
+            }
+        },
+
+        enableRunLogFollow() {
+            this.runLogAutoScroll = true;
+            this.$nextTick(() => this.scrollRunLogToBottom(true));
+        },
+
         visibleRuns() {
+            if (this.activeJobName && this.activeJobRunsName === this.activeJobName) {
+                return this.activeJobRuns || [];
+            }
             const job = this.activeJob;
             return job ? (job.recent_runs || []) : this.recentRuns;
         },
 
+        pagedVisibleRuns() {
+            const runs = this.visibleRuns();
+            const start = this.recentRunsPage * this.recentRunsPerPage;
+            return runs.slice(start, start + this.recentRunsPerPage);
+        },
+
+        pageRecentRuns(delta) {
+            const maxPage = Math.max(0, Math.ceil(this.visibleRuns().length / this.recentRunsPerPage) - 1);
+            this.recentRunsPage = Math.min(maxPage, Math.max(0, this.recentRunsPage + delta));
+        },
+
+        recentRunsRangeText() {
+            const total = this.visibleRuns().length;
+            if (!total) return '0 runs';
+            const start = this.recentRunsPage * this.recentRunsPerPage + 1;
+            const end = Math.min((this.recentRunsPage + 1) * this.recentRunsPerPage, total);
+            return `${start}-${end} of ${total}`;
+        },
+
         get activeJob() {
             return this.jobs.find(job => job.name === this.activeJobName) || null;
         },
@@ -2618,11 +3003,15 @@ function adminV2() {
                 hidden: item.is_hidden ? 'true' : 'false',
                 release_type: 'album',
                 year: '',
+                release_id: null,
+                track_number: '',
+                disc_number: '',
                 artist_ids: []
             };
             this.editorDetail = null;
             this.editorImageFile = null;
             this.editorArtistToAdd = '';
+            this.editorReleaseToAdd = '';
             this.editorOpen = true;
             this.loadEditorDetail(item);
         },
@@ -2640,10 +3029,14 @@ function adminV2() {
                     hidden: detail.hidden ? 'true' : 'false',
                     release_type: detail.release_type || 'album',
                     year: detail.year || '',
+                    release_id: detail.release_id || null,
+                    track_number: detail.track_number || '',
+                    disc_number: detail.disc_number || '',
                     artist_ids: Array.isArray(detail.selected_artist_ids) ? detail.selected_artist_ids.slice() : []
                 };
                 this.editorImageFile = null;
                 this.editorArtistToAdd = '';
+                this.editorReleaseToAdd = '';
             } catch (error) {
                 this.showToast(error.message);
             } finally {
@@ -2662,12 +3055,60 @@ function adminV2() {
             return this.activeLibraryItem && this.activeLibraryItem.kind === 'releases';
         },
 
+        isTrackEditor() {
+            return this.activeLibraryItem && this.activeLibraryItem.kind === 'tracks';
+        },
+
         canEditLibraryImage() {
             return this.isArtistEditor() || this.isReleaseEditor();
         },
 
+        canShowMetadataTags() {
+            return this.isArtistEditor() || this.isReleaseEditor() || this.isTrackEditor();
+        },
+
+        metadataTags() {
+            return this.editorDetail && Array.isArray(this.editorDetail.metadata_tags)
+                ? this.editorDetail.metadata_tags
+                : [];
+        },
+
+        metadataTagClass(tag) {
+            const source = String((tag && tag.source) || 'unknown').toLowerCase().replace(/_/g, '-');
+            return `metadata-${source}`;
+        },
+
+        metadataTagSourceLabel(tag) {
+            const source = String((tag && tag.source) || '').toLowerCase();
+            if (source === 'lastfm') return 'Last.fm';
+            if (source === 'file') return 'File';
+            if (source === 'review') return 'Review';
+            if (source === 'track_genre') return 'Track genre';
+            if (source === 'release_lastfm') return 'Release Last.fm';
+            if (source === 'release_file') return 'Release file';
+            if (source === 'release_review') return 'Release review';
+            return source || 'Source';
+        },
+
+        metadataTagScore(tag) {
+            const source = String((tag && tag.source) || '').toLowerCase();
+            const weight = Number((tag && tag.weight) || 0);
+            return (source === 'lastfm' || source === 'release_lastfm') && weight > 1 ? String(Math.round(weight)) : '';
+        },
+
+        metadataTagTitle(tag) {
+            if (!tag) return '';
+            const parts = [this.metadataTagSourceLabel(tag)];
+            const weight = Number(tag.weight || 0);
+            if (weight > 0) parts.push(`weight ${Math.round(weight)}`);
+            if (tag.updated_at) parts.push(tag.updated_at);
+            return parts.join(' / ');
+        },
+
         editorCanSave() {
-            return Boolean(this.activeLibraryItem && this.editorDetail && !this.editorLoading && !this.editorSaving);
+            if (!this.activeLibraryItem || !this.editorDetail || this.editorLoading || this.editorSaving) return false;
+            if (this.isTrackEditor() && !this.editorDraft.release_id) return false;
+            return true;
         },
 
         selectedEditorArtists() {
@@ -2710,7 +3151,7 @@ function adminV2() {
         },
 
         editorArtistSearchOpen() {
-            return this.isReleaseEditor() && String(this.editorArtistToAdd || '').trim().length > 0;
+            return (this.isReleaseEditor() || this.isTrackEditor()) && String(this.editorArtistToAdd || '').trim().length > 0;
         },
 
         addEditorArtist(artist = null) {
@@ -2729,6 +3170,51 @@ function adminV2() {
             this.editorDraft.artist_ids = (this.editorDraft.artist_ids || []).filter(value => Number(value) !== Number(id));
         },
 
+        selectedEditorRelease() {
+            const releases = (this.editorDetail && this.editorDetail.releases) || [];
+            return releases.find(row => Number(row.id) === Number(this.editorDraft.release_id));
+        },
+
+        selectedEditorReleaseLabel() {
+            const release = this.selectedEditorRelease();
+            if (!release) return '';
+            return release.subtitle ? `${release.title} / ${release.subtitle}` : release.title;
+        },
+
+        filteredEditorReleases() {
+            const releases = (this.editorDetail && this.editorDetail.releases) || [];
+            const query = String(this.editorReleaseToAdd || '').trim().toLowerCase();
+            const currentId = Number(this.editorDraft.release_id || 0);
+            const candidates = releases.filter(release => Number(release.id) !== currentId);
+            if (!query) return candidates.slice(0, 12);
+            return candidates
+                .map(release => {
+                    const haystack = `${release.title || ''} ${release.subtitle || ''}`.toLowerCase();
+                    let score = 3;
+                    if (String(release.title || '').toLowerCase() === query) score = 0;
+                    else if (String(release.title || '').toLowerCase().startsWith(query)) score = 1;
+                    else if (haystack.includes(query)) score = 2;
+                    return { release, score };
+                })
+                .filter(row => row.score < 3)
+                .sort((a, b) => a.score - b.score || a.release.title.localeCompare(b.release.title))
+                .slice(0, 12)
+                .map(row => row.release);
+        },
+
+        editorReleaseSearchOpen() {
+            return this.isTrackEditor() && String(this.editorReleaseToAdd || '').trim().length > 0;
+        },
+
+        selectEditorRelease(release = null) {
+            const candidates = this.filteredEditorReleases();
+            release = release || candidates[0];
+            if (!release) return false;
+            this.editorDraft.release_id = Number(release.id);
+            this.editorReleaseToAdd = '';
+            return true;
+        },
+
         setEditorImageFile(event) {
             this.editorImageFile = event.target.files && event.target.files.length ? event.target.files[0] : null;
         },
@@ -2844,6 +3330,12 @@ function adminV2() {
         },
 
         async saveLibraryItem() {
+            if (this.isTrackEditor() && String(this.editorReleaseToAdd || '').trim()) {
+                if (!this.selectEditorRelease()) {
+                    this.showToast('Choose a release from search results');
+                    return;
+                }
+            }
             if (!this.editorCanSave()) return;
             this.editorSaving = true;
             try {
@@ -2856,6 +3348,9 @@ function adminV2() {
                         hidden: this.editorDraft.hidden === 'true',
                         release_type: this.editorDraft.release_type || null,
                         year: this.editorDraft.year || '',
+                        release_id: this.editorDraft.release_id ? Number(this.editorDraft.release_id) : null,
+                        track_number: this.editorDraft.track_number || '',
+                        disc_number: this.editorDraft.disc_number || '',
                         artist_ids: this.editorDraft.artist_ids || []
                     })
                 });
@@ -2931,7 +3426,7 @@ function adminV2() {
         },
 
         pageSubtitle() {
-            if (this.activeView === 'library') return 'Fast entity control surface for artists, releases, and playlists';
+            if (this.activeView === 'library') return 'Fast entity control surface for artists, releases, tracks, and playlists';
             if (this.activeView === 'jobs') return 'Scheduler state, recent runs, and manual controls in one place';
             if (this.activeView === 'tools') return 'Reserved space for merge, split, enrichment, and destructive workflows';
             if (this.activeView === 'settings') return 'Application configuration and external API credentials';
@@ -2971,21 +3466,9 @@ function adminV2() {
             return `${start}-${end} of ${this.fmt(this.library.total)}`;
         },
 
-        pagedJobs() {
-            const start = this.jobsPage * this.jobsPerPage;
-            return this.jobs.slice(start, start + this.jobsPerPage);
-        },
-
-        pageJobs(delta) {
-            const maxPage = Math.max(0, Math.ceil(this.jobs.length / this.jobsPerPage) - 1);
-            this.jobsPage = Math.min(maxPage, Math.max(0, this.jobsPage + delta));
-        },
-
-        jobsRangeText() {
-            if (!this.jobs.length) return '0 tasks';
-            const start = this.jobsPage * this.jobsPerPage + 1;
-            const end = Math.min((this.jobsPage + 1) * this.jobsPerPage, this.jobs.length);
-            return `${start}-${end} of ${this.jobs.length}`;
+        cronLabel(job) {
+            const value = job && job.cron_expression ? String(job.cron_expression).trim() : '';
+            return value || 'manual only';
         },
 
         statusCount(status) {
@@ -3003,8 +3486,7 @@ function adminV2() {
         },
 
         runChipLabel(run) {
-            const duration = run.duration_ms || run.duration_ms === 0 ? this.duration(run.duration_ms) : this.relativeDate(run.started_at);
-            return `#${run.id} · ${duration}`;
+            return `#${run.id}`;
         },
 
         runTitle(run) {

templates/player/modals.html

@@ -11,6 +11,13 @@
                         </svg>
                     </button>
                 </div>
+                <div class="info-actions" x-show="$store.info.modal.actions && $store.info.modal.actions.length">
+                    <template x-for="(action, idx) in $store.info.modal.actions" :key="action.label + '-' + idx">
+                        <button class="info-action-btn" type="button" @click.stop.prevent="$store.info.runAction(idx)" :disabled="action.busy === true">
+                            <span x-text="action.busy ? '{{ t.player_resolving }}' : action.label"></span>
+                        </button>
+                    </template>
+                </div>
                 <div class="info-modal-body">
                     <template x-if="$store.info.modal.rows && $store.info.modal.rows.length">
                         <table class="info-table">
@@ -112,6 +119,21 @@
                     </div>
                 </div>
 
+                <div class="torrent-tabs">
+                    <button class="torrent-tab-btn"
+                            :class="{ active: $store.torrents.activeTab === 'import' }"
+                            @click="$store.torrents.showImportTab()">Import</button>
+                    <button class="torrent-tab-btn"
+                            :class="{ active: $store.torrents.activeTab === 'uploads' }"
+                            @click="$store.torrents.showUploadsTab()">
+                        <span>My uploads</span>
+                        <span class="torrent-tab-count"
+                              x-show="$store.torrents.uploadPendingTotal + $store.torrents.uploadQueuedTotal > 0"
+                              x-text="$store.torrents.uploadPendingTotal + $store.torrents.uploadQueuedTotal"></span>
+                    </button>
+                </div>
+
+                <template x-if="$store.torrents.activeTab === 'import'">
                 <div class="torrent-manager-layout">
                     <aside class="torrent-manager-sidebar">
                         <div class="torrent-manager-title">
@@ -319,6 +341,270 @@
                 </template>
                     </section>
                 </div>
+                </template>
+
+                <template x-if="$store.torrents.activeTab === 'uploads'">
+                    <section class="upload-manager-panel">
+                        <div class="upload-manager-head">
+                            <div>
+                                <h4>My uploaded tracks</h4>
+                                <p x-text="$store.torrents.uploadSummary()"></p>
+                            </div>
+                            <button class="modal-btn modal-btn-ghost"
+                                    @click="$store.torrents.loadUploads()"
+                                    :disabled="$store.torrents.uploadHasEditorOpen()">{{ t.player_refresh }}</button>
+                        </div>
+
+                        <template x-if="$store.torrents.uploadLoaded && $store.torrents.uploadTracks.length === 0 && $store.torrents.uploadPending.length === 0 && $store.torrents.uploadQueued.length === 0">
+                            <div class="empty-state torrent-workspace-empty">
+                                <p>No uploaded tracks yet</p>
+                            </div>
+                        </template>
+
+                        <div class="upload-manager-grid">
+                            <aside class="upload-review-column">
+                                <div class="upload-panel-card">
+                                    <div class="upload-panel-title">Needs approval</div>
+                                    <p class="upload-panel-subtitle" x-text="$store.torrents.uploadPendingTotal + ' pending or failed'"></p>
+                                    <template x-if="$store.torrents.uploadPending.length === 0">
+                                        <div class="upload-mini-empty">No tracks need approval</div>
+                                    </template>
+                                    <div class="upload-review-list">
+                                        <template x-for="item in $store.torrents.uploadPending" :key="item.id">
+                                            <button class="upload-review-row" :class="{ active: $store.torrents.uploadReviewEditId === item.id, failed: item.status === 'failed' }" @click="$store.torrents.editUploadReview(item)">
+                                                <span class="torrent-status-badge" :class="'status-' + item.status" x-text="item.status"></span>
+                                                <span class="upload-review-name" x-text="item.filename"></span>
+                                                <span class="upload-review-error" x-show="item.error_message" x-text="item.error_message"></span>
+                                            </button>
+                                        </template>
+                                    </div>
+                                </div>
+                                <template x-if="$store.torrents.uploadQueuedTotal > 0">
+                                    <div class="upload-panel-card upload-queue-panel">
+                                        <div class="upload-panel-title">Queued / processing</div>
+                                        <template x-for="item in $store.torrents.compactQueuedUploads()" :key="item.id">
+                                            <div class="upload-queue-row">
+                                                <span class="torrent-status-badge" :class="'status-' + item.status" x-text="item.status"></span>
+                                                <span class="upload-queue-name" x-text="item.filename"></span>
+                                            </div>
+                                        </template>
+                                        <div class="upload-mini-empty" x-show="$store.torrents.uploadQueuedTotal > $store.torrents.uploadQueued.length" x-text="'Showing ' + $store.torrents.uploadQueued.length + ' of ' + $store.torrents.uploadQueuedTotal"></div>
+                                    </div>
+                                </template>
+                            </aside>
+                            <section class="upload-library-column">
+                                <div class="upload-bulk-bar" x-show="$store.torrents.uploadSelectedCount() > 0">
+                                    <div class="upload-bulk-title" x-text="$store.torrents.uploadSelectedCount() + ' selected'"></div>
+                                    <input type="text" placeholder="Artists" x-model="$store.torrents.uploadBulkDraft.artists">
+                                    <input type="text" placeholder="Featured" x-model="$store.torrents.uploadBulkDraft.featured_artists">
+                                    <input type="text" placeholder="Album" x-model="$store.torrents.uploadBulkDraft.release_title">
+                                    <input type="number" placeholder="Year" x-model="$store.torrents.uploadBulkDraft.release_year">
+                                    <select x-model="$store.torrents.uploadBulkDraft.release_type">
+                                        <option value="">Type unchanged</option><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option>
+                                    </select>
+                                    <select x-model="$store.torrents.uploadBulkDraft.hidden">
+                                        <option value="">Visibility unchanged</option><option value="false">Visible</option><option value="true">Hidden</option>
+                                    </select>
+                                    <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadBulkEdit()" :disabled="$store.torrents.uploadBulkSaving">Apply</button>
+                                    <button class="modal-btn modal-btn-ghost" @click="$store.torrents.clearUploadSelection()">Clear</button>
+                                </div>
+                                <div class="upload-release-tree">
+                                    <template x-for="release in $store.torrents.uploadReleases" :key="release.id">
+                                        <div class="upload-release-node" :class="{ hidden: release.is_hidden }">
+                                            <div class="upload-release-row">
+                                                <button class="torrent-tree-check" :class="$store.torrents.uploadReleaseSelectionState(release)" @click="$store.torrents.toggleUploadReleaseSelection(release)">
+                                                    <template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'checked'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
+                                                    <template x-if="$store.torrents.uploadReleaseSelectionState(release) === 'partial'"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><line x1="5" y1="12" x2="19" y2="12"/></svg></template>
+                                                </button>
+                                                <button class="torrent-tree-toggle" :class="{ expanded: $store.torrents.uploadReleaseExpanded(release.id) }" @click="$store.torrents.toggleUploadRelease(release.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="9 18 15 12 9 6"/></svg></button>
+                                                <div class="upload-release-main">
+                                                    <div class="upload-release-title"><span x-text="release.title"></span><span class="upload-hidden-pill" x-show="release.is_hidden">hidden</span></div>
+                                                    <div class="upload-track-meta"><span x-text="$store.torrents.uploadReleaseArtistsText(release)"></span><span>-</span><span x-text="release.year || 'no year'"></span><span>-</span><span x-text="release.tracks.length + ' tracks'"></span></div>
+                                                </div>
+                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUploadRelease(release)">Edit release</button>
+                                            </div>
+                                            <div class="upload-track-children" x-show="$store.torrents.uploadReleaseExpanded(release.id)">
+                                                <template x-for="item in release.tracks" :key="item.track.id">
+                                                    <div class="upload-tree-track" :class="{ hidden: item.is_hidden, selected: $store.torrents.selectedUploadTracks.has(item.track.id) }">
+                                                        <button class="torrent-tree-check" :class="{ checked: $store.torrents.selectedUploadTracks.has(item.track.id) }" @click="$store.torrents.toggleUploadTrackSelection(item.track.id)">
+                                                            <template x-if="$store.torrents.selectedUploadTracks.has(item.track.id)"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3"><polyline points="20 6 9 17 4 12"/></svg></template>
+                                                        </button>
+                                                        <div class="upload-track-main">
+                                                            <div class="upload-track-title"><span x-text="item.track.track_number ? item.track.track_number + '. ' + item.track.title : item.track.title"></span><span class="upload-hidden-pill" x-show="item.is_hidden">hidden</span></div>
+                                                            <div class="upload-track-meta"><span x-text="$store.torrents.uploadArtistsText(item)"></span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)">feat.</span><span x-show="$store.torrents.uploadFeaturedArtistsText(item)" x-text="$store.torrents.uploadFeaturedArtistsText(item)"></span></div>
+                                                        </div>
+                                                        <div class="upload-track-actions">
+                                                            <button class="track-action-btn queue-insert-btn queue-next-btn" @click="$store.queue.addNextInQueue([item.track])" title="{{ t.player_play_next }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
+                                                            <button class="track-action-btn queue-insert-btn queue-end-btn" @click="$store.queue.addToEnd([item.track])" title="{{ t.player_add_to_queue }}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg></button>
+                                                            <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">Edit</button>
+                                                        </div>
+                                                    </div>
+                                                </template>
+                                            </div>
+                                        </div>
+                                    </template>
+                                </div>
+                            </section>
+                        </div>
+
+                        <template x-if="$store.torrents.uploadHasEditorOpen()">
+                            <div class="upload-editor-backdrop" @click.self="$store.torrents.closeUploadEditor()">
+                                <aside class="upload-editor-drawer">
+                                    <div class="upload-editor-head">
+                                        <div>
+                                            <div class="upload-panel-title" x-text="$store.torrents.uploadEditorKicker()"></div>
+                                            <h4 x-text="$store.torrents.uploadEditorTitle()"></h4>
+                                        </div>
+                                        <button class="track-action-btn" @click="$store.torrents.closeUploadEditor()" title="Close">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
+                                                <path d="M18 6L6 18M6 6l12 12"/>
+                                            </svg>
+                                        </button>
+                                    </div>
+
+                                    <template x-if="$store.torrents.uploadReviewDraft">
+                                        <div class="upload-editor-form">
+                                            <label class="upload-field upload-field-half"><span>Title</span><input type="text" x-model="$store.torrents.uploadReviewDraft.title"></label>
+                                            <label class="upload-field upload-field-half"><span>Artist</span><input type="text" x-model="$store.torrents.uploadReviewDraft.artist"></label>
+                                            <label class="upload-field upload-field-half"><span>Album</span><input type="text" x-model="$store.torrents.uploadReviewDraft.album"></label>
+                                            <label class="upload-field upload-field-half"><span>Featured</span><input type="text" x-model="$store.torrents.uploadReviewDraft.featured_artists" placeholder="Artist, Artist"></label>
+                                            <label class="upload-field upload-field-compact"><span>Year</span><input type="number" x-model="$store.torrents.uploadReviewDraft.year"></label>
+                                            <label class="upload-field upload-field-compact"><span>Track #</span><input type="number" min="1" x-model="$store.torrents.uploadReviewDraft.track_number"></label>
+                                            <label class="upload-field upload-field-compact"><span>Genre</span><input type="text" x-model="$store.torrents.uploadReviewDraft.genre"></label>
+                                            <label class="upload-field upload-field-compact">
+                                                <span>Type</span>
+                                                <select x-model="$store.torrents.uploadReviewDraft.release_type">
+                                                    <option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option>
+                                                </select>
+                                            </label>
+                                            <label class="upload-field upload-field-wide"><span>Notes</span><textarea rows="4" x-model="$store.torrents.uploadReviewDraft.notes"></textarea></label>
+                                            <div class="upload-editor-actions">
+                                                <button class="modal-btn modal-btn-danger" @click="$store.torrents.deleteUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">Delete review</button>
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.approveUploadReview()" :disabled="$store.torrents.uploadReviewSavingId === $store.torrents.uploadReviewEditId">Approve</button>
+                                            </div>
+                                        </div>
+                                    </template>
+
+                                    <template x-if="$store.torrents.uploadReleaseDraft">
+                                        <div class="upload-editor-form">
+                                            <label class="upload-field upload-field-wide"><span>Album</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.title"></label>
+                                            <label class="upload-field upload-field-wide"><span>Album artists</span><input type="text" x-model="$store.torrents.uploadReleaseDraft.artists"></label>
+                                            <label class="upload-field upload-field-half"><span>Year</span><input type="number" x-model="$store.torrents.uploadReleaseDraft.year"></label>
+                                            <label class="upload-field upload-field-half"><span>Type</span><select x-model="$store.torrents.uploadReleaseDraft.release_type"><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option></select></label>
+                                            <label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadReleaseDraft.is_hidden"><span>Hidden</span></label>
+                                            <div class="upload-editor-actions">
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadReleaseEdit()" :disabled="$store.torrents.uploadReleaseSavingId === $store.torrents.uploadReleaseEditId">Save release</button>
+                                            </div>
+                                        </div>
+                                    </template>
+
+                                    <template x-if="$store.torrents.uploadDraft">
+                                        <div class="upload-editor-form">
+                                            <label class="upload-field upload-field-wide"><span>Title</span><input type="text" x-model="$store.torrents.uploadDraft.title"></label>
+                                            <label class="upload-field upload-field-half"><span>Artists</span><input type="text" x-model="$store.torrents.uploadDraft.artists"></label>
+                                            <label class="upload-field upload-field-half"><span>Featured</span><input type="text" x-model="$store.torrents.uploadDraft.featured_artists"></label>
+                                            <label class="upload-field upload-field-half"><span>Album</span><input type="text" x-model="$store.torrents.uploadDraft.release_title"></label>
+                                            <label class="upload-field upload-field-half"><span>Type</span><select x-model="$store.torrents.uploadDraft.release_type"><option value="album">Album</option><option value="single">Single</option><option value="ep">EP</option><option value="compilation">Compilation</option><option value="mixtape">Mixtape</option><option value="live">Live</option><option value="soundtrack">Soundtrack</option><option value="remix">Remix</option><option value="demo">Demo</option></select></label>
+                                            <label class="upload-field upload-field-compact"><span>Year</span><input type="number" x-model="$store.torrents.uploadDraft.release_year"></label>
+                                            <label class="upload-field upload-field-compact"><span>Track #</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number"></label>
+                                            <label class="upload-field upload-field-compact"><span>Disc #</span><input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number"></label>
+                                            <label class="upload-field upload-field-toggle"><input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden"><span>Hidden</span></label>
+                                            <div class="upload-editor-actions">
+                                                <button class="modal-btn modal-btn-primary" @click="$store.torrents.saveUploadEdit()" :disabled="$store.torrents.uploadSavingId === $store.torrents.uploadEditId">Save track</button>
+                                            </div>
+                                        </div>
+                                    </template>
+                                </aside>
+                            </div>
+                        </template>
+
+                        <div class="upload-track-list" x-show="false">
+                            <template x-for="item in $store.torrents.uploadTracks" :key="item.track.id">
+                                <div class="upload-track-card" :class="{ hidden: item.is_hidden }">
+                                    <template x-if="$store.torrents.uploadEditId !== item.track.id">
+                                        <div class="upload-track-display">
+                                            <div class="upload-track-main">
+                                                <div class="upload-track-title">
+                                                    <span x-text="item.track.title"></span>
+                                                    <span class="upload-hidden-pill" x-show="item.is_hidden">hidden</span>
+                                                </div>
+                                                <div class="upload-track-meta">
+                                                    <span x-text="$store.torrents.uploadArtistsText(item)"></span>
+                                                    <span>·</span>
+                                                    <span x-text="item.track.release_title"></span>
+                                                    <span x-show="item.track.track_number">·</span>
+                                                    <span x-show="item.track.track_number" x-text="'#' + item.track.track_number"></span>
+                                                </div>
+                                            </div>
+                                            <div class="upload-track-actions">
+                                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click="$store.queue.addNextInQueue([item.track])" title="{{ t.player_play_next }}">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                                </button>
+                                                <button class="track-action-btn queue-insert-btn queue-end-btn" @click="$store.queue.addToEnd([item.track])" title="{{ t.player_add_to_queue }}">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                                </button>
+                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.editUpload(item)">Edit</button>
+                                            </div>
+                                        </div>
+                                    </template>
+
+                                    <template x-if="$store.torrents.uploadEditId === item.track.id">
+                                        <div class="upload-edit-form">
+                                            <label>
+                                                <span>Title</span>
+                                                <input type="text" x-model="$store.torrents.uploadDraft.title">
+                                            </label>
+                                            <label>
+                                                <span>Artists</span>
+                                                <input type="text" x-model="$store.torrents.uploadDraft.artists" placeholder="Artist, Featured Artist">
+                                            </label>
+                                            <label>
+                                                <span>Release</span>
+                                                <input type="text" x-model="$store.torrents.uploadDraft.release_title">
+                                            </label>
+                                            <label>
+                                                <span>Type</span>
+                                                <select x-model="$store.torrents.uploadDraft.release_type">
+                                                    <option value="album">Album</option>
+                                                    <option value="single">Single</option>
+                                                    <option value="ep">EP</option>
+                                                    <option value="compilation">Compilation</option>
+                                                    <option value="mixtape">Mixtape</option>
+                                                    <option value="live">Live</option>
+                                                    <option value="soundtrack">Soundtrack</option>
+                                                    <option value="remix">Remix</option>
+                                                    <option value="demo">Demo</option>
+                                                </select>
+                                            </label>
+                                            <label>
+                                                <span>Year</span>
+                                                <input type="number" x-model="$store.torrents.uploadDraft.release_year">
+                                            </label>
+                                            <label>
+                                                <span>Track #</span>
+                                                <input type="number" min="1" x-model="$store.torrents.uploadDraft.track_number">
+                                            </label>
+                                            <label>
+                                                <span>Disc #</span>
+                                                <input type="number" min="1" x-model="$store.torrents.uploadDraft.disc_number">
+                                            </label>
+                                            <label class="upload-hidden-toggle">
+                                                <input type="checkbox" x-model="$store.torrents.uploadDraft.is_hidden">
+                                                <span>Hidden</span>
+                                            </label>
+                                            <div class="upload-edit-actions">
+                                                <button class="modal-btn modal-btn-primary"
+                                                        @click="$store.torrents.saveUploadEdit()"
+                                                        :disabled="$store.torrents.uploadSavingId === item.track.id">Save</button>
+                                                <button class="modal-btn modal-btn-ghost" @click="$store.torrents.cancelUploadEdit()">Cancel</button>
+                                            </div>
+                                        </div>
+                                    </template>
+                                </div>
+                            </template>
+                        </div>
+                    </section>
+                </template>
             </div>
         </div>
     </template>
@@ -327,25 +613,93 @@
     <template x-if="$store.history.modal">
         <div class="modal-overlay" @click.self="$store.history.close()">
             <div class="modal-box history-modal">
-                <h3>{{ t.player_play_history }}</h3>
-                <p class="torrent-message" :class="{ error: $store.history.error }"
-                   x-text="$store.history.message"></p>
+                <div class="history-head">
+                    <div>
+                        <h3>{{ t.player_play_history }}</h3>
+                        <p class="torrent-message" :class="{ error: $store.history.error }"
+                           x-text="$store.history.message"></p>
+                    </div>
+                    <button class="mobile-list-action" @click="$store.history.close()" title="{{ t.player_close }}">
+                        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                            <line x1="18" y1="6" x2="6" y2="18"/>
+                            <line x1="6" y1="6" x2="18" y2="18"/>
+                        </svg>
+                    </button>
+                </div>
                 <div class="history-list">
                     <template x-if="!$store.history.loading && $store.history.items.length === 0">
                         <div class="empty-state" style="padding:32px 16px">
                             <p>{{ t.player_no_plays_yet }}</p>
                         </div>
                     </template>
-                    <template x-for="item in $store.history.items" :key="item.id">
-                        <div class="history-row">
-                            <div style="min-width:0">
-                                <div class="history-title" x-text="item.track_title"></div>
-                                <div class="history-release" x-text="item.release_title || '{{ t.player_unknown_release }}'"></div>
+                    <template x-if="$store.history.items.length > 0">
+                        <div class="history-table-head">
+                            <span></span>
+                            <span>{{ t.player_title }}</span>
+                            <span>{{ t.player_played_at }}</span>
+                            <span></span>
+                            <span style="text-align:right">{{ t.player_listened }}</span>
+                        </div>
+                    </template>
+                    <template x-for="(item, idx) in $store.history.items" :key="item.id">
+                        <div class="history-row track-row"
+                             :class="{ playing: $store.player.currentTrack && item.track && $store.player.currentTrack.id === item.track.id }"
+                             @dblclick="$store.history.playFrom(idx)">
+                            <button class="history-cover"
+                                    @click.stop="$store.history.playFrom(idx)"
+                                    :title="item.track?.title || item.track_title">
+                                <template x-if="item.track && item.track.cover_url">
+                                    <img :src="item.track.cover_url" :alt="item.track.title" loading="lazy">
+                                </template>
+                                <template x-if="!item.track || !item.track.cover_url">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="12" cy="12" r="4"/></svg>
+                                </template>
+                            </button>
+                            <div class="track-info">
+                                <div class="track-title" x-text="item.track?.title || item.track_title"></div>
+                                <div class="track-artists-inline">
+                                    <template x-for="(artist, artistIdx) in $store.library.trackArtistLinks(item.track)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
+                                        <span>
+                                            <template x-if="artistIdx > 0"><span>, </span></template>
+                                            <a class="artist-link" @click.stop="$store.history.close(); $store.library.openArtist(artist.id)" x-text="artist.label"></a>
+                                        </span>
+                                    </template>
+                                    <template x-if="!item.track || !$store.library.trackArtistLinks(item.track).length">
+                                        <span x-text="item.release_title || '{{ t.player_unknown_release }}'"></span>
+                                    </template>
+                                </div>
+                                <div class="history-release-line">
+                                    <a class="artist-link"
+                                       x-show="item.track && item.track.release_id"
+                                       @click.stop="$store.history.close(); $store.library.openRelease(item.track.release_id)"
+                                       x-text="item.track?.release_title || item.release_title || '{{ t.player_unknown_release }}'"></a>
+                                </div>
                             </div>
-                            <div>
-                                <div class="history-date" x-text="$store.history.date(item.played_at)"></div>
-                                <div class="history-duration" x-text="$store.history.duration(item.duration_listened)"></div>
+                            <div class="history-date" x-text="$store.history.date(item.played_at)"></div>
+                            <div class="track-actions">
+                                <button class="track-action-btn info-btn popularity-info-btn"
+                                        :class="{ 'has-popularity': $store.library.hasPopularity(item.track), 'no-popularity': !$store.library.hasPopularity(item.track) }"
+                                        :style="$store.library.popularityStyle(item.track)"
+                                        @click.stop="$store.library.openTrackInfo(item.track)"
+                                        :title="$store.library.trackInfoTitle(item.track)"
+                                        aria-label="{{ t.player_track_info }}">
+                                    <span x-show="$store.library.hasPopularity(item.track)" x-text="$store.library.popularityLabel(item.track)"></span>
+                                    <span x-show="!$store.library.hasPopularity(item.track)" class="info-letter">i</span>
+                                </button>
+                                <button class="like-btn" :class="{ liked: $store.likes.has(item.track_id) }" @click.stop="$store.likes.toggle(item.track_id)" title="{{ t.player_like }}">
+                                    <svg viewBox="0 0 24 24" :fill="$store.likes.has(item.track_id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
+                                </button>
+                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([item.track])" title="{{ t.player_play_next }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                </button>
+                                <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([item.track])" title="{{ t.player_add_to_queue }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                </button>
+                                <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([item.track_id])" title="{{ t.player_add_to_playlist }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
+                                </button>
                             </div>
+                            <span class="history-duration" x-text="$store.history.duration(item.duration_listened)"></span>
                         </div>
                     </template>
                 </div>

templates/player/shell.html

@@ -41,9 +41,15 @@
                 <button class="lastfm-profile-action"
                         :class="$store.user.lastfmClass()"
                         :disabled="$store.user.lastfmBusy || !$store.user.lastfm?.configured"
-                        @click="$store.user.handleLastfm()">
+                        @click="$store.user.handleLastfm()"
+                        :title="$store.user.lastfmLabel()"
+                        :aria-label="$store.user.lastfmLabel()">
                     <span class="lastfm-dot"></span>
-                    <span class="lastfm-profile-text" x-text="$store.user.lastfmLabel()"></span>
+                    <span class="lastfm-profile-text">
+                        <span class="lastfm-profile-brand">{{ t.player_lastfm_profile }}</span>
+                        <span class="lastfm-profile-separator">·</span>
+                        <span class="lastfm-profile-status" x-text="$store.user.lastfmStatusLabel()"></span>
+                    </span>
                 </button>
             </div>
             <div class="sidebar-header">
@@ -348,9 +354,15 @@
                     <button class="lastfm-profile-action"
                             :class="$store.user.lastfmClass()"
                             :disabled="$store.user.lastfmBusy || !$store.user.lastfm?.configured"
-                            @click="$store.user.handleLastfm()">
+                            @click="$store.user.handleLastfm()"
+                            :title="$store.user.lastfmLabel()"
+                            :aria-label="$store.user.lastfmLabel()">
                         <span class="lastfm-dot"></span>
-                        <span class="lastfm-profile-text" x-text="$store.user.lastfmLabel()"></span>
+                        <span class="lastfm-profile-text">
+                            <span class="lastfm-profile-brand">{{ t.player_lastfm_profile }}</span>
+                            <span class="lastfm-profile-separator">·</span>
+                            <span class="lastfm-profile-status" x-text="$store.user.lastfmStatusLabel()"></span>
+                        </span>
                     </button>
                     <button class="modal-btn modal-btn-primary mobile-account-logout"
                             @click="$store.user.logout()">
@@ -471,19 +483,16 @@
                                                     <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
                                                     <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                                 </button>
-                                                <button class="track-action-btn play-btn" @click.stop="$store.library.playSearchTrack(idx)" title="{{ t.player_play }}">
-                                                    <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                                </button>
                                                 <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                                 </button>
-                                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
-                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                                 </button>
-                                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
-                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                                <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
+                                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                                 </button>
-                                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
+                                                <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                                 </button>
                                             </div>
@@ -561,8 +570,17 @@
                                 <span>•</span>
                                 <span x-text="$store.library.currentArtist.total_play_count + ' {{ t.player_plays_count }}'"></span>
                             </div>
-                            <div class="release-actions">
-                                <button class="release-action-btn secondary"
+                            <div class="release-actions artist-actions">
+                                <button class="release-action-btn primary artist-listen-action"
+                                        :disabled="!($store.library.currentArtist.top_tracks && $store.library.currentArtist.top_tracks.length)"
+                                        @click="$store.library.playArtistTopTracks()"
+                                        title="{{ t.player_listen_artist }}">
+                                    <svg viewBox="0 0 24 24" fill="currentColor" stroke="none">
+                                        <path d="M8 5v14l11-7z"/>
+                                    </svg>
+                                    <span>{{ t.player_listen }}</span>
+                                </button>
+                                <button class="release-action-btn secondary artist-follow-action"
                                         :class="{ followed: $store.follows.has($store.library.currentArtist.id) }"
                                         @click="$store.follows.toggle($store.library.currentArtist.id)"
                                         :title="$store.follows.has($store.library.currentArtist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
@@ -651,19 +669,16 @@
                                             <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
                                             <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                         </button>
-                                        <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentArtist.featured_tracks, idx)" title="{{ t.player_play }}">
-                                            <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                        </button>
                                         <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                             <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                         </button>
-                                        <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
-                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                        <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                         </button>
-                                        <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
-                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                        <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
+                                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                         </button>
-                                        <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
+                                        <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                         </button>
                                     </div>
@@ -750,7 +765,7 @@
                     <template x-for="(track, idx) in $store.library.currentRelease.tracks" :key="track.id">
                         <div class="track-row"
                              :class="{ playing: $store.player.currentTrack && $store.player.currentTrack.id === track.id }"
-                             @dblclick="$store.queue.playRelease($store.library.currentRelease.tracks, idx)">
+                             @dblclick="$store.queue.playRelease([track], 0)">
                             <span class="track-num" x-text="track.track_number || (idx + 1)"></span>
                             <div class="track-info">
                                 <div class="track-title" x-text="track.title"></div>
@@ -774,19 +789,16 @@
                                     <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
                                     <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                 </button>
-                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentRelease.tracks, idx)" title="{{ t.player_play }}">
-                                    <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                </button>
                                 <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
+                                <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                 </button>
                             </div>
@@ -850,19 +862,16 @@
                                     <span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
                                     <span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
                                 </button>
-                                <button class="track-action-btn play-btn" @click.stop="$store.queue.playRelease($store.library.currentPlaylist.tracks, idx)" title="{{ t.player_play }}">
-                                    <svg viewBox="0 0 24 24" fill="currentColor"><path d="M8 5v14l11-7z"/></svg>
-                                </button>
                                 <button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
                                     <svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h8M5 18h14"/><path d="M17 10l4 3-4 3" fill="currentColor" stroke="none"/></svg>
+                                <button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h10M5 12h7M5 18h10"/><path d="M17 9l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
-                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                <button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
                                 </button>
-                                <button class="track-action-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
+                                <button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
                                     <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
                                 </button>
                             </div>
@@ -892,7 +901,9 @@
                 </template>
                 <template x-for="(track, idx) in $store.queue.tracks" :key="idx + '-' + track.id">
                     <div class="queue-track"
-                         :class="{ active: idx === $store.queue.currentIndex, dragging: $store.queue._dragIdx === idx }"
+                         :data-queue-index="idx"
+                         :class="{ active: idx === $store.queue.currentIndex, dragging: $store.queue._dragIdx === idx, 'foreign-jam-track': $store.queue.isForeignJamTrack(track) }"
+                         :style="$store.queue.isForeignJamTrack(track) ? $store.queue.contributorStyle(track) : ''"
                          @click="$store.queue.playFromIndex(idx)"
                          draggable="true"
                          @dragstart="$store.queue._dragIdx = idx; $event.dataTransfer.effectAllowed = 'move'"
@@ -900,7 +911,10 @@
                          @dragover.prevent="$event.dataTransfer.dropEffect = 'move'; $event.currentTarget.classList.add('drag-over')"
                          @dragleave="$event.currentTarget.classList.remove('drag-over')"
                          @drop.prevent="$event.currentTarget.classList.remove('drag-over'); if ($store.queue._dragIdx !== null) { $store.queue.moveTrack($store.queue._dragIdx, idx); $store.queue._dragIdx = null; }">
-                        <div class="queue-drag-handle" @mousedown.stop>
+                        <div class="queue-drag-handle"
+                             @mousedown.stop
+                             @click.stop
+                             @pointerdown.stop="$store.queue.startPointerReorder($event, idx)">
                             <svg viewBox="0 0 24 24" fill="currentColor"><circle cx="9" cy="6" r="1.5"/><circle cx="15" cy="6" r="1.5"/><circle cx="9" cy="12" r="1.5"/><circle cx="15" cy="12" r="1.5"/><circle cx="9" cy="18" r="1.5"/><circle cx="15" cy="18" r="1.5"/></svg>
                         </div>
                         <div class="queue-track-cover">
@@ -943,11 +957,21 @@
     </div>
 
     <!-- Player Bar -->
-    <div class="player-bar">
+    <div class="player-bar"
+         :class="{ 'mobile-expanded': $store.mobile.playerExpanded, 'mobile-dragging': $store.mobile.playerDragging }"
+         :style="$store.mobile.playerDragStyle()"
+         @click.capture="$store.mobile.handlePlayerClick($event)"
+         @pointerdown="$store.mobile.startPlayerDrag($event)">
+        <button class="mobile-player-collapse-btn" type="button" @click.stop="$store.mobile.closePlayerFullscreen()" title="{{ t.player_close }}" aria-label="{{ t.player_close }}">
+            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
+                <path d="M6 9l6 6 6-6"/>
+            </svg>
+        </button>
         <div class="player-now-playing">
             <template x-if="$store.player.currentTrack">
                 <div style="display:flex;align-items:center;gap:12px;overflow:hidden">
-                    <div class="player-cover">
+                    <div class="player-cover"
+                         @click.stop="$store.mobile.openPlayerFullscreen()">
                         <template x-if="$store.player.currentTrack.cover_url">
                             <img :src="$store.player.currentTrack.cover_url" :alt="$store.player.currentTrack.title">
                         </template>
@@ -977,6 +1001,9 @@
                                 <span class="player-release-year" x-text="' · ' + $store.player.currentTrack.release_year"></span>
                             </template>
                         </div>
+                        <div class="player-track-release" x-show="$store.player.currentTrack.release_title">
+                            <a class="artist-link" @click.stop="$store.player.currentTrack.release_id && $store.library.openRelease($store.player.currentTrack.release_id)" x-text="$store.player.currentTrack.release_title"></a>
+                        </div>
                     </div>
                 </div>
             </template>
@@ -1017,6 +1044,8 @@
                         <div class="progress-bar-thumb"></div>
                     </div>
                 </div>
+                <div class="player-progress-strip-times"
+                     x-text="'-' + formatTime(Math.max(0, $store.player.duration - $store.player.currentTime)) + ' / ' + formatTime($store.player.duration)"></div>
                 <span class="player-time" x-text="formatTime($store.player.duration)"></span>
             </div>
             <div class="player-version-chip">v{{ t.app_version() }}</div>
@@ -1038,7 +1067,7 @@
                 <div class="volume-slider"
                      @pointerdown.prevent="$store.player.startVolumeDrag($event)"
                      aria-label="{{ t.player_volume }}">
-                    <div class="volume-slider-fill" :style="'width:' + ($store.player.volume * 100) + '%'">
+                    <div class="volume-slider-fill" :style="'width:' + $store.player.volumeSliderPercent() + '%'">
                         <div class="volume-slider-thumb"></div>
                     </div>
                 </div>
@@ -1046,5 +1075,163 @@
             <button class="queue-toggle-btn" :class="{ active: $store.queue.visible }" @click="$store.queue.visible = !$store.queue.visible" title="{{ t.player_queue }}">
                 <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/></svg>
             </button>
+            <div class="device-picker" @click.outside="$store.devices.open = false">
+                <button class="queue-toggle-btn device-toggle-btn"
+                        :class="{ active: $store.devices.isActive() }"
+                        @click="$store.devices.toggle()"
+                        :title="$store.devices.activeLabel()"
+                        aria-label="Devices">
+                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                        <rect x="3" y="4" width="18" height="12" rx="2"/>
+                        <path d="M8 20h8"/>
+                        <path d="M12 16v4"/>
+                    </svg>
+                    <span class="jam-member-squares"
+                          x-show="$store.devices.activeJamMembers().length > 0"
+                          x-cloak>
+                        <template x-for="member in $store.devices.activeJamMembers().slice(0, 8)" :key="'device-jam-member-' + member.user_id">
+                            <span class="jam-member-square" :style="$store.devices.userColorStyle(member.user_id, member.name)"></span>
+                        </template>
+                    </span>
+                </button>
+                <div class="device-popover" x-show="$store.devices.open" x-transition x-cloak>
+                    <template x-for="device in $store.devices.devices" :key="device.id">
+                        <button class="device-row"
+                                :class="{ active: device.is_active, 'current-device': device.is_current }"
+                                @click="$store.devices.select(device.id)">
+                            <span class="device-row-icon">
+                                <template x-if="device.kind === 'phone'">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                        <rect x="7" y="2" width="10" height="20" rx="2"/>
+                                        <path d="M11 18h2"/>
+                                    </svg>
+                                </template>
+                                <template x-if="device.kind !== 'phone'">
+                                    <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                        <rect x="3" y="4" width="18" height="12" rx="2"/>
+                                        <path d="M8 20h8"/>
+                                        <path d="M12 16v4"/>
+                                    </svg>
+                                </template>
+                            </span>
+                            <span class="device-row-main">
+                                <span class="device-row-name" x-text="device.name"></span>
+                                <span class="device-row-current" x-show="device.is_current">This device</span>
+                            </span>
+                            <span class="device-row-check" x-show="device.is_active">
+                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
+                                    <polyline points="20 6 9 17 4 12"/>
+                                </svg>
+                            </span>
+                        </button>
+                    </template>
+                    <template x-if="$store.devices.jams.length > 0">
+                        <div class="device-section-label jam-section-label">Jams</div>
+                    </template>
+                    <template x-for="jam in $store.devices.jams" :key="jam.id">
+                        <button class="device-row jam-row"
+                                :class="{ active: jam.is_active, pending: jam.is_pending }"
+                                @click="$store.devices.handleJamRowClick(jam)">
+                            <span class="device-row-icon">
+                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                    <circle cx="8" cy="8" r="3"/>
+                                    <circle cx="16" cy="8" r="3"/>
+                                    <path d="M4 20v-1a4 4 0 014-4h0a4 4 0 014 4v1"/>
+                                    <path d="M12 20v-1a4 4 0 014-4h0a4 4 0 014 4v1"/>
+                                </svg>
+                            </span>
+                            <span class="device-row-main">
+                                <span class="device-row-name" x-text="jam.name"></span>
+                                <span class="device-row-current"
+                                      x-text="!jam.host_device_online ? 'Host offline' : (jam.is_pending ? 'Invite pending' : (jam.is_owner ? 'Your Jam' : 'Shared queue'))"></span>
+                            </span>
+                            <span class="device-row-check" x-show="jam.is_active">
+                                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4">
+                                    <polyline points="20 6 9 17 4 12"/>
+                                </svg>
+                            </span>
+                        </button>
+                    </template>
+                    <button class="device-row start-jam-row" x-show="!$store.devices.hasJoinedJam()" @click="$store.devices.openJamPanel()">
+                        <span class="device-row-icon">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                                <path d="M12 5v14"/>
+                                <path d="M5 12h14"/>
+                            </svg>
+                        </span>
+                        <span class="device-row-main">
+                            <span class="device-row-name">Start Jam</span>
+                            <span class="device-row-current">Invite listeners</span>
+                        </span>
+                    </button>
+                    <div class="jam-create-panel" x-show="$store.devices.jamPanelOpen" x-transition x-cloak>
+                        <div class="jam-panel-title" x-text="$store.devices.jamPanelMode === 'manage' ? 'Invite listeners' : 'Start Jam'"></div>
+                        <div class="jam-selected-users" x-show="$store.devices.jamSelectedUsers.length > 0">
+                            <template x-for="user in $store.devices.jamSelectedUsers" :key="user.id">
+                                <button class="jam-user-chip" @click="$store.devices.removeJamInvitee(user.id)">
+                                    <span x-text="user.display_name || user.username"></span>
+                                    <span aria-hidden="true">×</span>
+                                </button>
+                            </template>
+                        </div>
+                        <input class="jam-user-search"
+                               type="search"
+                               placeholder="Search users"
+                               x-model="$store.devices.jamQuery"
+                               @input="$store.devices.queueJamSearch()">
+                        <div class="jam-search-results" x-show="$store.devices.jamUsers.length > 0">
+                            <template x-for="user in $store.devices.jamUsers" :key="user.id">
+                                <button class="jam-search-row" @click="$store.devices.addJamInvitee(user)">
+                                    <span x-text="user.display_name || user.username"></span>
+                                    <small x-text="user.email || user.username"></small>
+                                </button>
+                            </template>
+                        </div>
+                        <div class="jam-panel-actions">
+                            <button class="jam-create-btn"
+                                    :disabled="$store.devices.jamSelectedUsers.length === 0 && $store.devices.jamPanelMode === 'manage'"
+                                    @click="$store.devices.submitJamPanel()"
+                                    x-text="$store.devices.jamPanelMode === 'manage' ? 'Invite' : 'Create Jam'"></button>
+                            <button class="jam-leave-btn"
+                                    x-show="$store.devices.jamPanelMode === 'manage'"
+                                    @click="$store.devices.leaveJam($store.devices.jamPanelJamId)">Leave</button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        <div class="mobile-expanded-queue">
+            <div class="mobile-expanded-queue-title">{{ t.player_queue }}</div>
+            <template x-if="$store.queue.upcoming().length === 0">
+                <div class="mobile-expanded-queue-empty">{{ t.player_queue_empty }}</div>
+            </template>
+            <template x-for="(track, idx) in $store.queue.upcoming()" :key="'mobile-expanded-queue-' + track.id + '-' + idx">
+                <button class="mobile-expanded-queue-row"
+                        :class="{ 'foreign-jam-track': $store.queue.isForeignJamTrack(track) }"
+                        :style="$store.queue.isForeignJamTrack(track) ? $store.queue.contributorStyle(track) : ''"
+                        type="button"
+                        @click="$store.queue.playFromIndex($store.queue.currentIndex + idx + 1)">
+                    <div class="mobile-expanded-queue-cover">
+                        <template x-if="track.cover_url">
+                            <img :src="track.cover_url" :alt="track.title" loading="lazy">
+                        </template>
+                        <template x-if="!track.cover_url">
+                            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M9 18V5l12-2v13"/><circle cx="6" cy="18" r="3"/><circle cx="18" cy="16" r="3"/></svg>
+                        </template>
+                    </div>
+                    <div class="mobile-expanded-queue-info">
+                        <div class="mobile-expanded-queue-name" x-text="track.title"></div>
+                        <div class="mobile-expanded-queue-artist">
+                            <template x-for="(artist, artistIdx) in $store.library.trackArtistLinks(track)" :key="artist.label + '-' + artist.id + '-' + artistIdx">
+                                <span>
+                                    <template x-if="artistIdx > 0"><span>, </span></template>
+                                    <span x-text="artist.label"></span>
+                                </span>
+                            </template>
+                        </div>
+                    </div>
+                    <span class="mobile-expanded-queue-time" x-text="formatTime(track.duration_seconds)"></span>
+                </button>
+            </template>
         </div>
     </div>