Fix connected devices

CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## v0.10.6 — 2026-09-02
+
+- Recover federation automatically after sleep, prolonged idle, or a degraded rendezvous transport.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "furumusic"
-version = "0.10.4"
+version = "0.10.7"
 edition = "2024"
 description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
 
@@ -45,4 +45,4 @@ uuid = "1"
 librqbit = { version = "8.1.1", features = ["disable-upload"] }
 # P2P federation: publishes the library into a shared DHT and serves audio /
 # catalogs to furumi peers (TUI clients) over the frid stack.
-music-dht = "0.4.0"
+music-dht = "0.5.0"

src/admin/mod.rs

@@ -81,6 +81,11 @@ struct PathId {
     id: i64,
 }
 
+#[derive(Debug, Deserialize)]
+struct PathStringId {
+    id: String,
+}
+
 #[derive(Debug, Deserialize)]
 struct PathName {
     name: String,
@@ -415,6 +420,43 @@ impl App for AdminApp {
                 }),
                 "admin_v2_settings_probe",
             ),
+            Route::with_handler_and_name(
+                "/v2/api/settings/youtube-cookies",
+                {
+                    let pool = Arc::clone(&pool);
+                    let pool_config = Arc::clone(&pool_config);
+                    cot::router::method::post(
+                        move |session: Session,
+                              db: Database,
+                              json: Json<v2::UploadYoutubeCookieFileRequest>| {
+                            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::upload_youtube_cookie_file(session, db, pg_pool, json).await
+                            }
+                        },
+                    )
+                },
+                "admin_v2_youtube_cookie_upload",
+            ),
+            Route::with_handler_and_name(
+                "/v2/api/settings/youtube-cookies/{id}",
+                cot::router::method::delete(
+                    move |session: Session, db: Database, path: Path<PathStringId>| async move {
+                        v2::delete_youtube_cookie_file(session, db, &path.0.id).await
+                    },
+                ),
+                "admin_v2_youtube_cookie_delete",
+            ),
             Route::with_handler_and_name(
                 "/v2/api/federation",
                 get(move |session: Session, db: Database| async move {
@@ -1442,6 +1484,9 @@ impl App for AdminApp {
         all.extend(cot::db::migrations::wrap_migrations(
             crate::auth::db_migrations::MIGRATIONS,
         ));
+        all.extend(cot::db::migrations::wrap_migrations(
+            crate::youtube::db_migrations::MIGRATIONS,
+        ));
         all
     }
 }

src/admin/v2.rs

@@ -16,7 +16,7 @@ use sqlx::{PgPool, Postgres, QueryBuilder};
 use super::BUILD_INFO;
 use crate::agent;
 use crate::auth::{self, AuthenticatedUser, Role};
-use crate::config::{AppConfig, ConfigEntry, ConfigSources, DownloadProxy};
+use crate::config::{AppConfig, ConfigEntry, ConfigSource, ConfigSources, DownloadProxy};
 use crate::i18n::{I18n, Translations};
 use crate::scheduler::{self, JobRegistry, JobRun, ScheduledJob};
 
@@ -165,6 +165,12 @@ pub(super) struct UploadLibraryImageRequest {
     mime_type: String,
 }
 
+#[derive(Debug, Deserialize)]
+pub(super) struct UploadYoutubeCookieFileRequest {
+    filename: String,
+    data: String,
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema)]
 struct ReviewFilter {
     status: Option<String>,
@@ -444,11 +450,42 @@ struct MergeReleasesResponse {
 struct AdminSettingsDto {
     values: AdminSettingsValues,
     sources: AdminSettingsSources,
+    youtube_cookie_files: Vec<AdminYoutubeCookieFileDto>,
     lastfm_api_key_configured: bool,
     lastfm_shared_secret_configured: bool,
     lastfm_scrobbling_configured: bool,
 }
 
+#[derive(Debug, Clone, Serialize, JsonSchema)]
+struct AdminYoutubeCookieFileDto {
+    id: String,
+    filename: String,
+    cookie_count: u64,
+    uploaded_at: String,
+}
+
+impl From<crate::youtube::YoutubeCookieFile> for AdminYoutubeCookieFileDto {
+    fn from(file: crate::youtube::YoutubeCookieFile) -> Self {
+        Self {
+            id: file.id_str().to_owned(),
+            filename: file.filename().to_owned(),
+            cookie_count: file.cookie_count(),
+            uploaded_at: file.uploaded_at().to_owned(),
+        }
+    }
+}
+
+impl From<crate::youtube::YoutubeCookieFileMetadata> for AdminYoutubeCookieFileDto {
+    fn from(file: crate::youtube::YoutubeCookieFileMetadata) -> Self {
+        Self {
+            id: file.id_str().to_owned(),
+            filename: file.filename().to_owned(),
+            cookie_count: file.cookie_count(),
+            uploaded_at: file.uploaded_at().to_owned(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
 struct AdminSettingsValues {
     auth_password_enabled: bool,
@@ -497,6 +534,8 @@ struct AdminSettingsValues {
     torrent_proxy_id: String,
     #[serde(default)]
     youtube_proxy_id: String,
+    #[serde(default)]
+    youtube_cookie_id: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
@@ -566,6 +605,7 @@ struct AdminSettingsSources {
     download_proxies: &'static str,
     torrent_proxy_id: &'static str,
     youtube_proxy_id: &'static str,
+    youtube_cookie_id: &'static str,
 }
 
 #[derive(Debug, Deserialize)]
@@ -616,6 +656,8 @@ pub(super) struct UpdateSettingsRequest {
     torrent_proxy_id: String,
     #[serde(default)]
     youtube_proxy_id: String,
+    #[serde(default)]
+    youtube_cookie_id: String,
 }
 
 fn default_similarity_model() -> String {
@@ -1055,7 +1097,10 @@ pub async fn settings(session: Session, db: Database) -> cot::Result<cot::respon
         return Ok(response);
     }
     let (config, sources) = AppConfig::load_with_db(&db).await;
-    Json(settings_dto(config, sources)).into_response()
+    let cookie_files = crate::youtube::list_cookie_files(&db)
+        .await
+        .map_err(|error| cot::Error::internal(error.to_string()))?;
+    Json(settings_dto(config, sources, cookie_files)).into_response()
 }
 
 pub async fn update_settings(
@@ -1117,6 +1162,7 @@ pub async fn update_settings(
     }
     let torrent_proxy_id = body.torrent_proxy_id.trim().to_string();
     let youtube_proxy_id = body.youtube_proxy_id.trim().to_string();
+    let youtube_cookie_id = body.youtube_cookie_id.trim().to_string();
     for (method, proxy_id) in [
         ("torrent", torrent_proxy_id.as_str()),
         ("YouTube", youtube_proxy_id.as_str()),
@@ -1128,6 +1174,16 @@ pub async fn update_settings(
             ));
         }
     }
+    if !youtube_cookie_id.is_empty()
+        && !crate::youtube::cookie_file_exists(&db, &youtube_cookie_id)
+            .await
+            .map_err(|error| cot::Error::internal(error.to_string()))?
+    {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "selected YouTube cookie file is not in the saved cookie file list",
+        ));
+    }
     let download_proxies_json = serde_json::to_string(&download_proxies)
         .map_err(|error| cot::Error::internal(error.to_string()))?;
     let fields = [
@@ -1200,6 +1256,7 @@ pub async fn update_settings(
         ("download_proxies", download_proxies_json),
         ("torrent_proxy_id", torrent_proxy_id),
         ("youtube_proxy_id", youtube_proxy_id),
+        ("youtube_cookie_id", youtube_cookie_id),
     ];
     for (key, value) in fields {
         let mut entry = ConfigEntry::new(key.to_string(), value);
@@ -1218,6 +1275,119 @@ pub async fn update_settings(
     Json(serde_json::json!({ "ok": true })).into_response()
 }
 
+pub async fn upload_youtube_cookie_file(
+    session: Session,
+    db: Database,
+    pool: &PgPool,
+    Json(body): Json<UploadYoutubeCookieFileRequest>,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let saved_count = match crate::youtube::cookie_file_count(&db).await {
+        Ok(count) => count,
+        Err(error) => {
+            tracing::error!(%error, "could not count saved YouTube cookie files");
+            return Ok(json_error(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "YouTube cookie storage is unavailable; restart the server to apply database migrations",
+            ));
+        }
+    };
+    if saved_count >= crate::youtube::MAX_COOKIE_FILES {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "at most 32 YouTube cookie files can be saved",
+        ));
+    }
+    let filename = Path::new(body.filename.trim())
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or_default()
+        .trim()
+        .chars()
+        .filter(|character| !character.is_control())
+        .take(255)
+        .collect::<String>();
+    if filename.is_empty() {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "cookie filename is empty",
+        ));
+    }
+    use base64::Engine;
+    let max_encoded_len = crate::youtube::MAX_COOKIE_FILE_BYTES.div_ceil(3) * 4;
+    if body.data.trim().len() > max_encoded_len {
+        return Ok(json_error(
+            StatusCode::BAD_REQUEST,
+            "cookie file is larger than 2 MiB",
+        ));
+    }
+    let data = match base64::engine::general_purpose::STANDARD.decode(body.data.trim()) {
+        Ok(data) => data,
+        Err(_) => {
+            return Ok(json_error(
+                StatusCode::BAD_REQUEST,
+                "cookie file payload is invalid",
+            ));
+        }
+    };
+    let (contents, cookie_count) = match crate::youtube::parse_cookie_file(&data) {
+        Ok(parsed) => parsed,
+        Err(error) => return Ok(json_error(StatusCode::BAD_REQUEST, &error.to_string())),
+    };
+    let file =
+        match crate::youtube::store_cookie_file(pool, &filename, cookie_count, &contents).await {
+            Ok(file) => file,
+            Err(error) => {
+                tracing::error!(%error, "could not save YouTube cookie file");
+                return Ok(json_error(
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    "could not save YouTube cookie file; check the server log for details",
+                ));
+            }
+        };
+    Json(AdminYoutubeCookieFileDto::from(file)).into_response()
+}
+
+pub async fn delete_youtube_cookie_file(
+    session: Session,
+    db: Database,
+    id: &str,
+) -> cot::Result<cot::response::Response> {
+    if let Err(response) = require_admin_json(&session, &db).await {
+        return Ok(response);
+    }
+    let id = id.trim();
+    if !crate::youtube::cookie_file_exists(&db, id)
+        .await
+        .map_err(|error| cot::Error::internal(error.to_string()))?
+    {
+        return Ok(json_error(
+            StatusCode::NOT_FOUND,
+            "YouTube cookie file not found",
+        ));
+    }
+    let (config, sources) = AppConfig::load_with_db(&db).await;
+    if config.youtube_cookie_id == id {
+        if sources.youtube_cookie_id == ConfigSource::Env {
+            return Ok(json_error(
+                StatusCode::BAD_REQUEST,
+                "this cookie file is selected by FURU_YOUTUBE_COOKIE_ID and cannot be deleted",
+            ));
+        }
+        let mut entry = ConfigEntry::new("youtube_cookie_id".to_owned(), String::new());
+        entry
+            .save(&db)
+            .await
+            .map_err(|error| cot::Error::internal(error.to_string()))?;
+    }
+    crate::youtube::YoutubeCookieFile::delete_by_id(&db, id)
+        .await
+        .map_err(|error| cot::Error::internal(error.to_string()))?;
+    Json(serde_json::json!({ "ok": true })).into_response()
+}
+
 // ---------------------------------------------------------------------------
 // Federation (status + manual controls)
 // ---------------------------------------------------------------------------
@@ -1373,7 +1543,11 @@ pub async fn settings_probe(
     .into_response()
 }
 
-fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
+fn settings_dto(
+    config: AppConfig,
+    sources: ConfigSources,
+    cookie_files: Vec<crate::youtube::YoutubeCookieFileMetadata>,
+) -> AdminSettingsDto {
     let download_proxies = config
         .parsed_download_proxies()
         .unwrap_or_else(|error| {
@@ -1384,6 +1558,10 @@ fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
         .map(AdminDownloadProxy::from)
         .collect();
     AdminSettingsDto {
+        youtube_cookie_files: cookie_files
+            .into_iter()
+            .map(AdminYoutubeCookieFileDto::from)
+            .collect(),
         lastfm_api_key_configured: !config.lastfm_api_key.trim().is_empty(),
         lastfm_shared_secret_configured: !config.lastfm_shared_secret.trim().is_empty(),
         lastfm_scrobbling_configured: !config.lastfm_api_key.trim().is_empty()
@@ -1422,6 +1600,7 @@ fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
             download_proxies,
             torrent_proxy_id: config.torrent_proxy_id,
             youtube_proxy_id: config.youtube_proxy_id,
+            youtube_cookie_id: config.youtube_cookie_id,
         },
         sources: AdminSettingsSources {
             auth_password_enabled: sources.auth_password_enabled.code(),
@@ -1457,6 +1636,7 @@ fn settings_dto(config: AppConfig, sources: ConfigSources) -> AdminSettingsDto {
             download_proxies: sources.download_proxies.code(),
             torrent_proxy_id: sources.torrent_proxy_id.code(),
             youtube_proxy_id: sources.youtube_proxy_id.code(),
+            youtube_cookie_id: sources.youtube_cookie_id.code(),
         },
     }
 }

src/config.rs

@@ -148,6 +148,7 @@ pub struct ConfigSources {
     pub download_proxies: ConfigSource,
     pub torrent_proxy_id: ConfigSource,
     pub youtube_proxy_id: ConfigSource,
+    pub youtube_cookie_id: ConfigSource,
 }
 
 impl Default for ConfigSources {
@@ -188,6 +189,7 @@ impl Default for ConfigSources {
             download_proxies: ConfigSource::Default,
             torrent_proxy_id: ConfigSource::Default,
             youtube_proxy_id: ConfigSource::Default,
+            youtube_cookie_id: ConfigSource::Default,
         }
     }
 }
@@ -403,6 +405,8 @@ pub struct AppConfig {
     pub torrent_proxy_id: String,
     /// Saved proxy id used for YouTube downloads; empty means a direct connection.
     pub youtube_proxy_id: String,
+    /// Saved cookie-file id used by yt-dlp; empty means no cookies.
+    pub youtube_cookie_id: String,
 }
 
 impl Default for AppConfig {
@@ -446,6 +450,7 @@ impl Default for AppConfig {
             download_proxies: "[]".into(),
             torrent_proxy_id: String::new(),
             youtube_proxy_id: String::new(),
+            youtube_cookie_id: String::new(),
         }
     }
 }
@@ -487,6 +492,7 @@ impl_env_overrides!(
     download_proxies,
     torrent_proxy_id,
     youtube_proxy_id,
+    youtube_cookie_id,
 );
 
 impl AppConfig {
@@ -581,11 +587,13 @@ impl AppConfig {
                             sources.$field = ConfigSource::Database;
                         }
                         Err(_) => {
-                            tracing::warn!(
-                                "ignoring invalid DB config value for {}: {:?}",
-                                stringify!($field),
-                                val,
-                            );
+                            if !val.trim().is_empty() {
+                                tracing::warn!(
+                                    "ignoring invalid DB config value for {}: {:?}",
+                                    stringify!($field),
+                                    val,
+                                );
+                            }
                         }
                     }
                 }
@@ -627,6 +635,7 @@ impl AppConfig {
         apply_db_field!(download_proxies);
         apply_db_field!(torrent_proxy_id);
         apply_db_field!(youtube_proxy_id);
+        apply_db_field!(youtube_cookie_id);
     }
 
     pub fn parsed_download_proxies(&self) -> anyhow::Result<Vec<DownloadProxy>> {

src/federation/devices.rs

@@ -5,6 +5,9 @@
 //! protocol as the TUI clients on `furumi/sync/1` and maps operations into
 //! user-scoped Postgres state.
 
+use music_dht::playback::{
+    Announcement, Checkpoint, CommandStamp, Config as PlaybackConfig, Engine,
+};
 use std::collections::BTreeMap;
 use std::str::FromStr;
 use std::sync::Arc;
@@ -24,7 +27,7 @@ use super::{TransportStats, record_stream_transport};
 pub const SYNC_ALPN: &[u8] = b"furumi/sync/2";
 
 const CLIENT_VERSION: &str = env!("CARGO_PKG_VERSION");
-const PROTOCOL_VERSION: u16 = 2;
+const PROTOCOL_VERSION: u16 = 3;
 const INVITE_TTL_MS: i64 = 10 * 60 * 1000;
 const PAIRING_WAIT_MS: i64 = 5 * 60 * 1000;
 const PAIRING_RETRY_DELAY: Duration = Duration::from_secs(1);
@@ -193,29 +196,8 @@ struct PlaybackStateWire {
     repeat: PlaybackRepeat,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-struct PlaybackSnapshot {
-    device_id: String,
-    device_name: String,
-    active: bool,
-    updated_at_ms: i64,
-    state: PlaybackStateWire,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "kind", rename_all = "snake_case")]
-enum PlaybackCommand {
-    SetState {
-        state: PlaybackStateWire,
-        #[serde(default)]
-        seek: bool,
-    },
-    ActiveChanged {
-        active_device_id: String,
-        active_device_name: String,
-        state: PlaybackStateWire,
-    },
-}
+type PlaybackSnapshot = music_dht::playback::Snapshot<PlaybackStateWire>;
+type PlaybackCommand = music_dht::playback::Command<PlaybackStateWire>;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 struct SyncOpWire {
@@ -273,6 +255,8 @@ enum SyncOpPayload {
     PlaybackCommand {
         target_device_id: String,
         command: PlaybackCommand,
+        #[serde(default)]
+        authority: Option<CommandStamp>,
     },
     ListenRecorded {
         event: ListenEvent,
@@ -1097,50 +1081,53 @@ pub async fn sync_loop(
     transport_stats: Arc<TransportStats>,
 ) {
     let mut interval = tokio::time::interval(DEVICE_SYNC_INTERVAL);
+    interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+    let mut polls = tokio::task::JoinSet::new();
+    let mut active = std::collections::HashMap::new();
     loop {
-        interval.tick().await;
-        if let Err(err) = sync_once_all(
-            &pool,
-            Arc::clone(&service),
-            Arc::clone(&hub),
-            Arc::clone(&transport_stats),
-        )
-        .await
-        {
-            tracing::debug!("web fed device sync tick failed: {err:#}");
+        tokio::select! {
+            _ = interval.tick() => {
+                let users: Vec<i64> = match sqlx::query_scalar(
+                    "SELECT DISTINCT user_id FROM furumusic__fed_device WHERE trusted_at_ms IS NOT NULL AND revoked_at_ms IS NULL"
+                ).fetch_all(&pool).await {
+                    Ok(users) => users,
+                    Err(error) => { tracing::warn!("device poll listing failed: {error:#}"); continue; }
+                };
+                for user_id in users {
+                    let devices = match active_remote_devices(&pool, user_id).await {
+                        Ok(devices) => devices,
+                        Err(error) => { let _ = set_last_error(&pool, user_id, Some(&format!("{error:#}"))).await; continue; }
+                    };
+                    for device in devices {
+                        let key = (user_id, device.device_id.clone());
+                        if device.endpoint_ticket.trim().is_empty() || active.values().any(|id| id == &key) { continue; }
+                        let pool = pool.clone();
+                        let service = Arc::clone(&service);
+                        let hub = Arc::clone(&hub);
+                        let stats = Arc::clone(&transport_stats);
+                        let handle = polls.spawn(async move {
+                            tokio::time::timeout(Duration::from_secs(30), sync_device(&pool, service, hub, stats, user_id, &device))
+                                .await.context("device sync exchange timed out")?
+                        });
+                        active.insert(handle.id(), key);
+                    }
+                }
+            }
+            Some(completed) = polls.join_next_with_id(), if !polls.is_empty() => {
+                let (task, result) = match completed {
+                    Ok((task, result)) => (task, result),
+                    Err(error) => (error.id(), Err(anyhow::Error::from(error))),
+                };
+                if let Some((user_id, device_id)) = active.remove(&task)
+                    && let Err(error) = result {
+                        tracing::debug!(device = %device_id, "web fed device sync failed: {error:#}");
+                        let _ = set_last_error(&pool, user_id, Some(&format!("{}: {error:#}", short_id(&device_id)))).await;
+                    }
+            }
         }
     }
 }
 
-pub async fn sync_once_all(
-    pool: &sqlx::PgPool,
-    service: Arc<MusicDhtService>,
-    hub: Arc<PlayerDeviceHub>,
-    transport_stats: Arc<TransportStats>,
-) -> Result<()> {
-    let rows = sqlx::query(
-        "SELECT DISTINCT user_id FROM furumusic__fed_device
-         WHERE trusted_at_ms IS NOT NULL AND revoked_at_ms IS NULL",
-    )
-    .fetch_all(pool)
-    .await?;
-    for row in rows {
-        let user_id: i64 = row.get("user_id");
-        if let Err(err) = sync_once(
-            pool,
-            Arc::clone(&service),
-            Arc::clone(&hub),
-            Arc::clone(&transport_stats),
-            user_id,
-        )
-        .await
-        {
-            set_last_error(pool, user_id, Some(&format!("{err:#}"))).await?;
-        }
-    }
-    Ok(())
-}
-
 pub async fn sync_once(
     pool: &sqlx::PgPool,
     service: Arc<MusicDhtService>,
@@ -1235,7 +1222,14 @@ async fn try_connect_invite(
                 enforce_single_user_binding(pool, user_id, &profile.device_id).await?;
                 apply_device_profile(pool, user_id, &profile, true).await?;
                 if let Some(playback) = playback {
-                    apply_playback_snapshot(Arc::clone(&hub), pool, user_id, playback).await?;
+                    apply_playback_snapshot(
+                        Arc::clone(&hub),
+                        pool,
+                        user_id,
+                        &profile.device_id,
+                        playback,
+                    )
+                    .await?;
                 }
             }
             apply_device_profiles(pool, user_id, &devices).await?;
@@ -1454,7 +1448,14 @@ async fn handle_pair_request(
     let own_profile = own_profile(pool, user_id, "", &own_ticket).await?;
     apply_device_profile(pool, user_id, &profile, true).await?;
     if let Some(playback) = playback {
-        apply_playback_snapshot(Arc::clone(&hub), pool, user_id, playback).await?;
+        apply_playback_snapshot(
+            Arc::clone(&hub),
+            pool,
+            user_id,
+            &profile.device_id,
+            playback,
+        )
+        .await?;
     }
     apply_snapshot(pool, user_id, incoming_snapshot).await?;
     apply_ops(pool, Arc::clone(&hub), user_id, ops).await?;
@@ -1524,7 +1525,14 @@ async fn handle_hello(
     apply_device_profile(pool, user_id, &profile, false).await?;
     apply_device_profiles(pool, user_id, &devices).await?;
     if let Some(playback) = playback {
-        apply_playback_snapshot(Arc::clone(&hub), pool, user_id, playback).await?;
+        apply_playback_snapshot(
+            Arc::clone(&hub),
+            pool,
+            user_id,
+            &profile.device_id,
+            playback,
+        )
+        .await?;
     }
     apply_snapshot(pool, user_id, incoming_snapshot).await?;
     apply_ops(pool, Arc::clone(&hub), user_id, ops).await?;
@@ -1618,7 +1626,14 @@ async fn sync_device(
         } => {
             apply_device_profiles(pool, user_id, &devices).await?;
             if let Some(playback) = playback {
-                apply_playback_snapshot(Arc::clone(&hub), pool, user_id, playback).await?;
+                apply_playback_snapshot(
+                    Arc::clone(&hub),
+                    pool,
+                    user_id,
+                    &device.device_id,
+                    playback,
+                )
+                .await?;
             }
             apply_snapshot(pool, user_id, snapshot).await?;
             apply_ops(pool, hub, user_id, ops).await?;
@@ -1952,8 +1967,33 @@ async fn own_profile(
     })
 }
 
-async fn record_local_op(pool: &sqlx::PgPool, user_id: i64, payload: SyncOpPayload) -> Result<()> {
+async fn record_local_op(
+    pool: &sqlx::PgPool,
+    user_id: i64,
+    mut payload: SyncOpPayload,
+) -> Result<()> {
     let identity = ensure_identity(pool, user_id, "").await?;
+    if let SyncOpPayload::PlaybackCommand {
+        command, authority, ..
+    } = &mut payload
+    {
+        *authority = Some(
+            with_playback_engine(pool, user_id, &identity, |engine| {
+                if let PlaybackCommand::ActiveChanged {
+                    active_device_id, ..
+                } = command
+                {
+                    if engine.owner() != Some(active_device_id.as_str()) {
+                        engine.transfer(active_device_id, playback_clock());
+                    }
+                }
+                engine.stamp()
+            })
+            .await?
+            .context("no playback owner; select an output first")?,
+        );
+    }
+
     let now = now_ms();
     let row = sqlx::query(
         "UPDATE furumusic__fed_device_identity
@@ -2193,12 +2233,8 @@ async fn apply_op(
             )
             .await
         }
-        SyncOpPayload::PlaybackCommand {
-            target_device_id,
-            command,
-        } => {
-            apply_playback_command(pool, hub, user_id, target_device_id, command, &op.op_id)
-                .await?;
+        SyncOpPayload::PlaybackCommand { .. } => {
+            apply_playback_command(pool, hub, user_id, op).await?;
             Ok(false)
         }
         SyncOpPayload::ListenRecorded { event } => {
@@ -2798,12 +2834,41 @@ async fn apply_playback_command(
     pool: &sqlx::PgPool,
     hub: Arc<PlayerDeviceHub>,
     user_id: i64,
-    target_device_id: &str,
-    command: &PlaybackCommand,
-    op_id: &str,
+    op: &SyncOpWire,
 ) -> Result<()> {
+    let SyncOpPayload::PlaybackCommand {
+        target_device_id,
+        command,
+        authority,
+    } = &op.payload
+    else {
+        return Ok(());
+    };
+    let authority = authority.as_ref();
+    let origin = &op.origin_device_id;
+    let op_id = &op.op_id;
     let identity = ensure_identity(pool, user_id, "").await?;
-    if target_device_id != identity.device_id {
+    let Some(authority) = authority else {
+        return Ok(());
+    };
+    let handoff = matches!(command, PlaybackCommand::ActiveChanged { .. });
+    if !handoff && target_device_id != &identity.device_id {
+        return Ok(());
+    }
+    if let PlaybackCommand::ActiveChanged {
+        active_device_id, ..
+    } = command
+    {
+        if active_device_id != &authority.claim.owner {
+            return Ok(());
+        }
+    }
+    let accepted = with_playback_engine(pool, user_id, &identity, |engine| {
+        engine.accept_command(origin, authority, handoff, playback_clock())
+            && (handoff || engine.is_owner())
+    })
+    .await?;
+    if !accepted || target_device_id != &identity.device_id {
         return Ok(());
     }
     let inserted = sqlx::query(
@@ -2822,17 +2887,36 @@ async fn apply_playback_command(
     }
     match command {
         PlaybackCommand::SetState { state, .. } => {
-            enqueue_web_transfer(pool, hub, user_id, state).await?;
+            enqueue_web_transfer(pool, hub, user_id, state, op).await?;
         }
         PlaybackCommand::ActiveChanged {
             active_device_id,
             state,
             ..
         } if active_device_id == &identity.device_id => {
-            enqueue_web_transfer(pool, hub, user_id, state).await?;
+            enqueue_web_transfer(pool, hub, user_id, state, op).await?;
         }
-        PlaybackCommand::ActiveChanged { .. } => {
-            let _ = hub.enqueue_fed_command(user_id, "pause", serde_json::json!({}));
+        PlaybackCommand::ActiveChanged {
+            active_device_id,
+            active_device_name,
+            state,
+        } => {
+            let payload = web_playback_payload(pool, state).await?;
+            if !with_playback_engine(pool, user_id, &identity, |engine| {
+                engine.command_is_current(origin, authority)
+            })
+            .await?
+            {
+                return Ok(());
+            }
+            hub.apply_fed_playback_state_json(
+                user_id,
+                active_device_id,
+                active_device_name,
+                true,
+                payload,
+            )
+            .map_err(|message| anyhow::anyhow!(message))?;
         }
     }
     Ok(())
@@ -2842,14 +2926,36 @@ async fn apply_playback_snapshot(
     hub: Arc<PlayerDeviceHub>,
     pool: &sqlx::PgPool,
     user_id: i64,
+    sender: &str,
     snapshot: PlaybackSnapshot,
 ) -> Result<()> {
+    if snapshot.device_id != sender {
+        return Ok(());
+    }
+    let identity = ensure_identity(pool, user_id, "").await?;
+    let Some(coordination) = &snapshot.coordination else {
+        return Ok(());
+    };
+    let owner = with_playback_engine(pool, user_id, &identity, |engine| {
+        if !engine.observe(&snapshot.device_id, coordination, playback_clock()) {
+            return None;
+        }
+        engine
+            .announcement_is_current(&snapshot.device_id, coordination)
+            .then(|| snapshot.device_id.clone())
+    })
+    .await?;
     let payload = web_playback_payload(pool, &snapshot.state).await?;
+    let active = owner.as_deref() == Some(snapshot.device_id.as_str())
+        && with_playback_engine(pool, user_id, &identity, |engine| {
+            engine.announcement_is_current(&snapshot.device_id, coordination)
+        })
+        .await?;
     hub.apply_fed_playback_state_json(
         user_id,
         &snapshot.device_id,
         &snapshot.device_name,
-        snapshot.active,
+        active,
         payload,
     )
     .map_err(|message| anyhow::anyhow!(message))?;
@@ -2861,8 +2967,24 @@ async fn enqueue_web_transfer(
     hub: Arc<PlayerDeviceHub>,
     user_id: i64,
     state: &PlaybackStateWire,
+    op: &SyncOpWire,
 ) -> Result<()> {
+    let identity = ensure_identity(pool, user_id, "").await?;
     let payload = web_playback_payload(pool, state).await?;
+    let SyncOpPayload::PlaybackCommand {
+        authority: Some(authority),
+        ..
+    } = &op.payload
+    else {
+        return Ok(());
+    };
+    if !with_playback_engine(pool, user_id, &identity, |engine| {
+        engine.command_is_current(&op.origin_device_id, authority)
+    })
+    .await?
+    {
+        return Ok(());
+    }
     if payload
         .get("tracks")
         .and_then(serde_json::Value::as_array)
@@ -2891,6 +3013,7 @@ pub async fn record_web_playback_command(
         pool,
         user_id,
         SyncOpPayload::PlaybackCommand {
+            authority: None,
             target_device_id: target_device_id.to_string(),
             command: PlaybackCommand::SetState {
                 state: wire,
@@ -2915,14 +3038,22 @@ pub async fn record_web_active_transfer(
     ensure_web_playback_target(pool, user_id, target_device_id).await?;
     let wire = playback_state_from_browser_json(pool, state).await?;
     let target_name = web_playback_target_name(pool, user_id, target_device_id).await?;
+    let identity = ensure_identity(pool, user_id, "").await?;
+    with_playback_engine(pool, user_id, &identity, |engine| {
+        engine.transfer(target_device_id, playback_clock())
+    })
+    .await?;
+
     record_local_op(
         pool,
         user_id,
         SyncOpPayload::PlaybackCommand {
+            authority: None,
             target_device_id: target_device_id.to_string(),
-            command: PlaybackCommand::SetState {
+            command: PlaybackCommand::ActiveChanged {
+                active_device_id: target_device_id.to_string(),
+                active_device_name: target_name.clone(),
                 state: wire.clone(),
-                seek: true,
             },
         },
     )
@@ -2940,6 +3071,7 @@ pub async fn record_web_active_transfer(
             pool,
             user_id,
             SyncOpPayload::PlaybackCommand {
+                authority: None,
                 target_device_id: previous_device_id.to_string(),
                 command,
             },
@@ -2958,10 +3090,15 @@ pub async fn record_web_active_takeover(
     ensure_web_playback_target(pool, user_id, previous_device_id).await?;
     let identity = ensure_identity(pool, user_id, "").await?;
     let wire = playback_state_from_browser_json(pool, state).await?;
+    with_playback_engine(pool, user_id, &identity, |engine| {
+        engine.transfer(&identity.device_id, playback_clock())
+    })
+    .await?;
     record_local_op(
         pool,
         user_id,
         SyncOpPayload::PlaybackCommand {
+            authority: None,
             target_device_id: previous_device_id.to_string(),
             command: PlaybackCommand::ActiveChanged {
                 active_device_id: identity.device_id,
@@ -3423,11 +3560,16 @@ async fn local_playback_snapshot(
     user_id: i64,
     identity: &Identity,
 ) -> Option<PlaybackSnapshot> {
-    // Keep publishing an inactive snapshot after a handoff. Omitting the
-    // snapshot left the last `active: true` value alive on trusted peers until
-    // its TTL elapsed, allowing the always-on web peer to reclaim playback.
-    let active = hub.federation_playback_is_local(user_id);
-    let state = hub.playback_state_json_for_commands(user_id)?;
+    let coordination = coordinate_web_output(pool, Arc::clone(&hub), user_id, identity)
+        .await
+        .ok()?;
+    let active = coordination
+        .claim
+        .as_ref()
+        .is_some_and(|claim| claim.owner == identity.device_id);
+    let state = hub
+        .playback_state_json_for_commands(user_id)
+        .unwrap_or_else(|| serde_json::json!({}));
     let wire = playback_state_from_browser_json(pool, state).await.ok()?;
     Some(PlaybackSnapshot {
         device_id: identity.device_id.clone(),
@@ -3435,9 +3577,123 @@ async fn local_playback_snapshot(
         active,
         updated_at_ms: now_ms(),
         state: wire,
+        coordination: Some(coordination),
     })
 }
 
+/// Drive coordination from browser HTTP traffic even before the first peer
+/// connects. This does not require a running federation transport.
+pub async fn refresh_web_output(
+    pool: &sqlx::PgPool,
+    hub: Arc<PlayerDeviceHub>,
+    user_id: i64,
+) -> Result<()> {
+    let identity = ensure_identity(pool, user_id, "").await?;
+    coordinate_web_output(pool, hub, user_id, &identity).await?;
+    Ok(())
+}
+
+async fn coordinate_web_output(
+    pool: &sqlx::PgPool,
+    hub: Arc<PlayerDeviceHub>,
+    user_id: i64,
+    identity: &Identity,
+) -> Result<Announcement> {
+    let (available, playing, report, startup) = hub.federation_output_report(user_id);
+    let coordination = with_playback_engine(pool, user_id, identity, |engine| {
+        engine.set_output(available, playing);
+        if startup {
+            engine.request_startup();
+        }
+        // A server poll cannot refresh the heartbeat of a suspended browser.
+        engine.output_report(report, playback_clock());
+        engine.tick(playback_clock());
+        engine.announcement()
+    })
+    .await?;
+    if let Some(owner) = &coordination.claim {
+        hub.enforce_federation_owner(user_id, &identity.device_id, &owner.owner);
+    }
+    Ok(coordination)
+}
+
+// One serialized coordinator per account. The lock covers checkpoint commit so
+// a later request cannot publish a term before its predecessor is durable.
+struct PlaybackSession {
+    engine: Option<Engine>,
+    group_id: String,
+}
+type PlaybackSessions = std::sync::Mutex<BTreeMap<i64, Arc<tokio::sync::Mutex<PlaybackSession>>>>;
+
+async fn with_playback_engine<R>(
+    pool: &sqlx::PgPool,
+    user_id: i64,
+    identity: &Identity,
+    f: impl FnOnce(&mut Engine) -> R,
+) -> Result<R> {
+    static SESSIONS: std::sync::OnceLock<PlaybackSessions> = std::sync::OnceLock::new();
+    let session = {
+        let mut sessions = SESSIONS
+            .get_or_init(Default::default)
+            .lock()
+            .expect("playback sessions");
+        sessions
+            .entry(user_id)
+            .or_insert_with(|| {
+                Arc::new(tokio::sync::Mutex::new(PlaybackSession {
+                    engine: None,
+                    group_id: String::new(),
+                }))
+            })
+            .clone()
+    };
+    let mut session = session.lock().await;
+    if session.engine.is_none() || session.group_id != identity.group_id {
+        session.group_id = identity.group_id.clone();
+        let row = sqlx::query("SELECT playback_coordination_json, playback_config_json FROM furumusic__fed_device_identity WHERE user_id = $1")
+            .bind(user_id).fetch_one(pool).await?;
+        let durable = row
+            .get::<Option<serde_json::Value>, _>("playback_coordination_json")
+            .map(serde_json::from_value::<Checkpoint>)
+            .transpose()?
+            .filter(|checkpoint| checkpoint.scope == identity.group_id)
+            .map(|checkpoint| checkpoint.state)
+            .unwrap_or_default();
+        let config = row
+            .get::<Option<serde_json::Value>, _>("playback_config_json")
+            .map(serde_json::from_value::<PlaybackConfig>)
+            .transpose()?
+            .unwrap_or_else(PlaybackConfig::passive);
+        session.engine = Some(Engine::new(
+            identity.device_id.clone(),
+            config,
+            durable,
+            playback_clock(),
+        ));
+    }
+    let engine = session
+        .engine
+        .as_mut()
+        .expect("initialized playback session");
+    let previous = engine.clone();
+    let result = f(engine);
+    if previous.durable() != engine.durable() {
+        if let Err(error) = sqlx::query("UPDATE furumusic__fed_device_identity SET playback_coordination_json = $2 WHERE user_id = $1")
+            .bind(user_id).bind(serde_json::to_value(&Checkpoint { scope: identity.group_id.clone(), state: engine.durable().clone() })?).execute(pool).await {
+            *engine = previous; return Err(error.into());
+        }
+    }
+    Ok(result)
+}
+
+fn playback_clock() -> u64 {
+    static START: std::sync::OnceLock<std::time::Instant> = std::sync::OnceLock::new();
+    START
+        .get_or_init(std::time::Instant::now)
+        .elapsed()
+        .as_millis() as u64
+}
+
 async fn playback_state_from_browser_json(
     pool: &sqlx::PgPool,
     state: serde_json::Value,
@@ -4787,3 +5043,6 @@ fn base64url_decode(value: &str) -> Result<Vec<u8>> {
     }
     Ok(out)
 }
+
+#[cfg(test)]
+mod interop_tests;

src/federation/devices/interop_tests.rs

@@ -0,0 +1,137 @@
+//! Cross-binary protocol contract; the peer is the TUI's production adapter.
+use super::*;
+use tokio::io::AsyncWriteExt;
+
+#[tokio::test]
+#[ignore = "run furumi_tui/scripts/test_device_interop.py"]
+async fn localhost_tui_peer() {
+    tokio::time::timeout(Duration::from_secs(30), async {
+        let dir =
+            std::path::PathBuf::from(std::env::var("FURUMI_INTEROP_DIR").expect("interop runner"));
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        std::fs::write(
+            dir.join("web-address"),
+            listener.local_addr().unwrap().to_string(),
+        )
+        .unwrap();
+        let (mut stream, _) = listener.accept().await.unwrap();
+        let hub = PlayerDeviceHub::default();
+        let web_id = "web-interop";
+        let mut engine = Engine::new(
+            web_id.into(),
+            PlaybackConfig::passive(),
+            Default::default(),
+            0,
+        );
+        for phase in 0..3 {
+            let hello: WireMessage =
+                serde_json::from_slice(&read_line(&mut stream).await.unwrap()).unwrap();
+            let WireMessage::Hello {
+                profile,
+                playback: Some(snapshot),
+                ..
+            } = hello
+            else {
+                panic!("expected TUI hello")
+            };
+            assert_eq!(profile.protocol_version, PROTOCOL_VERSION);
+            assert_eq!(snapshot.device_id, profile.device_id);
+            let announcement = snapshot
+                .coordination
+                .as_ref()
+                .expect("versioned playback envelope");
+            assert!(engine.observe(&profile.device_id, announcement, phase * 1000));
+            if phase == 0 {
+                assert_eq!(engine.owner(), Some(profile.device_id.as_str()));
+                assert!(
+                    !engine.tick(10_000),
+                    "passive web server must not seize playback"
+                );
+                assert_eq!(snapshot.state.position_secs, 42.5);
+                assert_eq!(snapshot.state.volume, 73);
+                assert!(snapshot.state.shuffle);
+                // Exercise the production browser hub projection without a
+                // PostgreSQL library or an audio device.
+                hub.apply_fed_playback_state_json(
+                    1,
+                    &profile.device_id,
+                    &profile.name,
+                    true,
+                    serde_json::json!({"tracks": [], "index": 0, "track": null,
+                        "position_seconds": 42.5, "duration_seconds": 100.0,
+                        "paused": false, "shuffle": true, "repeat_mode": "all",
+                        "volume": 0.73, "updated_at_ms": now_ms()}),
+                )
+                .unwrap();
+                assert_eq!(
+                    hub.active_device_id_for_commands(1),
+                    Some(format!("fed:{}", profile.device_id))
+                );
+            } else {
+                assert_eq!(
+                    engine.owner(),
+                    Some(if phase == 1 {
+                        web_id
+                    } else {
+                        profile.device_id.as_str()
+                    })
+                );
+            }
+            let mut state = snapshot.state;
+            let command = if phase < 2 {
+                let owner = if phase == 0 {
+                    web_id
+                } else {
+                    profile.device_id.as_str()
+                };
+                assert!(engine.transfer(owner, (phase + 1) * 1000));
+                PlaybackCommand::ActiveChanged {
+                    active_device_id: owner.into(),
+                    active_device_name: "interop".into(),
+                    state: state.clone(),
+                }
+            } else {
+                state.paused = true;
+                state.position_secs = 87.0;
+                PlaybackCommand::SetState {
+                    state: state.clone(),
+                    seek: true,
+                }
+            };
+            engine.set_output(true, engine.is_owner());
+            engine.heartbeat((phase + 1) * 1000);
+            let response = WireMessage::SyncResponse {
+                accepted: true,
+                error: None,
+                devices: vec![],
+                vector: BTreeMap::new(),
+                snapshot: SyncSnapshot::default(),
+                playback: Some(PlaybackSnapshot {
+                    device_id: web_id.into(),
+                    device_name: "WEB".into(),
+                    active: engine.is_owner(),
+                    updated_at_ms: now_ms(),
+                    state,
+                    coordination: Some(engine.announcement()),
+                }),
+                ops: vec![SyncOpWire {
+                    op_id: format!("{web_id}:{}", phase + 1),
+                    origin_device_id: web_id.into(),
+                    seq: (phase + 1) as i64,
+                    hlc_ms: now_ms(),
+                    payload: SyncOpPayload::PlaybackCommand {
+                        target_device_id: profile.device_id,
+                        command,
+                        authority: engine.stamp(),
+                    },
+                }],
+            };
+            let mut bytes = serde_json::to_vec(&response).unwrap();
+            bytes.push(b'\n');
+            stream.write_all(&bytes).await.unwrap();
+        }
+        assert_eq!(read_line(&mut stream).await.unwrap(), b"ok");
+    })
+    .await
+    .expect("TUI/web exchange timed out");
+}

src/federation/mod.rs

@@ -24,8 +24,9 @@ mod storage;
 
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, OnceLock};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use anyhow::{Context, Result};
 use music_dht::capabilities::CAPABILITIES_ALPN;
@@ -47,6 +48,8 @@ pub use similarity::SIMILARITY_ALPN;
 
 /// How often the published library is re-synchronized with the database.
 const SYNC_INTERVAL: Duration = Duration::from_secs(60);
+const SUPERVISOR_INTERVAL: Duration = Duration::from_secs(15);
+const RECOVERY_COOLDOWN: Duration = Duration::from_secs(5 * 60);
 const TRANSPORT_SAMPLE_LIMIT: usize = 16;
 
 struct Running {
@@ -273,6 +276,7 @@ pub struct Federation {
     data_dir: PathBuf,
     database_url: std::sync::Mutex<String>,
     storage_dir: std::sync::Mutex<String>,
+    desired_network: std::sync::Mutex<Option<String>>,
     save_on_listen: std::sync::atomic::AtomicBool,
     content_cache: std::sync::Mutex<HashMap<i64, (String, String)>>,
     content_pending: std::sync::Mutex<HashSet<i64>>,
@@ -281,6 +285,8 @@ pub struct Federation {
     download_locks: std::sync::Mutex<HashMap<String, Arc<tokio::sync::Mutex<()>>>>,
     pool: tokio::sync::OnceCell<PgPool>,
     running: tokio::sync::Mutex<Option<Running>>,
+    supervisor_started: AtomicBool,
+    recovery_count: AtomicU64,
     last_sync: std::sync::Mutex<Option<String>>,
     last_error: std::sync::Mutex<Option<String>>,
     transport_stats: Arc<TransportStats>,
@@ -304,6 +310,7 @@ pub fn handle() -> Arc<Federation> {
             data_dir: PathBuf::from(crate::media_paths::resolve_config_path("federation")),
             database_url: std::sync::Mutex::new(String::new()),
             storage_dir: std::sync::Mutex::new(String::new()),
+            desired_network: std::sync::Mutex::new(None),
             save_on_listen: std::sync::atomic::AtomicBool::new(false),
             content_cache: std::sync::Mutex::new(Default::default()),
             content_pending: std::sync::Mutex::new(Default::default()),
@@ -312,6 +319,8 @@ pub fn handle() -> Arc<Federation> {
             download_locks: std::sync::Mutex::new(Default::default()),
             pool: tokio::sync::OnceCell::new(),
             running: tokio::sync::Mutex::new(None),
+            supervisor_started: AtomicBool::new(false),
+            recovery_count: AtomicU64::new(0),
             last_sync: std::sync::Mutex::new(None),
             last_error: std::sync::Mutex::new(None),
             transport_stats: Arc::new(TransportStats::default()),
@@ -324,6 +333,16 @@ impl Federation {
         *lock(&self.last_error) = message;
     }
 
+    fn start_supervisor(self: &Arc<Self>) {
+        if self.supervisor_started.swap(true, Ordering::SeqCst) {
+            return;
+        }
+        let federation = Arc::clone(self);
+        tokio::spawn(async move {
+            federation.supervisor_loop().await;
+        });
+    }
+
     async fn pool(&self) -> Result<PgPool> {
         let url = lock(&self.database_url).clone();
         anyhow::ensure!(!url.is_empty(), "database is not configured");
@@ -343,6 +362,7 @@ impl Federation {
     /// settings live in the config KV table, so this waits for the database
     /// and resolves the same default → DB → env precedence the config uses.
     pub async fn boot(self: &Arc<Self>, config: &AppConfig) {
+        self.start_supervisor();
         *lock(&self.database_url) = config.database_url.clone();
         if config.database_url.is_empty() {
             return;
@@ -404,11 +424,13 @@ impl Federation {
         );
         let network = config.federation_network_id.trim().to_string();
         if config.federation_enabled && !network.is_empty() {
+            *lock(&self.desired_network) = Some(network.clone());
             if let Err(err) = self.start(network, config.agent_storage_dir.clone()).await {
                 tracing::error!("federation start failed: {err:#}");
                 self.set_error(Some(format!("start failed: {err}")));
             }
         } else {
+            *lock(&self.desired_network) = None;
             self.stop().await;
         }
     }
@@ -416,13 +438,38 @@ impl Federation {
     /// Starts the DHT node. Idempotent per network name; a node on another
     /// network is stopped and re-joined.
     async fn start(self: &Arc<Self>, network_name: String, storage_dir: String) -> Result<()> {
+        self.start_mode(network_name, storage_dir, false)
+            .await
+            .map(|_| ())
+    }
+
+    async fn start_mode(
+        self: &Arc<Self>,
+        network_name: String,
+        storage_dir: String,
+        recovery_only: bool,
+    ) -> Result<bool> {
         let pool = self.pool().await?;
         let mut guard = self.running.lock().await;
+        if recovery_only && lock(&self.desired_network).as_deref() != Some(network_name.as_str()) {
+            return Ok(false);
+        }
         if let Some(running) = guard.as_ref() {
             if running.network_name == network_name {
-                return Ok(());
+                if !recovery_only || !running.service.network_health().restart_recommended {
+                    return Ok(false);
+                }
+                tracing::warn!(
+                    network = %network_name,
+                    health = %running.service.network_health().state,
+                    "restarting degraded federation service"
+                );
+            } else if recovery_only {
+                return Ok(false);
             }
             stop_running(guard.take()).await;
+        } else if recovery_only {
+            tracing::warn!(network = %network_name, "retrying stopped federation service");
         }
 
         let dht_storage = Arc::new(PostgresFederationStorage::new(pool.clone()).await?);
@@ -565,7 +612,40 @@ impl Federation {
         drop(guard);
         // Publish right away instead of waiting for the first timer tick.
         self.spawn_sync_soon().await;
-        Ok(())
+        Ok(true)
+    }
+
+    async fn supervisor_loop(self: Arc<Self>) {
+        let mut interval = tokio::time::interval(SUPERVISOR_INTERVAL);
+        interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
+        interval.tick().await;
+        let mut last_attempt = None;
+        loop {
+            interval.tick().await;
+            if last_attempt.is_some_and(|attempt: Instant| attempt.elapsed() < RECOVERY_COOLDOWN) {
+                continue;
+            }
+            match self.recover_if_needed().await {
+                Ok(false) => {}
+                Ok(true) => {
+                    last_attempt = Some(Instant::now());
+                    self.recovery_count.fetch_add(1, Ordering::Relaxed);
+                }
+                Err(err) => {
+                    last_attempt = Some(Instant::now());
+                    tracing::error!(error = %err, "federation recovery failed");
+                    self.set_error(Some(format!("network recovery failed: {err}")));
+                }
+            }
+        }
+    }
+
+    async fn recover_if_needed(self: &Arc<Self>) -> Result<bool> {
+        let Some(network_name) = lock(&self.desired_network).clone() else {
+            return Ok(false);
+        };
+        let storage_dir = lock(&self.storage_dir).clone();
+        self.start_mode(network_name, storage_dir, true).await
     }
 
     async fn stop(&self) {
@@ -883,6 +963,7 @@ impl Federation {
         let node = match guard.as_ref() {
             Some(running) => {
                 let service = &running.service;
+                let health = service.network_health();
                 let published = service
                     .list_local_items()
                     .await
@@ -903,6 +984,13 @@ impl Federation {
                     "endpoint_id": service.endpoint_id().to_string(),
                     "connected_peers": peers,
                     "known_contacts": service.known_peers().len(),
+                    "network_health": health.state.to_string(),
+                    "rendezvous_failures": health.consecutive_rendezvous_failures,
+                    "peer_dial_failures": health.consecutive_peer_dial_failures,
+                    "rendezvous_restarts": health.rendezvous_restarts,
+                    "last_rendezvous_success_seconds": health.last_rendezvous_success_ago.map(|age| age.as_secs()),
+                    "last_rendezvous_error": health.last_rendezvous_error,
+                    "recovery_count": self.recovery_count.load(Ordering::Relaxed),
                     "similarity_routing_peers": running.similarity_dht.known_peers(),
                     "published_items": published,
                     "transport": transport,
@@ -1035,6 +1123,11 @@ impl Federation {
         .await
     }
 
+    pub async fn fed_device_web_refresh(&self, user_id: i64) -> Result<()> {
+        let pool = self.pool().await?;
+        devices::refresh_web_output(&pool, crate::player::PlayerDeviceHub::shared(), user_id).await
+    }
+
     pub async fn fed_device_web_command(
         &self,
         user_id: i64,

src/i18n/phrases.rs

@@ -406,6 +406,13 @@ translations! {
     player_youtube_select_all: "Select all"                    , "Отметить все";
     player_youtube_clear_selection: "Clear selection"           , "Снять все";
     player_youtube_selected_count: "selected"                  , "выбрано";
+    player_youtube_destination: "Add imported tracks to playlist" , "Добавить импортированные треки в плейлист";
+    player_youtube_no_destination: "Do not add to a playlist"   , "Не добавлять в плейлист";
+    player_youtube_create_playlist: "Create a new playlist"     , "Создать новый плейлист";
+    player_youtube_new_playlist_name: "New playlist name"       , "Название нового плейлиста";
+    player_youtube_destination_hint: "Every track created from the selected videos, including chapters and previously imported videos, will be added automatically." , "Все треки из выбранных видео, включая главы и уже импортированные видео, будут добавлены автоматически.";
+    player_youtube_playlist_create_failed: "Could not create playlist" , "Не удалось создать плейлист";
+    player_youtube_added_to: "added to"                         , "добавление в";
     player_youtube_start_import: "Start import"                , "Начать импорт";
     player_start_download:   "Start download"                  , "Начать загрузку";
     player_retry_failed:     "Retry failed"                    , "Повторить ошибки";
@@ -533,6 +540,7 @@ translations! {
     player_download_selected: "Download selected"              , "Скачать выбранное";
     player_pause_download:   "Pause download"                  , "Поставить на паузу";
     player_expand_all:       "Expand all"                      , "Развернуть всё";
+    player_expand:           "Expand"                          , "Развернуть";
     player_collapse:         "Collapse"                        , "Свернуть";
     player_selected:         "selected"                        , "выбрано";
     player_preview:          "Preview"                         , "Предпросмотр";

src/jobs/inbox_process.rs

@@ -1196,6 +1196,17 @@ pub async fn finalize_approved(
         }
     }
 
+    if let Err(error) =
+        crate::youtube::sync_target_playlists_for_imported_media(pool, media_file.id_val()).await
+    {
+        tracing::warn!(
+            track_id = track.id_val(),
+            media_file_id = media_file.id_val(),
+            %error,
+            "could not add an imported YouTube track to its target playlist; it will be retried"
+        );
+    }
+
     tracing::info!(
         track_id = track.id_val(),
         artist = artist_name,

src/main.rs

@@ -26,7 +26,7 @@ use cot::auth::PasswordVerificationResult;
 use cot::cli::CliMetadata;
 use cot::common_types::Password;
 use cot::config::{
-    DatabaseConfig, MiddlewareConfig, ProjectConfig, SameSite, SessionMiddlewareConfig,
+    DatabaseConfig, Expiry, MiddlewareConfig, ProjectConfig, SameSite, SessionMiddlewareConfig,
     SessionStoreConfig, SessionStoreTypeConfig,
 };
 use cot::db::Database;
@@ -522,6 +522,9 @@ impl Project for FuruProject {
                 MiddlewareConfig::builder()
                     .session(
                         SessionMiddlewareConfig::builder()
+                            .expiry(Expiry::OnInactivity(std::time::Duration::from_secs(
+                                365 * 24 * 60 * 60,
+                            )))
                             .secure(false)
                             .same_site(SameSite::Lax)
                             .store(

src/metrics.rs

@@ -832,6 +832,8 @@ const KNOWN_HTTP_ROUTES: &[&str] = &[
     "/admin/v2/api/jobs/{name}/run",
     "/admin/v2/api/settings",
     "/admin/v2/api/settings/probe",
+    "/admin/v2/api/settings/youtube-cookies",
+    "/admin/v2/api/settings/youtube-cookies/{id}",
     "/admin/v2/api/jobs/{name}/toggle",
     "/admin/v2/api/jobs/{name}/runs",
     "/admin/v2/api/jobs/{name}/runs/{run_id}",

src/music/mod.rs

@@ -1984,6 +1984,8 @@ pub mod db_migrations {
                 )",
             )
             .await?;
+        ctx.db.raw("ALTER TABLE furumusic__fed_device_identity ADD COLUMN IF NOT EXISTS playback_coordination_json JSONB").await?;
+        ctx.db.raw("ALTER TABLE furumusic__fed_device_identity ADD COLUMN IF NOT EXISTS playback_config_json JSONB").await?;
         ctx.db
             .raw(
                 "CREATE TABLE IF NOT EXISTS furumusic__fed_device (

src/player/mod.rs

@@ -93,13 +93,22 @@ fn download_proxy_for(
     result.map_err(|error| json_error(StatusCode::BAD_REQUEST, &error.to_string()))
 }
 
+async fn youtube_cookie_contents(
+    config: &AppConfig,
+    db: &Database,
+) -> Result<Option<String>, cot::response::Response> {
+    crate::youtube::selected_cookie_contents(db, &config.youtube_cookie_id)
+        .await
+        .map_err(|error| json_error(StatusCode::BAD_REQUEST, &error.to_string()))
+}
+
 #[derive(serde::Serialize)]
 struct LocalUploadResponse {
     ok: bool,
     upload: LocalUploadDto,
 }
 
-const PLAYER_DEVICE_TTL_MS: i64 = 30_000;
+const PLAYER_DEVICE_TTL_MS: i64 = 120_000;
 const PLAYER_DEVICE_RETURN_TAKEOVER_MS: i64 = 30 * 60 * 1_000;
 const PLAYER_DEVICE_COMMAND_TTL_MS: i64 = 20_000;
 const PLAYER_DEVICE_MAX_COMMANDS: usize = 32;
@@ -115,6 +124,7 @@ struct PlayerDevice {
     id: String,
     name: String,
     kind: String,
+    report_sequence: u64,
     last_seen_ms: i64,
 }
 
@@ -156,6 +166,8 @@ struct PlayerDeviceHubState {
     commands_by_device: HashMap<(i64, String), VecDeque<PendingPlayerDeviceCommand>>,
     playback_state_by_user: HashMap<i64, PlayerDevicePlaybackStateDto>,
     jams_by_id: HashMap<String, PlayerJamSession>,
+    playback_startup_by_user: HashMap<i64, std::time::Instant>,
+    output_report_sequence: u64,
 }
 
 #[derive(Debug, Default)]
@@ -178,6 +190,9 @@ impl PlayerDeviceHub {
         let now = current_millis();
         let mut state = self.state.lock().expect("player device hub lock");
         self.prune_locked(&mut state, now);
+        if self.user_has_joined_jam_locked(&state, user_id) {
+            return Ok(());
+        }
         let devices = state
             .devices_by_user
             .get(&user_id)
@@ -196,17 +211,105 @@ impl PlayerDeviceHub {
                     .map(|device| device.id.clone())
             })
             .ok_or("no browser playback device")?;
-        state.active_device_by_user.insert(user_id, target.clone());
+        if command == "transfer_state" {
+            state.active_device_by_user.insert(user_id, target.clone());
+        }
         self.enqueue_command_locked(&mut state, user_id, &target, command, payload, now);
         Ok(())
     }
 
-    pub(crate) fn federation_playback_is_local(&self, user_id: i64) -> bool {
-        let state = self.state.lock().expect("player device hub lock");
-        !state
+    pub(crate) fn federation_output_report(&self, user_id: i64) -> (bool, bool, u64, bool) {
+        let mut state = self.state.lock().expect("player device hub lock");
+        if self.user_has_joined_jam_locked(&state, user_id) {
+            return (false, false, 0, false);
+        }
+        let now = current_millis();
+        let active = state.active_device_by_user.get(&user_id);
+        let active_browser = active
+            .filter(|id| !is_fed_virtual_device_id(id))
+            .and_then(|id| state.devices_by_user.get(&user_id)?.get(id))
+            .filter(|device| now.saturating_sub(device.last_seen_ms) < PLAYER_DEVICE_TTL_MS);
+        let candidate = state.devices_by_user.get(&user_id).and_then(|devices| {
+            devices
+                .values()
+                .filter(|device| {
+                    !is_fed_virtual_device_id(&device.id)
+                        && now.saturating_sub(device.last_seen_ms) < PLAYER_DEVICE_TTL_MS
+                })
+                .max_by_key(|device| (device.report_sequence, &device.id))
+        });
+        let available = candidate.is_some();
+        // Only the selected browser can renew the gateway's owned output.
+        let report = active_browser.map_or(0, |device| device.report_sequence);
+        let playing = active_browser.is_some()
+            && state
+                .playback_state_by_user
+                .get(&user_id)
+                .is_some_and(|playback| playback.track.is_some() && !playback.paused);
+        let startup = state
+            .playback_startup_by_user
+            .remove(&user_id)
+            .is_some_and(|started| {
+                started.elapsed().as_millis() <= PLAYER_DEVICE_COMMAND_TTL_MS as u128
+            });
+        (available, playing, report, startup)
+    }
+
+    pub(crate) fn enforce_federation_owner(&self, user_id: i64, local: &str, owner: &str) {
+        let mut state = self.state.lock().expect("player device hub lock");
+        if self.user_has_joined_jam_locked(&state, user_id) {
+            return;
+        }
+        if owner == local {
+            let now = current_millis();
+            let active_local = state
+                .active_device_by_user
+                .get(&user_id)
+                .is_some_and(|id| !is_fed_virtual_device_id(id));
+            if !active_local {
+                let candidate = state.devices_by_user.get(&user_id).and_then(|devices| {
+                    devices
+                        .values()
+                        .filter(|device| {
+                            !is_fed_virtual_device_id(&device.id)
+                                && now.saturating_sub(device.last_seen_ms) < PLAYER_DEVICE_TTL_MS
+                        })
+                        .max_by_key(|device| (device.report_sequence, &device.id))
+                        .map(|device| device.id.clone())
+                });
+                if let Some(candidate) = candidate {
+                    state
+                        .active_device_by_user
+                        .insert(user_id, candidate.clone());
+                    if let Some(playback) =
+                        state
+                            .playback_state_by_user
+                            .get(&user_id)
+                            .and_then(|playback| {
+                                serde_json::to_value(playback_state_at(playback.clone(), now)).ok()
+                            })
+                    {
+                        self.enqueue_command_locked(
+                            &mut state,
+                            user_id,
+                            &candidate,
+                            "transfer_state",
+                            playback,
+                            now,
+                        );
+                    }
+                }
+            }
+            return;
+        }
+        state
             .active_device_by_user
-            .get(&user_id)
-            .is_some_and(|id| is_fed_virtual_device_id(id))
+            .insert(user_id, fed_virtual_device_id(owner));
+        // Poll responses also identify the winner. Purge delayed play/transfer
+        // commands so reconnecting browsers cannot resume an obsolete session.
+        state
+            .commands_by_device
+            .retain(|(user, _), _| *user != user_id);
     }
 
     pub(crate) fn playback_state_json_for_commands(
@@ -260,39 +363,27 @@ impl PlayerDeviceHub {
         state.devices_by_user.entry(user_id).or_default().insert(
             virtual_id.clone(),
             PlayerDevice {
+                report_sequence: 0,
                 id: virtual_id.clone(),
                 name: fed_device_name.to_string(),
                 kind: "fed".to_string(),
                 last_seen_ms: now,
             },
         );
-        // Match the trusted-device playback contract used by the TUI: a
-        // background/stale active snapshot must not steal playback from a
-        // browser that is actively playing. An explicit web handoff changes
-        // `active_device_by_user` to the federated virtual device before the
-        // snapshot arrives, so it still passes through here.
-        let local_playback_is_protected = state
-            .active_device_by_user
-            .get(&user_id)
-            .is_some_and(|active_id| !is_fed_virtual_device_id(active_id))
-            && state
-                .playback_state_by_user
-                .get(&user_id)
-                .is_some_and(|playback| playback.track.is_some() && !playback.paused);
-        if active && local_playback_is_protected {
+        // The shared coordinator has already resolved ownership. A local
+        // playing flag is not permission to reject its winning claim.
+        if self.user_has_joined_jam_locked(&state, user_id) {
             return Ok(());
         }
-        let should_update_playback = active
-            || state
-                .active_device_by_user
-                .get(&user_id)
-                .is_some_and(|active_id| active_id == &virtual_id);
         if active {
+            state
+                .commands_by_device
+                .retain(|(user, _), _| *user != user_id);
             state
                 .active_device_by_user
                 .insert(user_id, virtual_id.clone());
         }
-        if should_update_playback {
+        if active {
             state.playback_state_by_user.insert(user_id, playback_state);
         }
         Ok(())
@@ -321,9 +412,32 @@ impl PlayerDeviceHub {
             .playback_state_by_user
             .get(&user_id)
             .is_some_and(|playback| playback.track.is_some() && !playback.paused);
-        let should_claim_idle_playback = is_new_or_returning
-            && previous_active_id.as_deref() != Some(device_id)
-            && !active_is_playing;
+        let mut policy = music_dht::playback::Config::default();
+        // Local browser failover is permitted. The always-on gateway is not
+        // an automatic candidate against another federated output.
+        if previous_active_id
+            .as_deref()
+            .is_some_and(is_fed_virtual_device_id)
+        {
+            policy.automatic_failover = false;
+        }
+        let owner = previous_active_id.as_ref().map(|id| {
+            let age = state
+                .devices_by_user
+                .get(&user_id)
+                .and_then(|devices| devices.get(id))
+                .map_or(u64::MAX, |device| {
+                    now.saturating_sub(device.last_seen_ms).max(0) as u64
+                });
+            (active_is_playing, age)
+        });
+        let should_claim_idle_playback = previous_active_id.as_deref() != Some(device_id)
+            && policy.should_claim(is_new_or_returning, owner);
+        if is_new_or_returning {
+            state
+                .playback_startup_by_user
+                .insert(user_id, std::time::Instant::now());
+        }
         if should_claim_idle_playback {
             let transfer_state = state
                 .playback_state_by_user
@@ -370,9 +484,57 @@ impl PlayerDeviceHub {
         let now = current_millis();
         let mut state = self.state.lock().expect("player device hub lock");
         self.prune_locked(&mut state, now);
+        let previous = state.active_device_by_user.get(&user_id).cloned();
+        if let Some(previous) =
+            previous.filter(|id| id != device_id && !is_fed_virtual_device_id(id))
+        {
+            let age = state
+                .devices_by_user
+                .get(&user_id)
+                .and_then(|devices| devices.get(&previous))
+                .map_or(u64::MAX, |device| {
+                    now.saturating_sub(device.last_seen_ms).max(0) as u64
+                });
+            let playing = state
+                .playback_state_by_user
+                .get(&user_id)
+                .is_some_and(|playback| playback.track.is_some() && !playback.paused);
+            if music_dht::playback::Config::default().should_claim(false, Some((playing, age))) {
+                state
+                    .active_device_by_user
+                    .insert(user_id, device_id.to_string());
+                if let Some(payload) =
+                    state
+                        .playback_state_by_user
+                        .get(&user_id)
+                        .and_then(|playback| {
+                            serde_json::to_value(playback_state_at(playback.clone(), now)).ok()
+                        })
+                {
+                    self.enqueue_command_locked(
+                        &mut state,
+                        user_id,
+                        device_id,
+                        "transfer_state",
+                        payload,
+                        now,
+                    );
+                }
+            }
+        }
         self.touch_locked(&mut state, user_id, device_id, user_agent, now);
         self.update_playback_state_locked(&mut state, user_id, device_id, playback_state, now);
         self.touch_jam_locked(&mut state, user_id, device_id, current_jam_id, now);
+        if current_jam_id.is_none()
+            && state
+                .active_device_by_user
+                .get(&user_id)
+                .is_some_and(|active| active != device_id)
+        {
+            state
+                .commands_by_device
+                .remove(&(user_id, device_id.to_string()));
+        }
         let commands = state
             .commands_by_device
             .remove(&(user_id, device_id.to_string()))
@@ -525,8 +687,11 @@ impl PlayerDeviceHub {
         user_agent: Option<&str>,
         now: i64,
     ) {
+        state.output_report_sequence = state.output_report_sequence.saturating_add(1);
+        let report_sequence = state.output_report_sequence;
         let devices = state.devices_by_user.entry(user_id).or_default();
         let device = PlayerDevice {
+            report_sequence,
             id: device_id.to_string(),
             name: device_name_from_user_agent(user_agent),
             kind: device_kind_from_user_agent(user_agent).to_string(),
@@ -537,15 +702,7 @@ impl PlayerDeviceHub {
             .device_last_seen_ms
             .insert((user_id, device_id.to_string()), now);
 
-        let active_online = state
-            .active_device_by_user
-            .get(&user_id)
-            .is_some_and(|active_id| devices.contains_key(active_id));
-        if !active_online {
-            state
-                .active_device_by_user
-                .insert(user_id, device_id.to_string());
-        }
+        // Discovery only registers devices; startup/select decides ownership.
     }
 
     fn update_playback_state_locked(
@@ -967,25 +1124,11 @@ impl PlayerDeviceHub {
             devices.retain(|_, device| {
                 now.saturating_sub(device.last_seen_ms) <= PLAYER_DEVICE_TTL_MS
             });
-            let active_valid = state
-                .active_device_by_user
-                .get(user_id)
-                .is_some_and(|active_id| devices.contains_key(active_id));
-            if !active_valid {
-                if let Some(first_device_id) = devices.keys().next().cloned() {
-                    state
-                        .active_device_by_user
-                        .insert(*user_id, first_device_id);
-                } else {
-                    state.active_device_by_user.remove(user_id);
-                    state.playback_state_by_user.remove(user_id);
-                }
-            }
+            // Keep ownership and queue when presence expires. The shared
+            // protocol decides failover; HashMap order must never choose audio.
+            let _ = user_id;
             !devices.is_empty()
         });
-        state
-            .playback_state_by_user
-            .retain(|user_id, _| state.devices_by_user.contains_key(user_id));
 
         state
             .commands_by_device
@@ -1161,6 +1304,83 @@ fn device_kind_from_user_agent(user_agent: Option<&str>) -> &'static str {
 mod device_tests {
     use super::*;
 
+    #[test]
+    fn gateway_timer_does_not_manufacture_browser_reports() {
+        let hub = PlayerDeviceHub::default();
+        assert_eq!(hub.federation_output_report(1), (false, false, 0, false));
+        hub.heartbeat(1, "browser", None, None, None);
+        let first = hub.federation_output_report(1);
+        let repeated = hub.federation_output_report(1);
+        assert!(first.0);
+        assert!(first.3);
+        assert_eq!(first.2, repeated.2);
+        assert!(!repeated.3);
+    }
+
+    #[test]
+    fn an_old_browser_startup_does_not_claim_a_late_peer() {
+        let hub = PlayerDeviceHub::default();
+        hub.heartbeat(1, "browser", None, None, None);
+        hub.state.lock().unwrap().playback_startup_by_user.insert(
+            1,
+            std::time::Instant::now()
+                - std::time::Duration::from_millis(PLAYER_DEVICE_COMMAND_TTL_MS as u64 + 1),
+        );
+        assert!(!hub.federation_output_report(1).3);
+    }
+
+    #[test]
+    fn expired_presence_does_not_replace_federated_owner() {
+        let hub = PlayerDeviceHub::default();
+        hub.state
+            .lock()
+            .unwrap()
+            .active_device_by_user
+            .insert(1, "fed:remote".into());
+        let response = hub.poll(1, "browser", None, None, None);
+        assert_eq!(response.active_device_id.as_deref(), Some("fed:remote"));
+        assert!(response.commands.is_empty());
+    }
+
+    #[test]
+    fn browser_poll_fails_over_only_after_local_owner_timeout() {
+        let hub = PlayerDeviceHub::default();
+        hub.heartbeat(1, "first", None, None, None);
+        assert_eq!(
+            hub.poll(1, "second", None, None, None)
+                .active_device_id
+                .as_deref(),
+            Some("first")
+        );
+        hub.state
+            .lock()
+            .unwrap()
+            .devices_by_user
+            .get_mut(&1)
+            .unwrap()
+            .get_mut("first")
+            .unwrap()
+            .last_seen_ms = current_millis() - PLAYER_DEVICE_TTL_MS - 1;
+        assert_eq!(
+            hub.poll(1, "second", None, None, None)
+                .active_device_id
+                .as_deref(),
+            Some("second")
+        );
+    }
+
+    #[test]
+    fn pruning_keeps_the_owner_when_every_device_is_offline() {
+        let hub = PlayerDeviceHub::default();
+        hub.heartbeat(1, "browser", None, None, None);
+        let mut state = hub.state.lock().unwrap();
+        hub.prune_locked(&mut state, current_millis() + PLAYER_DEVICE_TTL_MS + 1);
+        assert_eq!(
+            state.active_device_by_user.get(&1).map(String::as_str),
+            Some("browser")
+        );
+    }
+
     #[test]
     fn detects_furumi_android_native_client() {
         let user_agent = Some("FurumiAndroid/1.0 Android Mobile");
@@ -1208,7 +1428,7 @@ mod device_tests {
     }
 
     #[test]
-    fn federated_snapshot_does_not_steal_active_browser_playback() {
+    fn resolved_federation_owner_overrides_a_playing_browser() {
         let hub = PlayerDeviceHub::default();
         let user_id = 7;
         {
@@ -1216,6 +1436,7 @@ mod device_tests {
             state.devices_by_user.entry(user_id).or_default().insert(
                 "browser".to_string(),
                 PlayerDevice {
+                    report_sequence: 0,
                     id: "browser".to_string(),
                     name: "Browser".to_string(),
                     kind: "computer".to_string(),
@@ -1267,7 +1488,7 @@ mod device_tests {
                 .active_device_by_user
                 .get(&user_id)
                 .map(String::as_str),
-            Some("browser")
+            Some("fed:remote")
         );
         assert!(
             state
@@ -1363,6 +1584,7 @@ mod device_tests {
             state.devices_by_user.entry(user_id).or_default().insert(
                 "browser".to_string(),
                 PlayerDevice {
+                    report_sequence: 0,
                     id: "browser".to_string(),
                     name: "Browser".to_string(),
                     kind: "computer".to_string(),
@@ -5338,6 +5560,12 @@ async fn devices_heartbeat_handler(
             return Ok(json_error(StatusCode::BAD_REQUEST, &format!("{err}")));
         }
     }
+    if let Err(error) = crate::federation::handle()
+        .fed_device_web_refresh(user.id)
+        .await
+    {
+        tracing::warn!(user_id = user.id, %error, "playback coordination startup failed");
+    }
     Json(response).into_response()
 }
 
@@ -5355,6 +5583,12 @@ async fn devices_poll_handler(
         return Ok(json_error(StatusCode::BAD_REQUEST, "invalid device id"));
     };
 
+    if let Err(error) = crate::federation::handle()
+        .fed_device_web_refresh(user.id)
+        .await
+    {
+        tracing::warn!(user_id = user.id, %error, "playback coordination refresh failed");
+    }
     let response = hub.poll(
         user.id,
         &device_id,
@@ -8542,12 +8776,23 @@ impl App for PlayerApp {
                                     Ok(proxy_url) => proxy_url,
                                     Err(response) => return Ok(response),
                                 };
+                                let cookie_contents = match youtube_cookie_contents(&live_config, &db).await {
+                                    Ok(cookie_contents) => cookie_contents,
+                                    Err(response) => return Ok(response),
+                                };
                                 let service = youtube_service
                                     .get_or_init(|| async {
                                         Arc::new(YouTubeService::new(Arc::clone(&scheduler_handle)))
                                     })
                                     .await;
-                                match service.preview(json.0, proxy_url.as_deref()).await {
+                                match service
+                                    .preview(
+                                        json.0,
+                                        proxy_url.as_deref(),
+                                        cookie_contents.as_deref(),
+                                    )
+                                    .await
+                                {
                                     Ok(preview) => Json(preview).into_response(),
                                     Err(err) => {
                                         Ok(json_error(StatusCode::BAD_REQUEST, &err.to_string()))
@@ -8603,12 +8848,17 @@ impl App for PlayerApp {
                                     Ok(proxy_url) => proxy_url,
                                     Err(response) => return Ok(response),
                                 };
+                                let cookie_contents = match youtube_cookie_contents(&live_config, &db).await {
+                                    Ok(cookie_contents) => cookie_contents,
+                                    Err(response) => return Ok(response),
+                                };
                                 match service
                                     .list(
                                         pg_pool,
                                         user.id,
                                         &live_config.agent_inbox_dir,
                                         proxy_url,
+                                        cookie_contents,
                                     )
                                     .await
                                 {
@@ -8670,6 +8920,10 @@ impl App for PlayerApp {
                                     Ok(proxy_url) => proxy_url,
                                     Err(response) => return Ok(response),
                                 };
+                                let cookie_contents = match youtube_cookie_contents(&live_config, &db).await {
+                                    Ok(cookie_contents) => cookie_contents,
+                                    Err(response) => return Ok(response),
+                                };
                                 match service
                                     .start(
                                         pg_pool,
@@ -8677,6 +8931,7 @@ impl App for PlayerApp {
                                         json.0,
                                         &live_config.agent_inbox_dir,
                                         proxy_url,
+                                        cookie_contents,
                                     )
                                     .await
                                 {
@@ -8738,6 +8993,10 @@ impl App for PlayerApp {
                                     Ok(proxy_url) => proxy_url,
                                     Err(response) => return Ok(response),
                                 };
+                                let cookie_contents = match youtube_cookie_contents(&live_config, &db).await {
+                                    Ok(cookie_contents) => cookie_contents,
+                                    Err(response) => return Ok(response),
+                                };
                                 match service
                                     .retry(
                                         pg_pool,
@@ -8745,6 +9004,7 @@ impl App for PlayerApp {
                                         &path.0.id,
                                         &live_config.agent_inbox_dir,
                                         proxy_url,
+                                        cookie_contents,
                                     )
                                     .await
                                 {

templates/admin/v2.html

@@ -959,6 +959,89 @@ tbody tr:hover {
     outline: none;
 }
 
+.youtube-cookie-settings {
+    display: grid;
+    gap: 9px;
+    margin-top: 11px;
+    padding-top: 11px;
+    border-top: 1px solid var(--border-color);
+}
+
+.youtube-cookie-picker,
+.youtube-cookie-upload,
+.youtube-cookie-row {
+    display: flex;
+    align-items: center;
+    gap: 9px;
+}
+
+.youtube-cookie-picker > span {
+    flex: 0 0 auto;
+    color: var(--text-subdued);
+    font-size: 11px;
+    font-weight: 750;
+}
+
+.youtube-cookie-picker select {
+    min-width: 0;
+    flex: 1;
+    height: 34px;
+    padding: 0 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    outline: none;
+}
+
+.youtube-cookie-upload {
+    justify-content: space-between;
+}
+
+.youtube-cookie-upload span,
+.youtube-cookie-empty {
+    color: var(--text-subdued);
+    font-size: 11px;
+}
+
+.youtube-cookie-list {
+    display: grid;
+    gap: 6px;
+}
+
+.youtube-cookie-row {
+    justify-content: space-between;
+    min-width: 0;
+    padding: 8px 9px;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background: var(--bg-primary);
+}
+
+.youtube-cookie-row.active {
+    border-color: rgba(29, 185, 84, 0.55);
+    background: rgba(29, 185, 84, 0.08);
+}
+
+.youtube-cookie-info {
+    display: grid;
+    min-width: 0;
+    gap: 3px;
+}
+
+.youtube-cookie-info strong {
+    overflow: hidden;
+    color: var(--text-primary);
+    font-size: 11px;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.youtube-cookie-info span {
+    color: var(--text-subdued);
+    font-size: 10px;
+}
+
 .proxy-editor {
     grid-column: 1 / -1;
     min-width: 0;
@@ -1148,6 +1231,8 @@ tbody tr:hover {
     .setting-field { max-width: none; }
     .download-method-controls,
     .proxy-row { grid-template-columns: 1fr; }
+    .youtube-cookie-picker,
+    .youtube-cookie-upload { align-items: stretch; flex-direction: column; }
 }
 
 .settings-note {
@@ -2725,7 +2810,43 @@ tbody tr:hover {
                                             </template>
                                         </select>
                                     </div>
-                                    <div class="setting-help">The selected proxy is passed to metadata lookup and downloads through yt-dlp's <code>--proxy</code> option.</div>
+                                    <div class="youtube-cookie-settings">
+                                        <div class="youtube-cookie-picker">
+                                            <span>
+                                                yt-dlp cookies
+                                                <span class="source-pill" :class="sourceClass('youtube_cookie_id')" x-text="settingSource('youtube_cookie_id')"></span>
+                                            </span>
+                                            <select x-model="settingsDraft.youtube_cookie_id" :disabled="!settingsDraft.downloads_enabled || !settingsDraft.youtube_downloads_enabled">
+                                                <option value="">No cookies</option>
+                                                <template x-for="file in settings.youtube_cookie_files || []" :key="file.id">
+                                                    <option :value="file.id" x-text="youtubeCookieLabel(file)"></option>
+                                                </template>
+                                            </select>
+                                        </div>
+                                        <input type="file" accept=".txt,text/plain" x-ref="youtubeCookieInput" style="display:none" @change="uploadYoutubeCookieFile($event)" />
+                                        <div class="youtube-cookie-upload">
+                                            <span>Netscape <code>cookies.txt</code>; maximum size 2 MiB.</span>
+                                            <button class="btn" type="button" @click="$refs.youtubeCookieInput.click()" :disabled="youtubeCookieUploading">
+                                                <i data-lucide="upload"></i>
+                                                <span x-text="youtubeCookieUploading ? 'Uploading…' : 'Upload cookie file'"></span>
+                                            </button>
+                                        </div>
+                                        <div class="youtube-cookie-empty" x-show="!(settings.youtube_cookie_files || []).length">No cookie files saved. yt-dlp will run without cookies.</div>
+                                        <div class="youtube-cookie-list" x-show="(settings.youtube_cookie_files || []).length">
+                                            <template x-for="file in settings.youtube_cookie_files || []" :key="file.id">
+                                                <div class="youtube-cookie-row" :class="{ active: settingsDraft.youtube_cookie_id === file.id }">
+                                                    <div class="youtube-cookie-info">
+                                                        <strong :title="file.filename" x-text="file.filename"></strong>
+                                                        <span x-text="`${fmt(file.cookie_count)} cookies · uploaded ${shortDate(file.uploaded_at)}`"></span>
+                                                    </div>
+                                                    <button class="icon-btn danger" type="button" @click="deleteYoutubeCookieFile(file)" :disabled="youtubeCookieUploading" title="Delete cookie file">
+                                                        <i data-lucide="trash-2"></i>
+                                                    </button>
+                                                </div>
+                                            </template>
+                                        </div>
+                                    </div>
+                                    <div class="setting-help">The selected proxy and cookie file are passed to both metadata lookup and downloads through yt-dlp.</div>
                                 </div>
 
                                 <div class="proxy-editor">
@@ -3718,7 +3839,7 @@ function adminV2() {
         mergeDetails: [],
         mergeArtistSearch: '',
         mergeDraft: { release_ids: [], target_release_id: null, title: '', release_type: 'album', year: '', hidden: 'false', cover_file_id: null, artist_ids: [], tracks: [] },
-        settings: { values: {}, sources: {}, lastfm_api_key_configured: false, lastfm_shared_secret_configured: false, lastfm_scrobbling_configured: false },
+        settings: { values: {}, sources: {}, youtube_cookie_files: [], lastfm_api_key_configured: false, lastfm_shared_secret_configured: false, lastfm_scrobbling_configured: false },
         settingsDraft: {
             auth_password_enabled: false,
             auth_sso_enabled: false,
@@ -3752,7 +3873,8 @@ function adminV2() {
             youtube_downloads_enabled: true,
             download_proxies: [],
             torrent_proxy_id: '',
-            youtube_proxy_id: ''
+            youtube_proxy_id: '',
+            youtube_cookie_id: ''
         },
         settingsProbe: { status: 'idle', ok: false },
         settingsProbeLoading: false,
@@ -3763,6 +3885,7 @@ function adminV2() {
         similarityStatus: { status: { phase: 'disabled' }, models: [], profiles: [] },
         similarityLoading: false,
         settingsSaving: false,
+        youtubeCookieUploading: false,
         routeReady: false,
         poller: null,
 
@@ -4070,6 +4193,64 @@ function adminV2() {
             return address || 'New proxy';
         },
 
+        youtubeCookieLabel(file) {
+            const filename = String(file?.filename || '').trim() || 'Cookie file';
+            return `${filename} (${this.fmt(file?.cookie_count)} cookies)`;
+        },
+
+        async uploadYoutubeCookieFile(event) {
+            const input = event?.target;
+            const file = input?.files && input.files.length ? input.files[0] : null;
+            if (!file || this.youtubeCookieUploading) return;
+            if (file.size > 2 * 1024 * 1024) {
+                this.showToast('Cookie file is larger than 2 MiB');
+                input.value = '';
+                return;
+            }
+            this.youtubeCookieUploading = true;
+            try {
+                const dataUrl = await this.readFileAsDataUrl(file);
+                const data = String(dataUrl).split(',')[1] || '';
+                const uploaded = await this.request(`${this.apiBase}/settings/youtube-cookies`, {
+                    method: 'POST',
+                    body: JSON.stringify({ filename: file.name, data })
+                });
+                this.settings.youtube_cookie_files = [
+                    uploaded,
+                    ...(this.settings.youtube_cookie_files || []).filter(item => item.id !== uploaded.id)
+                ];
+                this.settingsDraft.youtube_cookie_id = uploaded.id;
+                this.showToast('Cookie file uploaded; save settings to activate it');
+            } catch (error) {
+                this.showToast(error.message);
+            } finally {
+                this.youtubeCookieUploading = false;
+                if (input) input.value = '';
+                this.icons();
+            }
+        },
+
+        async deleteYoutubeCookieFile(file) {
+            if (!file || this.youtubeCookieUploading) return;
+            if (!window.confirm(`Delete cookie file "${file.filename}"? This cannot be undone.`)) return;
+            this.youtubeCookieUploading = true;
+            try {
+                await this.request(`${this.apiBase}/settings/youtube-cookies/${encodeURIComponent(file.id)}`, {
+                    method: 'DELETE'
+                });
+                this.settings.youtube_cookie_files = (this.settings.youtube_cookie_files || [])
+                    .filter(item => item.id !== file.id);
+                if (this.settingsDraft.youtube_cookie_id === file.id) this.settingsDraft.youtube_cookie_id = '';
+                if (this.settings.values?.youtube_cookie_id === file.id) this.settings.values.youtube_cookie_id = '';
+                this.showToast('Cookie file deleted');
+            } catch (error) {
+                this.showToast(error.message);
+            } finally {
+                this.youtubeCookieUploading = false;
+                this.icons();
+            }
+        },
+
         async saveSettings() {
             if (this.settingsSaving) return;
             const networkSimilarityWasEnabled = Boolean(

templates/player/modals.html

@@ -88,7 +88,8 @@
     <!-- Download Manager Modal -->
     <template x-if="$store.torrents.modal">
         <div class="modal-overlay" @click.self="$store.torrents.close()">
-            <div class="modal-box torrent-modal">
+            <div class="modal-box torrent-modal"
+                 :class="{ 'youtube-mode': $store.torrents.sourceTab === 'youtube' }">
                 <div class="torrent-modal-head">
                     <div>
                         <h3>{{ t.player_torrent_manager }}</h3>
@@ -205,6 +206,29 @@
                                     </label>
                                 </template>
                             </div>
+                            <div class="youtube-preview-destination">
+                                <label for="youtube-target-playlist">{{ t.player_youtube_destination }}</label>
+                                <div class="youtube-preview-destination-fields"
+                                     :class="{ creating: $store.torrents.youtubePlaylistChoice === '__new__' }">
+                                    <select id="youtube-target-playlist"
+                                            x-model="$store.torrents.youtubePlaylistChoice"
+                                            @change="$store.torrents.youtubePlaylistChoiceChanged()">
+                                        <option value="">{{ t.player_youtube_no_destination }}</option>
+                                        <template x-for="playlist in $store.torrents.youtubeOwnedPlaylists()" :key="playlist.id">
+                                            <option :value="String(playlist.id)" x-text="playlist.title"></option>
+                                        </template>
+                                        <option value="__new__">{{ t.player_youtube_create_playlist }}</option>
+                                    </select>
+                                    <template x-if="$store.torrents.youtubePlaylistChoice === '__new__'">
+                                        <input type="text"
+                                               maxlength="255"
+                                               autocomplete="off"
+                                               x-model="$store.torrents.youtubeNewPlaylistTitle"
+                                               placeholder="{{ t.player_youtube_new_playlist_name }}">
+                                    </template>
+                                </div>
+                                <p>{{ t.player_youtube_destination_hint }}</p>
+                            </div>
                             <div class="youtube-preview-footer">
                                 <span x-text="$store.torrents.youtubePreviewSelectedCount() + ' ' + T.youtubeSelectedCount"></span>
                                 <div>
@@ -212,7 +236,7 @@
                                             @click="$store.torrents.clearYoutubePreview()">{{ t.player_cancel }}</button>
                                     <button type="button" class="modal-btn modal-btn-primary"
                                             @click="$store.torrents.startYoutubeDownload()"
-                                            :disabled="$store.torrents.youtubeSubmitting || $store.torrents.youtubePreviewSelectedCount() === 0">
+                                            :disabled="$store.torrents.youtubeSubmitting || $store.torrents.youtubePreviewSelectedCount() === 0 || !$store.torrents.youtubeDestinationValid()">
                                         {{ t.player_youtube_start_import }}
                                     </button>
                                 </div>
@@ -235,16 +259,29 @@
                         </template>
 
                         <template x-for="job in $store.torrents.youtubeJobs" :key="job.id">
-                            <article class="youtube-job-card">
-                                <div class="youtube-job-head">
+                            <article class="youtube-job-card"
+                                     :class="{ collapsed: !$store.torrents.youtubeJobExpanded(job.id) }">
+                                <button type="button"
+                                        class="youtube-job-summary"
+                                        :aria-expanded="$store.torrents.youtubeJobExpanded(job.id)"
+                                        :title="$store.torrents.youtubeJobExpanded(job.id) ? T.collapse : T.expand"
+                                        @click="$store.torrents.toggleYoutubeJob(job.id)">
+                                    <span class="youtube-job-chevron" aria-hidden="true"></span>
                                     <div class="youtube-job-heading">
                                         <div class="youtube-job-title" x-text="job.title"></div>
                                         <div class="youtube-job-meta" x-text="$store.torrents.youtubeJobMeta(job)"></div>
                                     </div>
+                                    <span class="youtube-job-compact-progress"
+                                          x-text="$store.torrents.youtubeJobProgress(job) + '%'">
+                                    </span>
                                     <span class="torrent-status-badge"
                                           :class="$store.torrents.youtubeStatusClass(job.status)"
                                           x-text="$store.torrents.youtubeStatusLabel(job.status)"></span>
-                                </div>
+                                </button>
+
+                                <div class="youtube-job-details"
+                                     x-show="$store.torrents.youtubeJobExpanded(job.id)"
+                                     x-cloak>
 
                                 <div class="youtube-job-progress">
                                     <div class="torrent-session-progress">
@@ -316,6 +353,7 @@
                                             x-show="$store.torrents.youtubeJobTerminal(job.status)"
                                             @click="$store.torrents.removeYoutubeJob(job.id)">{{ t.player_remove_from_history }}</button>
                                 </div>
+                                </div>
                             </article>
                         </template>
                     </div>

templates/player/scripts.html

@@ -1,5 +1,23 @@
 <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3/dist/cdn.min.js"></script>
 <script>
+// Handle expired sessions centrally, including background player requests.
+let loginRedirectStarted = false;
+function redirectOnUnauthorized(status) {
+    if (status !== 401 || loginRedirectStarted) return;
+    loginRedirectStarted = true;
+    window.location.replace('/login');
+}
+
+const playerFetch = window.fetch.bind(window);
+window.fetch = async (input, init) => {
+    const response = await playerFetch(input, init);
+    const url = new URL(input instanceof Request ? input.url : input, window.location.href);
+    if (url.origin === window.location.origin && url.pathname.startsWith('/api/')) {
+        redirectOnUnauthorized(response.status);
+    }
+    return response;
+};
+
 const T = {
     info: "{{ t.player_info }}",
     noDetails: "{{ t.player_no_details }}",
@@ -162,6 +180,8 @@ const T = {
     youtubeSelectAll: "{{ t.player_youtube_select_all }}",
     youtubeClearSelection: "{{ t.player_youtube_clear_selection }}",
     youtubeSelectedCount: "{{ t.player_youtube_selected_count }}",
+    youtubePlaylistCreateFailed: "{{ t.player_youtube_playlist_create_failed }}",
+    youtubeAddedTo: "{{ t.player_youtube_added_to }}",
     youtubeCancelled: "{{ t.player_youtube_cancelled }}",
     youtubeStopConfirm: "{{ t.player_youtube_stop_confirm }}",
     youtubeStopping: "{{ t.player_youtube_stopping }}",
@@ -181,6 +201,8 @@ const T = {
     liveReleases: "{{ t.player_live_releases }}",
     soundtracks: "{{ t.player_soundtracks }}",
     likesPlaylist: "{{ t.player_likes_playlist }}",
+    expand: "{{ t.player_expand }}",
+    collapse: "{{ t.player_collapse }}",
 };
 
 function formatTime(seconds) {
@@ -1684,7 +1706,7 @@ document.addEventListener('alpine:init', () => {
                 }
 
                 const player = Alpine.store('player');
-                if (player && Array.isArray(data.commands)) {
+                if (player && (this.isActive() || this.shouldPlayJamLocally()) && Array.isArray(data.commands)) {
                     data.commands.forEach(command => player._executeRemoteCommand(command));
                 }
                 if (player && !this.isActive()) {
@@ -1702,7 +1724,6 @@ document.addEventListener('alpine:init', () => {
         },
 
         _apply(data) {
-            const wasActive = this.isActive();
             const previousJamId = this.currentJamId;
             this.activeDeviceId = data.active_device_id || null;
             this.devices = Array.isArray(data.devices) ? data.devices : [];
@@ -1718,7 +1739,7 @@ document.addEventListener('alpine:init', () => {
             if (previousJamId !== this.currentJamId || !this.canPlayJamLocally()) {
                 this._setJamLocalPlayback(false, { pauseLocal: true });
             }
-            if (wasActive && !this.isActive()) {
+            if (!this.isActive() && !this.shouldPlayJamLocally()) {
                 Alpine.store('player')?._pauseLocal();
             }
             this._maybeShowRemoteHint();
@@ -4611,8 +4632,13 @@ document.addEventListener('alpine:init', () => {
         youtubeUrl: '',
         youtubePreview: null,
         youtubePreviewSelected: new Set(),
+        youtubePlaylistChoice: '',
+        youtubeNewPlaylistTitle: '',
+        youtubePlaylistSyncKey: '',
         youtubePreviewLoading: false,
         youtubeJobs: [],
+        youtubeExpandedJobId: null,
+        youtubeJobsInitialized: false,
         youtubeLoading: false,
         youtubeSubmitting: false,
         youtubeCancellingIds: new Set(),
@@ -4728,6 +4754,31 @@ document.addEventListener('alpine:init', () => {
                 const data = await res.json().catch(() => null);
                 if (!res.ok) throw new Error(data?.error || T.youtubeLoadFailed);
                 this.youtubeJobs = Array.isArray(data) ? data : [];
+                if (
+                    this.youtubeExpandedJobId !== null
+                    && !this.youtubeJobs.some(job => job.id === this.youtubeExpandedJobId)
+                ) {
+                    this.youtubeExpandedJobId = null;
+                }
+                if (!this.youtubeJobsInitialized) {
+                    const activeJob = this.youtubeJobs.find(job => !this.youtubeJobTerminal(job.status));
+                    this.youtubeExpandedJobId = this.youtubePreview ? null : (activeJob?.id || null);
+                    this.youtubeJobsInitialized = true;
+                }
+                const playlistSyncKey = this.youtubeJobs
+                    .filter(job => Number(job.target_playlist_id || 0) > 0)
+                    .map(job => [
+                        job.id,
+                        job.status,
+                        Number(job.completed_items || 0),
+                        Number(job.failed_items || 0),
+                        Number(job.review_items || 0),
+                    ].join(':'))
+                    .join('|');
+                if (playlistSyncKey && playlistSyncKey !== this.youtubePlaylistSyncKey) {
+                    this.youtubePlaylistSyncKey = playlistSyncKey;
+                    Alpine.store('playlists')?.reload?.();
+                }
             } catch (err) {
                 if (!silent) this._setMessage(err.message || T.youtubeLoadFailed, true);
             } finally {
@@ -4738,6 +4789,8 @@ document.addEventListener('alpine:init', () => {
         clearYoutubePreview() {
             this.youtubePreview = null;
             this.youtubePreviewSelected = new Set();
+            this.youtubePlaylistChoice = '';
+            this.youtubeNewPlaylistTitle = '';
         },
 
         async previewYoutubeUrl() {
@@ -4761,6 +4814,7 @@ document.addEventListener('alpine:init', () => {
                 this.youtubePreviewSelected = new Set(
                     items.filter(item => item.selected_by_default).map(item => item.source_id)
                 );
+                this.youtubeExpandedJobId = null;
                 this._setMessage('');
             } catch (err) {
                 this._setMessage(err.message || T.youtubePreviewFailed, true);
@@ -4793,24 +4847,90 @@ document.addEventListener('alpine:init', () => {
             return this.youtubePreviewSelected.size;
         },
 
+        youtubeOwnedPlaylists() {
+            return (Alpine.store('playlists')?.list || []).filter(playlist => (
+                playlist.kind === 'user' && playlist.is_own && Number(playlist.id) > 0
+            ));
+        },
+
+        youtubePlaylistChoiceChanged() {
+            if (
+                this.youtubePlaylistChoice === '__new__'
+                && !String(this.youtubeNewPlaylistTitle || '').trim()
+            ) {
+                this.youtubeNewPlaylistTitle = String(this.youtubePreview?.title || '').slice(0, 255);
+            }
+        },
+
+        youtubeDestinationValid() {
+            return this.youtubePlaylistChoice !== '__new__'
+                || String(this.youtubeNewPlaylistTitle || '').trim().length > 0;
+        },
+
+        youtubePlaylistTitle(playlistId) {
+            const wanted = Number(playlistId || 0);
+            return this.youtubeOwnedPlaylists().find(playlist => Number(playlist.id) === wanted)?.title || '';
+        },
+
+        async resolveYoutubeTargetPlaylist() {
+            if (this.youtubePlaylistChoice !== '__new__') {
+                const playlistId = Number(this.youtubePlaylistChoice || 0);
+                return playlistId > 0 ? playlistId : null;
+            }
+
+            const title = String(this.youtubeNewPlaylistTitle || '').trim();
+            if (!title) throw new Error(T.youtubePlaylistCreateFailed);
+            const res = await fetch('/api/player/playlists', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ title }),
+            });
+            const playlist = await res.json().catch(() => null);
+            if (!res.ok || Number(playlist?.id || 0) <= 0) {
+                throw new Error(playlist?.error || T.youtubePlaylistCreateFailed);
+            }
+
+            // Switch to the created playlist before starting the job. If the
+            // YouTube request fails, retrying will reuse it instead of creating
+            // another playlist with the same name.
+            this.youtubePlaylistChoice = String(playlist.id);
+            const playlists = Alpine.store('playlists');
+            if (playlists) {
+                playlists.list = [
+                    ...(playlists.list || []).filter(item => Number(item.id) !== Number(playlist.id)),
+                    playlist,
+                ];
+                await playlists.reload();
+            }
+            return Number(playlist.id);
+        },
+
         async startYoutubeDownload() {
             const preview = this.youtubePreview;
             const selectedSourceIds = Array.from(this.youtubePreviewSelected);
-            if (!preview || !selectedSourceIds.length || this.youtubeSubmitting) return;
+            if (
+                !preview
+                || !selectedSourceIds.length
+                || !this.youtubeDestinationValid()
+                || this.youtubeSubmitting
+            ) return;
             this.youtubeSubmitting = true;
             this._setMessage(T.youtubeStarting);
             try {
+                const targetPlaylistId = await this.resolveYoutubeTargetPlaylist();
                 const res = await fetch('/api/player/youtube/start', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({
                         url: preview.source_url,
                         selected_source_ids: selectedSourceIds,
+                        target_playlist_id: targetPlaylistId,
                     }),
                 });
                 const data = await res.json().catch(() => null);
                 if (!res.ok) throw new Error(data?.error || T.youtubeStartFailed);
                 this.youtubeJobs = [data, ...this.youtubeJobs.filter(job => job.id !== data.id)];
+                this.youtubeExpandedJobId = data.id;
                 this.youtubeUrl = '';
                 this.clearYoutubePreview();
                 this._setMessage(T.youtubeStarted);
@@ -4942,11 +5062,21 @@ document.addEventListener('alpine:init', () => {
             return ['queued', 'resolving', 'downloading', 'postprocessing'].includes(String(status || '').toLowerCase());
         },
 
+        youtubeJobExpanded(jobId) {
+            return this.youtubeExpandedJobId === jobId;
+        },
+
+        toggleYoutubeJob(jobId) {
+            this.youtubeExpandedJobId = this.youtubeExpandedJobId === jobId ? null : jobId;
+        },
+
         youtubeJobMeta(job) {
             const kind = job.source_kind === 'playlist' ? T.youtubePlaylist : T.youtubeVideo;
             const parts = [kind];
             if (Number(job.total_items || 0) > 0) parts.push(Number(job.total_items) + ' ' + T.youtubeItems);
             if (Number(job.failed_items || 0) > 0) parts.push(Number(job.failed_items) + ' ' + T.youtubeErrors);
+            const playlistTitle = this.youtubePlaylistTitle(job.target_playlist_id);
+            if (playlistTitle) parts.push(T.youtubeAddedTo + ' ' + playlistTitle);
             return parts.join(' · ');
         },
 
@@ -5897,6 +6027,7 @@ document.addEventListener('alpine:init', () => {
                     this.uploadProgressText = this.uploadProgress.toFixed(1) + '%';
                 };
                 xhr.onload = () => {
+                    redirectOnUnauthorized(xhr.status);
                     let data = {};
                     try { data = JSON.parse(xhr.responseText || '{}'); } catch {}
                     if (xhr.status >= 200 && xhr.status < 300) resolve(data);

templates/player/styles.html

@@ -3291,6 +3291,11 @@ button.user-stat:hover {
     overflow: hidden;
 }
 
+.torrent-modal.youtube-mode {
+    width: min(1440px, calc(100vw - 32px));
+    max-width: 1440px;
+}
+
 .torrent-modal-head {
     display: flex;
     align-items: flex-start;
@@ -3613,8 +3618,8 @@ button.user-stat:hover {
 }
 
 .youtube-preview-card {
-    min-height: 0;
-    flex: 0 1 360px;
+    min-height: 370px;
+    flex: 1 1 520px;
     display: flex;
     flex-direction: column;
     gap: 10px;
@@ -3626,6 +3631,7 @@ button.user-stat:hover {
 
 .youtube-preview-head,
 .youtube-preview-footer {
+    flex: 0 0 auto;
     display: flex;
     align-items: center;
     justify-content: space-between;
@@ -3657,13 +3663,55 @@ button.user-stat:hover {
 }
 
 .youtube-preview-list {
-    min-height: 72px;
+    min-height: 190px;
+    flex: 1 1 260px;
     overflow-y: auto;
     border: 1px solid var(--border-color);
     border-radius: 7px;
     background: var(--bg-secondary);
 }
 
+.youtube-preview-destination {
+    flex: 0 0 auto;
+    display: grid;
+    grid-template-columns: minmax(280px, 360px) minmax(0, 1fr);
+    grid-template-rows: auto auto;
+    column-gap: 14px;
+    row-gap: 4px;
+    align-items: center;
+    padding: 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 7px;
+    background: var(--bg-secondary);
+}
+
+.youtube-preview-destination > label {
+    grid-column: 1;
+    grid-row: 1;
+    margin: 0;
+}
+
+.youtube-preview-destination-fields {
+    grid-column: 2;
+    grid-row: 1 / 3;
+    display: grid;
+    grid-template-columns: 1fr;
+    gap: 8px;
+}
+
+.youtube-preview-destination-fields.creating {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.youtube-preview-destination p {
+    grid-column: 1;
+    grid-row: 2;
+    margin: 0;
+    color: var(--text-subdued);
+    font-size: 10px;
+    line-height: 1.4;
+}
+
 .youtube-preview-row {
     display: grid;
     grid-template-columns: auto 30px minmax(0, 1fr);
@@ -3722,6 +3770,7 @@ button.user-stat:hover {
 
 .youtube-download-list {
     min-height: 0;
+    flex: 1 1 180px;
     display: flex;
     flex-direction: column;
     gap: 10px;
@@ -3737,10 +3786,63 @@ button.user-stat:hover {
 
 .youtube-job-card {
     flex: 0 0 auto;
-    padding: 13px;
+    padding: 0;
     border: 1px solid var(--border-color);
     border-radius: 9px;
     background: var(--bg-primary);
+    overflow: hidden;
+}
+
+.youtube-job-card.collapsed {
+    border-color: rgba(255,255,255,0.08);
+}
+
+.youtube-job-summary {
+    width: 100%;
+    min-height: 50px;
+    display: grid;
+    grid-template-columns: 16px minmax(0, 1fr) auto auto;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 13px;
+    border: 0;
+    background: transparent;
+    color: inherit;
+    font: inherit;
+    text-align: left;
+    cursor: pointer;
+}
+
+.youtube-job-summary:hover {
+    background: var(--bg-hover);
+}
+
+.youtube-job-chevron {
+    width: 8px;
+    height: 8px;
+    border-right: 2px solid var(--text-subdued);
+    border-bottom: 2px solid var(--text-subdued);
+    transform: rotate(45deg) translate(-2px, -2px);
+    transition: transform 140ms ease;
+}
+
+.youtube-job-card.collapsed .youtube-job-chevron {
+    transform: rotate(-45deg);
+}
+
+.youtube-job-card.collapsed .youtube-job-meta {
+    display: none;
+}
+
+.youtube-job-compact-progress {
+    color: var(--text-subdued);
+    font-size: 11px;
+    font-weight: 800;
+    white-space: nowrap;
+}
+
+.youtube-job-details {
+    padding: 0 13px 13px;
 }
 
 .youtube-job-head,
@@ -3781,7 +3883,7 @@ button.user-stat:hover {
     grid-template-columns: minmax(0, 1fr) auto;
     align-items: center;
     gap: 10px;
-    margin-top: 9px;
+    margin-top: 0;
     color: var(--text-subdued);
     font-size: 11px;
 }
@@ -6462,6 +6564,11 @@ button.user-stat:hover {
         overflow: hidden;
     }
 
+    .torrent-modal.youtube-mode {
+        width: 100vw;
+        max-width: none;
+    }
+
     .torrent-modal-head {
         display: grid;
         grid-template-columns: minmax(0, 1fr) auto;
@@ -6533,7 +6640,8 @@ button.user-stat:hover {
 
     .youtube-preview-card {
         flex-basis: auto;
-        max-height: 330px;
+        min-height: 420px;
+        max-height: none;
     }
 
     .youtube-preview-head,
@@ -6546,6 +6654,32 @@ button.user-stat:hover {
         flex-wrap: wrap;
     }
 
+    .youtube-preview-destination-fields {
+        grid-column: auto;
+        grid-row: auto;
+        grid-template-columns: 1fr;
+    }
+
+    .youtube-preview-destination {
+        display: block;
+    }
+
+    .youtube-preview-destination > label {
+        margin-bottom: 7px;
+    }
+
+    .youtube-preview-destination p {
+        margin-top: 7px;
+    }
+
+    .youtube-job-summary {
+        grid-template-columns: 16px minmax(0, 1fr) auto;
+    }
+
+    .youtube-job-summary .youtube-job-compact-progress {
+        display: none;
+    }
+
     .youtube-download-list {
         overflow: visible;
     }