@desklink/host 0.5.6 → 0.5.7

package/docs/PROTOCOL.md

@@ -198,7 +198,9 @@ build has, not what this machine can necessarily use.
 
 `input.unavailable_reason` and `input.grant` describe the portal/uinput path:
 without kernel input access a portal session opens and captures, but input
-messages are refused with `input-unavailable`. X display capture uses XTest
+messages are refused with `input-unavailable`. A Hyprland window share's
+pointer moves are the exception: they warp through Hyprland's own IPC instead
+of any device (see Input and clipboard). X display capture uses XTest
 instead and does not require that grant. The engine probes XTest on that named
 display; if it is unavailable, capture and clipboard still open, and input
 messages are refused with `input-unavailable`. X11 clipboard uses CLIPBOARD on the
@@ -270,7 +272,9 @@ animating in and out, with light and dark keylines so it reads on any content.
 On Wayland it uses a click-through layer-shell surface with an edge glow, drawn
 at the highest announced output integer scale, capped at 4; its bounded area is
 masked before capture/diff (pixels behind the effect can remain briefly stale).
-On bare X11 it is an override-redirect, click-through window that follows the
+On a located Hyprland window share the cue gets no pointer or click feedback —
+the engine places the pointer itself, so a stream fraction is not the window's
+desktop point (see Input and clipboard); keys still show. On bare X11 it is an override-redirect, click-through window that follows the
 pointer, so it stays
 visible over windows that set their own cursor and never replaces the cursor.
 Its size follows `Xft.dpi` from 96–384 DPI, defaulting to 1x otherwise;
@@ -688,6 +692,25 @@ so a tap would land at the same fraction of the desktop instead of on the
 window. Keys, text, wheel, pointer `cancel` and `release_all` are unaffected;
 share the monitor to point and click.
 
+On Hyprland the engine places the pointer itself. Hyprland announces each
+window share by title on its event socket, and the engine takes the one window
+in `j/clients` with that title and the stream's size. That match runs once, at
+the first tap, and the announcement says nothing else about which share it is:
+if the shared window's title changes before that first tap and another window
+of the stream's size now carries the announced title, taps land on the other
+window; and when two window shares are announced at once (another session, or
+any other consumer of the portal), the engine cannot tell which announcement
+is this share's, so every tap refuses with `input-unavailable` for the
+session's lifetime. Each `move`, `down` and
+`up` warps the pointer to the window's current position plus the local point
+(so a window moved after the share started still maps); buttons and keys go
+through the input device as before. A tap is still refused with
+`input-unavailable` when the window cannot be told apart (no announcement,
+no such window, or several that look alike), when it has closed or sits on a
+hidden workspace, when another window covers the tapped point or a layer
+surface sits over it, or when the window hangs off screen. Other compositors
+keep the refusal above.
+
 The engine holds its own pressed-key/button state. `close`, `release_all`,
 control-channel loss and process exit all synthesize releases for exactly the
 keys and buttons this session pressed, so a dropped connection cannot leave a

package/engine/Cargo.lock

@@ -536,7 +536,7 @@ checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 
 [[package]]
 name = "desklink-host"
-version = "0.5.6"
+version = "0.5.7"
 dependencies = [
  "anyhow",
  "ashpd",

package/engine/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "desklink-host"
-version = "0.5.6"
+version = "0.5.7"
 edition = "2021"
 rust-version = "1.97.1"
 license = "Apache-2.0"

package/engine/src/capture.rs

@@ -303,7 +303,6 @@ fn run_loop(
         *pw::keys::MEDIA_CATEGORY => "Capture",
         *pw::keys::MEDIA_ROLE => "Screen",
     };
-    props.insert(*pw::keys::TARGET_OBJECT, node_id.to_string());
     let stream = pw::stream::StreamBox::new(&core, "desklink-capture", props)
         .context("pw_stream_new failed")?;
 

package/engine/src/hyprland.rs

@@ -0,0 +1,319 @@
+//! Where a shared window sits on a Hyprland desktop, from Hyprland's own IPC.
+//!
+//! Hyprland's ScreenCast portal reports every stream at (0, 0) and never says
+//! which window was picked, while the pointer device spans the whole desktop.
+//! Hyprland itself announces each window share by title on its event socket
+//! (`screencastv2>>1,window,<title>`) and lists every window's place in
+//! `j/clients`. So the shared window is the one with that title and the
+//! stream's size, followed by its address from then on, and the pointer goes
+//! onto it through Hyprland's own cursor warp at the window's current place:
+//! a window moved after the share started still maps. Anything less certain
+//! (no announcement, no such window, two alike, a window off screen) is a
+//! refusal, never a guess.
+
+use serde_json::Value;
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::Shutdown;
+use std::os::unix::net::UnixStream;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex, MutexGuard};
+
+use crate::session::WINDOW_POINTER_REFUSAL as UNKNOWN;
+
+fn instance() -> Option<PathBuf> {
+    let signature = std::env::var_os("HYPRLAND_INSTANCE_SIGNATURE")?;
+    let runtime = std::env::var_os("XDG_RUNTIME_DIR")?;
+    Some(PathBuf::from(runtime).join("hypr").join(signature))
+}
+
+fn lock<T>(mutex: &Mutex<T>) -> MutexGuard<'_, T> {
+    mutex
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner())
+}
+
+/// Hyprland's window-share announcements, heard from before the portal asks
+/// for consent. Dropping it closes the event socket, which ends its reader.
+pub struct ShareWatch {
+    socket: UnixStream,
+    titles: Arc<Mutex<Vec<String>>>,
+}
+
+impl ShareWatch {
+    /// `None` when this is not a Hyprland session.
+    pub fn start() -> Option<Self> {
+        let socket = UnixStream::connect(instance()?.join(".socket2.sock")).ok()?;
+        let reader = socket.try_clone().ok()?;
+        let titles = Arc::new(Mutex::new(Vec::new()));
+        let heard = titles.clone();
+        std::thread::spawn(move || {
+            for line in BufReader::new(reader).lines().map_while(Result::ok) {
+                if let Some(title) = line.strip_prefix("screencastv2>>1,window,") {
+                    lock(&heard).push(title.to_owned());
+                }
+            }
+        });
+        Some(Self { socket, titles })
+    }
+}
+
+impl Drop for ShareWatch {
+    fn drop(&mut self) {
+        let _ = self.socket.shutdown(Shutdown::Both);
+    }
+}
+
+/// The window a portal window share shows, placed by Hyprland.
+pub struct WindowLocator {
+    watch: ShareWatch,
+    /// The stream's own pixel size, which the window's size times its
+    /// monitor's scale must match.
+    source: (i64, i64),
+    address: Mutex<Option<String>>,
+    /// Whether this Hyprland reads a Lua config, whose `dispatch` takes Lua.
+    lua: Mutex<Option<bool>>,
+}
+
+impl WindowLocator {
+    pub fn new(watch: ShareWatch, width: i32, height: i32) -> Self {
+        Self {
+            watch,
+            source: (i64::from(width.max(1)), i64::from(height.max(1))),
+            address: Mutex::new(None),
+            lua: Mutex::new(None),
+        }
+    }
+
+    /// Put the pointer on `(x, y)` in the shared window's own pixels.
+    pub fn place(&self, x: i64, y: i64) -> Result<(), String> {
+        let (clients, monitors) = (query("j/clients")?, query("j/monitors")?);
+        let clients = clients.as_array().map(Vec::as_slice).unwrap_or_default();
+        // A window nobody sees has no point on the screen.
+        let shown = |window: &Value| {
+            let workspace = &window["workspace"]["id"];
+            window["mapped"].as_bool() != Some(false)
+                && window["hidden"].as_bool() != Some(true)
+                && (window["pinned"].as_bool() == Some(true)
+                    || monitors.as_array().into_iter().flatten().any(|monitor| {
+                        &monitor["activeWorkspace"]["id"] == workspace
+                            || &monitor["specialWorkspace"]["id"] == workspace
+                    }))
+        };
+        let mut address = lock(&self.address);
+        if address.is_none() {
+            *address = Some(self.identify(clients, &monitors)?);
+        }
+        let index = clients
+            .iter()
+            .position(|client| client["address"].as_str() == address.as_deref())
+            .ok_or("a shared window cannot take taps: the window has closed")?;
+        let window = &clients[index];
+        if !shown(window) {
+            return Err(String::from(
+                "a shared window cannot take taps while it is on a hidden workspace",
+            ));
+        }
+        let (left, top, width, height) = bounds(window).ok_or(UNKNOWN)?;
+        let (source_w, source_h) = self.source;
+        let (px, py) = (
+            left + x as f64 * width / source_w as f64,
+            top + y as f64 * height / source_h as f64,
+        );
+        // Hyprland clamps the cursor to the screen edge, so a point off every
+        // monitor would press something else or nothing.
+        let on_screen = monitors.as_array().into_iter().flatten().any(|monitor| {
+            let scale = monitor["scale"].as_f64().filter(|scale| *scale > 0.0);
+            monitor["disabled"].as_bool() != Some(true)
+                && matches!(
+                    (
+                        monitor["x"].as_f64(),
+                        monitor["y"].as_f64(),
+                        monitor["width"].as_f64(),
+                        monitor["height"].as_f64(),
+                        scale
+                    ),
+                    (Some(mx), Some(my), Some(mw), Some(mh), Some(scale))
+                        if (mx..mx + mw / scale).contains(&px)
+                            && (my..my + mh / scale).contains(&py)
+                )
+        });
+        if !on_screen {
+            return Err(String::from(
+                "a shared window cannot take taps where it hangs off screen",
+            ));
+        }
+        // Hyprland draws tiled windows, then floating ones, then fullscreen
+        // ones, and pinned ones above all; j/clients lists them in the
+        // compositor's own stacking order, so a later layer-mate holding the
+        // point is what a press there would reach. A floating window let over
+        // fullscreen draws above it, but j/clients cannot tell that one from
+        // any floating window, so either pairing over the point is a refusal.
+        let layer = |w: &Value| {
+            if w["pinned"].as_bool() == Some(true) {
+                3
+            } else if w["fullscreen"].as_i64().is_some_and(|mode| mode > 0) {
+                2
+            } else {
+                u8::from(w["floating"].as_bool() == Some(true))
+            }
+        };
+        let covered = clients.iter().enumerate().any(|(i, other)| {
+            shown(other)
+                && bounds(other).is_some_and(|(l, t, w, h)| {
+                    (l..l + w).contains(&px) && (t..t + h).contains(&py)
+                })
+                && match (layer(other), layer(window), i > index) {
+                    (1, 2, _) | (2, 1, _) => true,
+                    (above, own, later) => above > own || (above == own && later),
+                }
+        });
+        if covered {
+            return Err(String::from(
+                "a shared window cannot take taps where another window covers it",
+            ));
+        }
+        // Bars, notifications and other layer surfaces draw above windows and
+        // are absent from the window-only video: a top or overlay one holding
+        // the point is what a press there would reach. Their boxes come local
+        // to their monitor, which j/monitors places.
+        let anchored = |name: &str| -> Option<(f64, f64)> {
+            for monitor in monitors.as_array().into_iter().flatten() {
+                if monitor["name"].as_str() == Some(name) {
+                    return Some((monitor["x"].as_f64()?, monitor["y"].as_f64()?));
+                }
+            }
+            None
+        };
+        let overlaid = query("j/layers")?
+            .as_object()
+            .into_iter()
+            .flatten()
+            .map(|(name, monitor)| Some((anchored(name)?, monitor)))
+            .collect::<Option<Vec<((f64, f64), &Value)>>>()
+            .ok_or(String::from(
+                "a shared window cannot take taps: a screen's layers are unknown",
+            ))?
+            .into_iter()
+            .any(|((mx, my), monitor)| {
+                monitor["levels"]
+                    .as_object()
+                    .into_iter()
+                    .flatten()
+                    .any(|(level, surfaces)| {
+                        let level = level.parse::<u8>().unwrap_or(0);
+                        (level >= 2)
+                            && surfaces.as_array().into_iter().flatten().any(|surface| {
+                                let (sx, sy) = (surface["x"].as_f64(), surface["y"].as_f64());
+                                let (sw, sh) = (surface["w"].as_f64(), surface["h"].as_f64());
+                                !matches!(
+                                    surface["namespace"].as_str(),
+                                    Some("desklink-agent" | "desklink-point")
+                                ) && matches!(
+                                    (sx, sy, sw, sh),
+                                    (Some(sx), Some(sy), Some(sw), Some(sh))
+                                        if (mx + sx..mx + sx + sw).contains(&px)
+                                            && (my + sy..my + sy + sh).contains(&py)
+                                )
+                            })
+                    })
+            });
+        if overlaid {
+            return Err(String::from(
+                "a shared window cannot take taps where an overlay covers it",
+            ));
+        }
+        self.warp((px.floor() as i64, py.floor() as i64))
+    }
+
+    /// The address of the one window Hyprland said it is sharing.
+    fn identify(&self, clients: &[Value], monitors: &Value) -> Result<String, String> {
+        let mut titles = lock(&self.watch.titles).clone();
+        titles.dedup();
+        let [title] = titles.as_slice() else {
+            return Err(String::from(UNKNOWN));
+        };
+        let (source_w, source_h) = self.source;
+        let scale = |monitor: &Value| {
+            monitors
+                .as_array()
+                .into_iter()
+                .flatten()
+                .find(|m| &m["id"] == monitor)
+                .and_then(|m| m["scale"].as_f64())
+        };
+        let alike: Vec<&Value> = clients
+            .iter()
+            .filter(|client| {
+                let size = |i: usize| client["size"][i].as_f64();
+                client["title"].as_str() == Some(title.as_str())
+                    && client["mapped"].as_bool() != Some(false)
+                    && client["hidden"].as_bool() != Some(true)
+                    && matches!(
+                        (size(0), size(1), scale(&client["monitor"])),
+                        (Some(w), Some(h), Some(s))
+                            if ((w * s).round() as i64 - source_w).abs() <= 1
+                                && ((h * s).round() as i64 - source_h).abs() <= 1
+                    )
+            })
+            .collect();
+        match alike.as_slice() {
+            [window] => window["address"]
+                .as_str()
+                .map(str::to_owned)
+                .ok_or_else(|| String::from(UNKNOWN)),
+            [] => Err(String::from(UNKNOWN)),
+            _ => Err(format!(
+                "a shared window cannot take taps: {} windows look like it; share the whole screen to point and click",
+                alike.len()
+            )),
+        }
+    }
+
+    fn warp(&self, (x, y): (i64, i64)) -> Result<(), String> {
+        let legacy = format!("dispatch movecursor {x} {y}");
+        let lua = format!("dispatch hl.dsp.cursor.move({{ x = {x}, y = {y} }})");
+        let mut dialect = lock(&self.lua);
+        let tries: &[(bool, &str)] = match *dialect {
+            Some(true) => &[(true, &lua)],
+            Some(false) => &[(false, &legacy)],
+            None => &[(false, &legacy), (true, &lua)],
+        };
+        let mut said = String::new();
+        for (is_lua, command) in tries {
+            said = request(command)?;
+            if said.trim() == "ok" {
+                *dialect = Some(*is_lua);
+                return Ok(());
+            }
+        }
+        Err(format!(
+            "Hyprland did not move the pointer: {}",
+            said.trim()
+        ))
+    }
+}
+
+/// A window's box in the layout: left, top, width, height.
+fn bounds(window: &Value) -> Option<(f64, f64, f64, f64)> {
+    let pair = |key: &str| Some((window[key][0].as_f64()?, window[key][1].as_f64()?));
+    let ((left, top), (width, height)) = pair("at").zip(pair("size"))?;
+    Some((left, top, width, height))
+}
+
+fn request(command: &str) -> Result<String, String> {
+    let ask = || -> std::io::Result<String> {
+        let path = instance()
+            .ok_or_else(|| std::io::Error::other("HYPRLAND_INSTANCE_SIGNATURE is not set"))?;
+        let mut socket = UnixStream::connect(path.join(".socket.sock"))?;
+        socket.write_all(command.as_bytes())?;
+        let mut reply = String::new();
+        socket.read_to_string(&mut reply)?;
+        Ok(reply)
+    };
+    ask().map_err(|error| format!("Hyprland's control socket did not answer: {error}"))
+}
+
+fn query(command: &str) -> Result<Value, String> {
+    serde_json::from_str(&request(command)?)
+        .map_err(|error| format!("Hyprland's {command} was not JSON: {error}"))
+}

package/engine/src/main.rs

@@ -45,6 +45,8 @@ mod h264_openh264;
 mod h264_vaapi;
 #[cfg(all(target_os = "macos", desklink_vpx))]
 mod h264_vt;
+#[cfg(target_os = "linux")]
+mod hyprland;
 #[cfg(any(
     target_os = "linux",
     all(any(target_os = "macos", target_os = "windows"), desklink_vpx)

package/engine/src/session.rs

@@ -816,6 +816,11 @@ struct Inner {
     point_overlay: Mutex<Option<crate::indicator::Indicator>>,
     #[cfg(target_os = "linux")]
     point_desktop: PointDesktop,
+    /// A portal window share's place on a Hyprland desktop; absent elsewhere,
+    /// where a shared window's taps are refused. Dropped on close, which
+    /// closes its Hyprland event socket.
+    #[cfg(target_os = "linux")]
+    window: Mutex<Option<crate::hyprland::WindowLocator>>,
     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.
@@ -1195,6 +1200,8 @@ impl Session {
                 None
             };
         let mut cursor_info = serde_json::json!({"mode":"embedded", "positions":false});
+        #[cfg(target_os = "linux")]
+        let mut share_watch = None;
         let Selected {
             source,
             capture,
@@ -1225,6 +1232,9 @@ impl Session {
                     _ => {
                         #[cfg(target_os = "linux")]
                         {
+                            // Hyprland names the window it shares only on its
+                            // event socket, as the share starts.
+                            share_watch = crate::hyprland::ShareWatch::start();
                             portal::open(request.restore_token.as_deref(), request.cursor).await
                         }
                         #[cfg(not(target_os = "linux"))]
@@ -1354,6 +1364,10 @@ impl Session {
         let source_w = source.width.max(1) as usize;
         let source_h = source.height.max(1) as usize;
         let (width, height) = fit(source_w, source_h, request.max_width, request.max_height);
+        #[cfg(target_os = "linux")]
+        let window = share_watch
+            .filter(|_| source.source_type.as_deref() == Some("Window"))
+            .map(|watch| crate::hyprland::WindowLocator::new(watch, source.width, source.height));
 
         let bitrate_kbps = if request.bitrate_kbps == 0 {
             auto_bitrate(width, height)
@@ -1469,6 +1483,8 @@ impl Session {
             } else {
                 PointDesktop::Wayland
             },
+            #[cfg(target_os = "linux")]
+            window: Mutex::new(window),
             capture: Mutex::new(Some(capture)),
             layout: Mutex::new(Some(layout)),
             #[cfg(target_os = "linux")]
@@ -1567,6 +1583,8 @@ impl Session {
             point_overlay: Mutex::new(None),
             #[cfg(target_os = "linux")]
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
+            #[cfg(target_os = "linux")]
+            window: Mutex::new(None),
             capture: Mutex::new(None),
             layout: Mutex::new(None),
             #[cfg(target_os = "linux")]
@@ -2118,6 +2136,8 @@ impl Inner {
         drop(capture);
         #[cfg(target_os = "linux")]
         drop(self.audio.lock().ok().and_then(|mut held| held.take()));
+        #[cfg(target_os = "linux")]
+        drop(lock(&self.window).take());
         self.notify(SessionEvent::State {
             capture: "ended",
             transport: String::from("closed"),
@@ -2245,17 +2265,31 @@ impl Inner {
         }
         // A shared window's place on the desktop is unknown (the portal reports
         // no origin for it), while the pointer device spans the whole desktop:
-        // a tap would land somewhere the person never pointed.
+        // a tap would land somewhere the person never pointed. Only Hyprland
+        // says where the window is.
+        #[cfg(target_os = "linux")]
+        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))
         {
             self.reject(seq, "input-unavailable", WINDOW_POINTER_REFUSAL);
             return;
         }
+        // A located window's pointer moves through the compositor; only its
+        // buttons need the input device, which `pointer` checks first.
         if !matches!(
             &message,
             ControlMessage::ClipboardRead { .. } | ControlMessage::ClipboardWrite { .. }
-        ) && lock(&self.input).is_none()
+        ) && !(located && matches!(&message, ControlMessage::Pointer { .. }))
+            && lock(&self.input).is_none()
         {
             self.reject(seq, "input-unavailable", "no input backend");
             return;
@@ -2380,6 +2414,28 @@ impl Inner {
         // created for, and clamps to, the source's own pixels. One conversion
         // here keeps every caller honest.
         let (x, y) = to_source_pixels(x, y, (width, height), &self.source);
+        #[cfg(target_os = "linux")]
+        if let Some(window) = lock(&self.window).as_ref() {
+            let place = || {
+                window
+                    .place(x, y)
+                    .map_err(|message| ("input-unavailable", message))
+            };
+            return match phase {
+                PointerPhase::Move => place(),
+                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))
+                }
+                PointerPhase::Up => {
+                    self.with_input(|target| target.button(Button::from_number(button), false))?;
+                    place()
+                }
+                PointerPhase::Cancel => self.with_input(InputTarget::release_all),
+            };
+        }
         self.with_input(|target| match phase {
             PointerPhase::Move => target.move_absolute(x, y),
             PointerPhase::Down => {
@@ -3407,7 +3463,10 @@ fn spawn_peer_events(inner: &Arc<Inner>, mut events: tokio_mpsc::UnboundedReceiv
                     // desklink scout trace: the session's transport emit, one
                     // line after the peer event that caused it.
                     if crate::peer::dl_trace_on() {
-                        crate::peer::dl_eng!("session_transport_emit {}", format!("{state}").to_lowercase());
+                        crate::peer::dl_eng!(
+                            "session_transport_emit {}",
+                            format!("{state}").to_lowercase()
+                        );
                     }
                 }
                 PeerEvent::ControlOpen => {
@@ -3467,7 +3526,7 @@ fn available_parallelism() -> usize {
         .unwrap_or(4)
 }
 
-const WINDOW_POINTER_REFUSAL: &str = "a shared window cannot take taps: its place on the desktop is unknown; share the whole screen to point and click";
+pub(crate) const WINDOW_POINTER_REFUSAL: &str = "a shared window cannot take taps: its place on the desktop is unknown; share the whole screen to point and click";
 
 /// Encoded-surface pixels to the source's own pixels. The client aims at what it
 /// sees; the applier is sized and clamped to the source, so the layout origin
@@ -3583,6 +3642,8 @@ mod tests {
             point_overlay: Mutex::new(None),
             #[cfg(target_os = "linux")]
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
+            #[cfg(target_os = "linux")]
+            window: Mutex::new(None),
             capture: Mutex::new(None),
             layout: Mutex::new(None),
             #[cfg(target_os = "linux")]
@@ -3842,6 +3903,8 @@ mod tests {
             point_overlay: Mutex::new(None),
             #[cfg(target_os = "linux")]
             point_desktop: PointDesktop::Unavailable("layer_shell_unavailable"),
+            #[cfg(target_os = "linux")]
+            window: Mutex::new(None),
             layout: Mutex::new(Some(Layout::from_environment().expect("a keymap"))),
             #[cfg(target_os = "linux")]
             audio: Mutex::new(None),

package/package.json

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