@lox-audioserver/node-librespot 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lox-audioserver/node-librespot",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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

@@ -513,6 +513,11 @@ impl Sink for ChannelSink {
     }
 
     fn stop(&mut self) -> SinkResult<()> {
+        // Reset pacing so the next start() (e.g. after Connect pause) is paced from now,
+        // not from the original stream_start. Without this the post-resume catch-up logic
+        // forwards minutes of decoded PCM at full speed.
+        self.start = None;
+        self.expected_elapsed = Duration::from_millis(0);
         Ok(())
     }
 
@@ -606,10 +611,20 @@ impl Sink for ChannelSink {
         if self.tx.try_send(bytes).is_err() {
             // Drop chunk if JS side is backpressured to avoid blocking the player thread.
         }
-        let start = self.start.get_or_insert_with(Instant::now);
-        self.expected_elapsed += duration;
-        let target = *start + self.expected_elapsed;
         let now = Instant::now();
+        // If wall-clock has drifted far ahead of our expected timeline (a pause that didn't
+        // route through stop()/start(), a decoder stall, etc.), rebase pacing onto `now`.
+        // Otherwise `sleep_dur` saturates to 0 for the duration of the gap and the sink
+        // dumps the catch-up backlog at full speed downstream.
+        if let Some(start) = self.start {
+            if now > start + self.expected_elapsed + Duration::from_millis(200) {
+                self.start = None;
+                self.expected_elapsed = Duration::from_millis(0);
+            }
+        }
+        let start = *self.start.get_or_insert(now);
+        self.expected_elapsed += duration;
+        let target = start + self.expected_elapsed;
         let sleep_dur = target.saturating_duration_since(now);
         if !sleep_dur.is_zero() {
             sleep(sleep_dur);
@@ -1850,12 +1865,21 @@ 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();
+        // [issue #252] Bumped by the player-event observer on signals that
+        // prove audio is flowing (`playing` / `position_correction`). Read by
+        // the log observer further down to suppress transient `audio_key_error`
+        // events that fire while spirc is already recovering from an
+        // account-side dealer-disconnect burst. A permanent audio-key fault
+        // never produces a healthy event, so the error still surfaces after
+        // the grace window.
+        let healthy_seq = Arc::new(AtomicU64::new(0));
         // Forward player events to JS if requested.
         if let Some(tsfn_ev) = event_tsfn.clone() {
             let mut ev_rx = player.get_player_event_channel();
             let session_for_events = session.clone();
             let device_id_for_events = device_id.clone();
             let session_id_for_events = session_id.clone();
+            let healthy_seq_for_events = healthy_seq.clone();
             let last_pcm_for_health = last_pcm_at.clone();
             let stop_flag_for_health = stop_flag_for_block.clone();
             let device_id_for_health = device_id.clone();
@@ -2235,6 +2259,13 @@ fn start_connect_device_inner(
                         _ => {}
                     }
 
+                    // [issue #252] Signal "audio is actually flowing" to the
+                    // log observer. Excludes `paused` because a paused stream
+                    // can't prove the dealer/session is healthy.
+                    if matches!(payload.r#type.as_str(), "playing" | "position_correction") {
+                        healthy_seq_for_events.fetch_add(1, Ordering::AcqRel);
+                    }
+
                     let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
                 }
             });
@@ -2250,6 +2281,16 @@ fn start_connect_device_inner(
             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();
+            let healthy_seq_for_logs = healthy_seq.clone();
+            // [issue #252] Grace window before surfacing audio_key_error to JS.
+            // Account-side Spotify dealer-disconnect bursts cause every
+            // offload=false zone to emit a single audio-key-timeout log line,
+            // while spirc reconnects internally within seconds. Without this
+            // delay every burst trips the per-zone cooldown in
+            // SpotifyConnectInstance and produces ~5 minutes of unplayable
+            // state per zone. 5s is well above typical spirc recovery time
+            // and well below the cooldown window.
+            const AUDIO_KEY_GRACE_MS: u64 = 5000;
             runtime().spawn(async move {
                 while let Some(event) = log_rx.recv().await {
                     if stop_flag_for_logs.load(Ordering::Acquire) {
@@ -2307,7 +2348,28 @@ fn start_connect_device_inner(
                         metric_message: None,
                         credentials_json: None,
                     };
-                    let _ = tsfn_ev.call(payload, ThreadsafeFunctionCallMode::NonBlocking);
+                    // [issue #252] Defer the emit by AUDIO_KEY_GRACE_MS and
+                    // suppress it if a healthy event arrived in the meantime
+                    // (spirc finished its internal reconnect). Re-arm
+                    // `error_sent` on suppression so a *later* fault in the
+                    // same session can still surface.
+                    let baseline = healthy_seq_for_logs.load(Ordering::Acquire);
+                    let healthy_seq_for_check = healthy_seq_for_logs.clone();
+                    let stop_flag_for_grace = stop_flag_for_logs.clone();
+                    let error_sent_for_reset = error_sent.clone();
+                    let tsfn_ev_for_grace = tsfn_ev.clone();
+                    runtime().spawn(async move {
+                        tokio::time::sleep(Duration::from_millis(AUDIO_KEY_GRACE_MS)).await;
+                        if stop_flag_for_grace.load(Ordering::Acquire) {
+                            return;
+                        }
+                        if healthy_seq_for_check.load(Ordering::Acquire) != baseline {
+                            error_sent_for_reset.store(false, Ordering::Release);
+                            return;
+                        }
+                        let _ = tsfn_ev_for_grace
+                            .call(payload, ThreadsafeFunctionCallMode::NonBlocking);
+                    });
                 }
             });
         }