Merge remote-tracking branch 'origin/main' into feat/kicad-variable-expansion

Author: hexdae

CHANGELOG.md

@@ -10,12 +10,14 @@ and this project adheres to Semantic Versioning (https://semver.org/spec/v2.0.0.
 
 ### Changed
 
+- Bump stdlib to 0.5.9
 - `pcb layout --check` now runs layout sync against a shadow copy.
 - Removed `--sync-board-config`; board config sync is now always enabled for layout sync (CLI, MCP `run_layout`, and `pcb_layout::process_layout`).
 - `pcb fmt` now formats KiCad S-expression files (for example `.kicad_pcb`, `.kicad_sch`, `fp-lib-table`) only when an explicit file path is provided; default/discovery mode remains `.zen`-only.
 - Stackup/layers patching in `pcb layout` now uses structural S-expression mutation + canonical KiCad-style formatting, with unconditional patch/write.
 - `pcb layout` stackup sync now also patches `general (thickness ...)` from computed stackup thickness.
 - Removed MCP resource `zener-docs` (https://docs.pcb.new/llms.txt) from `pcb mcp`, with Zener docs now embedded in `pcb doc`.
+- Move board-config/title-block patching to Rust; simplify Python sync; only update `.kicad_pro` netclass patterns when assignments exist.
 
 ### Fixed
 

crates/pcb-ipc2581-tools/src/accessors/drills.rs

@@ -1,6 +1,6 @@
-use std::collections::HashSet;
+use std::collections::BTreeMap;
 
-use ipc2581::types::Step;
+use ipc2581::types::{PlatingStatus, Step};
 use serde::{Deserialize, Serialize};
 
 use super::IpcAccessor;
@@ -10,42 +10,106 @@ use super::IpcAccessor;
 pub struct DrillStats {
     pub total_holes: usize,
     pub unique_sizes: usize,
+    /// Per-type distribution: via, plated, non-plated
+    pub distribution: Vec<DrillTypeDistribution>,
 }
 
-impl DrillStats {
-    pub fn new(total_holes: usize, unique_sizes: usize) -> Self {
-        Self {
-            total_holes,
-            unique_sizes,
+/// Distribution of holes for a single plating type
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DrillTypeDistribution {
+    pub hole_type: DrillHoleType,
+    pub total: usize,
+    /// Unique diameters sorted ascending, each with count
+    pub sizes: Vec<DrillSize>,
+}
+
+/// Categorized hole type
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub enum DrillHoleType {
+    Via,
+    Plated,
+    NonPlated,
+}
+
+impl DrillHoleType {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Via => "Via",
+            Self::Plated => "Plated (PTH)",
+            Self::NonPlated => "Non-Plated (NPTH)",
         }
     }
 }
 
+/// A unique drill size with its count
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DrillSize {
+    pub diameter_mm: f64,
+    pub count: usize,
+}
+
 impl<'a> IpcAccessor<'a> {
-    /// Get drill hole statistics (total count and unique sizes)
+    /// Get drill hole statistics with per-type distribution
     ///
     /// Returns None if no ECAD section or no steps exist
     pub fn drill_stats(&self) -> Option<DrillStats> {
         let step = self.first_step()?;
-        Some(count_drill_info(step))
+        Some(collect_drill_info(step))
     }
 }
 
-/// Count drill holes and unique diameters
-fn count_drill_info(step: &Step) -> DrillStats {
-    let mut total_holes = 0;
-    let mut unique_diameters = HashSet::new();
+/// Collect drill holes grouped by plating type, with per-diameter counts
+fn collect_drill_info(step: &Step) -> DrillStats {
+    // BTreeMap<DrillHoleType, BTreeMap<diameter_mils, count>>
+    let mut by_type: BTreeMap<DrillHoleType, BTreeMap<i32, (f64, usize)>> = BTreeMap::new();
+    let mut total_holes = 0usize;
+    let mut all_diameters = std::collections::HashSet::new();
 
     for layer_feature in &step.layer_features {
         for set in &layer_feature.sets {
             for hole in &set.holes {
                 total_holes += 1;
-                // Convert diameter to integer mils to avoid floating point comparison issues
                 let diameter_mils = (hole.diameter * 39370.0) as i32;
-                unique_diameters.insert(diameter_mils);
+                all_diameters.insert(diameter_mils);
+
+                let hole_type = match hole.plating_status {
+                    PlatingStatus::Via => DrillHoleType::Via,
+                    PlatingStatus::Plated => DrillHoleType::Plated,
+                    PlatingStatus::NonPlated => DrillHoleType::NonPlated,
+                };
+
+                let entry = by_type
+                    .entry(hole_type)
+                    .or_default()
+                    .entry(diameter_mils)
+                    .or_insert((hole.diameter, 0));
+                entry.1 += 1;
             }
         }
     }
 
-    DrillStats::new(total_holes, unique_diameters.len())
+    let distribution = by_type
+        .into_iter()
+        .map(|(hole_type, sizes_map)| {
+            let mut total = 0usize;
+            let sizes: Vec<DrillSize> = sizes_map
+                .into_values()
+                .map(|(diameter_mm, count)| {
+                    total += count;
+                    DrillSize { diameter_mm, count }
+                })
+                .collect();
+            DrillTypeDistribution {
+                hole_type,
+                total,
+                sizes,
+            }
+        })
+        .collect();
+
+    DrillStats {
+        total_holes,
+        unique_sizes: all_diameters.len(),
+        distribution,
+    }
 }

crates/pcb-ipc2581-tools/src/accessors/mod.rs

@@ -13,11 +13,12 @@ mod stackup;
 pub use board::{BoardDimensions, StackupInfo};
 pub use bom::{AvlLookup, BomStats, CharacteristicsData};
 pub use components::ComponentStats;
-pub use drills::DrillStats;
+pub use drills::{DrillHoleType, DrillSize, DrillStats, DrillTypeDistribution};
 pub use layers::{LayerStats, NetStats};
 pub use metadata::{FileMetadata, SoftwareInfo};
 pub use stackup::{
-    ColorInfo, StackupDetails, StackupLayerInfo, StackupLayerType, SurfaceFinishInfo,
+    ColorInfo, ImpedanceControlInfo, MaterialInfo, StackupDetails, StackupLayerInfo,
+    StackupLayerType, SurfaceFinishInfo,
 };
 
 /// Main accessor for IPC-2581 data extraction

crates/pcb-ipc2581-tools/src/accessors/stackup.rs

@@ -416,6 +416,86 @@ impl<'a> IpcAccessor<'a> {
     }
 }
 
+/// Dielectric material information extracted from stackup
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MaterialInfo {
+    /// Distinct dielectric material names (e.g., ["FR4", "Rogers 4350B"])
+    pub dielectric: Vec<String>,
+}
+
+/// Impedance control information extracted from stackup
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ImpedanceControlInfo {
+    /// Whether any dielectric layer has Dk specified
+    pub has_dielectric_constant: bool,
+    /// Whether any dielectric layer has loss tangent specified
+    pub has_loss_tangent: bool,
+    /// Distinct Dk values found across dielectric layers
+    pub dielectric_constants: Vec<f64>,
+    /// Distinct loss tangent values found across dielectric layers
+    pub loss_tangents: Vec<f64>,
+}
+
+impl ImpedanceControlInfo {
+    /// A design is likely impedance-controlled if Dk values are specified
+    pub fn is_impedance_controlled(&self) -> bool {
+        self.has_dielectric_constant
+    }
+}
+
+impl<'a> IpcAccessor<'a> {
+    /// Extract dielectric material names from the stackup
+    pub fn material_info(&self) -> Option<MaterialInfo> {
+        let stackup = self.stackup_details()?;
+
+        let dielectric: Vec<String> = stackup
+            .layers
+            .iter()
+            .filter(|l| l.layer_type.is_dielectric())
+            .filter_map(|l| l.material.clone())
+            .collect::<std::collections::BTreeSet<_>>()
+            .into_iter()
+            .collect();
+
+        if dielectric.is_empty() {
+            return None;
+        }
+
+        Some(MaterialInfo { dielectric })
+    }
+
+    /// Extract impedance control information from the stackup
+    pub fn impedance_control_info(&self) -> Option<ImpedanceControlInfo> {
+        let stackup = self.stackup_details()?;
+
+        let mut dk_set = std::collections::BTreeSet::new();
+        let mut df_set = std::collections::BTreeSet::new();
+
+        for layer in &stackup.layers {
+            if !layer.layer_type.is_dielectric() {
+                continue;
+            }
+            if let Some(dk) = layer.dielectric_constant {
+                // Use fixed-precision key to dedup
+                dk_set.insert((dk * 1000.0) as i64);
+            }
+            if let Some(df) = layer.loss_tangent {
+                df_set.insert((df * 100000.0) as i64);
+            }
+        }
+
+        let dielectric_constants: Vec<f64> = dk_set.iter().map(|&v| v as f64 / 1000.0).collect();
+        let loss_tangents: Vec<f64> = df_set.iter().map(|&v| v as f64 / 100000.0).collect();
+
+        Some(ImpedanceControlInfo {
+            has_dielectric_constant: !dielectric_constants.is_empty(),
+            has_loss_tangent: !loss_tangents.is_empty(),
+            dielectric_constants,
+            loss_tangents,
+        })
+    }
+}
+
 /// Format FinishType enum to display string
 /// Values per IPC-6012 Table 3-3 "Final Finish and Coating Requirements"
 /// -N suffix = suitable for soldering (Nickel barrier critical)