style: apply rustfmt to the deepnsm crate

deepnsm is a workspace-excluded crate, so `cargo fmt --all` and the CI
fmt job never reach it; its sources had drifted from rustfmt's default
rules (manual column alignment across 28 files). Apply `cargo fmt` to
bring the whole crate to a rustfmt-clean baseline.

Pure formatting, no behavioural change. 217 lib tests still pass.
`cargo fmt -- --check` is now clean (lib.rs needed a second pass for a
trailing-comment reflow after reorder_modules; default rustfmt rules,
no rustfmt.toml in the tree).

Follow-up worth considering: wire deepnsm into the CI fmt check so it
can't silently drift again.

https://claude.ai/code/session_014A4JuRCqKP2yNENrQ9Ha7H

Author: claude

crates/deepnsm/examples/probe_semantic_sanity.rs

@@ -49,8 +49,8 @@
 use std::fs;
 use std::path::PathBuf;
 
-use deepnsm::DeepNsmEngine;
 use deepnsm::spo::WordDistanceMatrix;
+use deepnsm::DeepNsmEngine;
 
 fn main() {
     println!("# Probe: DeepNSM Semantic Layer Sanity");
@@ -86,7 +86,11 @@ fn main() {
         let nonzero_diagonals: Vec<(usize, u8)> = (0..k)
             .filter_map(|i| {
                 let d = dm.get(i as u16, i as u16);
-                if d != 0 { Some((i, d)) } else { None }
+                if d != 0 {
+                    Some((i, d))
+                } else {
+                    None
+                }
             })
             .take(5)
             .collect();
@@ -113,10 +117,14 @@ fn main() {
     // Convert to f64 for stats
     let n = off.len() as f64;
     let mean: f64 = off.iter().map(|&v| v as f64).sum::<f64>() / n;
-    let var: f64 = off.iter().map(|&v| {
-        let diff = v as f64 - mean;
-        diff * diff
-    }).sum::<f64>() / n;
+    let var: f64 = off
+        .iter()
+        .map(|&v| {
+            let diff = v as f64 - mean;
+            diff * diff
+        })
+        .sum::<f64>()
+        / n;
     let std_dev = var.sqrt();
 
     // Percentiles via sort
@@ -165,12 +173,20 @@ fn main() {
     //    has no per-row distinguishing structure → degenerate.
     let row_sum_f64: Vec<f64> = row_sum.iter().map(|&s| s as f64).collect();
     let mean_rs = row_sum_f64.iter().sum::<f64>() / k as f64;
-    let var_rs = row_sum_f64.iter().map(|&s| {
-        let diff = s - mean_rs;
-        diff * diff
-    }).sum::<f64>() / k as f64;
+    let var_rs = row_sum_f64
+        .iter()
+        .map(|&s| {
+            let diff = s - mean_rs;
+            diff * diff
+        })
+        .sum::<f64>()
+        / k as f64;
     let std_rs = var_rs.sqrt();
-    let cv = if mean_rs.abs() > 1e-9 { std_rs / mean_rs } else { 0.0 };
+    let cv = if mean_rs.abs() > 1e-9 {
+        std_rs / mean_rs
+    } else {
+        0.0
+    };
     println!("## Row-sum constancy (matrix isotropy proxy)");
     println!("- mean row sum: {:.2}", mean_rs);
     println!("- std  row sum: {:.2}", std_rs);
@@ -186,17 +202,25 @@ fn main() {
     for i in 0..k {
         let mut best = u32::MAX;
         for j in 0..k {
-            if i == j { continue; }
+            if i == j {
+                continue;
+            }
             let d = dm.get(i as u16, j as u16) as u32;
-            if d < best { best = d; }
+            if d < best {
+                best = d;
+            }
         }
         nn_dist.push(best);
     }
     let nn_mean: f64 = nn_dist.iter().map(|&v| v as f64).sum::<f64>() / k as f64;
-    let nn_var: f64 = nn_dist.iter().map(|&v| {
-        let diff = v as f64 - nn_mean;
-        diff * diff
-    }).sum::<f64>() / k as f64;
+    let nn_var: f64 = nn_dist
+        .iter()
+        .map(|&v| {
+            let diff = v as f64 - nn_mean;
+            diff * diff
+        })
+        .sum::<f64>()
+        / k as f64;
     let nn_std = nn_var.sqrt();
     println!("## Nearest-neighbor distance (excluding self)");
     println!("- mean: {:.2}", nn_mean);
@@ -232,8 +256,10 @@ fn main() {
     println!("| matrix size | 256×256 | {}×{} |", k, k);
     println!("| off-diag mean | 0.640 (cos) | {:.2} (u8 dist) |", mean);
     println!("| effective rank | 1.82 | see Python follow-up |");
-    println!("| frac > 0.9 (cos) / high u8 | 43.76% | {:.2}% (top 10 bins) |",
-             top10 as f64 / n * 100.0);
+    println!(
+        "| frac > 0.9 (cos) / high u8 | 43.76% | {:.2}% (top 10 bins) |",
+        top10 as f64 / n * 100.0
+    );
     println!("| nearest-neighbor similarity | 0.9407 (cos) | see std above |");
     println!();
 
@@ -242,7 +268,10 @@ fn main() {
     println!();
     println!("```python");
     println!("import numpy as np");
-    println!("d = np.fromfile('{}', dtype=np.uint8).reshape(4096, 4096).astype(np.float64)", dump_path);
+    println!(
+        "d = np.fromfile('{}', dtype=np.uint8).reshape(4096, 4096).astype(np.float64)",
+        dump_path
+    );
     println!("# Convert distance to similarity: normalize [0,255] → [0,1], invert");
     println!("max_d = d.max()");
     println!("sim = 1.0 - d / max(max_d, 1)");

crates/deepnsm/src/arcs.rs

@@ -66,7 +66,10 @@ mod tests {
         let ranks = [12_u16, 670, 2942];
         let (basin, literal) = t.split_arcs(&ranks);
         assert_eq!(basin.0, t.fingerprint, "basin arc IS the spine bundle");
-        assert_eq!(literal.0, ranks, "literal arc carries the COCA ranks verbatim");
+        assert_eq!(
+            literal.0, ranks,
+            "literal arc carries the COCA ranks verbatim"
+        );
     }
 
     #[test]

crates/deepnsm/src/arcuate.rs

@@ -166,6 +166,9 @@ mod tests {
         }
         let result = arc.disambiguate([fp(1.0), fp(-1.0)]);
         assert_eq!(result.candidate_count, 2, "both candidates evaluated");
-        assert!(result.winner_index < 2, "a real winner over the ±5 evidence");
+        assert!(
+            result.winner_index < 2,
+            "a real winner over the ±5 evidence"
+        );
     }
 }

crates/deepnsm/src/cam64.rs

@@ -65,31 +65,51 @@ impl Cam64 {
 
     /// Raw u64 value.
     #[inline]
-    pub fn raw(self) -> u64 { self.0 }
+    pub fn raw(self) -> u64 {
+        self.0
+    }
 
     /// Construct from raw u64.
     #[inline]
-    pub fn from_raw(v: u64) -> Self { Self(v) }
+    pub fn from_raw(v: u64) -> Self {
+        Self(v)
+    }
 
     // ── Named lane accessors ─────────────────────────────────────────────────
 
     /// Vocabulary bucket of the active subject (lane 0).
     /// Bucket = rank >> 5 → 128 buckets of 32 adjacent vocabulary items each.
-    pub fn entity_state(self)    -> u8 { self.lane(0) }
+    pub fn entity_state(self) -> u8 {
+        self.lane(0)
+    }
     /// Vocabulary bucket of the active predicate (lane 1).
-    pub fn predicate_state(self) -> u8 { self.lane(1) }
+    pub fn predicate_state(self) -> u8 {
+        self.lane(1)
+    }
     /// Vocabulary bucket of the active object, or 0 if absent (lane 2).
-    pub fn object_state(self)    -> u8 { self.lane(2) }
+    pub fn object_state(self) -> u8 {
+        self.lane(2)
+    }
     /// `MorphFlags` bits 0-7: tense, number, person, passive, negated (lane 3).
-    pub fn morph_state(self)     -> u8 { self.lane(3) }
+    pub fn morph_state(self) -> u8 {
+        self.lane(3)
+    }
     /// `MorphFlags` bits 8-13: clause structure flags (lane 4).
-    pub fn clause_state(self)    -> u8 { self.lane(4) }
+    pub fn clause_state(self) -> u8 {
+        self.lane(4)
+    }
     /// Discourse / anaphora: entity-stack depth (bits 0-6) + coreference flag (bit 7) (lane 5).
-    pub fn discourse_state(self) -> u8 { self.lane(5) }
+    pub fn discourse_state(self) -> u8 {
+        self.lane(5)
+    }
     /// Causal / temporal / conditional markers (lane 6).
-    pub fn causal_state(self)    -> u8 { self.lane(6) }
+    pub fn causal_state(self) -> u8 {
+        self.lane(6)
+    }
     /// Episodic basin markers: novelty/entropy/epiphany flags (lane 7).
-    pub fn basin_state(self)     -> u8 { self.lane(7) }
+    pub fn basin_state(self) -> u8 {
+        self.lane(7)
+    }
 
     // ── Construction helpers ─────────────────────────────────────────────────
 
@@ -109,38 +129,46 @@ impl Cam64 {
     ) -> Self {
         // Lanes 0-2: vocabulary-bucket of each role (128 buckets of 32 ranks).
         // Adjacent vocabulary items share a bucket → helps basin-matching.
-        let entity_lane   = (triple.subject() >> 5) as u8;
-        let pred_lane     = (triple.predicate() >> 5) as u8;
-        let obj_lane      = if triple.object() != NO_ROLE {
+        let entity_lane = (triple.subject() >> 5) as u8;
+        let pred_lane = (triple.predicate() >> 5) as u8;
+        let obj_lane = if triple.object() != NO_ROLE {
             (triple.object() >> 5) as u8
         } else {
             0
         };
 
         // Lanes 3-4: split MorphFlags across two bytes.
-        let morph_bits    = morph.bits();
+        let morph_bits = morph.bits();
         // MorphFlags is defined over bits 0-13 (bits 14-15 spare; see morphology.rs).
         // clause_lane below carries bits 8-15, so a future flag at bit 14/15 would
         // land there with no defined meaning — guard the invariant in debug builds.
-        debug_assert!(morph_bits <= 0x3FFF, "MorphFlags bit 14/15 set — cam64 clause lane has no slot for it");
-        let morph_lane    = (morph_bits & 0xFF) as u8;
-        let clause_lane   = ((morph_bits >> 8) & 0xFF) as u8;
+        debug_assert!(
+            morph_bits <= 0x3FFF,
+            "MorphFlags bit 14/15 set — cam64 clause lane has no slot for it"
+        );
+        let morph_lane = (morph_bits & 0xFF) as u8;
+        let clause_lane = ((morph_bits >> 8) & 0xFF) as u8;
 
         // Lane 5: discourse — stack depth (bits 0-6) + coreference flag (bit 7).
         let depth_clamped = entity_stack_depth.min(127);
         let discourse_lane = depth_clamped | if coreference_resolved { 0x80 } else { 0 };
 
         // Lane 6: causal/temporal — bit 0 = temporal marker present (v1;
         // causal/conditional markers in bits 1-7 reserved for v2).
-        let causal_lane   = if has_temporal { 0x01u8 } else { 0x00 };
+        let causal_lane = if has_temporal { 0x01u8 } else { 0x00 };
 
         // Lane 7: basin — bit 0 = novelty_high (v1 placeholder; epiphany/wisdom baked in v2).
-        let basin_lane    = if novelty_high { 0x01u8 } else { 0x00 };
+        let basin_lane = if novelty_high { 0x01u8 } else { 0x00 };
 
         Self::from_lanes([
-            entity_lane, pred_lane, obj_lane,
-            morph_lane, clause_lane,
-            discourse_lane, causal_lane, basin_lane,
+            entity_lane,
+            pred_lane,
+            obj_lane,
+            morph_lane,
+            clause_lane,
+            discourse_lane,
+            causal_lane,
+            basin_lane,
         ])
     }
 
@@ -179,7 +207,7 @@ impl Cam64 {
     #[inline]
     pub fn continues_basin(self, prev: Cam64) -> bool {
         let diff = self.0 ^ prev.0;
-        let diff_bits  = diff.count_ones();
+        let diff_bits = diff.count_ones();
         let shared_bits = 64 - diff_bits; // XNOR popcount via complement
         shared_bits >= CAM64_CONTINUATION_MIN_SHARED && diff_bits <= CAM64_CONTINUATION_MAX_DIFF
     }
@@ -209,9 +237,14 @@ impl core::fmt::Debug for Cam64 {
             f,
             "Cam64(entity={:#04x} pred={:#04x} obj={:#04x} morph={:#04x} \
              clause={:#04x} discourse={:#04x} causal={:#04x} basin={:#04x})",
-            self.entity_state(), self.predicate_state(), self.object_state(),
-            self.morph_state(), self.clause_state(), self.discourse_state(),
-            self.causal_state(), self.basin_state(),
+            self.entity_state(),
+            self.predicate_state(),
+            self.object_state(),
+            self.morph_state(),
+            self.clause_state(),
+            self.discourse_state(),
+            self.causal_state(),
+            self.basin_state(),
         )
     }
 }
@@ -256,7 +289,7 @@ mod tests {
         let t = SpoTriple::new(1, 2, 3);
         // Set a flag that lands in the high byte (RELATIVE_CLAUSE = bit 11)
         let m = MorphFlags::default()
-            .set(MorphFlags::NEGATED)          // bit 9 → high byte bit 1
+            .set(MorphFlags::NEGATED) // bit 9 → high byte bit 1
             .set(MorphFlags::RELATIVE_CLAUSE); // bit 11 → high byte bit 3
         let c = Cam64::from_triple(&t, m, 0, false, false, false);
         // morph_lane = low byte of flags
@@ -270,7 +303,7 @@ mod tests {
         let t = SpoTriple::new(1, 2, 3);
         let m = MorphFlags::default();
         let c_yes = Cam64::from_triple(&t, m, 5, true, false, false);
-        let c_no  = Cam64::from_triple(&t, m, 5, false, false, false);
+        let c_no = Cam64::from_triple(&t, m, 5, false, false, false);
         assert!(c_yes.has_coreference());
         assert!(!c_no.has_coreference());
         assert_eq!(c_yes.entity_stack_depth(), 5);

crates/deepnsm/src/codebook.rs

@@ -75,12 +75,11 @@ impl Codebook {
             .map_err(|e| format!("Failed to read {}: {}", path.display(), e))?;
 
         // Simple JSON parsing for the arrays we need
-        let mean = extract_f32_array(&content, "\"mean\"")
-            .ok_or("Failed to extract mean array")?;
-        let std_vals = extract_f32_array(&content, "\"std\"")
-            .ok_or("Failed to extract std array")?;
-        let centroids = extract_codebook_array(&content)
-            .ok_or("Failed to extract codebook array")?;
+        let mean = extract_f32_array(&content, "\"mean\"").ok_or("Failed to extract mean array")?;
+        let std_vals =
+            extract_f32_array(&content, "\"std\"").ok_or("Failed to extract std array")?;
+        let centroids =
+            extract_codebook_array(&content).ok_or("Failed to extract codebook array")?;
 
         Ok(Codebook {
             centroids,

crates/deepnsm/src/comprehension.rs

@@ -93,7 +93,10 @@ mod tests {
         let s = two_triples_first_temporal();
         assert!(s.is_temporal(0));
         let l = s.triple_landing(0);
-        assert!(l.fact && l.story, "temporal triple → BOTH fact and story (fork)");
+        assert!(
+            l.fact && l.story,
+            "temporal triple → BOTH fact and story (fork)"
+        );
     }
 
     #[test]
@@ -110,8 +113,20 @@ mod tests {
         let s = two_triples_first_temporal();
         let ls = s.landings();
         assert_eq!(ls.len(), 2);
-        assert_eq!(ls[0], Landing { fact: true, story: true });
-        assert_eq!(ls[1], Landing { fact: true, story: false });
+        assert_eq!(
+            ls[0],
+            Landing {
+                fact: true,
+                story: true
+            }
+        );
+        assert_eq!(
+            ls[1],
+            Landing {
+                fact: true,
+                story: false
+            }
+        );
     }
 
     #[test]
@@ -124,6 +139,12 @@ mod tests {
         };
         assert!(s.landings().is_empty());
         // Out-of-range index is fact-only (no temporal marker can match).
-        assert_eq!(s.triple_landing(7), Landing { fact: true, story: false });
+        assert_eq!(
+            s.triple_landing(7),
+            Landing {
+                fact: true,
+                story: false
+            }
+        );
     }
 }