Function RegisterWaitWithQueue

crates/stdlib/src/overlapped.rs:1742–1788

(
        object: isize,
        completion_port: isize,
        overlapped: usize,
        timeout: u32,
        vm: &VirtualMachine,
    )

    #[pyfunction]
    fn RegisterWaitWithQueue(
        object: isize,
        completion_port: isize,
        overlapped: usize,
        timeout: u32,
        vm: &VirtualMachine,
    ) -> PyResult<isize> {
        use windows_sys::Win32::System::Threading::{
            RegisterWaitForSingleObject, WT_EXECUTEINWAITTHREAD, WT_EXECUTEONLYONCE,
        };

        let data = alloc::sync::Arc::new(PostCallbackData {
            completion_port: completion_port as HANDLE,
            overlapped: overlapped as *mut OVERLAPPED,
        });

        // Create raw pointer for the callback - this increments refcount
        let data_ptr = alloc::sync::Arc::into_raw(data.clone());

        let mut new_wait_object: HANDLE = core::ptr::null_mut();
        let ret = unsafe {
            RegisterWaitForSingleObject(
                &mut new_wait_object,
                object as HANDLE,
                Some(post_to_queue_callback),
                data_ptr as *mut _,
                timeout,
                WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE,
            )
        };

        if ret == 0 {
            // Registration failed - reconstruct Arc to drop the extra reference
            unsafe {
                let _ = alloc::sync::Arc::from_raw(data_ptr);
            }
            return Err(set_from_windows_err(0, vm));
        }

        // Store in registry for cleanup tracking
        let wait_handle = new_wait_object as isize;
        if let Ok(mut registry) = wait_callback_registry().lock() {
            registry.insert(wait_handle, data);
        }

        Ok(wait_handle)
    }

    // Helper to cleanup callback data when unregistering
    // Just removes from registry - Arc ensures memory stays alive if callback is running