refactor(firmware): centralize configuration and diagnostics

firmware/libs/kaptan-flight-config/src/profile/candidate.rs

@@ -1,60 +1,100 @@
 //! Private vehicle candidate and whole-profile validation boundary.
 
 use kaptan_config::{
-    ConfigAggregate, ConfigModel, ConfigValidate, ConfigValue, ConfigViolation, FieldDescriptor,
-    FieldId, FieldWriteError, ValidateFields, ValidationRule,
+    Config, ConfigModel, ConfigValue, ConfigViolation, FieldDescriptor, FieldId, FieldWriteError,
+    ValidationRule,
 };
+use kaptan_log::Severity;
 
 use super::{
-    ActuatorLimits, AidingSettings, ControlSettings, ObservabilitySettings, PidSettings,
+    ActuatorLimits, AidingSettings, ControlSettings, MavlinkLoggingSettings, PidSettings,
     SafetySettings, ThrustSettings, TimingSettings, VehicleCapabilities, VehicleProfile,
     control::{
         ActuatorLimitsCandidate, AidingCandidate, ControlCandidate, PidCandidate, ThrustCandidate,
     },
-    observability::ObservabilityCandidate,
-    registry,
+    mavlink_logging::MavlinkLoggingCandidate,
     safety::SafetyCandidate,
     timing::TimingCandidate,
 };
 
 /// Current persisted CBOR schema for the vehicle candidate.
-pub const FORMAT_VERSION: u16 = 1;
+pub const FORMAT_VERSION: u16 = 2;
 
 /// Complete editable vehicle candidate.
 ///
-/// Fields are private outside this crate. Operators, CBOR import, and MAVLink
-/// transport all use the same descriptor/mutation and full-validation path.
-#[derive(Clone, Copy, ConfigValidate)]
+/// Fields are private outside this crate. Local snapshot recovery and MAVLink
+/// scalar writes both use the same descriptor/mutation and full-validation
+/// path.
+#[derive(Clone, Copy, Config)]
 pub struct CandidateProfile {
-    #[config(section)]
     pub(super) safety: SafetyCandidate,
-    #[config(section)]
     pub(super) timing: TimingCandidate,
-    #[config(section)]
     pub(super) aiding: AidingCandidate,
-    #[config(section)]
     pub(super) control: ControlCandidate,
-    #[config(section)]
     pub(super) thrust: ThrustCandidate,
-    #[config(section)]
     pub(super) rate_pid: PidCandidate,
-    #[config(section)]
     pub(super) actuator_limits: ActuatorLimitsCandidate,
-    #[config(section)]
-    pub(super) observability: ObservabilityCandidate,
-}
-
-impl Default for CandidateProfile {
-    fn default() -> Self {
-        <Self as ConfigAggregate>::default_aggregate()
-            .expect("compiled configuration defaults must validate")
-    }
+    pub(super) mavlink_logging: MavlinkLoggingCandidate,
 }
 
 impl CandidateProfile {
+    /// Explicit factory candidate used by the vehicle-profile examples.
+    ///
+    /// Board firmware supplies its own factory [`Config`] through the board
+    /// composition root; configuration types never synthesize values through
+    /// [`Default`].
+    pub const fn factory() -> Self {
+        Self {
+            safety: SafetyCandidate {
+                prearm_dwell_microseconds: 100_000,
+            },
+            timing: TimingCandidate {
+                maximum_imu_interval_microseconds: 50_000,
+                imu_freshness_microseconds: 50_000,
+                local_state_freshness_microseconds: 150_000,
+                command_link_freshness_microseconds: 500_000,
+            },
+            aiding: AidingCandidate {
+                position_variance_m2: 0.04,
+                velocity_variance_m2_per_second_squared: 0.04,
+            },
+            control: ControlCandidate {
+                position_gain_per_second_squared: 0.8,
+                velocity_gain_per_second: 1.2,
+                maximum_horizontal_acceleration_mps2: 3.0,
+                maximum_upward_acceleration_mps2: 2.0,
+                maximum_downward_acceleration_mps2: 2.0,
+            },
+            thrust: ThrustCandidate {
+                mass_kg: 1.2,
+                maximum_collective_thrust_newtons: 18.0,
+                maximum_tilt_tangent: 0.700_207_53,
+            },
+            rate_pid: PidCandidate {
+                proportional: 0.035,
+                integral: 0.006,
+                derivative: 0.0,
+                output_limit: 0.10,
+                integral_limit: 0.025,
+            },
+            actuator_limits: ActuatorLimitsCandidate {
+                minimum: 0.0,
+                maximum: 1.0,
+                slew_per_second: 8.0,
+            },
+            mavlink_logging: MavlinkLoggingCandidate {
+                enabled: true,
+                maximum_severity: Severity::Info,
+            },
+        }
+    }
+
     /// Returns the complete transport-neutral descriptor registry.
-    pub const fn descriptors() -> &'static [FieldDescriptor; Self::FIELD_COUNT] {
-        registry::descriptors()
+    pub fn descriptors() -> impl ExactSizeIterator<Item = &'static FieldDescriptor> + Clone {
+        (0..Self::FIELD_COUNT).map(|index| {
+            <Self as Config>::descriptor(index)
+                .expect("derived aggregate descriptor count must be exact")
+        })
     }
 
     fn from_active(active: &VehicleProfile) -> Self {
@@ -65,7 +105,7 @@ impl CandidateProfile {
         let thrust = active.thrust();
         let rate_pid = active.rate_pid();
         let actuator_limits = active.actuator_limits();
-        let observability = active.observability();
+        let mavlink_logging = active.mavlink_logging();
         Self {
             safety: SafetyCandidate {
                 prearm_dwell_microseconds: safety.prearm_dwell_microseconds(),
@@ -106,8 +146,9 @@ impl CandidateProfile {
                 maximum: actuator_limits.maximum(),
                 slew_per_second: actuator_limits.slew_per_second(),
             },
-            observability: ObservabilityCandidate {
-                maximum_log_level: observability.maximum_log_level(),
+            mavlink_logging: MavlinkLoggingCandidate {
+                enabled: mavlink_logging.enabled(),
+                maximum_severity: mavlink_logging.maximum_severity(),
             },
         }
     }
@@ -116,7 +157,7 @@ impl CandidateProfile {
         &self,
         capabilities: &VehicleCapabilities,
     ) -> Result<VehicleProfile, ConfigViolation> {
-        self.validate_fields()?;
+        <Self as Config>::validate(self)?;
         self.validate_capabilities(capabilities)?;
         Ok(VehicleProfile {
             safety: SafetySettings {
@@ -162,7 +203,10 @@ impl CandidateProfile {
                 maximum: self.actuator_limits.maximum,
                 slew_per_second: self.actuator_limits.slew_per_second,
             },
-            observability: ObservabilitySettings::new(self.observability.maximum_log_level),
+            mavlink_logging: MavlinkLoggingSettings::new(
+                self.mavlink_logging.enabled,
+                self.mavlink_logging.maximum_severity,
+            ),
             mixer: capabilities.mixer(),
         })
     }
@@ -183,10 +227,10 @@ impl CandidateProfile {
 impl ConfigModel for CandidateProfile {
     type Active = VehicleProfile;
     type Context = VehicleCapabilities;
-    const SCHEMA_ID: [u8; 16] = crate::SCHEMA_ID;
+    const SCHEMA_ID: [u8; 16] = <Self as Config>::SCHEMA_ID;
 
     fn descriptor(index: u16) -> Option<&'static FieldDescriptor> {
-        registry::descriptor(index)
+        <Self as Config>::descriptor(usize::from(index))
     }
 
     fn field_count() -> u16 {
@@ -194,15 +238,15 @@ impl ConfigModel for CandidateProfile {
     }
 
     fn field_value(&self, id: FieldId) -> Option<ConfigValue> {
-        <Self as ConfigAggregate>::field_value(self, id)
+        <Self as Config>::field_value(self, id)
     }
 
     fn active_field_value(active: &Self::Active, id: FieldId) -> Option<ConfigValue> {
-        <Self as ConfigAggregate>::field_value(&Self::from_active(active), id)
+        <Self as Config>::field_value(&Self::from_active(active), id)
     }
 
     fn set_field(&mut self, id: FieldId, value: ConfigValue) -> Result<(), FieldWriteError> {
-        <Self as ConfigAggregate>::set_field(self, id, value)
+        <Self as Config>::set_field(self, id, value)
     }
 
     fn validate(&self, context: &Self::Context) -> Result<Self::Active, ConfigViolation> {
@@ -214,36 +258,43 @@ impl ConfigModel for CandidateProfile {
 mod tests {
     use kaptan_config::{ConfigModel, ConfigValue, FieldId, FieldWriteError, ValidationRule};
 
-    use super::{CandidateProfile, VehicleCapabilities};
+    use super::{CandidateProfile, Severity, VehicleCapabilities};
     use crate::profile::ids;
 
     const CAPABILITIES: VehicleCapabilities = VehicleCapabilities::quad_x();
 
+    #[test]
+    fn generated_schema_fingerprint_is_stable() {
+        assert_eq!(
+            crate::SCHEMA_ID,
+            [
+                0xc4, 0xf6, 0x36, 0xc0, 0x29, 0xd2, 0x3e, 0x29, 0xa3, 0x85, 0x5b, 0x36, 0xb7, 0xb3,
+                0x59, 0x9c,
+            ]
+        );
+    }
+
     fn descriptor_id(display_key: &str) -> FieldId {
         CandidateProfile::descriptors()
-            .iter()
             .find(|descriptor| descriptor.display_key == display_key)
             .expect("declared field descriptor")
             .id
     }
 
     #[test]
-    fn every_descriptor_has_a_readable_default_value() {
-        let candidate = CandidateProfile::default();
+    fn every_descriptor_has_a_readable_factory_value() {
+        let candidate = CandidateProfile::factory();
         for descriptor in CandidateProfile::descriptors() {
-            assert_eq!(
-                candidate.field_value(descriptor.id),
-                Some(descriptor.default)
-            );
+            assert!(candidate.field_value(descriptor.id).is_some());
         }
     }
 
     #[test]
     fn aggregated_descriptor_ids_are_unique() {
-        for (index, descriptor) in CandidateProfile::descriptors().iter().enumerate() {
+        for (index, descriptor) in CandidateProfile::descriptors().enumerate() {
             assert!(
-                CandidateProfile::descriptors()[index + 1..]
-                    .iter()
+                CandidateProfile::descriptors()
+                    .skip(index + 1)
                     .all(|other| other.id != descriptor.id)
             );
         }
@@ -251,7 +302,7 @@ mod tests {
 
     #[test]
     fn cross_field_invalid_edit_is_retained_only_in_the_candidate() {
-        let mut candidate = CandidateProfile::default();
+        let mut candidate = CandidateProfile::factory();
         candidate
             .set_field(
                 ids::MAXIMUM_IMU_INTERVAL_MICROSECONDS,
@@ -266,7 +317,7 @@ mod tests {
 
     #[test]
     fn local_write_error_retains_exact_field_and_rule() {
-        let mut candidate = CandidateProfile::default();
+        let mut candidate = CandidateProfile::factory();
         assert_eq!(
             candidate.set_field(ids::MASS_KG, ConfigValue::F32(f32::NAN)),
             Err(FieldWriteError::non_finite(ids::MASS_KG))
@@ -280,7 +331,7 @@ mod tests {
                 .into_iter()
                 .flatten()
             {
-                let mut candidate = CandidateProfile::default();
+                let mut candidate = CandidateProfile::factory();
                 candidate
                     .set_field(descriptor.id, bound)
                     .expect("descriptor bound must pass the descriptor-backed setter");
@@ -297,20 +348,26 @@ mod tests {
     }
 
     #[test]
-    fn observability_filter_is_persisted_restart_only_and_cannot_hide_errors() {
-        let mut candidate = CandidateProfile::default();
+    fn mavlink_logging_policy_is_persisted_and_restart_only() {
+        let mut candidate = CandidateProfile::factory();
+        let severity_descriptor = CandidateProfile::descriptors()
+            .find(|descriptor| descriptor.display_key == "mavlink.logging.maximum_severity")
+            .unwrap();
+        assert_eq!(
+            severity_descriptor.enum_options,
+            Severity::CONFIG_ENUM_OPTIONS
+        );
         candidate
             .set_field(
-                descriptor_id("observability.maximum_log_level"),
-                ConfigValue::U32(3),
+                descriptor_id("mavlink.logging.enabled"),
+                ConfigValue::Bool(false),
             )
             .unwrap();
         let active = candidate.validate(&CAPABILITIES).unwrap();
-        assert_eq!(active.observability().maximum_log_level(), 3);
-        assert_eq!(active.observability().maximum_log_level(), 3);
+        assert!(!active.mavlink_logging().enabled());
         candidate
             .set_field(
-                descriptor_id("observability.maximum_log_level"),
+                descriptor_id("mavlink.logging.maximum_severity"),
                 ConfigValue::U32(5),
             )
             .unwrap();
@@ -318,27 +375,27 @@ mod tests {
             candidate
                 .validate(&CAPABILITIES)
                 .unwrap()
-                .observability()
-                .maximum_log_level(),
-            5
+                .mavlink_logging()
+                .maximum_severity(),
+            Severity::Notice
         );
         assert!(matches!(
             candidate.set_field(
-                descriptor_id("observability.maximum_log_level"),
-                ConfigValue::U32(2),
+                descriptor_id("mavlink.logging.maximum_severity"),
+                ConfigValue::U32(8),
             ),
             Err(FieldWriteError::Violation(issue))
-                if issue.rule() == ValidationRule::BelowMinimum
+                if issue.rule() == ValidationRule::InvalidEnumValue
         ));
     }
 
     #[test]
     fn every_persisted_log_severity_is_retained_exactly() {
-        for raw in [3, 4, 5, 6, 7] {
-            let mut candidate = CandidateProfile::default();
+        for raw in 0..=7 {
+            let mut candidate = CandidateProfile::factory();
             candidate
                 .set_field(
-                    descriptor_id("observability.maximum_log_level"),
+                    descriptor_id("mavlink.logging.maximum_severity"),
                     ConfigValue::U32(raw),
                 )
                 .expect("descriptor range accepts the stable severity");
@@ -346,9 +403,9 @@ mod tests {
                 candidate
                     .validate(&CAPABILITIES)
                     .expect("valid complete profile")
-                    .observability()
-                    .maximum_log_level(),
-                raw
+                    .mavlink_logging()
+                    .maximum_severity(),
+                Severity::try_from_wire(u8::try_from(raw).unwrap()).unwrap()
             );
         }
     }