feat(host/windows): ViGEm rumble back-channel + Windows clippy clean

Wire the host→client rumble path on Windows, the analogue of the Linux
uinput EV_FF read loop: a game's force-feedback on the virtual Xbox 360
pad is delivered by ViGEm's notification API (`request_notification` →
`spawn_thread`, gated by the crate's `unstable_xtarget_notification`
feature). A per-pad background thread stores the latest motor levels;
`pump_rumble` relays changes to the client on the universal 0xCA plane
(motors scaled 0..255 → 0..65535). Dropping the target aborts the
notification, so the thread exits with the session. Live verification
still needs a physical pad.

Also fix the Windows backends' clippy debt — these modules are cfg-
excluded from Linux CI, so `clippy -D warnings` never saw them, and the
VM's rustc 1.96 clippy is stricter on shared code than the CI image:
- dxgi: manual checked division → checked_div().map_or
- sendinput: `x = x | y` → `x |= y`
- sudovda: `.then(|| ptr)` → `.then_some(ptr)`
- m3 pick_compositor: drop the needless early return (match form)
- m3 resolve_compositor: Windows arm is a tail expr, not `return`

All Windows backends now build + clippy clean (default and --features
nvenc); Linux unaffected (fmt/clippy/check green).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/punktfunk-host/src/capture/dxgi.rs

@@ -152,11 +152,9 @@ impl DuplCapturer {
                 .filter(|&hz| hz > 0)
                 .unwrap_or_else(|| {
                     let r = dd.ModeDesc.RefreshRate;
-                    if r.Denominator > 0 {
-                        (r.Numerator / r.Denominator).max(1)
-                    } else {
-                        60
-                    }
+                    r.Numerator
+                        .checked_div(r.Denominator)
+                        .map_or(60, |hz| hz.max(1))
                 });
             let timeout_ms = std::env::var("PUNKTFUNK_CAPTURE_TIMEOUT_MS")
                 .ok()

crates/punktfunk-host/src/inject/gamepad_windows.rs

@@ -4,16 +4,33 @@
 //! triggers 0..255), so the mapping is ~1:1.
 //!
 //! Needs the ViGEmBus driver installed (like SudoVDA for the display); absent → gamepad is disabled
-//! and the session continues without it. Rumble back-channel: TODO (ViGEm notification API).
+//! and the session continues without it. Rumble flows back the *other* way: a game on the host writes
+//! force-feedback to the virtual pad, ViGEm's notification API delivers it on a background thread,
+//! and [`GamepadManager::pump_rumble`] relays level changes to the client (the universal 0xCA plane),
+//! mirroring the Linux `EV_FF` read path.
 
 use crate::gamestream::gamepad::GamepadEvent;
 use std::collections::HashMap;
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::Arc;
+use std::thread::JoinHandle;
 use vigem_client::{Client, TargetId, XButtons, XGamepad, Xbox360Wired};
 
+/// A plugged virtual pad plus its rumble back-channel. The notification thread stores the latest
+/// motor levels into `rumble` (packed `large << 8 | small`, both 0..255); [`GamepadManager::pump_rumble`]
+/// reads it and emits level changes. Dropping `target` aborts the outstanding notification request,
+/// so the thread's `poll` returns an error and it exits on its own — we detach it (per ViGEm's docs,
+/// dropping the `JoinHandle` does not stop the thread, but the target-drop abort does).
+struct PadEntry {
+    target: Xbox360Wired<Arc<Client>>,
+    rumble: Arc<AtomicU32>,
+    last_emitted: u32,
+    _notif_thread: Option<JoinHandle<()>>,
+}
+
 pub struct GamepadManager {
     client: Option<Arc<Client>>,
-    pads: HashMap<u8, Xbox360Wired<Arc<Client>>>,
+    pads: HashMap<u8, PadEntry>,
 }
 
 impl GamepadManager {
@@ -37,19 +54,58 @@ impl GamepadManager {
         }
     }
 
+    /// Lazily plug pad `index` on its first event, arming the rumble notification thread. Returns
+    /// `None` if ViGEmBus is unavailable or the pad failed to plug.
+    fn ensure_pad(&mut self, index: u8) -> Option<&mut PadEntry> {
+        if !self.pads.contains_key(&index) {
+            let client = self.client.clone()?;
+            let mut target = Xbox360Wired::new(client, TargetId::XBOX360_WIRED);
+            if let Err(e) = target.plugin() {
+                tracing::warn!(error = format!("{e:?}"), "ViGEm pad plugin failed");
+                return None;
+            }
+            let _ = target.wait_ready();
+            // Arm the force-feedback back-channel: a background thread writes each notification's
+            // motor levels into the shared atomic; the input thread drains changes via pump_rumble.
+            let rumble = Arc::new(AtomicU32::new(0));
+            let notif_thread = match target.request_notification() {
+                Ok(req) => {
+                    let sink = rumble.clone();
+                    Some(req.spawn_thread(move |_req, n| {
+                        sink.store(
+                            ((n.large_motor as u32) << 8) | n.small_motor as u32,
+                            Ordering::Relaxed,
+                        );
+                    }))
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        error = format!("{e:?}"),
+                        "ViGEm rumble notification unavailable — pad runs without force feedback"
+                    );
+                    None
+                }
+            };
+            self.pads.insert(
+                index,
+                PadEntry {
+                    target,
+                    rumble,
+                    last_emitted: 0,
+                    _notif_thread: notif_thread,
+                },
+            );
+        }
+        self.pads.get_mut(&index)
+    }
+
     pub fn handle(&mut self, ev: &GamepadEvent) {
-        let Some(client) = self.client.clone() else {
-            return;
-        };
         let GamepadEvent::State(f) = ev else {
             return; // Arrival metadata — the pad is created lazily on the first State
         };
-        let target = self.pads.entry(f.index.max(0) as u8).or_insert_with(|| {
-            let mut t = Xbox360Wired::new(client, TargetId::XBOX360_WIRED);
-            let _ = t.plugin();
-            let _ = t.wait_ready();
-            t
-        });
+        let Some(entry) = self.ensure_pad(f.index.max(0) as u8) else {
+            return;
+        };
         let gp = XGamepad {
             buttons: XButtons {
                 raw: (f.buttons & 0xffff) as u16,
@@ -61,10 +117,22 @@ impl GamepadManager {
             thumb_rx: f.rs_x,
             thumb_ry: f.rs_y,
         };
-        let _ = target.update(&gp);
+        let _ = entry.target.update(&gp);
     }
 
-    pub fn pump_rumble(&mut self, _send: impl FnMut(u16, u16, u16)) {
-        // TODO: wire the ViGEm rumble notification back-channel (Xbox360Wired::request_notification).
+    /// Relay any changed rumble level to the client. The notification thread keeps `rumble` current;
+    /// we emit only on change (the input thread re-sends the steady state every 500 ms to heal drops).
+    /// ViGEm motors are 0..255; the wire carries 0..65535, so scale by 257 (255 → 65535). `large`
+    /// (low-frequency) maps to the universal datagram's `low`, `small` (high-frequency) to `high`.
+    pub fn pump_rumble(&mut self, mut send: impl FnMut(u16, u16, u16)) {
+        for (idx, entry) in self.pads.iter_mut() {
+            let packed = entry.rumble.load(Ordering::Relaxed);
+            if packed != entry.last_emitted {
+                entry.last_emitted = packed;
+                let large = ((packed >> 8) & 0xff) as u16;
+                let small = (packed & 0xff) as u16;
+                send(*idx as u16, large * 257, small * 257);
+            }
+        }
     }
 }

crates/punktfunk-host/src/inject/sendinput.rs

@@ -214,10 +214,10 @@ impl InputInjector for SendInputInjector {
                 let scan = (sc_ex & 0xff) as u16;
                 let mut flags = KEYEVENTF_SCANCODE;
                 if extended {
-                    flags = flags | KEYEVENTF_EXTENDEDKEY;
+                    flags |= KEYEVENTF_EXTENDEDKEY;
                 }
                 if !down {
-                    flags = flags | KEYEVENTF_KEYUP;
+                    flags |= KEYEVENTF_KEYUP;
                 }
                 let ki = KEYBDINPUT {
                     wVk: VIRTUAL_KEY(0),

crates/punktfunk-host/src/m3.rs

@@ -1520,12 +1520,10 @@ fn pick_compositor(
     available: &[crate::vdisplay::Compositor],
     detected: Option<crate::vdisplay::Compositor>,
 ) -> Option<crate::vdisplay::Compositor> {
-    if let Some(want) = crate::vdisplay::Compositor::from_pref(pref) {
-        if available.contains(&want) {
-            return Some(want);
-        }
+    match crate::vdisplay::Compositor::from_pref(pref) {
+        Some(want) if available.contains(&want) => Some(want),
+        _ => detected,
     }
-    detected
 }
 
 /// Resolve the client's compositor preference to a concrete backend (the I/O shell around
@@ -1539,7 +1537,7 @@ fn resolve_compositor(pref: CompositorPref) -> Result<crate::vdisplay::Composito
     #[cfg(target_os = "windows")]
     {
         let _ = pref;
-        return Ok(Compositor::Kwin);
+        Ok(Compositor::Kwin)
     }
     #[cfg(not(target_os = "windows"))]
     {

crates/punktfunk-host/src/vdisplay/sudovda.rs

@@ -78,8 +78,8 @@ struct RemoveParams {
 /// One `DeviceIoControl` round trip (METHOD_BUFFERED). `input`/`output` may be empty.
 unsafe fn ioctl(h: HANDLE, code: u32, input: &[u8], output: &mut [u8]) -> Result<u32> {
     let mut returned = 0u32;
-    let inp = (!input.is_empty()).then(|| input.as_ptr() as *const c_void);
-    let outp = (!output.is_empty()).then(|| output.as_mut_ptr() as *mut c_void);
+    let inp = (!input.is_empty()).then_some(input.as_ptr() as *const c_void);
+    let outp = (!output.is_empty()).then_some(output.as_mut_ptr() as *mut c_void);
     DeviceIoControl(
         h,
         code,