diff --git a/src/wayland/protocols/output_configuration/handlers/cosmic.rs b/src/wayland/protocols/output_configuration/handlers/cosmic.rs
index f36d002d..b0b768df 100644
--- a/src/wayland/protocols/output_configuration/handlers/cosmic.rs
+++ b/src/wayland/protocols/output_configuration/handlers/cosmic.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use smithay::{
-    output::{Mode, Output},
+    output::Mode,
     reexports::{
         wayland_protocols_wlr::output_management::v1::server::{
             zwlr_output_configuration_head_v1::{self, ZwlrOutputConfigurationHeadV1},
@@ -99,10 +99,9 @@ where
                 }
             }
             zcosmic_output_manager_v1::Request::GetConfiguration { extended, config } => {
-                if let Some(pending) = config.data::<PendingConfiguration>() {
-                    let obj = data_init.init(extended, config.downgrade());
-                    pending.lock().unwrap().extension_obj = Some(obj);
-                }
+                let pending = config.data::<PendingConfiguration>().unwrap();
+                let obj = data_init.init(extended, config.downgrade());
+                pending.lock().unwrap().extension_obj = Some(obj);
             }
             zcosmic_output_manager_v1::Request::GetConfigurationHead {
                 extended,
@@ -178,54 +177,55 @@ where
                 mirroring,
             } => {
                 if let Ok(obj) = obj.upgrade() {
-                    if let Some(data) = obj.data::<PendingConfiguration>() {
-                        if let Some(output) = mirroring.data::<Output>() {
-                            let mut pending = data.lock().unwrap();
-                            if pending.heads.iter().any(|(h, _)| *h == head) {
-                                obj.post_error(
-                                    zwlr_output_configuration_v1::Error::AlreadyConfiguredHead,
-                                    format!("{:?} was already configured", head),
-                                );
-                                return;
-                            }
+                    let data = obj.data::<PendingConfiguration>().unwrap();
+                    if let Some(output) = mirroring.data::<WeakOutput>().unwrap().upgrade() {
+                        let mut pending = data.lock().unwrap();
+                        if pending.heads.iter().any(|(h, _)| *h == head) {
+                            obj.post_error(
+                                zwlr_output_configuration_v1::Error::AlreadyConfiguredHead,
+                                format!("{:?} was already configured", head),
+                            );
+                            return;
+                        }
 
-                            if pending.heads.iter().any(|(h, c)| {
-                                match c.as_ref() {
-                                    Some(c) => {
-                                        if let Some(conf) = c.data::<PendingOutputConfiguration>() {
-                                            match conf.lock().unwrap().mirroring.as_ref() {
-                                                Some(mirrored) => {
-                                                    head.data::<Output>().is_some_and(|o| o == mirrored) // we are already a mirror target -> invalid
-                                                    || *h == mirroring // our target already mirrors -> invalid
-                                                }
-                                                None => false,
-                                            }
-                                        } else {
-                                            *h == mirroring // unknown state for our mirror target -> invalid
+                        if pending.heads.iter().any(|(h, c)| {
+                            match c.as_ref() {
+                                Some(c) => {
+                                    let conf = c.data::<PendingOutputConfiguration>().unwrap();
+                                    match conf.lock().unwrap().mirroring.as_ref() {
+                                        Some(mirrored) => {
+                                            head.data::<WeakOutput>().unwrap() == mirrored // we are already a mirror target -> invalid
+                                            || *h == mirroring // our target already mirrors -> invalid
                                         }
+                                        None => false,
                                     }
-                                    None => *h == mirroring, // disabled state for our mirror target -> invalid
                                 }
-                            }) {
-                                extension_obj.post_error(
-                                zcosmic_output_configuration_v1::Error::MirroredHeadBusy,
-                                format!("{:?} can't mirror, it is either a mirror target itself or {:?} is not enabled/already mirroring", head, mirroring),
-                            );
+                                None => *h == mirroring, // disabled state for our mirror target -> invalid
                             }
-
-                            let output_conf = PendingOutputConfiguration::default();
-                            output_conf.lock().unwrap().mirroring = Some(output.clone());
-                            let conf_head = data_init.init(id, output_conf);
-                            pending.heads.push((head, Some(conf_head)));
+                        }) {
+                            extension_obj.post_error(
+                            zcosmic_output_configuration_v1::Error::MirroredHeadBusy,
+                            format!("{:?} can't mirror, it is either a mirror target itself or {:?} is not enabled/already mirroring", head, mirroring),
+                        );
                         }
+
+                        let output_conf = PendingOutputConfiguration::default();
+                        output_conf.lock().unwrap().mirroring = Some(output.clone());
+                        let conf_head = data_init.init(id, output_conf);
+                        pending.heads.push((head, Some(conf_head)));
+                    } else {
+                        let output_conf = PendingOutputConfiguration::default();
+                        data_init.init(id, output_conf);
                     }
+                } else {
+                    let output_conf = PendingOutputConfiguration::default();
+                    data_init.init(id, output_conf);
                 }
             }
             zcosmic_output_configuration_v1::Request::Release => {
                 if let Ok(obj) = obj.upgrade() {
-                    if let Some(data) = obj.data::<PendingConfiguration>() {
-                        data.lock().unwrap().extension_obj.take();
-                    }
+                    let data = obj.data::<PendingConfiguration>().unwrap();
+                    data.lock().unwrap().extension_obj.take();
                 }
             }
             _ => {}
@@ -257,40 +257,38 @@ where
         match request {
             zcosmic_output_configuration_head_v1::Request::SetScale1000 { scale_1000 } => {
                 if let Ok(obj) = obj.upgrade() {
-                    if let Some(data) = obj.data::<PendingOutputConfiguration>() {
-                        let mut pending = data.lock().unwrap();
-                        if pending.scale.is_some() {
-                            obj.post_error(
-                                zwlr_output_configuration_head_v1::Error::AlreadySet,
-                                format!("{:?} already had a scale configured", obj),
-                            );
-                            return;
-                        }
-                        pending.scale = Some((scale_1000 as f64) / 1000.0);
+                    let data = obj.data::<PendingOutputConfiguration>().unwrap();
+                    let mut pending = data.lock().unwrap();
+                    if pending.scale.is_some() {
+                        obj.post_error(
+                            zwlr_output_configuration_head_v1::Error::AlreadySet,
+                            format!("{:?} already had a scale configured", obj),
+                        );
+                        return;
                     }
+                    pending.scale = Some((scale_1000 as f64) / 1000.0);
                 }
             }
             zcosmic_output_configuration_head_v1::Request::SetAdaptiveSyncExt { state } => {
                 if let Ok(obj) = obj.upgrade() {
-                    if let Some(data) = obj.data::<PendingOutputConfiguration>() {
-                        let mut pending = data.lock().unwrap();
-                        if pending.adaptive_sync.is_some() {
-                            obj.post_error(
-                                zwlr_output_configuration_head_v1::Error::AlreadySet,
-                                format!("{:?} already had an adaptive_sync state configured", obj),
-                            );
-                            return;
-                        }
-                        pending.adaptive_sync = match state.into_result() {
-                            Ok(zcosmic_output_head_v1::AdaptiveSyncStateExt::Always) => {
-                                Some(AdaptiveSync::Force)
-                            }
-                            Ok(zcosmic_output_head_v1::AdaptiveSyncStateExt::Automatic) => {
-                                Some(AdaptiveSync::Enabled)
-                            }
-                            _ => Some(AdaptiveSync::Disabled),
-                        };
+                    let data = obj.data::<PendingOutputConfiguration>().unwrap();
+                    let mut pending = data.lock().unwrap();
+                    if pending.adaptive_sync.is_some() {
+                        obj.post_error(
+                            zwlr_output_configuration_head_v1::Error::AlreadySet,
+                            format!("{:?} already had an adaptive_sync state configured", obj),
+                        );
+                        return;
                     }
+                    pending.adaptive_sync = match state.into_result() {
+                        Ok(zcosmic_output_head_v1::AdaptiveSyncStateExt::Always) => {
+                            Some(AdaptiveSync::Force)
+                        }
+                        Ok(zcosmic_output_head_v1::AdaptiveSyncStateExt::Automatic) => {
+                            Some(AdaptiveSync::Enabled)
+                        }
+                        _ => Some(AdaptiveSync::Disabled),
+                    };
                 }
             }
             _ => {}
diff --git a/src/wayland/protocols/output_configuration/handlers/wlr.rs b/src/wayland/protocols/output_configuration/handlers/wlr.rs
index 1ac7ee19..4666b114 100644
--- a/src/wayland/protocols/output_configuration/handlers/wlr.rs
+++ b/src/wayland/protocols/output_configuration/handlers/wlr.rs
@@ -233,16 +233,10 @@ where
 
                 if pending.heads.iter().any(|(_, c)| match c {
                     Some(conf) => {
-                        if let Some(output_conf) = conf.data::<PendingOutputConfiguration>() {
-                            if let Some(output) = head.data::<Output>() {
-                                let pending_conf = output_conf.lock().unwrap();
-                                pending_conf.mirroring.as_ref().is_some_and(|o| o == output)
-                            } else {
-                                false
-                            }
-                        } else {
-                            false
-                        }
+                        let output_conf = conf.data::<PendingOutputConfiguration>().unwrap();
+                        let output = head.data::<WeakOutput>().unwrap();
+                        let pending_conf = output_conf.lock().unwrap();
+                        pending_conf.mirroring.as_ref().is_some_and(|o| o == output)
                     }
                     None => false,
                 }) {