@desklink/host 0.5.7 → 0.5.9

package/engine/src/session.rs

@@ -703,7 +703,7 @@ pub struct OpenRequest {
     pub max_height: usize,
     pub bitrate_kbps: u32,
     pub max_fps: u32,
-    pub ice_servers: Vec<(String, Option<String>, Option<String>)>,
+    pub ice_servers: Vec<(Vec<String>, Option<String>, Option<String>)>,
     pub restore_token: Option<String>,
     pub ttl: Option<Duration>,
     /// Offer a passive ICE-TCP candidate on the loopback, for a forwarded client.
@@ -762,6 +762,13 @@ pub enum SessionEvent {
     KeyframeRequest {
         generation: u64,
     },
+    /// An ICE server URL the request asked for that the peer's configuration
+    /// does not carry: one the WebRTC stack cannot dial (TURN over anything
+    /// but UDP). Reported once per open, naming the URL, so a skipped URL is
+    /// a warning the consumer sees rather than a silent drop.
+    IceServerSkipped {
+        url: String,
+    },
     RestoreToken(String),
     CaptureStopped {
         reason: String,
@@ -821,6 +828,13 @@ struct Inner {
     /// closes its Hyprland event socket.
     #[cfg(target_os = "linux")]
     window: Mutex<Option<crate::hyprland::WindowLocator>>,
+    /// Which Hyprland output the agent cue helper draws on (a located window
+    /// share's desktop mode): the helper respawns only when a press lands
+    /// elsewhere. Same for the point helper.
+    #[cfg(target_os = "linux")]
+    cue_output: Mutex<Option<String>>,
+    #[cfg(target_os = "linux")]
+    point_output: Mutex<Option<String>>,
     capture: Mutex<Option<FrameSource>>,
     /// Absent for an encoded source: there is no local keyboard to translate a
     /// character through, because the client's keys are forwarded instead.
@@ -1267,9 +1281,19 @@ impl Session {
                 let source_h = source.height.max(1) as usize;
                 let (width, height) =
                     fit(source_w, source_h, request.max_width, request.max_height);
+                // A Hyprland window share's cues go to the desktop point each
+                // press lands on, and its picture holds no layer surface to mask.
+                #[cfg(target_os = "linux")]
+                let desktop =
+                    share_watch.is_some() && source.source_type.as_deref() == Some("Window");
                 #[cfg(target_os = "linux")]
                 if request.agent_indicator {
-                    indicator = crate::indicator::Indicator::start_wayland(source_w, source_h).ok();
+                    // No press has landed yet, so no output is chosen: the
+                    // compositor places this first helper, and the first
+                    // located press moves it onto the landed output.
+                    indicator =
+                        crate::indicator::Indicator::start_wayland(source_w, source_h, desktop, None)
+                            .ok();
                 }
                 #[cfg(target_os = "macos")]
                 if request.agent_indicator {
@@ -1312,6 +1336,7 @@ impl Session {
                     sink,
                     indicator
                         .as_ref()
+                        .filter(|_| !desktop)
                         .map(crate::indicator::Indicator::position),
                     Box::new({
                         let status = capture_status.clone();
@@ -1485,6 +1510,10 @@ impl Session {
             },
             #[cfg(target_os = "linux")]
             window: Mutex::new(window),
+            #[cfg(target_os = "linux")]
+            cue_output: Mutex::new(None),
+            #[cfg(target_os = "linux")]
+            point_output: Mutex::new(None),
             capture: Mutex::new(Some(capture)),
             layout: Mutex::new(Some(layout)),
             #[cfg(target_os = "linux")]
@@ -1585,6 +1614,10 @@ impl Session {
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
             #[cfg(target_os = "linux")]
             window: Mutex::new(None),
+            #[cfg(target_os = "linux")]
+            cue_output: Mutex::new(None),
+            #[cfg(target_os = "linux")]
+            point_output: Mutex::new(None),
             capture: Mutex::new(None),
             layout: Mutex::new(None),
             #[cfg(target_os = "linux")]
@@ -1731,6 +1764,10 @@ impl Session {
             if let Some(helper) = overlay.take() {
                 helper.stop();
             }
+            #[cfg(target_os = "linux")]
+            {
+                *lock(&self.inner.point_output) = None;
+            }
             return Ok(());
         }
         let (x, y) = params
@@ -1754,6 +1791,36 @@ impl Session {
                 "timeout must be 1..120000 ms; label must be at most 96 printable ASCII bytes",
             ));
         }
+        // A located window's point shows where a press there would land, on
+        // the output holding it; the helper moves only when that output
+        // changes, so repeats on one output reuse it with no new process.
+        #[cfg(target_os = "linux")]
+        let landed = match lock(&self.inner.window).as_ref() {
+            Some(window) => {
+                let (px, py) = window
+                    .locate(x, y)
+                    .map_err(|message| SessionError::new("indicator-unavailable", message))?;
+                Some((px.floor() as i64, py.floor() as i64))
+            }
+            None => None,
+        };
+        #[cfg(target_os = "linux")]
+        let landed_output: Option<String> = match landed {
+            Some((px, py)) => {
+                crate::hyprland::monitor_containing(px as f64, py as f64).unwrap_or(None)
+            }
+            None => None,
+        };
+        #[cfg(target_os = "linux")]
+        if match (&landed, &landed_output) {
+            (Some(_), output) => lock(&self.inner.point_output).clone() != *output,
+            (None, _) => overlay.is_none(),
+        } {
+            if let Some(helper) = overlay.take() {
+                helper.stop();
+            }
+            *lock(&self.inner.point_output) = landed_output.clone();
+        }
         #[cfg(not(target_os = "windows"))]
         if overlay.is_none() {
             #[cfg(target_os = "linux")]
@@ -1762,7 +1829,10 @@ impl Session {
                 PointDesktop::Wayland => crate::indicator::Indicator::start_point_wayland(
                     source.width,
                     source.height,
-                    source.position,
+                    landed
+                        .map(|(x, y)| (x as i32, y as i32))
+                        .or(source.position),
+                    landed.is_some(),
                 ),
                 PointDesktop::Unavailable(_) => unreachable!("validated point target"),
             };
@@ -1784,6 +1854,8 @@ impl Session {
                 }
             })?);
         }
+        #[cfg(target_os = "linux")]
+        let (x, y) = landed.unwrap_or((x, y));
         #[cfg(not(target_os = "windows"))]
         return overlay
             .as_mut()
@@ -2110,6 +2182,11 @@ impl Inner {
         if let Some(helper) = lock(&self.point_overlay).take() {
             helper.stop();
         }
+        #[cfg(target_os = "linux")]
+        {
+            *lock(&self.cue_output) = None;
+            *lock(&self.point_output) = None;
+        }
         // Release first, then tear down: a stuck modifier is the one failure the
         // user cannot undo by reconnecting.
         if let Ok(mut input) = self.input.lock() {
@@ -2239,7 +2316,7 @@ impl Inner {
             }
             *last = seq;
         }
-        let feedback = match &message {
+        let mut feedback = match &message {
             ControlMessage::Pointer { phase, x, y, .. } if lock(&self.encoded).is_none() => {
                 let (x, y) = to_source_pixels(*x, *y, self.encoded_size(), &self.source);
                 Some((
@@ -2271,11 +2348,6 @@ impl Inner {
         let located = lock(&self.window).is_some();
         #[cfg(not(target_os = "linux"))]
         let located = false;
-        let feedback = if located {
-            feedback.filter(|(kind, ..)| *kind == 'T')
-        } else {
-            feedback
-        };
         if self.source.source_type.as_deref() == Some("Window")
             && !located
             && matches!(&message, ControlMessage::Pointer { phase, .. } if !matches!(phase, PointerPhase::Cancel))
@@ -2294,6 +2366,10 @@ impl Inner {
             self.reject(seq, "input-unavailable", "no input backend");
             return;
         }
+        // Only a located window-share press can move the cue helper: other
+        // paths have no desktop point to choose an output from.
+        #[cfg(target_os = "linux")]
+        let located_press = located && matches!(&message, ControlMessage::Pointer { .. });
         let outcome = match message {
             ControlMessage::Pointer {
                 phase,
@@ -2301,7 +2377,14 @@ impl Inner {
                 y,
                 button,
                 ..
-            } => self.pointer(phase, x, y, button, seq),
+            } => self.pointer(phase, x, y, button, seq).map(|landed| {
+                // A located window's cue goes where the press landed, or nowhere.
+                if located {
+                    feedback = feedback
+                        .zip(landed)
+                        .map(|((kind, ..), (x, y))| (kind, x, y));
+                }
+            }),
             ControlMessage::Wheel { dx, dy, .. } => self.wheel(dx, dy, seq),
             ControlMessage::Key {
                 name,
@@ -2330,6 +2413,14 @@ impl Inner {
         };
         match outcome {
             Ok(()) => {
+                #[cfg(target_os = "linux")]
+                if located_press {
+                    // Onto the landed output before the cue is told where to
+                    // draw, so a cross-output tap draws there, not nowhere.
+                    if let Some((_, x, y)) = feedback {
+                        self.move_cue_to(x, y);
+                    }
+                }
                 if let Some((kind, x, y)) = feedback {
                     if let Ok(mut indicator) = self.indicator.lock() {
                         if let Some(indicator) = indicator.as_mut() {
@@ -2395,6 +2486,49 @@ impl Inner {
         }
     }
 
+    /// Move the agent cue helper onto the output holding desktop point
+    /// `(x, y)`, where a located press just landed. A press on the helper's
+    /// own output reuses it with no new process; anything else respawns it
+    /// with the landed origin, which selects that output through the point
+    /// helper's xdg-output selection. Best-effort: when the output or the
+    /// respawn is unavailable, the standing helper keeps the cue.
+    #[cfg(target_os = "linux")]
+    fn move_cue_to(&self, x: i64, y: i64) {
+        let output = match crate::hyprland::monitor_containing(x as f64, y as f64) {
+            Ok(output) => output,
+            Err(error) => {
+                log::warn!("agent cue stays on its output: {error}");
+                return;
+            }
+        };
+        if lock(&self.cue_output).clone() == output {
+            return;
+        }
+        let Some(name) = output else { return };
+        let mut indicator = lock(&self.indicator);
+        if let Some(helper) = indicator.take() {
+            helper.stop();
+        }
+        let (width, height) = (
+            self.source.width.max(1) as usize,
+            self.source.height.max(1) as usize,
+        );
+        match crate::indicator::Indicator::start_wayland(
+            width,
+            height,
+            true,
+            Some((x as i32, y as i32)),
+        ) {
+            Ok(helper) => {
+                *indicator = Some(helper);
+                *lock(&self.cue_output) = Some(name);
+            }
+            Err(error) => {
+                log::warn!("agent cue stays on its output: the {name} helper did not start: {error:#}");
+            }
+        }
+    }
+
     fn pointer(
         &self,
         phase: PointerPhase,
@@ -2402,7 +2536,7 @@ impl Inner {
         y: i64,
         button: i64,
         _seq: u64,
-    ) -> std::result::Result<(), (&'static str, String)> {
+    ) -> std::result::Result<Option<(i64, i64)>, (&'static str, String)> {
         let (width, height) = self.encoded_size();
         if !(0..width as i64).contains(&x) || !(0..height as i64).contains(&y) {
             return Err((
@@ -2421,19 +2555,21 @@ impl Inner {
                     .place(x, y)
                     .map_err(|message| ("input-unavailable", message))
             };
+            // The desktop point the pointer landed on, where its cue belongs.
             return match phase {
-                PointerPhase::Move => place(),
+                PointerPhase::Move => place().map(Some),
                 PointerPhase::Down => {
                     // Refused before the pointer moves: nothing could press.
                     self.with_input(|_| Ok(()))?;
-                    place()?;
-                    self.with_input(|target| target.button(Button::from_number(button), true))
+                    let point = place()?;
+                    self.with_input(|target| target.button(Button::from_number(button), true))?;
+                    Ok(Some(point))
                 }
                 PointerPhase::Up => {
                     self.with_input(|target| target.button(Button::from_number(button), false))?;
-                    place()
+                    place().map(Some)
                 }
-                PointerPhase::Cancel => self.with_input(InputTarget::release_all),
+                PointerPhase::Cancel => self.with_input(InputTarget::release_all).map(|()| None),
             };
         }
         self.with_input(|target| match phase {
@@ -2448,6 +2584,7 @@ impl Inner {
             }
             PointerPhase::Cancel => target.release_all(),
         })
+        .map(|()| None)
     }
 
     fn wheel(
@@ -2770,6 +2907,12 @@ fn auto_bitrate(width: usize, height: usize) -> u32 {
 const QUEUE_HIGH: Duration = Duration::from_millis(25);
 /// Below this the path has room again and the target may creep back up.
 const QUEUE_LOW: Duration = Duration::from_millis(10);
+/// The same thresholds for a TCP path. TCP never drops, so its queue is read
+/// as delay alone, and a relay's bridge adds 20-30 ms of delivery jitter that is
+/// not queueing: at 25/10 ms that jitter backs the target off to its floor
+/// with the link idle. Only a queue that stands over 100 ms is a backlog here.
+const QUEUE_HIGH_TCP: Duration = Duration::from_millis(100);
+const QUEUE_LOW_TCP: Duration = Duration::from_millis(60);
 /// How often queueing delay may back the target off: long enough for the last
 /// back-off to reach the far end and show in its feedback, short enough that a
 /// queue is drained in a few steps rather than a few seconds.
@@ -2791,6 +2934,8 @@ struct RateControl {
     last_change: Option<Instant>,
     /// The last queueing delay reported, while the path reports one.
     queue: Option<Duration>,
+    queue_high: Duration,
+    queue_low: Duration,
 }
 
 impl RateControl {
@@ -2809,9 +2954,21 @@ impl RateControl {
             target: ceiling,
             last_change: None,
             queue: None,
+            queue_high: QUEUE_HIGH,
+            queue_low: QUEUE_LOW,
         }
     }
 
+    /// Read queueing delay against the thresholds for the transport the selected
+    /// pair runs over.
+    fn set_tcp(&mut self, tcp: bool) {
+        (self.queue_high, self.queue_low) = if tcp {
+            (QUEUE_HIGH_TCP, QUEUE_LOW_TCP)
+        } else {
+            (QUEUE_HIGH, QUEUE_LOW)
+        };
+    }
+
     /// The new target when these loss reports (RFC 3550 fractions, /256) or
     /// this path report move it: down on a standing queue at most every
     /// `DELAY_BACKOFF_EVERY`, otherwise at most once a second.
@@ -2822,7 +2979,7 @@ impl RateControl {
         let since = self.last_change.map(|at| now.duration_since(at));
         let waited = |gap: Duration| since.is_none_or(|since| since >= gap);
         let floor = (self.ceiling / 8).max(500);
-        let next = if let Some(path) = path.filter(|path| path.queue_delay > QUEUE_HIGH) {
+        let next = if let Some(path) = path.filter(|path| path.queue_delay > self.queue_high) {
             if !waited(DELAY_BACKOFF_EVERY) {
                 return None;
             }
@@ -2834,7 +2991,7 @@ impl RateControl {
                 return None;
             }
             let loss = worst as f64 / 256.0;
-            let roomy = self.queue.is_none_or(|queue| queue < QUEUE_LOW);
+            let roomy = self.queue.is_none_or(|queue| queue < self.queue_low);
             if loss > 0.10 {
                 ((self.target as f64 * 0.7) as u32).max(floor)
             } else if loss < 0.02 && roomy {
@@ -3083,6 +3240,9 @@ fn spawn_pipeline(
                 }
                 let reports = peer.take_loss_reports();
                 let path = peer.take_path_report();
+                if path.is_some() {
+                    rate.set_tcp(handle.block_on(peer.selected_pair_is_tcp()));
+                }
                 if let Some(kbps) = rate.update(&reports, path, Instant::now()) {
                     let applied = inner.encoder.lock().map(|mut encoder| {
                         encoder
@@ -3644,6 +3804,10 @@ mod tests {
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
             #[cfg(target_os = "linux")]
             window: Mutex::new(None),
+            #[cfg(target_os = "linux")]
+            cue_output: Mutex::new(None),
+            #[cfg(target_os = "linux")]
+            point_output: Mutex::new(None),
             capture: Mutex::new(None),
             layout: Mutex::new(None),
             #[cfg(target_os = "linux")]
@@ -3723,7 +3887,7 @@ mod tests {
         )
         .await
         .expect("a peer connection builds without a network");
-        test_inner_with(events, peer, 64, 64)
+        test_inner_with(events, Arc::new(peer), 64, 64)
     }
 
     #[cfg(target_os = "linux")]
@@ -3858,7 +4022,7 @@ mod tests {
 
     fn test_inner_with(
         events: tokio_mpsc::UnboundedSender<Notice>,
-        peer: VideoPeer,
+        peer: Arc<VideoPeer>,
         width: usize,
         height: usize,
     ) -> (Arc<Inner>, Arc<Mutex<Vec<(i16, bool)>>>) {
@@ -3886,7 +4050,7 @@ mod tests {
             latest: Arc::new(Mutex::new(None)),
             capture_error: Arc::new(Mutex::new(None)),
             frame_changes: tokio::sync::watch::channel(0).1,
-            peer: Mutex::new(Some(Arc::new(peer))),
+            peer: Mutex::new(Some(peer)),
             encoder: Mutex::new(Some(VideoEncoder::Vp9(
                 Encoder::new(width, height, 1000, 30, 1).expect("an encoder"),
             ))),
@@ -3905,6 +4069,10 @@ mod tests {
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
             #[cfg(target_os = "linux")]
             window: Mutex::new(None),
+            #[cfg(target_os = "linux")]
+            cue_output: Mutex::new(None),
+            #[cfg(target_os = "linux")]
+            point_output: Mutex::new(None),
             layout: Mutex::new(Some(Layout::from_environment().expect("a keymap"))),
             #[cfg(target_os = "linux")]
             audio: Mutex::new(None),
@@ -4484,7 +4652,7 @@ mod tests {
         let codec = crate::peer::tests::h264_receiver_codec();
         let (peer, _) = crate::peer::tests::answered(vec![codec.clone()]).await;
         let (events, mut received) = tokio_mpsc::unbounded_channel();
-        let (inner, _) = test_inner_with(events, peer, 64, 64);
+        let (inner, _) = test_inner_with(events, Arc::new(peer), 64, 64);
         let session = Session { inner };
         let mut offers = Vec::new();
         for _ in 0..3 {
@@ -4656,6 +4824,72 @@ mod tests {
         assert_eq!((later.codec, later.encoder), ("vp9", "libvpx"));
     }
 
+    /// The rate target after 3 s of delivery jitter on a connected pair: a queue
+    /// that alternates between 5 and 30 ms with nothing lost, and 800 kbps
+    /// delivered. The pipeline runs for real; only the path reports are fed.
+    async fn target_under_bridge_jitter(tcp: bool) -> u32 {
+        let peers = crate::peer::tests::connected(
+            if tcp {
+                Vec::new()
+            } else {
+                vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))]
+            },
+            if tcp {
+                vec![std::net::SocketAddr::from(([127, 0, 0, 1], 0))]
+            } else {
+                Vec::new()
+            },
+            tcp,
+        )
+        .await;
+        let engine = Arc::clone(&peers.engine);
+        assert_eq!(
+            engine.selected_pair_is_tcp().await,
+            tcp,
+            "the selected pair must run over {}",
+            if tcp { "TCP" } else { "UDP" }
+        );
+        let (events, _events_rx) = tokio_mpsc::unbounded_channel();
+        let (inner, _recorded) = test_inner_with(events, Arc::clone(&engine), 64, 64);
+        let (_frame_tx, frame_rx) = latest_frame();
+        spawn_pipeline(
+            &inner,
+            Arc::clone(&engine),
+            frame_rx,
+            Arc::new(AtomicBool::new(true)),
+            30,
+            1000,
+        );
+        for step in 0..300 {
+            let queue_delay = Duration::from_millis(if step % 2 == 0 { 5 } else { 30 });
+            engine.report_path(PathReport {
+                queue_delay,
+                delivered_kbps: 800,
+            });
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+        let target = inner.metrics.lock().unwrap().target_kbps;
+        drop(peers);
+        target
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn a_tcp_path_with_bridge_jitter_holds_its_rate_ceiling() {
+        assert_eq!(
+            target_under_bridge_jitter(true).await,
+            1000,
+            "a 5-30 ms jitter that is not a queue must not back a TCP path off"
+        );
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn a_udp_path_with_the_same_jitter_still_backs_off() {
+        assert!(
+            target_under_bridge_jitter(false).await < 1000,
+            "a UDP path reads the same 30 ms as a standing queue and must back off"
+        );
+    }
+
     #[tokio::test]
     async fn a_receiver_that_asks_for_h264_is_sent_h264_from_the_first_frame() {
         let Some(info) = tokio::task::spawn_blocking(crate::h264::probe)
@@ -4668,7 +4902,7 @@ mod tests {
         let (peer, _answer) =
             crate::peer::tests::answered(vec![crate::peer::tests::h264_receiver_codec()]).await;
         let (events, _events_rx) = tokio_mpsc::unbounded_channel();
-        let (inner, _recorded) = test_inner_with(events, peer, 320, 240);
+        let (inner, _recorded) = test_inner_with(events, Arc::new(peer), 320, 240);
         // The answer is real, so ICE runs and, with no candidates, never
         // connects; each state it reports would take back `assume_connected`.
         let pinned = current_peer(&inner).expect("the test's peer");

package/engine/vendor/rtc-ice/DESKLINK-PATCH.md

@@ -97,8 +97,8 @@ No public API changed; no signalling or wire change.
 
 Do this once upstream rtc-ice keeps the previous selected pair across a restart
 on its own and nominates a freshly validated pair without waiting for the next
-check tick (an upstream PR is a follow-up; it needs the captain's word first,
-since it would carry his name).
+check tick (an upstream PR is a follow-up; that needs a maintainer decision first,
+since the contribution would carry its author's name).
 
 ## Dev-only measurement instrumentation (not part of the patch)
 

package/engine/vendor/rtc-ice/src/agent/agent_selector.rs

@@ -10,7 +10,7 @@ use stun::textattrs::*;
 
 use crate::attributes::{control::*, priority::*, use_candidate::*};
 use crate::candidate::{candidate_pair::*, *};
-// desklink scout trace (dl-roam-postnom-attr):
+// desklink scout trace: dev-only ICE timeline instrumentation.
 use crate::dl_trace;
 use crate::dl_trace::dl_ice;
 

package/engine/vendor/rtc-ice/src/agent/mod.rs

@@ -38,7 +38,7 @@ use stun::xoraddr::*;
 
 use crate::candidate::candidate_peer_reflexive::CandidatePeerReflexiveConfig;
 use crate::candidate::{candidate_pair::*, *};
-// desklink scout trace (dl-roam-postnom-attr):
+// desklink scout trace: dev-only ICE timeline instrumentation.
 use crate::dl_trace;
 use crate::dl_trace::dl_ice;
 use crate::mdns::{MulticastDnsMode, create_multicast_dns, generate_multicast_dns_name};

package/engine/vendor/rtc-ice/src/dl_trace.rs

@@ -1,7 +1,7 @@
 //! desklink scout instrumentation (dev-only, `DESKLINK_ICE_TRACE=1`).
 //!
 //! Timestamped stderr trace of the ICE agent's restart/check/nomination timeline
-//! for task dl-roam-postnom-attr. Not part of the shipped patch; see
+//! for ICE restart diagnosis. Not part of the shipped patch; see
 //! DESKLINK-PATCH.md. Every call site is marked `// desklink scout trace:` so the
 //! whole diff is trivially droppable.
 

package/engine/vendor/rtc-ice/src/lib.rs

@@ -58,7 +58,7 @@
 /// without adding — and version-matching — a direct `rtc-crypto` dependency.
 pub use crypto;
 
-// desklink scout trace: dev-only ICE timeline instrumentation (dl-roam-postnom-attr).
+// desklink scout trace: dev-only ICE timeline instrumentation.
 pub(crate) mod dl_trace;
 
 pub mod agent;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@desklink/host",
-    "version": "0.5.7",
+    "version": "0.5.9",
     "license": "Apache-2.0",
     "repository": {
         "type": "git",
@@ -38,7 +38,7 @@
         "ws": "8.21.3"
     },
     "optionalDependencies": {
-        "@desklink/host-linux-x64-gnu": "0.5.7",
-        "@desklink/host-darwin-arm64": "0.5.7"
+        "@desklink/host-linux-x64-gnu": "0.5.9",
+        "@desklink/host-darwin-arm64": "0.5.9"
     }
 }