style(core): format v8 gameplay modules

Author: AxonOS-BCI

crates/neural-boundary-core/src/combo.rs

@@ -168,10 +168,19 @@ mod tests {
     #[test]
     fn detect_matches_all_five_combos() {
         use PlayerAction::*;
-        assert_eq!(ComboKind::detect(Audit, Authorize), ComboKind::AuditAuthorize);
-        assert_eq!(ComboKind::detect(Quarantine, SealVault), ComboKind::QuarantineSeal);
+        assert_eq!(
+            ComboKind::detect(Audit, Authorize),
+            ComboKind::AuditAuthorize
+        );
+        assert_eq!(
+            ComboKind::detect(Quarantine, SealVault),
+            ComboKind::QuarantineSeal
+        );
         assert_eq!(ComboKind::detect(Throttle, Audit), ComboKind::ThrottleAudit);
-        assert_eq!(ComboKind::detect(Revoke, Quarantine), ComboKind::RevokeQuarantine);
+        assert_eq!(
+            ComboKind::detect(Revoke, Quarantine),
+            ComboKind::RevokeQuarantine
+        );
         assert_eq!(ComboKind::detect(Audit, Release), ComboKind::AuditRelease);
     }
 
@@ -190,7 +199,10 @@ mod tests {
         assert_eq!(w.on_action(PlayerAction::Audit), ComboKind::None);
         assert_eq!(w.ticks_left, COMBO_WINDOW_TICKS);
         // Follow-up within window: combo completes.
-        assert_eq!(w.on_action(PlayerAction::Authorize), ComboKind::AuditAuthorize);
+        assert_eq!(
+            w.on_action(PlayerAction::Authorize),
+            ComboKind::AuditAuthorize
+        );
         assert_eq!(w.last(), ComboKind::AuditAuthorize);
     }
 

crates/neural-boundary-core/src/grade.rs

@@ -198,7 +198,10 @@ mod tests {
 
     #[test]
     fn terminal_failure_is_f() {
-        let g = GradeInputs { terminal_failure: true, ..base() };
+        let g = GradeInputs {
+            terminal_failure: true,
+            ..base()
+        };
         assert_eq!(grade_for(g), Grade::Unsafe);
     }
 
@@ -209,19 +212,32 @@ mod tests {
 
     #[test]
     fn strong_release_is_s() {
-        let g = GradeInputs { score: 750, boundary_integrity: 80, consent_coherence: 80, vault_integrity: 80, ..base() };
+        let g = GradeInputs {
+            score: 750,
+            boundary_integrity: 80,
+            consent_coherence: 80,
+            vault_integrity: 80,
+            ..base()
+        };
         assert_eq!(grade_for(g), Grade::Sealed);
     }
 
     #[test]
     fn imperfect_release_is_a() {
-        let g = GradeInputs { score: 400, ..base() };
+        let g = GradeInputs {
+            score: 400,
+            ..base()
+        };
         assert_eq!(grade_for(g), Grade::Reviewable);
     }
 
     #[test]
     fn timeout_with_health_is_contained_else_compromised() {
-        let survived = GradeInputs { released_safely: false, score: 300, ..base() };
+        let survived = GradeInputs {
+            released_safely: false,
+            score: 300,
+            ..base()
+        };
         assert_eq!(grade_for(survived), Grade::Contained);
         let damaged = GradeInputs {
             released_safely: false,
@@ -231,7 +247,11 @@ mod tests {
             ..base()
         };
         assert_eq!(grade_for(damaged), Grade::Compromised);
-        let breached = GradeInputs { released_safely: false, breached: true, ..base() };
+        let breached = GradeInputs {
+            released_safely: false,
+            breached: true,
+            ..base()
+        };
         assert_eq!(grade_for(breached), Grade::Compromised);
     }
 

crates/neural-boundary-core/src/threat.rs

@@ -230,9 +230,17 @@ mod tests {
         use PlayerAction as A;
         // (threat, best, follow) straight from TZ §3.4.
         let table = [
-            (ThreatKind::RawSignalExposure, A::Quarantine, Some(A::SealVault)),
+            (
+                ThreatKind::RawSignalExposure,
+                A::Quarantine,
+                Some(A::SealVault),
+            ),
             (ThreatKind::ConsentDrift, A::Audit, Some(A::Revoke)),
-            (ThreatKind::PermissionEscalation, A::Audit, Some(A::Authorize)),
+            (
+                ThreatKind::PermissionEscalation,
+                A::Audit,
+                Some(A::Authorize),
+            ),
             (ThreatKind::VaultLeak, A::SealVault, None),
             (ThreatKind::StimulationSpike, A::Throttle, None),
             (ThreatKind::LatencyStorm, A::Throttle, None),
@@ -241,7 +249,11 @@ mod tests {
             (ThreatKind::SensorNoiseBurst, A::Audit, None),
             (ThreatKind::PolicyConflict, A::Audit, Some(A::Revoke)),
             (ThreatKind::CognitiveOverload, A::Throttle, None),
-            (ThreatKind::EmergencyOverride, A::Quarantine, Some(A::SealVault)),
+            (
+                ThreatKind::EmergencyOverride,
+                A::Quarantine,
+                Some(A::SealVault),
+            ),
         ];
         for (threat, best, follow) in table {
             assert_eq!(threat.best_action(), best, "best for {:?}", threat);
@@ -252,8 +264,14 @@ mod tests {
     #[test]
     fn rate_action_classifies_correctly() {
         let t = ThreatKind::RawSignalExposure;
-        assert_eq!(t.rate_action(PlayerAction::Quarantine), CounterRating::Correct);
-        assert_eq!(t.rate_action(PlayerAction::SealVault), CounterRating::Partial);
+        assert_eq!(
+            t.rate_action(PlayerAction::Quarantine),
+            CounterRating::Correct
+        );
+        assert_eq!(
+            t.rate_action(PlayerAction::SealVault),
+            CounterRating::Partial
+        );
         assert_eq!(t.rate_action(PlayerAction::Throttle), CounterRating::Wrong);
         assert_eq!(t.rate_action(PlayerAction::None), CounterRating::Neutral);
     }
@@ -269,7 +287,10 @@ mod tests {
             ThreatKind::from_event(EventKind::RawSignalExposure),
             ThreatKind::RawSignalExposure
         );
-        assert_eq!(ThreatKind::from_event(EventKind::BenignFlow), ThreatKind::None);
+        assert_eq!(
+            ThreatKind::from_event(EventKind::BenignFlow),
+            ThreatKind::None
+        );
     }
 
     #[test]