@desklink/host 0.5.8 → 0.5.10

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.
@@ -714,6 +714,8 @@ pub struct OpenRequest {
     pub local_frames: bool,
     /// Capture the desktop's own system audio for `session.audio`.
     pub audio: bool,
+    /// Listen to the desktop's own pointer buttons, cursor and keys.
+    pub observe_input: bool,
 }
 
 /// Events a session raises for its consumer.
@@ -755,6 +757,11 @@ pub enum SessionEvent {
     Input {
         input: serde_json::Value,
     },
+    /// A pointer button or key the person pressed, observed rather than applied.
+    Observed {
+        timestamp_us: u64,
+        input: crate::protocol::ObservedInput,
+    },
     /// The far end needs a fresh reference frame and only the consumer can make
     /// one: the encoder for this track is on its side. Raised by an RTCP PLI or
     /// FIR, and once when the transport connects, because everything sent before
@@ -762,6 +769,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 +835,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.
@@ -840,6 +861,9 @@ struct Inner {
     #[cfg(target_os = "linux")]
     audio: Mutex<Option<crate::audio::AudioCapture>>,
     cursor_info: serde_json::Value,
+    /// `session.open`'s `inputObservation` member, fixed when the session opened.
+    observation: serde_json::Value,
+    observer: Mutex<Option<crate::observe::Tap>>,
 }
 
 /// A source whose video arrives already encoded.
@@ -964,6 +988,7 @@ pub fn capabilities() -> serde_json::Value {
             }),
         ),
     };
+    let observe = crate::input::observe_probe();
     serde_json::json!({
         "protocol": crate::protocol::PROTOCOL_VERSION,
         "engine": format!("desklink-host/{}", env!("CARGO_PKG_VERSION")),
@@ -995,6 +1020,11 @@ pub fn capabilities() -> serde_json::Value {
             "layout": keymap::LayoutNames::from_environment().identity(),
             "unavailable_reason": unavailable,
             "grant": input_grant,
+            "observe": {
+                "mechanism": "cgeventtap",
+                "grant": if observe.is_ok() { "granted" } else { "missing-input-monitoring" },
+                "unavailable_reason": observe.as_ref().err().map(|e| serde_json::json!({"reason": e.reason, "remedy": e.remedy})),
+            },
         },
         "clipboard": { "read": true, "write": true, "mime": ["text/plain;charset=utf-8"],
             "maxBytes": clipboard::MAX_CLIPBOARD_BYTES },
@@ -1274,8 +1304,11 @@ impl Session {
                     share_watch.is_some() && source.source_type.as_deref() == Some("Window");
                 #[cfg(target_os = "linux")]
                 if request.agent_indicator {
+                    // 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)
+                        crate::indicator::Indicator::start_wayland(source_w, source_h, desktop, None)
                             .ok();
                 }
                 #[cfg(target_os = "macos")]
@@ -1463,6 +1496,29 @@ impl Session {
             "origin": { "x": source.origin_x, "y": source.origin_y },
         });
 
+        // Observation is an addition to the stream, never a condition of it: a
+        // desktop that cannot be observed still streams, and the reply says why.
+        let observed = request.observe_input.then(|| {
+            let sink: crate::observe::Sink = {
+                let events = events.clone();
+                let id = id.clone();
+                Arc::new(move |observation| {
+                    let event = match observation {
+                        crate::observe::Observation::Input { timestamp_us, input } => {
+                            SessionEvent::Observed { timestamp_us, input }
+                        }
+                        crate::observe::Observation::Cursor(position) => SessionEvent::Cursor { position },
+                    };
+                    let _ = events.send(Notice { session_id: id.clone(), event });
+                })
+            };
+            crate::observe::start(source.node_id, (source_w, source_h), sink)
+        });
+        if let Some(Err(error)) = &observed {
+            log::warn!("input observation unavailable: {} ({})", error.reason, error.code);
+        }
+        let observation = crate::observe::status(observed.as_ref());
+
         let pipeline = Arc::new(AtomicBool::new(true));
         let inner = Arc::new(Inner {
             id,
@@ -1493,6 +1549,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")]
@@ -1505,6 +1565,8 @@ impl Session {
             encoded: Mutex::new(None),
             local_frames: request.local_frames,
             cursor_info,
+            observation,
+            observer: Mutex::new(observed.and_then(Result::ok)),
         });
 
         inner.notify(SessionEvent::Description {
@@ -1593,6 +1655,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")]
@@ -1616,6 +1682,13 @@ impl Session {
             })),
             local_frames: false,
             cursor_info: serde_json::json!({"mode":"unavailable", "positions":false}),
+            observation: serde_json::json!({
+                "observing": false,
+                "code": "unsupported-source",
+                "reason": "consumer-encoded video has no desktop of its own to observe",
+                "remedy": "observe the device where its pixels come from",
+            }),
+            observer: Mutex::new(None),
         });
         inner.notify(SessionEvent::State {
             capture: "consented",
@@ -1681,6 +1754,10 @@ impl Session {
         &self.inner.cursor_info
     }
 
+    pub fn observation_info(&self) -> &serde_json::Value {
+        &self.inner.observation
+    }
+
     pub fn geometry(&self) -> &serde_json::Value {
         &self.inner.geometry
     }
@@ -1739,6 +1816,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
@@ -1763,21 +1844,35 @@ impl Session {
             ));
         }
         // A located window's point shows where a press there would land, on
-        // the output holding it; the next may land on another output, so each
-        // gets its own helper.
+        // 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))?;
-                if let Some(helper) = overlay.take() {
-                    helper.stop();
-                }
                 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")]
@@ -2133,12 +2228,19 @@ impl Inner {
         // handlers, and `shutdown` exits right after this. The encode thread
         // finds it gone and stops.
         drop(lock(&self.encoder).take());
+        // Stop listening to the person's keys the moment the session ends.
+        drop(lock(&self.observer).take());
         if let Ok(mut indicator) = self.indicator.lock() {
             indicator.take();
         }
         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() {
@@ -2318,6 +2420,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,
@@ -2361,6 +2467,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() {
@@ -2426,6 +2540,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,
@@ -2804,6 +2961,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.
@@ -2825,6 +2988,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 {
@@ -2843,9 +3008,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.
@@ -2856,7 +3033,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;
             }
@@ -2868,7 +3045,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 {
@@ -3117,6 +3294,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
@@ -3678,6 +3858,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")]
@@ -3699,6 +3883,8 @@ mod tests {
             })),
             local_frames: false,
             cursor_info: serde_json::json!({"mode":"unavailable", "positions":false}),
+            observation: serde_json::json!({"observing": false}),
+            observer: Mutex::new(None),
         });
         spawn_peer_events(&inner, peer_events_rx);
         spawn_encoded(&inner, feed_rx);
@@ -3757,7 +3943,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")]
@@ -3892,7 +4078,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)>>>) {
@@ -3920,7 +4106,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"),
             ))),
@@ -3939,6 +4125,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),
@@ -3950,6 +4140,8 @@ mod tests {
             encoded: Mutex::new(None),
             local_frames: true,
             cursor_info: serde_json::json!({"mode":"embedded", "positions":false}),
+            observation: serde_json::json!({"observing": false}),
+            observer: Mutex::new(None),
         });
         (inner, recorded)
     }
@@ -4350,6 +4542,7 @@ mod tests {
             agent_indicator: false,
             local_frames: true,
             audio: false,
+            observe_input: false,
         }
     }
 
@@ -4518,7 +4711,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 {
@@ -4690,6 +4883,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)
@@ -4702,7 +4961,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.8",
+    "version": "0.5.10",
     "license": "Apache-2.0",
     "repository": {
         "type": "git",
@@ -38,7 +38,7 @@
         "ws": "8.21.3"
     },
     "optionalDependencies": {
-        "@desklink/host-linux-x64-gnu": "0.5.8",
-        "@desklink/host-darwin-arm64": "0.5.8"
+        "@desklink/host-linux-x64-gnu": "0.5.10",
+        "@desklink/host-darwin-arm64": "0.5.10"
     }
 }