@desklink/host 0.5.8 → 0.5.9

package/dist/protocol.d.ts

@@ -208,6 +208,7 @@ export type EngineEvent = {
             type: 'offer';
             sdp: string;
         };
+        geometry?: SurfaceGeometry;
     };
 } | {
     event: 'session.candidate';

package/dist/protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"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"}

package/docs/PROTOCOL.md

@@ -265,6 +265,20 @@ rate and X11 capture loop; portal capture offers it as the preferred PipeWire
 frame rate, and macOS sets its ScreenCaptureKit stream minimum frame interval.
 A source may still supply fewer frames.
 
+`ice_servers` carries the STUN/TURN servers the user brought, one object per
+server with every URL that server lists. Each URL an entry lists reaches the
+WebRTC stack with that entry's `username` and `credential` — listing
+`stun:a` and `stun:b` in one entry uses both, so a fallback behind an
+unreachable primary still gathers candidates. A TURN URL (`turn:`/`turns:`)
+whose transport is not UDP — `?transport=tcp`, or a bare `turns:` URL, which
+is TLS over TCP by default — is one the WebRTC stack cannot dial: the engine
+leaves it out of the configuration and reports it once with a
+`session.iceServerSkipped` warning event naming the URL, so a skipped URL is
+never a silent drop. Everything else in the entry — including a URL the
+parser cannot read — is handed to the WebRTC stack unchanged, whose own
+verdict then applies: for example a `turn:` URL on an entry without both a
+`username` and a `credential` refuses the open in the stack's own words.
+
 `agent_indicator` is opt-in local feedback for an agent controller; desklink-axi
 sets it for sessions it drives (except Windows); human phone control omits it. On
 Linux it adds an eased arrow inside a halo that brightens on clicks and keys,
@@ -275,9 +289,11 @@ masked before capture/diff (pixels behind the effect can remain briefly stale).
 On a located Hyprland window share each pointer cue goes to the desktop point
 the pointer landed on — the window's place plus the tapped point (see Input and
 clipboard) — and the window's picture holds no layer surface, so nothing is
-masked; a refused tap draws no cue. Known limit: the cue's surface sits on the
-one output the compositor gave it as the share started, and a tap landing on
-another output draws no cue. On bare X11 it is an override-redirect, click-through window that follows the
+masked; a refused tap draws no cue. When a tap lands on another output than
+the cue helper is on, the engine moves the helper there — respawning it with
+the landed layout point, which selects that output exactly like a point
+marker — and the cue draws at the landed point with its edge glow; a tap on
+the helper's own output reuses it with no new process. 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;
@@ -316,6 +332,17 @@ the SDP and candidates to the client and brings back the answer.
   "description":{"type":"offer","sdp":"v=0\r\n…"}}}
 ```
 
+A renegotiation offer may include `geometry` when the captured source changes
+size. It uses the same shape as the `session.open` result; consumers should
+apply its encoded dimensions to the presented surface. Older hosts omit it.
+
+```jsonc
+{"event":"session.description","params":{"sessionId":"…","generation":1,
+  "description":{"type":"offer","sdp":"v=0\r\n…"},
+  "geometry":{"source":{"width":1200,"height":600},
+    "encoded":{"width":1200,"height":600},"origin":{"x":0,"y":0}}}}
+```
+
 ```jsonc
 {"id":5,"method":"session.description","params":{"session_id":"…","generation":1,
   "description":{"type":"answer","sdp":"v=0\r\n…"}}}
@@ -500,7 +527,9 @@ FIR), and when the coded size changes that way, so a receiver never has to scale
 references across a size change. `target_kbps` is the current rate target after
 any back-off: for a standing queue on the path, measured from the receiver's
 transport-wide congestion feedback (RTP `transport-cc`), and for the loss
-its receiver reports carry. It starts at the requested ceiling capped at
+its receiver reports carry. A path that runs over ICE-TCP backs off only on a
+queue above 100 ms, not 25 ms, so a relay's delivery jitter does not pull the
+target to its floor. It starts at the requested ceiling capped at
 3000 kbps on an unknown link, then grows toward the ceiling on clean
 loss/delay feedback. `codec` is what frames go out in
 (`vp9` or `h264`) and `encoder` what codes them (`libvpx`, `videotoolbox`,
@@ -611,7 +640,9 @@ origin, before video scaling (`geometry.source`, not `geometry.encoded`). On X11
 this is the root screen; on macOS it is the selected display, with native pixels
 converted to display points. On a located Hyprland window share (see Input and
 clipboard) they are the window's own pixels, and the ring shows on the desktop
-point a press there would land, on the output holding it; a point the window
+point a press there would land, on the output holding it; when a later point
+lands on another output the helper moves there, and a point on its own output
+reuses it with no new process. A point the window
 cannot take there is refused with `indicator-unavailable` and the reason. Both
 coordinates must be within its bounds. The
 ring may clip at an edge; its label stays inside the display. `timeout_ms`

package/engine/Cargo.lock

@@ -536,7 +536,7 @@ checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 
 [[package]]
 name = "desklink-host"
-version = "0.5.8"
+version = "0.5.9"
 dependencies = [
  "anyhow",
  "ashpd",
@@ -557,6 +557,7 @@ dependencies = [
  "pipewire",
  "rand 0.8.8",
  "rtc",
+ "rtc-ice",
  "serde",
  "serde_json",
  "sha2",

package/engine/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "desklink-host"
-version = "0.5.8"
+version = "0.5.9"
 edition = "2021"
 rust-version = "1.97.1"
 license = "Apache-2.0"
@@ -18,7 +18,7 @@ base64 = "0.22"
 
 [target.'cfg(any(target_os = "linux", target_os = "macos", target_os = "windows"))'.dependencies]
 anyhow = "1"
-tokio = { version = "1", features = ["rt-multi-thread", "macros", "io-util", "io-std", "sync", "time", "signal"] }
+tokio = { version = "1", features = ["rt-multi-thread", "macros", "io-util", "io-std", "sync", "time", "signal", "net"] }
 libc = "0.2"
 bytes = "1"
 # rtc-sctp 0.21.1 is required through this stack: 0.21.0 replaces an
@@ -27,6 +27,9 @@ bytes = "1"
 # session. Cargo.lock pins 0.21.1; drop the pin when a later release carries it.
 webrtc = { version = "0.21", default-features = false, features = ["runtime-tokio", "crypto-ring"] }
 rtc = { version = "0.21", default-features = false, features = ["crypto-ring"] }
+# Parses ice server URLs when the engine sorts out which ones the WebRTC
+# stack can dial; the [patch.crates-io] entry below keeps this the vendored copy.
+rtc-ice = { version = "0.21", default-features = false }
 log = "0.4"
 async-trait = "0.1"
 rand = "0.8"

package/engine/native/agent_overlay_wayland.c

@@ -252,7 +252,9 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
         }
         if(wl_display_roundtrip(o.display)<0)return 2;
     }
-    if(point_mode) {
+    // Point markers always name their output; a desktop agent cue does once
+    // the engine has seen a press land, so the cue opens on that output.
+    if(point_mode || (desktop && origin_known)) {
         for(int i=0;i<o.output_count;i++) {
             struct Output *out=&o.outputs[i];
             if(origin_known && out->valid && origin_x>=out->x && origin_y>=out->y && origin_x<out->x+out->w && origin_y<out->y+out->h){selected=out->handle;o.mine=out;matches++;}
@@ -269,8 +271,9 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
     FT_Library library=NULL;FT_Face font=point_mode?point_font(&library):NULL;
     if(point_mode&&!font){wl_display_disconnect(o.display);return 2;}
     o.surface=wl_compositor_create_surface(o.compositor);
-    // An agent cue's surface lands where the compositor puts it; it learns which output that is.
-    if(desktop && !point_mode)wl_surface_add_listener(o.surface,&surface_listener,&o);
+    // A desktop surface learns which output it is on, whether the compositor
+    // placed it or a layout origin selected it.
+    if(desktop)wl_surface_add_listener(o.surface,&surface_listener,&o);
     o.layer=wl_proxy_marshal_flags(o.shell,0,&layer_surface_interface,1,0,NULL,o.surface,selected,3,point_mode?"desklink-point":"desklink-agent");
     wl_proxy_add_listener(o.layer,layer_listener,&o);
     uint32_t anchor,keyboard_focus,empty_input;
@@ -356,7 +359,7 @@ static int overlay_main(int source_w,int source_h,int point_mode,int origin_know
     return 0;
 }
 
-int desklink_agent_overlay_wayland(int w,int h,int desktop){return overlay_main(w,h,0,0,0,0,desktop);}
+int desklink_agent_overlay_wayland(int w,int h,int desktop,int known,int x,int y){return overlay_main(w,h,0,known,x,y,desktop);}
 int desklink_point_overlay_wayland(int w,int h,int known,int x,int y,int desktop){return overlay_main(w,h,1,known,x,y,desktop);}
 
 // Read-only capability probe for idempotent clear before a helper exists.

package/engine/src/hyprland.rs

@@ -303,6 +303,31 @@ impl WindowLocator {
     }
 }
 
+/// The name of the monitor holding desktop point `(px, py)`, if any.
+/// Geometry math matches `WindowLocator::locate`'s on-screen check, so a
+/// point a press landed on maps to the output whose overlay must draw it.
+pub fn monitor_containing(px: f64, py: f64) -> Result<Option<String>, String> {
+    let monitors = query("j/monitors")?;
+    for monitor in monitors.as_array().into_iter().flatten() {
+        if monitor["disabled"].as_bool() == Some(true) {
+            continue;
+        }
+        let scale = monitor["scale"].as_f64().filter(|scale| *scale > 0.0);
+        if let (Some(mx), Some(my), Some(mw), Some(mh), Some(scale)) = (
+            monitor["x"].as_f64(),
+            monitor["y"].as_f64(),
+            monitor["width"].as_f64(),
+            monitor["height"].as_f64(),
+            scale,
+        ) {
+            if (mx..mx + mw / scale).contains(&px) && (my..my + mh / scale).contains(&py) {
+                return Ok(monitor["name"].as_str().map(str::to_owned));
+            }
+        }
+    }
+    Ok(None)
+}
+
 /// 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()?));

package/engine/src/indicator.rs

@@ -222,19 +222,29 @@ impl Indicator {
     }
 
     /// `desktop`: cues are compositor layout coordinates, drawn only where
-    /// they fall on the output the overlay opened on.
+    /// they fall on the output the overlay opened on. `origin` selects that
+    /// output by layout point, reusing the point helper's xdg-output
+    /// selection; without one the compositor places the surface.
     #[cfg(target_os = "linux")]
-    pub fn start_wayland(width: usize, height: usize, desktop: bool) -> Result<Self> {
+    pub fn start_wayland(
+        width: usize,
+        height: usize,
+        desktop: bool,
+        origin: Option<(i32, i32)>,
+    ) -> Result<Self> {
         let executable = std::env::current_exe()?;
-        Self::spawn(
-            Command::new(executable)
-                .arg("agent-overlay-wayland")
-                .arg(width.to_string())
-                .arg(height.to_string())
-                .args(desktop.then_some("desktop")),
-            1.0,
-            1.0,
-        )
+        let mut command = Command::new(executable);
+        command
+            .arg("agent-overlay-wayland")
+            .arg(width.to_string())
+            .arg(height.to_string());
+        if desktop {
+            command.arg("desktop");
+            if let Some((x, y)) = origin {
+                command.arg(x.to_string()).arg(y.to_string());
+            }
+        }
+        Self::spawn(&mut command, 1.0, 1.0)
     }
 
     #[cfg(target_os = "linux")]
@@ -369,7 +379,14 @@ mod tests {
         };
         let mut drained = vec![];
         for _ in 0..200 {
-            drained.extend(feed.drain().into_iter().map(|cue| cue.x));
+            // Each drain re-reports the last two remembered states, so the
+            // same state can arrive in several drains when the helper's lines
+            // are split across reads. Keep each state once, in pipe order.
+            for cue in feed.drain() {
+                if !drained.contains(&cue.x) {
+                    drained.push(cue.x);
+                }
+            }
             if drained.len() >= 3 {
                 break;
             }

package/engine/src/main.rs

@@ -136,7 +136,14 @@ use tokio::sync::mpsc as tokio_mpsc;
 unsafe extern "C" {
     fn desklink_point_overlay_main(display: *const std::ffi::c_char) -> i32;
     fn desklink_agent_overlay_main(display: *const std::ffi::c_char) -> i32;
-    fn desklink_agent_overlay_wayland(source_w: i32, source_h: i32, desktop: i32) -> i32;
+    fn desklink_agent_overlay_wayland(
+        source_w: i32,
+        source_h: i32,
+        desktop: i32,
+        origin_known: i32,
+        origin_x: i32,
+        origin_y: i32,
+    ) -> i32;
     fn desklink_wayland_layer_shell_available() -> i32;
     fn desklink_point_overlay_wayland(
         w: i32,
@@ -212,7 +219,21 @@ fn main() {
                 2
             } else {
                 let desktop = i32::from(args.get(3).map(String::as_str) == Some("desktop"));
-                unsafe { desklink_agent_overlay_wayland(width, height, desktop) }
+                // A desktop cue respawned after a press names the layout
+                // point that chose its output: `w h desktop ox oy`.
+                let (known, ox, oy) = match (args.get(4), args.get(5)) {
+                    (Some(x), Some(y)) => match (x.parse(), y.parse()) {
+                        (Ok(x), Ok(y)) => (1, x, y),
+                        _ => (0, 0, 0),
+                    },
+                    _ => (0, 0, 0),
+                };
+                let (known, ox, oy) = if desktop == 1 {
+                    (known, ox, oy)
+                } else {
+                    (0, 0, 0)
+                };
+                unsafe { desklink_agent_overlay_wayland(width, height, desktop, known, ox, oy) }
             }
         }
         "capabilities" => {
@@ -542,6 +563,47 @@ async fn serve() -> Result<()> {
     Ok(())
 }
 
+/// Splits the requested ICE servers into the configuration the peer gets and
+/// the URLs this engine leaves out. Every URL the WebRTC stack can dial goes
+/// through with its entry's username and credential — all of an entry's URLs,
+/// so a fallback behind an unreachable primary still gathers candidates. A
+/// TURN URL whose transport is not UDP is one the stack cannot dial, so it is
+/// skipped here and reported once by the caller, never dropped silently. A
+/// URL the parser cannot read is forwarded unchanged: the peer connection
+/// owns that verdict and refuses the open in its own words.
+#[cfg(any(
+    target_os = "linux",
+    all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
+))]
+fn usable_ice_servers(
+    servers: Vec<protocol::IceServerParam>,
+) -> (
+    Vec<(Vec<String>, Option<String>, Option<String>)>,
+    Vec<String>,
+) {
+    use rtc_ice::url::{ProtoType, SchemeType, Url};
+    let mut usable = Vec::new();
+    let mut skipped = Vec::new();
+    for server in servers {
+        let mut urls = Vec::with_capacity(server.urls.len());
+        for url in server.urls {
+            let undialable = Url::parse_url(&url).is_ok_and(|parsed| {
+                matches!(parsed.scheme, SchemeType::Turn | SchemeType::Turns)
+                    && parsed.proto != ProtoType::Udp
+            });
+            if undialable {
+                skipped.push(url);
+            } else {
+                urls.push(url);
+            }
+        }
+        if !urls.is_empty() {
+            usable.push((urls, server.username, server.credential));
+        }
+    }
+    (usable, skipped)
+}
+
 #[cfg(any(
     target_os = "linux",
     all(any(target_os = "macos", target_os = "windows"), desklink_vpx)
@@ -616,6 +678,10 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.capture.stopped",
             serde_json::json!({ "sessionId": session_id, "reason": reason }),
         ),
+        session::SessionEvent::IceServerSkipped { url } => (
+            "session.iceServerSkipped",
+            serde_json::json!({ "sessionId": session_id, "url": url }),
+        ),
         session::SessionEvent::Revoked { reason, code } => (
             "session.revoked",
             serde_json::json!({ "sessionId": session_id, "reason": reason, "code": code }),
@@ -672,6 +738,7 @@ async fn dispatch(
             }
             let params: protocol::OpenParams = serde_json::from_value(request.params.clone())
                 .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            let usable = usable_ice_servers(params.ice_servers);
             let open = session::OpenRequest {
                 source: params.source,
                 cursor: params.cursor,
@@ -685,16 +752,7 @@ async fn dispatch(
                 agent_indicator: params.agent_indicator,
                 local_frames: params.local_frames,
                 audio: params.audio,
-                ice_servers: params
-                    .ice_servers
-                    .into_iter()
-                    .filter_map(|server| {
-                        server
-                            .urls
-                            .first()
-                            .map(|url| (url.clone(), server.username, server.credential))
-                    })
-                    .collect(),
+                ice_servers: usable.0,
             };
             let session = session::Session::open(open, events.clone())
                 .await
@@ -713,6 +771,15 @@ async fn dispatch(
                 "agentIndicator": session.agent_indicator(),
                 "audio": session.audio_info(),
             });
+            // URLs the WebRTC stack cannot dial were left out of the peer's
+            // configuration; each skipped one is named once instead of
+            // vanishing from a multi-URL entry without a trace.
+            for url in usable.1 {
+                let _ = events.send(session::Notice {
+                    session_id: session.id().to_owned(),
+                    event: session::SessionEvent::IceServerSkipped { url },
+                });
+            }
             *current = Some(session);
             Ok(result)
         }
@@ -947,6 +1014,26 @@ mod tests {
         );
     }
 
+    #[test]
+    fn the_skipped_ice_server_warning_names_the_url_once() {
+        let line = render_event(session::Notice {
+            session_id: String::from("session-1"),
+            event: session::SessionEvent::IceServerSkipped {
+                url: String::from("turn:turn.example.com:3478?transport=tcp"),
+            },
+        })
+        .expect("a skipped-URL warning is renderable");
+        let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
+        assert_eq!(parsed["event"], "session.iceServerSkipped");
+        assert_eq!(
+            parsed["params"],
+            serde_json::json!({
+                "sessionId": "session-1",
+                "url": "turn:turn.example.com:3478?transport=tcp"
+            })
+        );
+    }
+
     #[tokio::test]
     async fn the_state_notification_carries_exactly_what_the_document_promises() {
         let line = render_event(session::Notice {

package/engine/src/peer.rs

@@ -23,7 +23,7 @@ use rtc::peer_connection::configuration::media_engine::{
 use rtc::peer_connection::configuration::RTCConfigurationBuilder;
 use rtc::peer_connection::event::RTCPeerConnectionIceEvent;
 use rtc::peer_connection::sdp::RTCSessionDescription;
-use rtc::peer_connection::transport::{RTCIceCandidateInit, RTCIceServer};
+use rtc::peer_connection::transport::{RTCIceCandidateInit, RTCIceProtocol, RTCIceServer};
 use rtc::rtcp::payload_feedbacks::full_intra_request::FullIntraRequest;
 use rtc::rtcp::payload_feedbacks::picture_loss_indication::PictureLossIndication;
 use rtc::rtcp::receiver_report::ReceiverReport;
@@ -47,7 +47,7 @@ use webrtc::peer_connection::{
 };
 use webrtc::runtime::default_runtime;
 
-// desklink scout trace (dl-roam-postnom-attr): engine-side restart timeline.
+// desklink scout trace: engine-side restart timeline.
 // Enabled with `DESKLINK_ICE_TRACE=1`; stamps microseconds since the Unix epoch
 // so these lines interleave with the vendored ICE agent's `[ice ...]` lines in
 // one order. Droppable: grep `desklink scout trace`.
@@ -258,7 +258,10 @@ pub enum PeerEvent {
 /// Transport settings the consumer chose for this session.
 #[derive(Debug, Clone)]
 pub struct TransportOptions {
-    pub ice_servers: Vec<(String, Option<String>, Option<String>)>,
+    /// One entry per ICE server the consumer asked for, carrying every URL
+    /// that entry listed; the engine has already left out the ones the
+    /// WebRTC stack cannot dial and reported those to the consumer.
+    pub ice_servers: Vec<(Vec<String>, Option<String>, Option<String>)>,
     /// Listen for ICE over TCP on the loopback too. A phone that reaches this
     /// computer only through SSH has no UDP path; it forwards this port over
     /// the SSH connection it already has, and the picture rides that.
@@ -474,7 +477,7 @@ impl PeerConnectionEventHandler for Handler {
     }
 
     async fn on_connection_state_change(&self, state: RTCPeerConnectionState) {
-        // desklink scout trace (dl-roam-postnom-attr): the engine's rtc-level
+        // desklink scout trace: the engine's rtc-level
         // transport state event, on the same microsecond clock as the vendored
         // agent's `[ice ...]` lines, so the rtc Connected gate is separable.
         if dl_trace_on() {
@@ -898,8 +901,8 @@ impl VideoPeer {
                 options
                     .ice_servers
                     .iter()
-                    .map(|(url, username, credential)| RTCIceServer {
-                        urls: vec![url.clone()],
+                    .map(|(urls, username, credential)| RTCIceServer {
+                        urls: urls.clone(),
                         username: username.clone().unwrap_or_default(),
                         credential: credential.clone().unwrap_or_default(),
                     })
@@ -1130,6 +1133,21 @@ impl VideoPeer {
         self.connected.load(Ordering::SeqCst)
     }
 
+    /// Whether ICE selected a TCP candidate pair (the relay's ICE-TCP path).
+    /// False until a pair is selected.
+    pub async fn selected_pair_is_tcp(&self) -> bool {
+        let Some(sender) = self.peer.get_senders().await.into_iter().next() else {
+            return false;
+        };
+        let Ok(Some(dtls)) = sender.transport().await else {
+            return false;
+        };
+        matches!(
+            dtls.ice_transport().get_selected_candidate_pair().await,
+            Ok(Some(pair)) if pair.local().protocol == RTCIceProtocol::Tcp
+        )
+    }
+
     /// Stand in for a connected transport, for a pipeline under test.
     #[cfg(test)]
     pub fn assume_connected(&self) {
@@ -1172,6 +1190,12 @@ impl VideoPeer {
         lock(&self.path).take()
     }
 
+    /// Stand in for transport-wide feedback that reports a path, for a pipeline under test.
+    #[cfg(test)]
+    pub fn report_path(&self, report: PathReport) {
+        *lock(&self.path) = Some(report);
+    }
+
     /// Take the pending "the far end needs a reference frame" request, if any.
     pub fn take_keyframe_request(&self) -> bool {
         self.wants_keyframe.swap(false, Ordering::SeqCst)
@@ -1697,6 +1721,7 @@ pub(crate) mod tests {
     async fn media_receiver(
         receiver: Arc<MediaReceiver>,
         udp: Vec<std::net::SocketAddr>,
+        tcp: Vec<std::net::SocketAddr>,
     ) -> Arc<dyn PeerConnection> {
         let mut media_engine = MediaEngine::default();
         media_engine
@@ -1710,6 +1735,7 @@ pub(crate) mod tests {
             .with_runtime(default_runtime().expect("a runtime"))
             .with_handler(receiver)
             .with_udp_addrs(udp)
+            .with_tcp_addrs(tcp)
             .build()
             .await
             .expect("a receiving peer");
@@ -1719,17 +1745,27 @@ pub(crate) mod tests {
     /// An engine and a client receiving on `client_udp`, offered, answered and
     /// connected over ICE, with the client's RTP arrival times and the
     /// candidates the engine offered.
-    struct Connected {
-        engine: Arc<VideoPeer>,
+    pub(crate) struct Connected {
+        pub(crate) engine: Arc<VideoPeer>,
         offer: String,
-        client: Arc<dyn PeerConnection>,
+        pub(crate) client: Arc<dyn PeerConnection>,
         arrivals: Arc<Mutex<Vec<Instant>>>,
         offered: Arc<Mutex<Vec<String>>>,
     }
 
-    async fn connected(client_udp: Vec<std::net::SocketAddr>) -> Connected {
+    /// `client_tcp` and `loopback_tcp` give a pair that runs over ICE-TCP: a
+    /// client with no UDP candidates can only reach the engine over TCP.
+    pub(crate) async fn connected(
+        client_udp: Vec<std::net::SocketAddr>,
+        client_tcp: Vec<std::net::SocketAddr>,
+        loopback_tcp: bool,
+    ) -> Connected {
         let (events, mut events_rx) = tokio::sync::mpsc::unbounded_channel();
-        let (engine, offer) = VideoPeer::offer(transport(), events, VideoCodec::Vp9)
+        let options = TransportOptions {
+            loopback_tcp,
+            ..transport()
+        };
+        let (engine, offer) = VideoPeer::offer(options, events, VideoCodec::Vp9)
             .await
             .expect("an offering peer");
         let engine = Arc::new(engine);
@@ -1743,7 +1779,7 @@ pub(crate) mod tests {
             arrivals: Arc::clone(&arrivals),
             connected: Arc::clone(&connected),
         });
-        let client = media_receiver(Arc::clone(&receiver), client_udp).await;
+        let client = media_receiver(Arc::clone(&receiver), client_udp, client_tcp).await;
 
         client
             .set_remote_description(RTCSessionDescription::offer(offer.clone()).expect("an offer"))
@@ -1824,7 +1860,12 @@ pub(crate) mod tests {
             client,
             arrivals,
             offered,
-        } = connected(vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))]).await;
+        } = connected(
+            vec![std::net::SocketAddr::from(([0, 0, 0, 0], 0))],
+            Vec::new(),
+            false,
+        )
+        .await;
         eprintln!("restart: the engine offered {:?}", offered.lock().unwrap());
 
         // Any bytes the VP9 packetizer turns into one access unit.
@@ -1968,10 +2009,14 @@ pub(crate) mod tests {
             arrivals,
             offered,
             ..
-        } = connected(vec![std::net::SocketAddr::from((
-            std::net::Ipv6Addr::LOCALHOST,
-            0,
-        ))])
+        } = connected(
+            vec![std::net::SocketAddr::from((
+                std::net::Ipv6Addr::LOCALHOST,
+                0,
+            ))],
+            Vec::new(),
+            false,
+        )
         .await;
         let offered = offered.lock().unwrap().clone();
         eprintln!("ipv6: the engine offered {offered:?}");
@@ -2047,4 +2092,110 @@ pub(crate) mod tests {
             "no one else is offered a port on the loopback"
         );
     }
+
+    /// A STUN responder bound on the wildcard that answers every Binding
+    /// request with the requester's own address, the way a real STUN server
+    /// would. Reach it at the address `primary_ip` names, not at its bind
+    /// address: the wildcard receives for every interface.
+    async fn stun_responder() -> std::net::SocketAddr {
+        use rtc::stun::message::Setter;
+        let socket = tokio::net::UdpSocket::bind("0.0.0.0:0")
+            .await
+            .expect("a socket");
+        let addr = socket.local_addr().expect("a bound port");
+        tokio::spawn(async move {
+            let mut buffer = vec![0u8; 1500];
+            while let Ok((size, peer)) = socket.recv_from(&mut buffer).await {
+                let mut request = rtc::stun::message::Message::new();
+                request.raw = buffer[..size].to_vec();
+                if request.decode().is_err() {
+                    continue;
+                }
+                let mut response = rtc::stun::message::Message::new();
+                response.set_type(rtc::stun::message::BINDING_SUCCESS);
+                response.transaction_id = request.transaction_id;
+                let mapped = rtc::stun::xoraddr::XorMappedAddress {
+                    ip: peer.ip(),
+                    port: peer.port(),
+                };
+                if mapped.add_to(&mut response).is_err() {
+                    continue;
+                }
+                response.write_header();
+                let _ = socket.send_to(&response.raw, peer).await;
+            }
+        });
+        addr
+    }
+
+    /// The interface address this machine sources its own traffic from — the
+    /// address a socket bound to this machine's interfaces can reach. The
+    /// peer binds one socket per non-loopback interface (loopback is skipped
+    /// when host candidates are gathered), and Windows' strong-host model
+    /// refuses to send an interface-bound datagram to 127.0.0.1, where the
+    /// Linux weak-host model allows it — so a loopback STUN fixture gathers
+    /// nothing on Windows. A real STUN server sits on the subnet, and the
+    /// fixture does the same. The probe is a connected UDP socket: the OS
+    /// resolves the route and its source address without sending a packet.
+    fn primary_ip() -> std::net::IpAddr {
+        let probe = std::net::UdpSocket::bind("0.0.0.0:0").and_then(|probe| {
+            probe.connect("192.0.2.1:9")?; // TEST-NET-1: connected UDP sends nothing
+            probe.local_addr()
+        });
+        match probe {
+            Ok(addr) if !addr.ip().is_unspecified() && !addr.ip().is_loopback() => addr.ip(),
+            _ => std::net::IpAddr::from([127, 0, 0, 1]),
+        }
+    }
+
+    /// One ice_servers entry listing two URLs must put both in front of the
+    /// peer connection: the first responder here never answers, so any
+    /// reflexive candidate can only have come from the second URL. The engine
+    /// used to forward only the first URL of each entry, which lost the rest.
+    #[tokio::test]
+    async fn the_second_url_of_an_ice_server_entry_gathers_a_reflexive_candidate() {
+        let ip = primary_ip();
+        // A server that never answers: bound, so its port cannot be reused,
+        // and silent, so it is as good as unreachable.
+        let silent = tokio::net::UdpSocket::bind("0.0.0.0:0")
+            .await
+            .expect("a socket");
+        let unreachable = silent.local_addr().expect("a port");
+        let answering = stun_responder().await;
+
+        let (events, mut events_rx) = tokio::sync::mpsc::unbounded_channel();
+        let (_peer, _offer) = VideoPeer::offer(
+            TransportOptions {
+                ice_servers: vec![(
+                    vec![
+                        format!("stun:{ip}:{}", unreachable.port()),
+                        format!("stun:{ip}:{}", answering.port()),
+                    ],
+                    None,
+                    None,
+                )],
+                loopback_tcp: false,
+                pace_bps: 20_000_000.0,
+            },
+            events,
+            VideoCodec::Vp9,
+        )
+        .await
+        .expect("a peer connection");
+
+        // Host candidates arrive without the network; the reflexive one needs
+        // the binding round trip through the second URL of the entry.
+        let deadline = tokio::time::Instant::now() + Duration::from_secs(10);
+        loop {
+            let event = tokio::time::timeout_at(deadline, events_rx.recv())
+                .await
+                .expect("no reflexive candidate was ever gathered")
+                .expect("the peer event stream ended");
+            if let PeerEvent::Candidate { candidate, .. } = event {
+                if candidate.contains(" typ srflx ") {
+                    break;
+                }
+            }
+        }
+    }
 }

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.
@@ -1274,8 +1288,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")]
@@ -1493,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")]
@@ -1593,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")]
@@ -1739,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
@@ -1763,21 +1792,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")]
@@ -2139,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() {
@@ -2318,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,
@@ -2361,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() {
@@ -2426,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,
@@ -2804,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.
@@ -2825,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 {
@@ -2843,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.
@@ -2856,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;
             }
@@ -2868,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 {
@@ -3117,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
@@ -3678,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")]
@@ -3757,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")]
@@ -3892,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)>>>) {
@@ -3920,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"),
             ))),
@@ -3939,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),
@@ -4518,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 {
@@ -4690,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)
@@ -4702,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.8",
+    "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.8",
-        "@desklink/host-darwin-arm64": "0.5.8"
+        "@desklink/host-linux-x64-gnu": "0.5.9",
+        "@desklink/host-darwin-arm64": "0.5.9"
     }
 }