KiCad - the KiCad Bridge

@@ -28,6 +28,7 @@ use kicad_ipc_rs::{BoardLayerInfo, BoardNet, DocumentSpecifier, DocumentType, Ed use crate::cli; use crate::pcb::{self, Board, Plan, RoutingError}; use crate::placement;+use crate::zones;  /// The ipc cargo feature is compiled in. The verb group asks this before promising live /// routing; a build with the feature off has no `ipc` module at all.@@ -767,6 +768,113 @@ pub fn routing_validate(ctx: &Ctx, args: &Value) -> RResult<Value> {     Ok(out) } +// ---------------------------------------------------------------------------+// Zones: kicad_add_zone, kicad_zone_state+// ---------------------------------------------------------------------------++/// `kicad_add_zone`: one or more copper zones (pours) as ONE native Undo step, with the+/// same revision guard and DRC preflight as `route_net`: the zones' s-expressions are+/// spliced into the editor's snapshot, KiCad's DRC (zones refilled) must add no error, or+/// nothing lands. After the commit the new zones are filled (`refill:false` skips that).+pub fn add_zone(ctx: &Ctx, args: &Value) -> RResult<Value> {+    let s = connect(ctx, args)?;+    let (text, data, revision) = s.snapshot()?;+    check_revision(args, &revision)?;+    let specs = zones::parse_specs(&data, args)?;+    let blocks: Vec<String> = specs.iter().map(zones::zone_sexpr).collect();+    let mut check = Value::Null;+    if args.get("validate") != Some(&json!(false)) {+        let source = s.source_path();+        let before = drc_snapshot(ctx.kicad_cli.as_deref(), &source, &text)?;+        let after = drc_snapshot(ctx.kicad_cli.as_deref(), &source, &pcb::splice(&text, &blocks))?;+        let added = new_errors(&before, &after)?;+        if !added.is_empty() {+            return Err(RoutingError::new("drc_rejected", "The zone adds DRC errors once filled; no live copper was changed").with("violations", json!(added)).with("mutated", json!(false)));+        }+        check = after;+    }+    let public: Vec<Value> = specs.iter().map(zones::ZoneSpec::public).collect();+    if args.get("dryRun") == Some(&json!(true)) {+        return Ok(json!({"success": true, "dryRun": true, "revision": revision, "drc": check, "zones": public,+            "_hint": "Zones validated (filled and DRC-checked on a snapshot) without editing. Submit with dryRun:false and the same revision."}));+    }+    check_revision(args, &s.revision()?)?;+    let nets = s.client.get_nets().map_err(map_err)?;+    let mut items = Vec::with_capacity(specs.len());+    for z in &specs {+        let Some(net) = nets.iter().find(|n| n.name == z.net.name) else {+            return Err(RoutingError::new("unknown_net", format!("The live board has no net named '{}'", z.net.name)).with("mutated", json!(false)));+        };+        let mut ids = Vec::with_capacity(z.layers.len());+        for l in &z.layers {+            ids.push(BoardLayerInfo::id_from_name(l).ok_or_else(|| RoutingError::new("unknown_layer", format!("KiCad has no layer named {l}")))?);+        }+        items.push(prost_types::Any { type_url: zones::ZONE_TYPE_URL.to_string(), value: zones::zone_bytes(z, &ids, net.code) });+    }+    let count = items.len();+    let label = format!("Adom zone {}", specs.iter().map(|z| z.net.name.clone()).collect::<Vec<_>>().join(", "));+    let created = transaction(&s, &label, || {+        let created = s.client.create_items(items, None)?;+        if created.len() != count {+            return Err(IpcFailure::from("KiCad did not create every requested zone".to_string()));+        }+        Ok(created)+    })?;+    let ids: Vec<String> = created.iter().filter_map(|a| zones::zone_id(&a.value)).collect();+    let mut result = json!({+        "success": true, "mutated": true, "source": "live-editor",+        "itemIds": ids, "undoSteps": 1, "zones": public, "drc": check, "saved": false, "refilled": false,+        "_hint": "Zones committed live as one KiCad Undo step and filled. kicad_zone_state reads the filled copper per layer; kicad_routing_validate is the DRC on the live board. The file is saved only with save:true.",+    });+    if ids.len() != count {+        result["postCommitError"] = json!(format!("KiCad answered with {} zone ids for {} zones", ids.len(), count));+    }+    if args.get("refill") != Some(&json!(false)) && !ids.is_empty() {+        match s.client.refill_zones(ids.clone()) {+            Ok(()) => result["refilled"] = json!(true),+            Err(e) => result["postCommitError"] = json!(format!("zones created but not filled: {e}")),+        }+    }+    match s.revision() {+        Ok(r) => {+            result["revision"] = json!(r);+            if args.get("save") == Some(&json!(true)) {+                match s.client.save_document() {+                    Ok(()) => result["saved"] = json!(true),+                    Err(e) => result["postCommitError"] = json!(e.to_string()),+                }+            }+        }+        Err(e) => result["postCommitError"] = json!(e.message),+    }+    Ok(result)+}++/// `kicad_zone_state`: every zone on the live board with its filled copper area per layer+/// (KiCad's own fill polygons), the sum per layer and the coverage against the outline+/// box. `refill:true` refills every zone first (the fill can be stale after routing).+pub fn zone_state(ctx: &Ctx, args: &Value) -> RResult<Value> {+    let s = connect(ctx, args)?;+    let mut refilled = false;+    if args.get("refill") == Some(&json!(true)) {+        s.client.refill_zones(Vec::new()).map_err(map_err)?;+        refilled = true;+    }+    let (_text, data, revision) = s.snapshot()?;+    let raws = s.client.get_items_raw_by_type_codes(vec![PcbObjectTypeCode::new_zone().code]).map_err(map_err)?;+    let mut read = Vec::with_capacity(raws.len());+    for a in &raws {+        read.push(zones::decode_zone(&a.value).map_err(|e| RoutingError::new("zone_undecodable", format!("KiCad returned a zone the bridge could not decode: {e}")))?);+    }+    let mut out = json!({+        "success": true, "boardPath": s.file_path, "revision": revision, "source": "live-editor",+        "kicadVersion": s.version.full_version, "socket": s.socket, "refilled": refilled,+        "_hint": "filledAreaByLayerMm2 is the copper KiCad's zones keep on each layer: for a copper-ablation process, what does not have to be milled away. Add pours with kicad_add_zone; kicad_routing_validate is the DRC.",+    });+    merge(&mut out, &zones::state_json(&read, &data));+    Ok(out)+}+ // --------------------------------------------------------------------------- // Placement: kicad_placement_state, kicad_move_footprint, kicad_placement_validate // ---------------------------------------------------------------------------