Expose building source selector bytes

crates/rrt-runtime/src/building.rs

@@ -17,6 +17,10 @@ pub struct BuildingTypeSourceFile {
     pub raw_stem: String,
     pub canonical_stem: String,
     pub source_kind: BuildingTypeSourceKind,
+    #[serde(default)]
+    pub byte_len: Option<usize>,
+    #[serde(default)]
+    pub bca_selector_probe: Option<BuildingTypeBcaSelectorProbe>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -27,6 +31,29 @@ pub struct BuildingTypeSourceEntry {
     pub file_names: Vec<String>,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BuildingTypeBcaSelectorProbe {
+    pub byte_0xb8: u8,
+    pub byte_0xb8_hex: String,
+    pub byte_0xb9: u8,
+    pub byte_0xb9_hex: String,
+    pub byte_0xba: u8,
+    pub byte_0xba_hex: String,
+    pub byte_0xbb: u8,
+    pub byte_0xbb_hex: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BuildingTypeBcaSelectorPatternSummary {
+    pub byte_len: usize,
+    pub byte_0xb8_hex: String,
+    pub byte_0xb9_hex: String,
+    pub byte_0xba_hex: String,
+    pub byte_0xbb_hex: String,
+    pub file_count: usize,
+    pub sample_file_names: Vec<String>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct BuildingTypeNamedBindingComparison {
     pub bindings_path: String,
@@ -42,9 +69,11 @@ pub struct BuildingTypeSourceReport {
     pub bca_file_count: usize,
     pub bty_file_count: usize,
     pub unique_canonical_stem_count: usize,
+    pub bca_selector_pattern_count: usize,
     #[serde(default)]
     pub named_binding_comparison: Option<BuildingTypeNamedBindingComparison>,
     pub notes: Vec<String>,
+    pub bca_selector_patterns: Vec<BuildingTypeBcaSelectorPatternSummary>,
     pub files: Vec<BuildingTypeSourceFile>,
     pub entries: Vec<BuildingTypeSourceEntry>,
 }
@@ -78,6 +107,7 @@ pub fn inspect_building_types_dir_with_bindings(
             "bty" => BuildingTypeSourceKind::Bty,
             _ => continue,
         };
+        let bytes = fs::read(entry.path())?;
         let raw_stem = Path::new(&file_name)
             .file_stem()
             .and_then(|stem| stem.to_str())
@@ -90,7 +120,12 @@ pub fn inspect_building_types_dir_with_bindings(
             file_name,
             canonical_stem: canonicalize_building_stem(&raw_stem),
             raw_stem,
-            source_kind,
+            source_kind: source_kind.clone(),
+            byte_len: Some(bytes.len()),
+            bca_selector_probe: match source_kind {
+                BuildingTypeSourceKind::Bca => Some(probe_bca_selector_bytes(&bytes)),
+                BuildingTypeSourceKind::Bty => None,
+            },
         });
     }
 
@@ -141,10 +176,45 @@ pub fn inspect_building_types_dir_with_bindings(
         .iter()
         .filter(|file| matches!(file.source_kind, BuildingTypeSourceKind::Bty))
         .count();
+    let mut grouped_selector_patterns =
+        BTreeMap::<(usize, String, String, String, String), Vec<String>>::new();
+    for file in &files {
+        let Some(probe) = &file.bca_selector_probe else {
+            continue;
+        };
+        grouped_selector_patterns
+            .entry((
+                file.byte_len.unwrap_or_default(),
+                probe.byte_0xb8_hex.clone(),
+                probe.byte_0xb9_hex.clone(),
+                probe.byte_0xba_hex.clone(),
+                probe.byte_0xbb_hex.clone(),
+            ))
+            .or_default()
+            .push(file.file_name.clone());
+    }
+    let bca_selector_patterns = grouped_selector_patterns
+        .into_iter()
+        .map(
+            |(
+                (byte_len, byte_0xb8_hex, byte_0xb9_hex, byte_0xba_hex, byte_0xbb_hex),
+                file_names,
+            )| BuildingTypeBcaSelectorPatternSummary {
+                byte_len,
+                byte_0xb8_hex,
+                byte_0xb9_hex,
+                byte_0xba_hex,
+                byte_0xbb_hex,
+                file_count: file_names.len(),
+                sample_file_names: file_names.into_iter().take(12).collect(),
+            },
+        )
+        .collect::<Vec<_>>();
 
     let notes = vec![
         "BuildingTypes sources are grouped by a canonical stem that lowercases and strips spaces, underscores, and hyphens so paired .bca/.bty variants collapse onto one asset token.".to_string(),
         "This report is an offline asset-pool view only; it does not by itself assign live candidate ids or prove scenario candidate-table availability.".to_string(),
+        "For .bca files, the report also exposes the narrow selector-byte window at offsets 0xb8..0xbb used by the grounded aux-candidate and live-candidate stream decoders.".to_string(),
     ];
 
     let named_binding_comparison = if let Some(bindings_path) = bindings_path {
@@ -158,13 +228,32 @@ pub fn inspect_building_types_dir_with_bindings(
         bca_file_count,
         bty_file_count,
         unique_canonical_stem_count: entries.len(),
+        bca_selector_pattern_count: bca_selector_patterns.len(),
         named_binding_comparison,
         notes,
+        bca_selector_patterns,
         files,
         entries,
     })
 }
 
+fn probe_bca_selector_bytes(bytes: &[u8]) -> BuildingTypeBcaSelectorProbe {
+    let byte_0xb8 = bytes.get(0xb8).copied().unwrap_or(0);
+    let byte_0xb9 = bytes.get(0xb9).copied().unwrap_or(0);
+    let byte_0xba = bytes.get(0xba).copied().unwrap_or(0);
+    let byte_0xbb = bytes.get(0xbb).copied().unwrap_or(0);
+    BuildingTypeBcaSelectorProbe {
+        byte_0xb8,
+        byte_0xb8_hex: format!("0x{byte_0xb8:02x}"),
+        byte_0xb9,
+        byte_0xb9_hex: format!("0x{byte_0xb9:02x}"),
+        byte_0xba,
+        byte_0xba_hex: format!("0x{byte_0xba:02x}"),
+        byte_0xbb,
+        byte_0xbb_hex: format!("0x{byte_0xbb:02x}"),
+    }
+}
+
 fn load_named_binding_comparison(
     bindings_path: &Path,
     entries: &[BuildingTypeSourceEntry],
@@ -214,3 +303,24 @@ struct BuildingBindingRow {
     #[serde(default)]
     candidate_name: Option<String>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn probes_bca_selector_bytes_from_fixed_offsets() {
+        let mut bytes = vec![0u8; 0xbc + 1];
+        bytes[0xb8] = 0x12;
+        bytes[0xb9] = 0x34;
+        bytes[0xba] = 0x56;
+        bytes[0xbb] = 0x78;
+        let probe = probe_bca_selector_bytes(&bytes);
+        assert_eq!(probe.byte_0xb8, 0x12);
+        assert_eq!(probe.byte_0xb9, 0x34);
+        assert_eq!(probe.byte_0xba, 0x56);
+        assert_eq!(probe.byte_0xbb, 0x78);
+        assert_eq!(probe.byte_0xb8_hex, "0x12");
+        assert_eq!(probe.byte_0xbb_hex, "0x78");
+    }
+}