Clarify constructor failures and borrowed API contracts

compositor/src/activities.rs

@@ -51,7 +51,7 @@ impl Default for Engine {
             ),
             rules: Arc::new(RwLock::new(Arc::new(Rules {
                 enabled: false,
-                matcher: ferese_config::activities::Matcher::new(&settings)
+                matcher: ferese_config::activities::Matcher::try_new(&settings)
                     .expect("built-in rules"),
             }))),
             monitor: None,
@@ -691,7 +691,7 @@ mod tests {
             .spawn()
             .unwrap();
         let (owner, fd, _) = crate::ipc::activity_owner::inspect(child.id()).unwrap();
-        let matched = ferese_config::activities::Matcher::new(&Default::default())
+        let matched = ferese_config::activities::Matcher::try_new(&Default::default())
             .unwrap()
             .matches("cargo test", "/tmp", &[])
             .unwrap();
@@ -707,7 +707,7 @@ mod tests {
         let mut engine = Engine::default();
         let (owner, fd, _) = crate::ipc::activity_owner::inspect(std::process::id()).unwrap();
         let settings = ferese_config::activities::Settings::default();
-        let matched = ferese_config::activities::Matcher::new(&settings)
+        let matched = ferese_config::activities::Matcher::try_new(&settings)
             .unwrap()
             .matches("cargo test", "/tmp/test", &[])
             .unwrap();
@@ -859,7 +859,7 @@ mod tests {
     #[test]
     fn rule_is_pinned_across_atomic_reload_and_no_raw_metadata_is_published() {
         let settings = ferese_config::activities::Settings::default();
-        let matched = ferese_config::activities::Matcher::new(&settings)
+        let matched = ferese_config::activities::Matcher::try_new(&settings)
             .unwrap()
             .matches("cargo test --secret", "/secret/cwd", &[])
             .unwrap();
@@ -883,7 +883,7 @@ mod tests {
         replacement.rules[0].title = "Replacement".into();
         engine.configure(
             &replacement,
-            ferese_config::activities::Matcher::new(&replacement).unwrap(),
+            ferese_config::activities::Matcher::try_new(&replacement).unwrap(),
         );
         let after = engine.store.entries().next().unwrap();
         assert_eq!(after.data.title, "cargo test");

compositor/src/backends/direct.rs

@@ -442,12 +442,11 @@ pub fn init(event_loop: &mut EventLoop<Ferese>, state: &mut Ferese) -> Result<()
                     if let Some(token) = backend.power_retry.take() {
                         handle.remove(token);
                     }
-                    backend
-                        .presentation
-                        .values_mut()
-                        .for_each(PresentationClock::reset_timing);
-                    backend.devices.values_mut().for_each(|device| {
-                        device.outputs.values_mut().for_each(|output| {
+                    for clock in backend.presentation.values_mut() {
+                        clock.reset_timing();
+                    }
+                    for device in backend.devices.values_mut() {
+                        for output in device.outputs.values_mut() {
                             output.gamma.suspend();
                             cancel_output_timers(&handle, output);
                             output.surface.reset_buffers();
@@ -456,9 +455,9 @@ pub fn init(event_loop: &mut EventLoop<Ferese>, state: &mut Ferese) -> Result<()
                             output.capture_texture = None;
                             output.frame_pending = false;
                             output.power.suspended();
-                        });
+                        }
                         device.drm.pause();
-                    });
+                    }
                 }
 
                 state.display_presentation.clear();
@@ -2178,30 +2177,27 @@ fn send_frame_callbacks(state: &mut Ferese, output: &Output) {
         state.lock_frame_callbacks(output);
         return;
     }
-    state
-        .space
-        .elements()
-        .filter(|window| {
-            state
-                .windows
-                .ids()
-                .get(*window)
-                .is_some_and(|id| state.window_belongs_to_output(*id, output))
-        })
-        .for_each(|window| {
-            window.send_frame(output, state.start_time.elapsed(), None, |surface, _| {
-                eligible.get(&surface.into()).cloned()
-            });
+    let visible_windows = state.space.elements().filter(|window| {
+        state
+            .windows
+            .ids()
+            .get(*window)
+            .is_some_and(|id| state.window_belongs_to_output(*id, output))
+    });
+    for window in visible_windows {
+        window.send_frame(output, state.start_time.elapsed(), None, |surface, _| {
+            eligible.get(&surface.into()).cloned()
         });
+    }
     let layers = layer_map_for_output(output)
         .layers()
         .cloned()
         .collect::<Vec<_>>();
-    layers.iter().for_each(|layer| {
+    for layer in &layers {
         layer.send_frame(output, state.start_time.elapsed(), None, |surface, _| {
             eligible.get(&surface.into()).cloned()
         });
-    });
+    }
     state.send_cursor_frame(output);
     state.space.refresh();
     state.popups.cleanup();

compositor/src/backends/direct/topology.rs

@@ -2,11 +2,11 @@
 use std::path::PathBuf;
 
 use super::{
-    DrmNode, Duration, Ferese, HashMap, HashSet, Instant, OutputMode, Path, PresentationClock,
-    RegistrationToken, Scale, Session, TimeoutAction, Timer, all_gpus, cancel_output_timers,
-    drm_device_key, lid, monotonic_now, open_device, output_transform, refresh_connected_info,
-    refresh_monitor_policy, remember_applied_configuration, remove_device, rescan_device,
-    sync_battery_timer, transaction, validate_desired_outputs,
+    DrmNode, Duration, Ferese, HashMap, HashSet, Instant, OutputMode, Path, RegistrationToken,
+    Scale, Session, TimeoutAction, Timer, all_gpus, cancel_output_timers, drm_device_key, lid,
+    monotonic_now, open_device, output_transform, refresh_connected_info, refresh_monitor_policy,
+    remember_applied_configuration, remove_device, rescan_device, sync_battery_timer, transaction,
+    validate_desired_outputs,
 };
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -203,10 +203,9 @@ pub(super) fn reconcile_outputs(state: &mut Ferese, reactivate: bool) {
     backend.topology.dirty = false;
     backend.output_error = None;
     if reactivate {
-        backend
-            .presentation
-            .values_mut()
-            .for_each(PresentationClock::reset_timing);
+        for clock in backend.presentation.values_mut() {
+            clock.reset_timing();
+        }
     }
     if let Some(token) = backend.topology.retry_timer.take() {
         state.loop_handle.remove(token);

compositor/src/config.rs

@@ -149,7 +149,7 @@ impl Config {
         let binding_modes = self.binding_modes(&input_settings, &bindings)?;
         Ok(crate::RuntimeConfig {
             activity_settings: self.activities.clone(),
-            activity_matcher: ferese_config::activities::Matcher::new(&self.activities)
+            activity_matcher: ferese_config::activities::Matcher::try_new(&self.activities)
                 .map_err(ConfigError::Binding)?,
             lock_idle: self.lock_screen.validate()?,
             night_light: self.night_light.validate().map_err(ConfigError::Binding)?,

compositor/src/render/corner_tests.rs

@@ -344,7 +344,7 @@ fn panel_shader_matches_core_outlines_and_resets_for_popovers() {
                         },
                         bounds,
                         &groups,
-                        PixelGrid::new(scale).unwrap(),
+                        PixelGrid::try_new(scale).unwrap(),
                     )
                     .unwrap(),
                 );

compositor/src/render/materials.rs

@@ -896,7 +896,7 @@ mod region_geometry_tests {
                         },
                         ferese_layout::Rect::new((320. - width) / 2., 0., width, 44.),
                         &[],
-                        PixelGrid::new(scale).unwrap(),
+                        PixelGrid::try_new(scale).unwrap(),
                     )
                     .unwrap();
                     let presentation = crate::effects::PanelPresentation {
@@ -947,7 +947,7 @@ mod region_geometry_tests {
         use ferese_panel::shape::{AnchoredRadii, PixelGrid};
         for scale in [1., 1.25, 1.5, 2.] {
             for edge in [ferese_panel::Edge::Top, ferese_panel::Edge::Bottom] {
-                let mut hub = Hub::new(Profile::default(), 34.).unwrap();
+                let mut hub = Hub::try_new(Profile::default(), 34.).unwrap();
                 for mode in [Mode::Peek, Mode::Idle] {
                     hub.retarget(mode, [400., 300.]).unwrap();
                     for frame in 0..160 {
@@ -977,7 +977,7 @@ mod region_geometry_tests {
                             },
                             bounds,
                             &[],
-                            PixelGrid::new(scale).unwrap(),
+                            PixelGrid::try_new(scale).unwrap(),
                         )
                         .unwrap();
                         // Reproduce the f32 transport and logical capture bounds used by native materials.