feat(pf-frame,pf-win-display): leaf primitives for the lid-closed first-frame fix

Three leaf-crate additions the IDD-push capturer (pf-capture, plan §W6 C6)
builds on — committed ahead so the capture-crate extraction and the HID
compose kick can land on top:

- pf-frame session_tuning::DisplayWakeRequest — RAII PowerCreateRequest/
  PowerSetRequest(PowerRequestDisplayRequired + SystemRequired), the
  service-grade 'someone is watching this screen' assertion (visible in
  powercfg /requests), held for a capture session so the console cannot
  drop into display-off mid-stream. Object-lifetime, unlike the
  thread-bound ES_* flags in on_hot_thread. Prevention only: no power
  request turns an already-off display back on — that wake is input's
  job (the virtual-mouse compose kick).

- pf-win-display win_display::desktop_bounds() — the virtual-desktop
  bounds as the union of every ACTIVE CCD path's source rect. From the
  CCD database (global), NOT GetSystemMetrics (a per-session view), so
  a non-console-session host still aims HID absolute coordinates at the
  console's real layout.

- pf-win-display console_session_mismatch() — the session guard from
  3d9b3290, copied into the leaf so pf-capture reads it as a peer
  instead of reaching into the orchestrator (relocation authored by the
  W6 extraction session).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/pf-frame/src/session_tuning.rs

@@ -32,6 +32,21 @@ mod imp {
         fn GetCurrentProcess() -> Handle;
         fn SetPriorityClass(hProcess: Handle, dwPriorityClass: u32) -> Bool;
         fn SetThreadExecutionState(esFlags: u32) -> u32;
+        fn PowerCreateRequest(Context: *const ReasonContext) -> Handle;
+        fn PowerSetRequest(PowerRequest: Handle, RequestType: i32) -> Bool;
+        fn PowerClearRequest(PowerRequest: Handle, RequestType: i32) -> Bool;
+        fn CloseHandle(hObject: Handle) -> Bool;
+    }
+
+    /// `REASON_CONTEXT` (minwinbase.h), simple-string flavour: `Version` (ULONG), `Flags` (DWORD),
+    /// then the union collapses to `SimpleReasonString` (LPWSTR) under
+    /// `POWER_REQUEST_CONTEXT_SIMPLE_STRING` — same size/alignment as the C layout (4+4, 8-aligned
+    /// pointer).
+    #[repr(C)]
+    struct ReasonContext {
+        version: u32,
+        flags: u32,
+        simple_reason: *const u16,
     }
     #[link(name = "dwmapi")]
     extern "system" {
@@ -46,6 +61,61 @@ mod imp {
     const ES_CONTINUOUS: u32 = 0x8000_0000;
     const ES_SYSTEM_REQUIRED: u32 = 0x0000_0001;
     const ES_DISPLAY_REQUIRED: u32 = 0x0000_0002;
+    const POWER_REQUEST_CONTEXT_VERSION: u32 = 0; // DIAGNOSTIC_REASON_VERSION
+    const POWER_REQUEST_CONTEXT_SIMPLE_STRING: u32 = 0x0000_0001;
+    const POWER_REQUEST_DISPLAY_REQUIRED: i32 = 0;
+    const POWER_REQUEST_SYSTEM_REQUIRED: i32 = 1;
+    const INVALID_HANDLE_VALUE: isize = -1;
+
+    /// RAII display+system availability request (`PowerRequestDisplayRequired`, visible in
+    /// `powercfg /requests`) — the service-grade "someone is watching this screen" assertion,
+    /// held for a capture session so the console cannot drop into display-off mid-stream. This is
+    /// object-lifetime (unlike the thread-bound `ES_*` flags in [`on_hot_thread`], which the OS
+    /// reverts at thread exit), so a capturer can hold it across whatever threads serve the
+    /// session. PREVENTION only: no power request turns an already-off display back ON — that
+    /// wake needs input, which is the virtual-mouse compose kick's job.
+    pub struct DisplayWakeRequest(Handle);
+
+    // SAFETY: the wrapped power-request HANDLE is a kernel object handle — a plain opaque value
+    // that any thread may use; this type never aliases it (set at new, cleared+closed at drop).
+    unsafe impl Send for DisplayWakeRequest {}
+
+    impl DisplayWakeRequest {
+        /// Create + set the request. `None` when the kernel refuses (best-effort — the caller
+        /// streams without the assertion, exactly the pre-existing behavior).
+        pub fn new() -> Option<DisplayWakeRequest> {
+            let reason: Vec<u16> = "punktfunk streaming session\0".encode_utf16().collect();
+            let ctx = ReasonContext {
+                version: POWER_REQUEST_CONTEXT_VERSION,
+                flags: POWER_REQUEST_CONTEXT_SIMPLE_STRING,
+                simple_reason: reason.as_ptr(),
+            };
+            // SAFETY: `ctx` (and the reason buffer it points into) outlives the call, which copies
+            // the string into the kernel object; the returned handle is owned here and released in
+            // Drop. PowerSetRequest takes the just-created handle + a plain enum value.
+            unsafe {
+                let h = PowerCreateRequest(&ctx);
+                if h.is_null() || h as isize == INVALID_HANDLE_VALUE {
+                    return None;
+                }
+                PowerSetRequest(h, POWER_REQUEST_DISPLAY_REQUIRED);
+                PowerSetRequest(h, POWER_REQUEST_SYSTEM_REQUIRED);
+                Some(DisplayWakeRequest(h))
+            }
+        }
+    }
+
+    impl Drop for DisplayWakeRequest {
+        fn drop(&mut self) {
+            // SAFETY: `self.0` is the owned, still-open power-request handle (created in `new`,
+            // dropped exactly once); clear + close are plain handle calls.
+            unsafe {
+                PowerClearRequest(self.0, POWER_REQUEST_DISPLAY_REQUIRED);
+                PowerClearRequest(self.0, POWER_REQUEST_SYSTEM_REQUIRED);
+                CloseHandle(self.0);
+            }
+        }
+    }
 
     static PROCESS_TUNED: OnceLock<()> = OnceLock::new();
 
@@ -94,7 +164,7 @@ mod imp {
 }
 
 #[cfg(target_os = "windows")]
-pub use imp::on_hot_thread;
+pub use imp::{on_hot_thread, DisplayWakeRequest};
 
 /// No-op on non-Windows (Linux uses `setpriority` nice + CUDA stream priority instead — see
 /// `native::boost_thread_priority` and `zerocopy::cuda`).