@lox-audioserver/node-librespot 0.3.4 → 0.3.6

package/dist/types.d.ts

@@ -25,7 +25,7 @@ export interface CredentialsResult {
 }
 /** Helper signature for OAuth-based credentials minting. */
 export type LoginWithAccessToken = (accessToken: string, deviceName?: string) => Promise<CredentialsResult>;
-export type LibrespotEventType = 'playing' | 'paused' | 'loading' | 'stopped' | 'end_of_track' | 'unavailable' | 'volume' | 'position_correction' | 'health' | 'error' | 'metric' | 'preloading' | 'time_to_preload' | 'play_request_id' | 'other';
+export type LibrespotEventType = 'playing' | 'paused' | 'loading' | 'stopped' | 'end_of_track' | 'unavailable' | 'volume' | 'position_correction' | 'health' | 'error' | 'metric' | 'preloading' | 'time_to_preload' | 'play_request_id' | 'credentials_changed' | 'other';
 export type LibrespotErrorCode = 'audio_key_error' | 'no_pcm' | 'end_of_track' | 'pcm_missing' | 'pcm_stalled' | 'pcm_ok' | 'unavailable' | 'unknown';
 /** Event payload emitted by the connect host. */
 export interface ConnectEvent {
@@ -45,6 +45,7 @@ export interface ConnectEvent {
     metricName?: string;
     metricValueMs?: number;
     metricMessage?: string;
+    credentialsJson?: string;
 }
 /** Log payload emitted by the native module. */
 export interface LogEvent {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lox-audioserver/node-librespot",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Node.js bindings for librespot (Spotify Connect) via N-API with prebuild support.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/lib.rs

@@ -12,8 +12,8 @@ use bytes::Bytes;
 use librespot_audio::{AudioDecrypt, AudioFile};
 use librespot_connect::{ConnectConfig, Spirc};
 use librespot_core::{
-    authentication::Credentials, cache::Cache, config::SessionConfig, session::Session, SpotifyId,
-    SpotifyUri, spotify_id::FileId,
+    authentication::Credentials, cache::Cache, config::SessionConfig, session::Session,
+    spotify_id::FileId, SpotifyId, SpotifyUri,
 };
 use librespot_discovery::{DeviceType, Discovery};
 use librespot_metadata::audio::{AudioFileFormat, AudioFiles, AudioItem};
@@ -43,12 +43,45 @@ use tokio_stream::StreamExt;
 static RUNTIME: OnceLock<tokio::runtime::Runtime> = OnceLock::new();
 static LOGGER_INIT: OnceLock<()> = OnceLock::new();
 static SESSION_COUNTER: AtomicU64 = AtomicU64::new(1);
+static COLLECTION_PARSE_LOG_NEXT_AT_MS: AtomicU64 = AtomicU64::new(0);
 
 fn next_session_id(prefix: &str) -> String {
     let next = SESSION_COUNTER.fetch_add(1, Ordering::Relaxed);
     format!("{prefix}-{next}")
 }
 
+fn unix_epoch_ms() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_else(|_| Duration::from_secs(0))
+        .as_millis() as u64
+}
+
+fn normalize_collection_parse_warning(event: &mut LogEvent) -> bool {
+    let scope = event.scope.as_deref().unwrap_or("").to_lowercase();
+    if !scope.contains("librespot_core::dealer") {
+        return false;
+    }
+    let message = event.message.to_lowercase();
+    let looks_like_collection_parse_noise = message
+        .contains("failure during data parsing for hm://collection/collection/")
+        && message.contains("base64 decoding failed");
+    if !looks_like_collection_parse_noise {
+        return false;
+    }
+
+    let now = unix_epoch_ms();
+    let next_at = COLLECTION_PARSE_LOG_NEXT_AT_MS.load(Ordering::Relaxed);
+    if now < next_at {
+        return true;
+    }
+    COLLECTION_PARSE_LOG_NEXT_AT_MS.store(now + 60_000, Ordering::Relaxed);
+    event.level = "debug".to_string();
+    event.message =
+        "suppressed recurring dealer parse warning for hm://collection payload".to_string();
+    false
+}
+
 fn runtime() -> &'static tokio::runtime::Runtime {
     RUNTIME.get_or_init(|| {
         tokio::runtime::Runtime::new().expect("failed to create tokio runtime for librespot addon")
@@ -131,6 +164,8 @@ pub struct ConnectEvent {
     pub metric_name: Option<String>,
     pub metric_value_ms: Option<u32>,
     pub metric_message: Option<String>,
+    /// Credentials JSON blob delivered via mDNS discovery when a new Spotify user connects.
+    pub credentials_json: Option<String>,
 }
 
 /// Log payload emitted by the native module.
@@ -308,13 +343,16 @@ impl Log for NativeLogger {
     }
 
     fn log(&self, record: &Record<'_>) {
-        let event = LogEvent {
+        let mut event = LogEvent {
             level: record.level().to_string().to_lowercase(),
             message: record.args().to_string(),
             scope: Some(record.target().to_string()),
             device_id: None,
             session_id: None,
         };
+        if normalize_collection_parse_warning(&mut event) {
+            return;
+        }
         let mut observers = log_observers()
             .lock()
             .unwrap_or_else(|err| err.into_inner());
@@ -537,6 +575,7 @@ impl Sink for ChannelSink {
                         metric_name: Some("first_pcm_ms".into()),
                         metric_value_ms: Some(elapsed_ms_u32),
                         metric_message: None,
+                        credentials_json: None,
                     };
                     let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
                 }
@@ -654,6 +693,9 @@ impl LibrespotSession {
                             env.create_string(&metric_message)?,
                         )?;
                     }
+                    if let Some(creds_json) = val.credentials_json {
+                        obj.set_named_property("credentialsJson", env.create_string(&creds_json)?)?;
+                    }
                     Ok(vec![obj.into_unknown()])
                 })
             })
@@ -812,6 +854,7 @@ impl LibrespotSession {
                                 metric_name: Some("decode_error".into()),
                                 metric_value_ms: None,
                                 metric_message: Some(event.message.clone()),
+                                credentials_json: None,
                             };
                             let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
                         }
@@ -844,6 +887,7 @@ impl LibrespotSession {
                         metric_name: None,
                         metric_value_ms: None,
                         metric_message: None,
+                        credentials_json: None,
                     };
                     let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
                 }
@@ -902,6 +946,7 @@ impl LibrespotSession {
               metric_name: None,
               metric_value_ms: None,
               metric_message: None,
+              credentials_json: None,
             };
             let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
           }
@@ -955,6 +1000,7 @@ impl LibrespotSession {
               metric_name: Some("buffer_stall_ms".into()),
               metric_value_ms: Some(stall_ms_u32),
               metric_message: Some("pcm stalled".into()),
+              credentials_json: None,
             };
               let _ = tsfn_ev.call(metric_payload, ThreadsafeFunctionCallMode::NonBlocking);
             }
@@ -975,6 +1021,7 @@ impl LibrespotSession {
               metric_name: None,
               metric_value_ms: None,
               metric_message: None,
+              credentials_json: None,
             };
             let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
           }
@@ -1068,6 +1115,7 @@ impl LibrespotSession {
                     metric_name: None,
                     metric_value_ms: None,
                     metric_message: None,
+                    credentials_json: None,
                   };
                   let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
                 }
@@ -1092,6 +1140,7 @@ impl LibrespotSession {
                   metric_name: None,
                   metric_value_ms: None,
                   metric_message: None,
+                  credentials_json: None,
                 },
                 PlayerEvent::Paused { track_id, position_ms, .. } => ConnectEvent {
                   r#type: "paused".into(),
@@ -1110,6 +1159,7 @@ impl LibrespotSession {
                   metric_name: None,
                   metric_value_ms: None,
                   metric_message: None,
+                  credentials_json: None,
                 },
                 PlayerEvent::Loading { track_id, position_ms, .. } => ConnectEvent {
                   r#type: "loading".into(),
@@ -1128,6 +1178,7 @@ impl LibrespotSession {
                   metric_name: None,
                   metric_value_ms: None,
                   metric_message: None,
+                  credentials_json: None,
                 },
                 PlayerEvent::Stopped { track_id, .. } => ConnectEvent {
                   r#type: "stopped".into(),
@@ -1146,16 +1197,17 @@ impl LibrespotSession {
                   metric_name: None,
                   metric_value_ms: None,
                   metric_message: None,
+                  credentials_json: None,
                 },
                 PlayerEvent::EndOfTrack { track_id, .. } => {
                   if !saw_playing || last_duration_ms.is_none() {
                     if !error_sent_for_spawn.swap(true, Ordering::AcqRel) {
-                      let fallback_id = track_id.to_id();
+                      let fallback_id = Some(track_id.to_id());
                       let payload = ConnectEvent {
                         r#type: "error".into(),
                         device_id: Some(device_id_for_events.clone()),
                         session_id: Some(session_id_for_events.clone()),
-                        track_id: Some(fallback_id),
+                        track_id: fallback_id,
                         uri: Some(track_id.to_uri()),
                         title: None,
                         artist: None,
@@ -1168,6 +1220,7 @@ impl LibrespotSession {
                         metric_name: None,
                         metric_value_ms: None,
                         metric_message: None,
+                        credentials_json: None,
                       };
                       let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
                     }
@@ -1190,6 +1243,7 @@ impl LibrespotSession {
                     metric_name: None,
                     metric_value_ms: None,
                     metric_message: None,
+                    credentials_json: None,
                   }
                 }
                 PlayerEvent::Unavailable { track_id, .. } => ConnectEvent {
@@ -1209,6 +1263,7 @@ impl LibrespotSession {
                   metric_name: None,
                   metric_value_ms: None,
                   metric_message: None,
+                  credentials_json: None,
                 },
                 PlayerEvent::VolumeChanged { volume } => ConnectEvent {
                   r#type: "volume".into(),
@@ -1227,6 +1282,7 @@ impl LibrespotSession {
                   metric_name: None,
                   metric_value_ms: None,
                   metric_message: None,
+                  credentials_json: None,
                 },
                 PlayerEvent::PositionCorrection { track_id, position_ms, .. } => ConnectEvent {
                   r#type: "position_correction".into(),
@@ -1245,6 +1301,7 @@ impl LibrespotSession {
                   metric_name: None,
                   metric_value_ms: None,
                   metric_message: None,
+                  credentials_json: None,
                 },
                 _ => continue,
               };
@@ -1357,64 +1414,61 @@ impl LibrespotSession {
             .try_into()
             .map_err(|e| Error::from_reason(format!("invalid spotify id: {e:?}")))?;
 
-        let (encrypted_file, key) = runtime()
-            .block_on(async {
-                let audio_item = AudioItem::get_file(&session, spotify_uri.clone())
-                    .await
-                    .map_err(|e| Error::from_reason(format!("failed to load audio item: {e:?}")))?;
+        let (encrypted_file, key) = runtime().block_on(async {
+            let audio_item = AudioItem::get_file(&session, spotify_uri.clone())
+                .await
+                .map_err(|e| Error::from_reason(format!("failed to load audio item: {e:?}")))?;
 
-                let select_format =
-                    |files: &AudioFiles, bitrate: Option<u32>| -> Option<(AudioFileFormat, FileId)> {
-                        let prefer = match bitrate {
-                            Some(96) => {
-                                vec![AudioFileFormat::OGG_VORBIS_96, AudioFileFormat::MP3_96]
-                            }
-                            Some(160) => {
-                                vec![AudioFileFormat::OGG_VORBIS_160, AudioFileFormat::MP3_160]
-                            }
-                            _ => vec![
-                                AudioFileFormat::OGG_VORBIS_320,
-                                AudioFileFormat::MP3_320,
-                                AudioFileFormat::MP3_256,
-                            ],
-                        };
-                        for f in prefer {
-                            if let Some(id) = files.get(&f) {
-                                return Some((f, *id));
-                            }
+            let select_format =
+                |files: &AudioFiles, bitrate: Option<u32>| -> Option<(AudioFileFormat, FileId)> {
+                    let prefer = match bitrate {
+                        Some(96) => {
+                            vec![AudioFileFormat::OGG_VORBIS_96, AudioFileFormat::MP3_96]
+                        }
+                        Some(160) => {
+                            vec![AudioFileFormat::OGG_VORBIS_160, AudioFileFormat::MP3_160]
                         }
-                        files.iter().next().map(|(f, id)| (*f, *id))
+                        _ => vec![
+                            AudioFileFormat::OGG_VORBIS_320,
+                            AudioFileFormat::MP3_320,
+                            AudioFileFormat::MP3_256,
+                        ],
                     };
-
-                let (format, file_id) = select_format(&audio_item.files, bitrate_pref)
-                    .ok_or_else(|| Error::from_reason("no audio files available"))?;
-
-                let bytes_per_second = stream_data_rate(format)
-                    .ok_or_else(|| Error::from_reason("unable to compute data rate"))?;
-
-                let encrypted_file = AudioFile::open(&session, file_id, bytes_per_second)
-                    .await
-                    .map_err(|e| {
-                        Error::from_reason(format!("failed to open audio file: {e:?}"))
-                    })?;
-
-                let key = match session.audio_key().request(track_id, file_id).await {
-                    Ok(key) => Some(key),
-                    Err(e) => {
-                        emit_log_ctx(
-                            &log_tsfn,
-                            "warn",
-                            format!("audio key unavailable, continuing without decryption: {e:?}"),
-                            Some("download_track"),
-                            None,
-                            None,
-                        );
-                        None
+                    for f in prefer {
+                        if let Some(id) = files.get(&f) {
+                            return Some((f, *id));
+                        }
                     }
+                    files.iter().next().map(|(f, id)| (*f, *id))
                 };
 
-                Ok::<_, Error>((encrypted_file, key))
-            })?;
+            let (format, file_id) = select_format(&audio_item.files, bitrate_pref)
+                .ok_or_else(|| Error::from_reason("no audio files available"))?;
+
+            let bytes_per_second = stream_data_rate(format)
+                .ok_or_else(|| Error::from_reason("unable to compute data rate"))?;
+
+            let encrypted_file = AudioFile::open(&session, file_id, bytes_per_second)
+                .await
+                .map_err(|e| Error::from_reason(format!("failed to open audio file: {e:?}")))?;
+
+            let key = match session.audio_key().request(track_id, file_id).await {
+                Ok(key) => Some(key),
+                Err(e) => {
+                    emit_log_ctx(
+                        &log_tsfn,
+                        "warn",
+                        format!("audio key unavailable, continuing without decryption: {e:?}"),
+                        Some("download_track"),
+                        None,
+                        None,
+                    );
+                    None
+                }
+            };
+
+            Ok::<_, Error>((encrypted_file, key))
+        })?;
 
         let stop_flag_clone = stop_flag.clone();
         let log_tsfn_clone = log_tsfn.clone();
@@ -1630,6 +1684,9 @@ fn start_connect_device_inner(
                 if let Some(metric_message) = val.metric_message {
                     obj.set_named_property("metricMessage", env.create_string(&metric_message)?)?;
                 }
+                if let Some(creds_json) = val.credentials_json {
+                    obj.set_named_property("credentialsJson", env.create_string(&creds_json)?)?;
+                }
                 Ok(vec![obj.into_unknown()])
             })
         })
@@ -1690,6 +1747,7 @@ fn start_connect_device_inner(
                 session_config.client_id = client_id_override;
             }
         }
+        let client_id_for_discovery = session_config.client_id.clone();
         // Spirc::new neemt zelf de connect stap; we maken hier alleen een verse session.
         let session = Session::new(session_config.clone(), None);
 
@@ -1697,12 +1755,12 @@ fn start_connect_device_inner(
             name: name.clone(),
             device_type: DeviceType::Speaker,
             is_group: false,
-            emit_set_queue_events: false,
             // Start with full volume so we rely on zone-side volume control; we do not sync Spotify volume.
             // Spotify volume scale is 0..65535; use max to avoid muted start.
             initial_volume: u16::MAX,
             disable_volume: false,
             volume_steps: 64,
+            emit_set_queue_events: false,
         };
 
         let player_config = PlayerConfig::default();
@@ -1757,6 +1815,8 @@ fn start_connect_device_inner(
         };
 
         let player = Player::new(player_config, session.clone(), volume_getter, sink_builder);
+        // Clone log_tsfn before it is moved into the player-event spawn below.
+        let log_tsfn_for_disc = log_tsfn.clone();
         // Forward player events to JS if requested.
         if let Some(tsfn_ev) = event_tsfn.clone() {
             let mut ev_rx = player.get_player_event_channel();
@@ -1811,6 +1871,7 @@ fn start_connect_device_inner(
                             metric_name: Some("buffer_stall_ms".into()),
                             metric_value_ms: Some(stall_ms_u32),
                             metric_message: Some("pcm stalled".into()),
+                            credentials_json: None,
                         };
                         let _ = tsfn_health
                             .call(metric_payload, ThreadsafeFunctionCallMode::NonBlocking);
@@ -1832,6 +1893,7 @@ fn start_connect_device_inner(
                         metric_name: None,
                         metric_value_ms: None,
                         metric_message: None,
+                        credentials_json: None,
                     };
                     let _ = tsfn_health.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
                 }
@@ -1912,6 +1974,7 @@ fn start_connect_device_inner(
                             metric_name: None,
                             metric_value_ms: None,
                             metric_message: None,
+                            credentials_json: None,
                         },
                         PlayerEvent::Paused {
                             track_id,
@@ -1934,6 +1997,7 @@ fn start_connect_device_inner(
                             metric_name: None,
                             metric_value_ms: None,
                             metric_message: None,
+                            credentials_json: None,
                         },
                         PlayerEvent::Loading {
                             track_id,
@@ -1956,6 +2020,7 @@ fn start_connect_device_inner(
                             metric_name: None,
                             metric_value_ms: None,
                             metric_message: None,
+                            credentials_json: None,
                         },
                         PlayerEvent::Stopped { track_id, .. } => ConnectEvent {
                             r#type: "stopped".into(),
@@ -1974,6 +2039,7 @@ fn start_connect_device_inner(
                             metric_name: None,
                             metric_value_ms: None,
                             metric_message: None,
+                            credentials_json: None,
                         },
                         PlayerEvent::EndOfTrack { track_id, .. } => {
                             if !saw_playing || last_duration_ms.is_none() {
@@ -1996,6 +2062,7 @@ fn start_connect_device_inner(
                                 metric_name: None,
                                 metric_value_ms: None,
                                 metric_message: None,
+                                credentials_json: None,
                             }
                         }
                         PlayerEvent::Unavailable { track_id, .. } => ConnectEvent {
@@ -2015,6 +2082,7 @@ fn start_connect_device_inner(
                             metric_name: None,
                             metric_value_ms: None,
                             metric_message: None,
+                            credentials_json: None,
                         },
                         PlayerEvent::VolumeChanged { volume } => ConnectEvent {
                             r#type: "volume".into(),
@@ -2033,6 +2101,7 @@ fn start_connect_device_inner(
                             metric_name: None,
                             metric_value_ms: None,
                             metric_message: None,
+                            credentials_json: None,
                         },
                         PlayerEvent::PositionCorrection {
                             track_id,
@@ -2055,6 +2124,7 @@ fn start_connect_device_inner(
                             metric_name: None,
                             metric_value_ms: None,
                             metric_message: None,
+                            credentials_json: None,
                         },
                         _ => continue,
                     };
@@ -2137,6 +2207,78 @@ fn start_connect_device_inner(
             });
         }
 
+        // Log observer: detect audio_key_error and decoder errors from librespot log output.
+        // This mirrors the same pattern used in stream_track to ensure the JS layer receives
+        // error events and can trigger recovery (e.g. re-authentication, skip to next track).
+        if let Some(tsfn_ev) = event_tsfn.clone() {
+            let mut log_rx = subscribe_log_events();
+            let error_sent = Arc::new(AtomicBool::new(false));
+            let decoder_metric_sent = Arc::new(AtomicBool::new(false));
+            let stop_flag_for_logs = stop_flag_for_block.clone();
+            let device_id_for_logs = device_id.clone();
+            let session_id_for_logs = session_id.clone();
+            runtime().spawn(async move {
+                while let Some(event) = log_rx.recv().await {
+                    if stop_flag_for_logs.load(Ordering::Acquire) {
+                        break;
+                    }
+                    if is_decoder_error(&event) {
+                        if !decoder_metric_sent.swap(true, Ordering::AcqRel) {
+                            let payload = ConnectEvent {
+                                r#type: "metric".into(),
+                                device_id: Some(device_id_for_logs.clone()),
+                                session_id: Some(session_id_for_logs.clone()),
+                                track_id: None,
+                                uri: None,
+                                title: None,
+                                artist: None,
+                                album: None,
+                                duration_ms: None,
+                                position_ms: None,
+                                volume: None,
+                                error_code: None,
+                                error_message: None,
+                                metric_name: Some("decode_error".into()),
+                                metric_value_ms: None,
+                                metric_message: Some(event.message.clone()),
+                                credentials_json: None,
+                            };
+                            let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
+                        }
+                    }
+                    if error_sent.load(Ordering::Acquire) {
+                        continue;
+                    }
+                    if !is_audio_key_error(&event) {
+                        continue;
+                    }
+                    if error_sent.swap(true, Ordering::AcqRel) {
+                        continue;
+                    }
+                    let payload = ConnectEvent {
+                        r#type: "error".into(),
+                        device_id: Some(device_id_for_logs.clone()),
+                        session_id: Some(session_id_for_logs.clone()),
+                        track_id: None,
+                        uri: None,
+                        title: None,
+                        artist: None,
+                        album: None,
+                        duration_ms: None,
+                        position_ms: None,
+                        volume: None,
+                        error_code: Some("audio_key_error".into()),
+                        error_message: Some(event.message.clone()),
+                        metric_name: None,
+                        metric_value_ms: None,
+                        metric_message: None,
+                        credentials_json: None,
+                    };
+                    let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
+                }
+            });
+        }
+
         let (spirc, spirc_task) = Spirc::new(
             connect_config,
             session,
@@ -2147,6 +2289,108 @@ fn start_connect_device_inner(
         .await
         .map_err(|e| Error::from_reason(format!("spirc start failed: {e}")))?;
 
+        // Launch mDNS Discovery so the device is visible to ALL Spotify users on the LAN,
+        // not just the owner of the credentials used to start the connect host. This is the
+        // same mechanism hardware devices (Sonos, Onkyo, etc.) use. When a different user
+        // connects via mDNS, their credentials are emitted as a "credentials_changed" event
+        // so the JS layer can restart the connect host under the new account.
+        match Discovery::builder(device_id.clone(), client_id_for_discovery)
+            .name(name.clone())
+            .device_type(DeviceType::Speaker)
+            .launch()
+        {
+            Ok(mut discovery) => {
+                emit_log_ctx(
+                    &log_tsfn_for_disc,
+                    "info",
+                    "mDNS discovery started; device is now visible to all Spotify users on the LAN",
+                    Some("connect_host"),
+                    Some(&device_id),
+                    Some(&session_id),
+                );
+                let event_tsfn_disc = event_tsfn.clone();
+                let log_tsfn_disc = log_tsfn_for_disc.clone();
+                let stop_flag_disc = stop_flag_for_block.clone();
+                let device_id_disc = device_id.clone();
+                let session_id_disc = session_id.clone();
+                runtime().spawn(async move {
+                    loop {
+                        if stop_flag_disc.load(Ordering::Acquire) {
+                            break;
+                        }
+                        match tokio::time::timeout(
+                            Duration::from_secs(2),
+                            discovery.next(),
+                        )
+                        .await
+                        {
+                            Ok(None) => break,
+                            Ok(Some(creds)) => {
+                                match serde_json::to_string_pretty(&creds) {
+                                    Ok(json) => {
+                                        emit_log_ctx(
+                                            &log_tsfn_disc,
+                                            "info",
+                                            "mDNS: new Spotify user connected; emitting credentials_changed",
+                                            Some("connect_host"),
+                                            Some(&device_id_disc),
+                                            Some(&session_id_disc),
+                                        );
+                                        if let Some(ref tsfn) = event_tsfn_disc {
+                                            let payload = ConnectEvent {
+                                                r#type: "credentials_changed".into(),
+                                                credentials_json: Some(json),
+                                                device_id: Some(device_id_disc.clone()),
+                                                session_id: Some(session_id_disc.clone()),
+                                                track_id: None,
+                                                uri: None,
+                                                title: None,
+                                                artist: None,
+                                                album: None,
+                                                duration_ms: None,
+                                                position_ms: None,
+                                                volume: None,
+                                                error_code: None,
+                                                error_message: None,
+                                                metric_name: None,
+                                                metric_value_ms: None,
+                                                metric_message: None,
+                                            };
+                                            let _ = tsfn.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
+                                        }
+                                        break;
+                                    }
+                                    Err(e) => {
+                                        emit_log_ctx(
+                                            &log_tsfn_disc,
+                                            "warn",
+                                            &format!("mDNS: failed to serialize new credentials: {e}"),
+                                            Some("connect_host"),
+                                            Some(&device_id_disc),
+                                            Some(&session_id_disc),
+                                        );
+                                    }
+                                }
+                            }
+                            Err(_timeout) => {
+                                // No new connection in this window; loop and check stop flag.
+                            }
+                        }
+                    }
+                });
+            }
+            Err(e) => {
+                emit_log_ctx(
+                    &log_tsfn_for_disc,
+                    "warn",
+                    &format!("mDNS discovery failed to start (device only visible to owner account): {e}"),
+                    Some("connect_host"),
+                    Some(&device_id),
+                    Some(&session_id),
+                );
+            }
+        }
+
         let (stop_tx, mut stop_rx) = mpsc::channel::<()>(1);
         let task_handle = runtime().spawn(async move {
             tokio::select! {
@@ -2252,8 +2496,7 @@ pub fn start_connect_device_with_token(
                     epoch_ms,
                     std::process::id()
                 ));
-                fs::create_dir_all(&temp_dir)
-                    .map_err(|e| Error::from_reason(format!("{e}")))?;
+                fs::create_dir_all(&temp_dir).map_err(|e| Error::from_reason(format!("{e}")))?;
                 let cache = Cache::new(
                     Some(&temp_dir),
                     None::<&std::path::PathBuf>,
@@ -2268,9 +2511,9 @@ pub fn start_connect_device_with_token(
                     .await
                     .map_err(|e| Error::from_reason(format!("session connect failed: {e}")))?;
 
-                let reusable_credentials = cache
-                    .credentials()
-                    .ok_or_else(|| Error::from_reason("no reusable credentials after oauth login"))?;
+                let reusable_credentials = cache.credentials().ok_or_else(|| {
+                    Error::from_reason("no reusable credentials after oauth login")
+                })?;
 
                 drop(session);
                 let _ = fs::remove_dir_all(&temp_dir);

package/src/types.ts

@@ -50,6 +50,7 @@ export type LibrespotEventType =
   | 'preloading'
   | 'time_to_preload'
   | 'play_request_id'
+  | 'credentials_changed'
   | 'other';
 
 export type LibrespotErrorCode =
@@ -80,6 +81,7 @@ export interface ConnectEvent {
   metricName?: string;
   metricValueMs?: number;
   metricMessage?: string;
+  credentialsJson?: string;
 }
 
 /** Log payload emitted by the native module. */