Fusion - the Fusion 360 Bridge

@@ -395,6 +395,88 @@ pub fn panelize(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, Value) -> Value) ->     } } +/// A package's pads by name: (x, y, w, h, shape, drill, turn, layer).+fn pad_rows(pkg: &Element) -> BTreeMap<String, (f64, f64, f64, f64, String, f64, f64, String)> {+    pkg.children.iter().filter(|c| c.tag == "smd" || c.tag == "pad").filter_map(|c| {+        let n = c.attr("name")?.to_string();+        let row = if c.tag == "smd" { (num(c, "x"), num(c, "y"), num(c, "dx"), num(c, "dy"), format!("smd roundness {}", c.attr("roundness").unwrap_or("0")), 0.0, rot_deg(c), c.attr("layer").unwrap_or("1").to_string()) }+                  else { let d = num(c, "diameter"); (num(c, "x"), num(c, "y"), d, d, format!("pad {}", c.attr("shape").unwrap_or("round")), num(c, "drill"), rot_deg(c), "1-16".into()) };+        Some((n, row))+    }).collect()+}++/// What differs between a placed footprint (the board's embedded package) and the library's.+fn pad_diff(board: &Element, lib: &Element) -> Option<Value> {+    let (a, b) = (pad_rows(board), pad_rows(lib));+    let added: Vec<&String> = b.keys().filter(|k| !a.contains_key(*k)).collect();+    let removed: Vec<&String> = a.keys().filter(|k| !b.contains_key(*k)).collect();+    let mut changed = Vec::new();+    for (k, x) in &a {+        let Some(y) = b.get(k) else { continue };+        let mut c = Vec::new();+        let e = |p: f64, q: f64| (p - q).abs() > 1e-4;+        if e(x.0, y.0) || e(x.1, y.1) { c.push(format!("at ({}, {}) -> ({}, {})", f(x.0), f(x.1), f(y.0), f(y.1))); }+        if e(x.2, y.2) || e(x.3, y.3) { c.push(format!("size {} x {} -> {} x {}", f(x.2), f(x.3), f(y.2), f(y.3))); }+        if x.4 != y.4 { c.push(format!("shape {} -> {}", x.4, y.4)); }+        if e(x.5, y.5) { c.push(format!("drill {} -> {}", f(x.5), f(y.5))); }+        if e(x.6, y.6) { c.push(format!("turn {} -> {}", f(x.6), f(y.6))); }+        if x.7 != y.7 { c.push(format!("layer {} -> {}", x.7, y.7)); }+        if !c.is_empty() { changed.push(json!({"pad": k, "changes": c})); }+    }+    if added.is_empty() && removed.is_empty() && changed.is_empty() { None } else { Some(json!({"padsAdded": added, "padsRemoved": removed, "padsChanged": changed})) }+}++/// `fusion_update_footprints_from_library`: the standard's update_footprints_from_library, the plan.+/// Each placed footprint (the package the board embeds) is compared pad by pad with the same-named+/// package in the libraries given (a Fusion design's libraries are cloud items, so the .lbr files to+/// compare against are named). apply is refused: Fusion's UPDATE asks about each part in a dialog,+/// which the bridge never raises.+pub fn update_footprints_from_library(args: &Value, pass: &dyn Fn(&str, Value) -> Value) -> Value {+    let paths: Vec<String> = match (args["libraries"].as_array(), args["libraryPath"].as_str()) {+        (Some(a), _) => a.iter().filter_map(|x| x.as_str().map(|s| s.replace('\\', "/"))).collect(),+        (None, Some(p)) => vec![p.replace('\\', "/")],+        _ => vec![],+    };+    if paths.is_empty() { return json!({"success": false, "errorCode": "bad_args", "error": "libraryPath or libraries ([.lbr]) is required: a Fusion design's libraries are cloud items, so name the .lbr files to compare against",+        "_hint": "fusion_export_library_part or the .lbr a part came from; fusion_list_installed_libraries lists the hub's libraries."}); }+    let mut libs: Vec<(String, Vec<Element>)> = Vec::new();+    for p in &paths { match std::fs::read_to_string(p).map_err(|e| e.to_string()).and_then(|t| lbr_packages(&t)) { Ok(pk) => libs.push((p.clone(), pk)), Err(e) => return json!({"success": false, "errorCode": "library_unreadable", "error": format!("{p}: {e}")}) } }+    let src = crate::routing::call("board_source", &json!({"expectDocument": args["expectDocument"]}), pass);+    let Some(text) = src["source"].as_str().or(src["data"]["source"].as_str()) else { return json!({"success": false, "errorCode": "board_unreadable", "error": src["error"]}) };+    let root = match Element::parse(text) { Ok(r) => r, Err(e) => return json!({"success": false, "errorCode": "board_unreadable", "error": e.to_string()}) };+    let Some(board) = deep(&root, "board") else { return json!({"success": false, "errorCode": "board_unreadable", "error": "no <board>"}) };+    let refs: Option<Vec<String>> = args["refs"].as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_uppercase)).collect());+    let blibs = board.find_child("libraries");+    let mut rows = Vec::new();+    let mut differs = 0;+    for e in board.find_child("elements").map(|x| x.children.iter().filter(|c| c.tag == "element").collect::<Vec<_>>()).unwrap_or_default() {+        let (r, l, pk) = (e.attr("name").unwrap_or(""), e.attr("library").unwrap_or(""), e.attr("package").unwrap_or(""));+        if let Some(want) = &refs { if !want.contains(&r.to_uppercase()) { continue; } }+        let placed = blibs.and_then(|b| child_named(b, "library", l)).and_then(|x| x.find_child("packages")).and_then(|x| child_named(x, "package", pk));+        let found = libs.iter().find_map(|(p, pks)| pks.iter().find(|k| k.attr("name").map(|n| n.eq_ignore_ascii_case(pk)).unwrap_or(false)).map(|k| (p.clone(), k)));+        let row = match (placed, found) {+            (Some(pl), Some((path, lk))) => match pad_diff(pl, lk) {+                Some(d) => { differs += 1; json!({"ref": r, "footprint": pk, "library": path, "status": "differs", "diff": d}) }+                None => json!({"ref": r, "footprint": pk, "library": path, "status": "up_to_date"}),+            },+            (_, None) => json!({"ref": r, "footprint": pk, "library": l, "status": "library_not_found", "why": "no package of that name in the libraries given"}),+            (None, Some((path, _))) => json!({"ref": r, "footprint": pk, "library": path, "status": "library_not_found", "why": "the board holds no copy of its package"}),+        };+        rows.push(row);+    }+    let plan = json!({"plan": true, "mutated": false, "revision": src["revision"], "differs": differs, "footprints": rows});+    if args["apply"].as_bool() == Some(true) {+        let mut out = json!({"success": false, "errorCode": "not_supported", "error": "apply is not supported in Fusion: its UPDATE asks about each part in a dialog, which the bridge never raises. The plan is below.",+            "_hint": "Update the parts in Fusion (Library Manager > update, or right-click the part > Update), or swap one footprint on a board kept as EAGLE source with fusion_swap_footprint."});+        for (k, v) in plan.as_object().unwrap() { out[k] = v.clone(); }+        return out;+    }+    let mut out = json!({"success": true});+    for (k, v) in plan.as_object().unwrap() { out[k] = v.clone(); }+    out["_hint"] = json!("A plan: each placed footprint against the same-named package in the libraries given, pad by pad. Fusion updates parts from their library itself (it asks about each one), so apply is refused.");+    out+}+ /// "A;B;C" or a list. fn list(v: &Value, sep: char) -> Vec<String> {     match v { Value::Array(a) => a.iter().filter_map(|x| x.as_str().map(|s| s.trim().to_string())).filter(|s| !s.is_empty()).collect(),@@ -673,6 +755,18 @@ mod tests {         assert!(!xml.contains("boardshape"), "Fusion recomputes the panel's shape");     } +    #[test]+    fn a_widened_pad_reads_as_a_difference() {+        let pk = lbr_packages(LBR).unwrap();+        let mut wide = pk[0].clone();+        for c in wide.children.iter_mut().filter(|c| c.attr("name") == Some("1")) { for a in c.attrs.iter_mut() { if a.0 == "dx" { a.1 = "2".into(); } } }+        let d = pad_diff(&pk[0], &wide).unwrap();+        assert_eq!(d["padsChanged"][0]["pad"], "1");+        assert!(d["padsChanged"][0]["changes"][0].as_str().unwrap().starts_with("size 0.9 x 0.9 -> 2 x 0.9"), "{d}");+        assert!(pad_diff(&pk[0], &pk[0]).is_none());+        assert_eq!(pad_diff(&pk[0], &pk[1]).unwrap()["padsAdded"], json!(["3"]));+    }+     #[test]     fn outlines_refuse_bad_shapes() {         assert!(outline_wires(&json!({"rect": [0, 0, 0, 5]})).is_err());

@@ -508,13 +508,13 @@ fn main() {                     "fusion_generate_body_engine" => { let mut r = body::generate(&parsed["args"]); r["bridgeVersion"] = json!(VERSION); r["shell"] = json!("rust"); r },                     "fusion_read_sheet_file" | "read_sheet_file" => { let mut r = sheet::read_sheet_file(&parsed["args"]); r["bridgeVersion"] = json!(VERSION); r["shell"] = json!("rust"); r },                     "fusion_netlist" | "netlist" if parsed["args"]["schPath"].is_string() => { let mut r = sheet::netlist_from_sch(&parsed["args"]); r["bridgeVersion"] = json!(VERSION); r["shell"] = json!("rust"); r },-                    v if routing::owns(v.strip_prefix("fusion_").unwrap_or(v)) || matches!(v.strip_prefix("fusion_").unwrap_or(v), "replicate_layout" | "silkscreen_prep" | "list_installed_libraries") || sch::owns(v.strip_prefix("fusion_").unwrap_or(v)) || docs::owns(v.strip_prefix("fusion_").unwrap_or(v)) || checks::owns(v.strip_prefix("fusion_").unwrap_or(v)) => {+                    v if routing::owns(v.strip_prefix("fusion_").unwrap_or(v)) || matches!(v.strip_prefix("fusion_").unwrap_or(v), "replicate_layout" | "silkscreen_prep" | "list_installed_libraries" | "update_footprints_from_library") || sch::owns(v.strip_prefix("fusion_").unwrap_or(v)) || docs::owns(v.strip_prefix("fusion_").unwrap_or(v)) || checks::owns(v.strip_prefix("fusion_").unwrap_or(v)) => {                         let (sc, ca) = (sidecar.clone(), caller.clone());                         let side = |verb: &str, a: Value, t: u64| proxy_with_timeout(&sc, &json!({"command":verb,"args":a}).to_string(), &ca, t);                         let dlg = |r: Value| r;                         let ctx = addin::Ctx { host: &**h, fusion_exe:h.fusion_executable(), short_path:|p|host().short_path(p), state_dir:h.bridge_state_dir(), caller:caller.clone(), pids:h.fusion_processes().iter().map(|p|p.pid).collect(), sidecar:&side, dialogs:&dlg };                         let cmd=v.strip_prefix("fusion_").unwrap_or(v);-                        let mut r=match cmd { "bodies" => bodies::bodies(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "replicate_layout" => replicate::replicate_layout(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "silkscreen_prep" => checks::silkscreen_prep(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "list_installed_libraries" => appverbs::list_installed_libraries(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "simulate" => spice::simulate(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "jlcpcb_order" => order::jlcpcb_order(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "export_bom" => routing::export_bom(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "save_document" => savedoc::save_document(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "save_to_cloud" => savedoc::save_to_cloud(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), c if sch::owns(c) => sch::call(c,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), c if docs::owns(c) => docs::call(c,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), c if writers::owns(c) => writers::call(c,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), c if checks::owns(c) => checks::call(c,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), _ => routing::call(cmd,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)) };+                        let mut r=match cmd { "bodies" => bodies::bodies(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "replicate_layout" => replicate::replicate_layout(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "silkscreen_prep" => checks::silkscreen_prep(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "list_installed_libraries" => appverbs::list_installed_libraries(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "update_footprints_from_library" => boardgen::update_footprints_from_library(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "simulate" => spice::simulate(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "jlcpcb_order" => order::jlcpcb_order(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "export_bom" => routing::export_bom(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "save_document" => savedoc::save_document(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), "save_to_cloud" => savedoc::save_to_cloud(&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), c if sch::owns(c) => sch::call(c,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), c if docs::owns(c) => docs::call(c,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), c if writers::owns(c) => writers::call(c,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), c if checks::owns(c) => checks::call(c,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)), _ => routing::call(cmd,&parsed["args"],&|v,a|addin::pass_through(v,&a,&ctx)) };                         if cmd=="netlist" { r=sheet::shape_board_netlist(r,&parsed["args"]); }                         r["bridgeVersion"]=json!(VERSION); r["shell"]=json!("rust"); r                     },@@ -691,7 +691,7 @@ fn main() {                     "fusion_edit_footprint" | "edit_footprint" => native_edit_footprint(&parsed["args"]),                     v @ ("fusion_create_footprint" | "create_footprint" | "fusion_create_symbol" | "create_symbol" | "fusion_read_symbol" | "read_symbol" | "fusion_find_symbol" | "find_symbol"                         | "fusion_copy_footprint" | "copy_footprint" | "fusion_rename_footprint" | "rename_footprint" | "fusion_remove_footprint" | "remove_footprint" | "fusion_xcopy_footprint" | "xcopy_footprint"-                        | "fusion_clone_symbol" | "clone_symbol" | "fusion_rename_symbol" | "rename_symbol" | "fusion_remove_symbol" | "remove_symbol" | "fusion_set_params" | "set_params" | "fusion_footprint_from_land_pattern" | "footprint_from_land_pattern" | "fusion_set_models" | "set_models" | "fusion_add_models" | "add_models" | "fusion_symbol_prims" | "symbol_prims" | "fusion_set_visibility" | "set_visibility" | "fusion_add_symbol_art" | "add_symbol_art") => native_lib_authoring(v.strip_prefix("fusion_").unwrap_or(v), &parsed["args"]),+                        | "fusion_clone_symbol" | "clone_symbol" | "fusion_rename_symbol" | "rename_symbol" | "fusion_remove_symbol" | "remove_symbol" | "fusion_set_params" | "set_params" | "fusion_footprint_from_land_pattern" | "footprint_from_land_pattern" | "fusion_set_models" | "set_models" | "fusion_add_models" | "add_models" | "fusion_symbol_prims" | "symbol_prims" | "fusion_set_visibility" | "set_visibility" | "fusion_add_symbol_art" | "add_symbol_art" | "fusion_lint_library" | "lint_library") => native_lib_authoring(v.strip_prefix("fusion_").unwrap_or(v), &parsed["args"]),                     "fusion_preflight_lbr" | "preflight_lbr" => native_preflight_lbr(&parsed["args"]),                     "fusion_not_supported" | "not_supported" => unsupported::answer(&parsed["args"]),                     // Native since Phase 2: the raw authenticated APS GET (never-charge guarded).@@ -984,9 +984,11 @@ fn native_edit_footprint(args: &Value) -> Value {     let after = fusion_lbr::read_footprint(&text, None, name).unwrap_or(Value::Null);     let tmp = std::env::temp_dir().join(format!("adom-edit-fp-{}.lbr", std::process::id()));     let _ = std::fs::write(&tmp, &text);-    let pf = fusion_lbr::preflight_lbr(&tmp);+    // the authoring preflight, as create_footprint uses: a footprint-only library (no symbols or+    // components yet) is fine to write; opening a component in it is what needs them+    let (ok, errors) = fusion_lbr::authoring::preflight_text(&tmp);     let _ = std::fs::remove_file(&tmp);-    if !pf.ok { return json!({"success": false, "errorCode": "lbr_preflight_failed", "error": "the edited library would not open cleanly in Fusion; nothing was written", "preflight": pf, "summary": summary, "shell": "rust"}); }+    if !ok { return json!({"success": false, "errorCode": "lbr_preflight_failed", "error": "the edited library would not open cleanly in Fusion; nothing was written", "preflight": errors, "summary": summary, "shell": "rust"}); }     if args["dryRun"].as_bool() == Some(true) { return json!({"success": true, "mutated": false, "summary": summary, "footprint": after, "shell": "rust"}); }     let bak = format!("{path}.bak");     if let Err(e) = std::fs::copy(&path, &bak).and_then(|_| std::fs::write(&path, &text)) { return json!({"success": false, "errorCode": "write_failed", "error": e.to_string(), "shell": "rust"}); }@@ -1032,6 +1034,13 @@ fn native_lib_authoring(verb: &str, args: &Value) -> Value {     let existing = std::fs::read_to_string(&path).ok();     let creates = matches!(verb, "create_footprint" | "create_symbol" | "xcopy_footprint" | "footprint_from_land_pattern");     if existing.is_none() && !creates { return json!({"success": false, "errorCode": "library_unreadable", "error": format!("cannot read {path}"), "libraryPath": path, "shell": "rust"}); }+    if verb == "lint_library" {+        // the library read into the standard's shape, judged by the shared engine+        return match a::lint_input(existing.as_deref().unwrap()) {+            Ok(lib) => { let mut r = lint_judge(lib, args); r["libraryPath"] = json!(path); r["shell"] = json!("rust"); r }+            Err(e) => json!({"success": false, "errorCode": "library_unreadable", "error": e, "shell": "rust"}),+        };+    }     if verb == "symbol_prims" {         let name = s("symbolName").or(s("name")).unwrap_or_default();         return match a::symbol_prims(existing.as_deref().unwrap(), &name) { Ok(mut v) => { v["success"] = json!(true); v["mutated"] = json!(false); v["libraryPath"] = json!(path); v["shell"] = json!("rust"); v }, Err(e) => json!({"success": false, "errorCode": "symbol_not_found", "error": e, "shell": "rust"}) };@@ -1101,6 +1110,11 @@ fn native_lib_authoring(verb: &str, args: &Value) -> Value {            "_hint": "Written and preflighted. A Fusion library is opened with fusion_open_lbr (or fusion_show_footprint / fusion_show_symbol to see one item); a library already open in Fusion does not see the change until it is reopened."}) } +/// The shared engine's lint_library on a library read by fusion_lbr, with names passed through.+fn lint_judge(lib: Value, args: &Value) -> Value {+    adom_eda_checks::run("lint_library", &json!({"library": lib, "args": {"names": args["names"]}}))+}+ /// `fusion_preflight_lbr`: will this .lbr open cleanly in Fusion? Offline, instant. fn native_preflight_lbr(args: &Value) -> Value {     let path = lbr_path_arg(args, &["libraryPath", "filePath"]);@@ -1772,6 +1786,22 @@ fn chains_owner_is_exe(h: &dyn HostBoth) -> bool { owner_is_exe(h, "chainsOwner"  fn addin_owner_is_exe(h: &dyn HostBoth) -> bool { owner_is_exe(h, "addinOwner") } +#[cfg(test)]+mod lint_library_tests {+    use super::*;+    #[test]+    fn a_library_read_by_fusion_lbr_is_judged_by_the_engine() {+        let sym = "META|LDO-X|reg|U\nMODE|0|n\nRECT|0|0|-300|600|0\nPIN|0|1|IN|0|-100|left|300||power_in\nPIN|0|2|OUT|600|-100|right|300||power_out\nPIN|0|3|EN|0|-200|left|300||input\n";+        let fp = "META|SOT-X|x\nPAD|1|-1|0|1|0.6|rect|0|top|0\nPAD|2|1|0|1|0.6|rect|0|top|0\nPAD|3|1|1|1|0.6|rect|0|top|0\nLINE|courtyard|-2|-1|2|1|0.05\n";+        let (xml, _) = fusion_lbr::import::import_part(None, Some(fp), Some(sym), None, &json!({})).unwrap();+        let r = lint_judge(fusion_lbr::authoring::lint_input(&xml).unwrap(), &json!({}));+        let rules: Vec<&str> = r["findings"].as_array().unwrap().iter().filter_map(|f| f["rule"].as_str()).collect();+        assert_eq!(r["errors"], 0, "{r}");+        assert!(rules.contains(&"no_silkscreen") && rules.contains(&"no_3d_body") && rules.contains(&"no_part_number"), "{rules:?}");+        assert!(!rules.contains(&"no_courtyard") && !rules.contains(&"pin_without_pad"), "{rules:?}");+    }+}+ #[cfg(test)] mod standard_alias_tests {     #[test]

@@ -651,6 +651,98 @@ pub fn add_symbol_art(xml: &str, name: &str, kicad_sym: &str, clear: bool) -> Re     Ok((root.to_xml_document(), json!({"component": comp, "polylines": polys.len(), "points": polys.iter().map(|p| p.len()).sum::<usize>(), "lines": drawn, "removed": removed, "bodyRectMil": body_out}))) } +/// The standard's lint_library input, read from an EAGLE library: each package as a footprint+/// (pads in its own frame, mm; holes as mechanical pads; the courtyard from tKeepout, silk from+/// tPlace, its 3D packages, its description) and each component as a symbol per device (pin numbers+/// from the device's connects, its package, the MPN attribute). The engine judges them.+pub fn lint_input(xml: &str) -> Result<Value, String> {+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let num = |e: &Element, k: &str| e.attr(k).and_then(|v| v.parse::<f64>().ok()).unwrap_or(0.0);+    let turned = |e: &Element| e.attr("rot").map(|r| { let d: f64 = r.trim_start_matches(['M', 'S', 'R']).parse().unwrap_or(0.0); ((d / 90.0).round() as i64).rem_euclid(2) == 1 }).unwrap_or(false);+    // which packages a 3D package instances+    let mut bodies: std::collections::BTreeMap<String, Vec<Value>> = Default::default();+    if let Some(p3) = lib.find_child("packages3d") {+        for d in p3.children.iter().filter(|c| c.tag == "package3d") {+            for pi in d.find_child("packageinstances").map(|x| x.children.clone()).unwrap_or_default() {+                if let Some(n) = pi.attr("name") { bodies.entry(n.to_string()).or_default().push(json!({"name": d.attr("name"), "urn": d.attr("urn").or(d.attr("wip_urn"))})); }+            }+        }+    }+    let mut fps = Vec::new();+    for pk in section(lib, "packages").children.iter().filter(|c| c.tag == "package") {+        let name = pk.attr("name").unwrap_or("").to_string();+        let mut pads = Vec::new();+        let (mut court, mut silk) = (Vec::new(), 0usize);+        for c in &pk.children {+            match c.tag.as_str() {+                "smd" => { let (w, h) = (num(c, "dx"), num(c, "dy")); let (w, h) = if turned(c) { (h, w) } else { (w, h) };+                           pads.push(json!({"number": c.attr("name").unwrap_or(""), "x": num(c, "x"), "y": num(c, "y"), "w": w, "h": h})); }+                "pad" => { let d = if c.attr("diameter").is_some() { num(c, "diameter") } else { num(c, "drill") * 1.6 };+                           pads.push(json!({"number": c.attr("name").unwrap_or(""), "x": num(c, "x"), "y": num(c, "y"), "w": d, "h": d, "hole": num(c, "drill")})); }+                "hole" => pads.push(json!({"number": "", "x": num(c, "x"), "y": num(c, "y"), "w": num(c, "drill"), "h": num(c, "drill"), "hole": num(c, "drill"), "mechanical": true, "plated": false})),+                _ => {}+            }+            match c.attr("layer") {+                Some("39") => {+                    for (kx, ky) in [("x1", "y1"), ("x2", "y2"), ("x", "y")] { if c.attr(kx).is_some() { court.push(json!([num(c, kx), num(c, ky)])); } }+                    for v in c.children.iter().filter(|v| v.tag == "vertex") { court.push(json!([num(v, "x"), num(v, "y")])); }+                }+                Some("21") => silk += 1,+                _ => {}+            }+        }+        fps.push(json!({"name": name, "pads": pads, "courtyard": court, "silk": if silk > 0 { json!([silk]) } else { json!([]) },+                        "bodies": bodies.get(&name).cloned().unwrap_or_default(), "description": pk.find_child("description").map(|d| d.text.trim().to_string()).unwrap_or_default()}));+    }+    let mut syms = Vec::new();+    let _ = section(lib, "symbols");+    let sets: Vec<Element> = section(lib, "devicesets").children.iter().filter(|c| c.tag == "deviceset").cloned().collect();+    let lib = &*lib;+    for ds in &sets {+        let dsn = ds.attr("name").unwrap_or("").to_string();+        let devs: Vec<&Element> = ds.find_child("devices").map(|d| d.children.iter().filter(|x| x.tag == "device").collect()).unwrap_or_default();+        let many = devs.len() > 1;+        for dev in devs {+            let pkg = dev.attr("package").unwrap_or("").to_string();+            let mut pins: Vec<Value> = Vec::new();+            for c in dev.find_child("connects").map(|x| x.children.iter().filter(|c| c.tag == "connect").collect::<Vec<_>>()).unwrap_or_default() {+                for pad in c.attr("pad").unwrap_or("").split_whitespace() { pins.push(json!({"number": pad.split('@').next().unwrap_or(pad), "name": c.attr("pin")})); }+            }+            if pins.is_empty() {+                // a device with no footprint has no connects: its pins carry their numbers in+                // ADOM_PINMAP ("1:G$1.IN;..."), else they are the gates' symbol pins, unnumbered+                let mut map = String::new();+                let mut w = vec![dev];+                while let Some(e) = w.pop() { for c in &e.children { if c.tag == "attribute" && c.attr("name") == Some("ADOM_PINMAP") { map = c.attr("value").unwrap_or("").to_string(); } w.push(c); } }+                if !map.is_empty() {+                    for item in map.split(';').filter(|x| !x.is_empty()) { if let Some((n, gp)) = item.split_once(':') { pins.push(json!({"number": n, "name": gp.split_once('.').map(|x| x.1).unwrap_or(gp)})); } }+                } else {+                    let gates: Vec<String> = ds.find_child("gates").map(|g| g.children.iter().filter_map(|x| x.attr("symbol").map(str::to_string)).collect()).unwrap_or_default();+                    for g in gates {+                        if let Some(sym) = lib.find_child("symbols").and_then(|sec| sec.children.iter().find(|x| x.attr("name") == Some(g.as_str()))) {+                            for p in sym.children.iter().filter(|c| c.tag == "pin") { pins.push(json!({"number": "", "name": p.attr("name")})); }+                        }+                    }+                }+            }+            let mut mpn = String::new();+            let mut walk = vec![dev];+            while let Some(e) = walk.pop() {+                for c in &e.children {+                    if c.tag == "attribute" && ["MPN", "MANUFACTURER_PART_NUMBER", "MANUFACTURER PART NUMBER", "PARTNUMBER", "PART_NUMBER"].contains(&c.attr("name").unwrap_or("").to_uppercase().as_str()) {+                        if let Some(v) = c.attr("value").filter(|v| !v.trim().is_empty()) { mpn = v.to_string(); }+                    }+                    walk.push(c);+                }+            }+            let name = if many { format!("{dsn}{}", dev.attr("name").unwrap_or("")) } else { dsn.clone() };+            syms.push(json!({"name": name, "pins": pins, "footprint": pkg, "partNumber": mpn}));+        }+    }+    Ok(json!({"footprints": fps, "symbols": syms}))+}+ /// The standard's add_models: each footprint becomes another device of the component (EAGLE's /// several-packages-per-component), pins joined by pad number; a footprint already attached is /// skipped, since a device names it once. `sources` holds other .lbr texts a model's footprint is@@ -758,6 +850,31 @@ pub fn preflight_text(path: &std::path::Path) -> (bool, Vec<String>) {     (errs.is_empty(), errs) } +#[cfg(test)]+mod lint_tests {+    use super::*;++    #[test]+    fn a_library_is_read_for_the_engine_and_judged() {+        let sym = "META|LDO-X|reg|U\nMODE|0|n\nRECT|0|0|-300|600|0\nPIN|0|1|IN|0|-100|left|300||power_in\nPIN|0|2|OUT|600|-100|right|300||power_out\n";+        let fp = "META|SOT-X|x\nPAD|1|-1|0|1|0.6|rect|0|top|0\nPAD|2|1|0|1|0.6|rect|0|top|0\nLINE|courtyard|-2|-1|2|1|0.05\n";+        let (xml, _) = crate::import::import_part(None, Some(fp), Some(sym), None, &json!({"params": {"MPN": "LDO-X-1"}})).unwrap();+        // a footprint-less component keeps its pin numbers in ADOM_PINMAP+        let (bare, _) = create_symbol(None, &json!({"name": "BARE", "pins": "1,A,left,100;2,B,right,100"})).unwrap();+        let b = lint_input(&bare).unwrap();+        assert_eq!(b["symbols"][0]["pins"].as_array().unwrap().len(), 2, "{b}");+        assert_eq!((b["symbols"][0]["pins"][0]["number"].as_str(), b["symbols"][0]["footprint"].as_str()), (Some("1"), Some("")));+        let lib = lint_input(&xml).unwrap();+        assert_eq!(lib["footprints"][0]["pads"].as_array().unwrap().len(), 2);+        assert_eq!(lib["symbols"][0]["partNumber"], "LDO-X-1");+        assert_eq!(lib["symbols"][0]["footprint"], "SOT-X");+        assert_eq!(lib["footprints"][0]["silk"], json!([]), "no silk drawn: sent empty, so the engine reports it");+        assert_eq!(lib["footprints"][0]["bodies"], json!([]));+        assert_eq!(lib["footprints"][0]["courtyard"].as_array().unwrap().len(), 2);+        assert_eq!(lib["symbols"][0]["pins"].as_array().unwrap().len(), 2);+    }+}+ #[cfg(test)] mod art_tests {     use super::*;

@@ -0,0 +1,207 @@+//! Library lint (EDA Bridge Standard #28): is a symbol or footprint library fit to ship? The content rules every bridge+//! can share, from the footprints and symbols it already reads; a bridge adds its tool's own (KiCad's+//! `tool_refuses_file`) to the same findings. Severity belongs to the rule, not the bridge. A rule is only evaluated+//! when the bridge sent what it needs: a key left out means "not read" and emits nothing, a key sent empty is a finding.+use serde_json::{json, Value};+use std::collections::{BTreeMap, BTreeSet};++/// The shared vocabulary: (kind, rule, severity).+pub const RULES: &[(&str, &str, &str)] = &[+    ("footprint", "no_pads", "error"),+    ("footprint", "zero_size_pad", "error"),+    ("footprint", "unnumbered_pad", "warning"),+    ("footprint", "duplicate_pad_number", "warning"),+    ("footprint", "no_courtyard", "warning"),+    ("footprint", "origin_off_part", "warning"),+    ("footprint", "no_silkscreen", "info"),+    ("footprint", "no_3d_body", "info"),+    ("footprint", "no_description", "info"),+    ("symbol", "no_pins", "error"),+    ("symbol", "footprint_not_found", "error"),+    ("symbol", "pin_without_pad", "error"),+    ("symbol", "unnumbered_pin", "warning"),+    ("symbol", "duplicate_pin_number", "warning"),+    ("symbol", "no_footprint", "warning"),+    ("symbol", "pad_without_pin", "warning"),+    ("symbol", "no_part_number", "info"),+    ("library", "tool_refuses_file", "error"),+];++/// How far past the pads and courtyard the origin may sit before it counts as off the part (mm).+pub const ORIGIN_MARGIN_MM: f64 = 1.0;++fn severity(rule: &str) -> &'static str { RULES.iter().find(|r| r.1 == rule).map(|r| r.2).unwrap_or("warning") }+fn f(v: &Value) -> f64 { v.as_f64().unwrap_or(0.0) }+fn text(v: &Value) -> String { match v { Value::String(s) => s.trim().to_string(), Value::Number(n) => n.to_string(), _ => String::new() } }+/// Sent but empty: null, "", [] or {}.+fn empty(v: &Value) -> bool { match v { Value::Null => true, Value::String(s) => s.trim().is_empty(), Value::Array(a) => a.is_empty(), Value::Object(o) => o.is_empty(), _ => false } }+/// A pad no pin connects to: a mechanical hole, or unplated.+fn mechanical(p: &Value) -> bool { p["mechanical"] == true || p["plated"] == false }+/// "Lib:Name" and "Name" name the same footprint.+fn base(name: &str) -> &str { name.rsplit(':').next().unwrap_or(name) }+/// "pin 3 has" or "pins 2, 3 have".+fn list(word: &str, items: &[&String]) -> String {+    let names = items.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", ");+    if items.len() == 1 { format!("{word} {names} has") } else { format!("{word}s {names} have") }+}++/// A courtyard's extent: [x0, y0, x1, y1], {x0, y0, x1, y1}, or a list of [x, y] points.+fn extent(c: &Value) -> Option<(f64, f64, f64, f64)> {+    if let Some(a) = c.as_array() {+        if a.len() == 4 && a.iter().all(|v| v.is_number()) { return Some((f(&a[0]).min(f(&a[2])), f(&a[1]).min(f(&a[3])), f(&a[0]).max(f(&a[2])), f(&a[1]).max(f(&a[3])))); }+        let pts: Vec<(f64, f64)> = a.iter().filter_map(|p| p.as_array().filter(|q| q.len() >= 2).map(|q| (f(&q[0]), f(&q[1])))).collect();+        if pts.is_empty() { return None; }+        return Some(pts.iter().fold((f64::MAX, f64::MAX, f64::MIN, f64::MIN), |b, p| (b.0.min(p.0), b.1.min(p.1), b.2.max(p.0), b.3.max(p.1))));+    }+    if c["x0"].is_number() { return Some((f(&c["x0"]).min(f(&c["x1"])), f(&c["y0"]).min(f(&c["y1"])), f(&c["x0"]).max(f(&c["x1"])), f(&c["y0"]).max(f(&c["y1"])))); }+    None+}++fn finding(name: &str, kind: &str, rule: &str, detail: String) -> Value {+    json!({"name": name, "kind": kind, "rule": rule, "severity": severity(rule), "detail": detail})+}++/// The findings for one footprint (pads in its own frame, mm, origin at 0,0).+pub fn lint_footprint(fp: &Value) -> Vec<Value> {+    let name = text(&fp["name"]);+    let mut out = Vec::new();+    let pads = fp["pads"].as_array().cloned().unwrap_or_default();+    if pads.is_empty() { out.push(finding(&name, "footprint", "no_pads", "the footprint has no pads".into())); }+    let mut seen: BTreeMap<String, usize> = BTreeMap::new();+    for p in &pads {+        let (w, h, hole) = (f(&p["w"]), f(&p["h"]), f(&p["hole"]));+        if (w <= 0.0 || h <= 0.0) && hole <= 0.0 { out.push(finding(&name, "footprint", "zero_size_pad", format!("pad {} is {w} x {h} mm", text(&p["number"])))); }+        let n = text(&p["number"]);+        if n.is_empty() { if !mechanical(p) { out.push(finding(&name, "footprint", "unnumbered_pad", format!("a pad at ({}, {}) has no number", f(&p["x"]), f(&p["y"])))); } }+        else { *seen.entry(n).or_default() += 1; }+    }+    for (n, k) in &seen { if *k > 1 { out.push(finding(&name, "footprint", "duplicate_pad_number", format!("{k} pads are numbered {n} (fine for a split thermal pad, a mistake otherwise)"))); } }+    let court = fp.get("courtyard");+    if court.map(empty).unwrap_or(false) { out.push(finding(&name, "footprint", "no_courtyard", "no courtyard".into())); }+    // the origin should sit on the part: inside the pads and courtyard, grown by the margin+    let mut b: Option<(f64, f64, f64, f64)> = None;+    let mut grow = |e: (f64, f64, f64, f64)| b = Some(b.map_or(e, |o| (o.0.min(e.0), o.1.min(e.1), o.2.max(e.2), o.3.max(e.3))));+    for p in &pads { let (x, y, w, h) = (f(&p["x"]), f(&p["y"]), f(&p["w"]).max(f(&p["hole"])) / 2.0, f(&p["h"]).max(f(&p["hole"])) / 2.0); grow((x - w, y - h, x + w, y + h)); }+    if let Some(e) = court.and_then(extent) { grow(e); }+    if let Some((x0, y0, x1, y1)) = b {+        let m = ORIGIN_MARGIN_MM;+        if 0.0 < x0 - m || 0.0 > x1 + m || 0.0 < y0 - m || 0.0 > y1 + m {+            let (dx, dy) = ((x0 - m).max(0.0) + (0.0f64).max(-(x1 + m)), (y0 - m).max(0.0) + (0.0f64).max(-(y1 + m)));+            out.push(finding(&name, "footprint", "origin_off_part", format!("the origin is {:.3} mm outside the pads and courtyard (part spans x {x0:.3}..{x1:.3}, y {y0:.3}..{y1:.3})", (dx * dx + dy * dy).sqrt())));+        }+    }+    if fp.get("silk").map(empty).unwrap_or(false) { out.push(finding(&name, "footprint", "no_silkscreen", "no silkscreen".into())); }+    if fp.get("bodies").map(empty).unwrap_or(false) { out.push(finding(&name, "footprint", "no_3d_body", "no 3D body".into())); }+    if fp.get("description").map(empty).unwrap_or(false) { out.push(finding(&name, "footprint", "no_description", "no description".into())); }+    out+}++/// The findings for one symbol, against the footprints the bridge sent (None: footprints not read, so the+/// footprint rules that need them are not evaluated).+pub fn lint_symbol(sym: &Value, footprints: Option<&BTreeMap<String, Value>>) -> Vec<Value> {+    let name = text(&sym["name"]);+    let mut out = Vec::new();+    let pins = sym["pins"].as_array().cloned().unwrap_or_default();+    if pins.is_empty() { out.push(finding(&name, "symbol", "no_pins", "the symbol has no pins".into())); }+    let mut numbers: BTreeMap<String, usize> = BTreeMap::new();+    for p in &pins {+        let n = text(&p["number"]);+        if n.is_empty() { out.push(finding(&name, "symbol", "unnumbered_pin", format!("pin {} has no number", text(&p["name"])))); }+        else { *numbers.entry(n).or_default() += 1; }+    }+    for (n, k) in &numbers { if *k > 1 { out.push(finding(&name, "symbol", "duplicate_pin_number", format!("{k} pins are numbered {n}"))); } }+    let fps: Vec<String> = match sym.get("footprint") {+        Some(Value::Array(a)) => a.iter().map(text).filter(|s| !s.is_empty()).collect(),+        Some(v) => Some(text(v)).filter(|s| !s.is_empty()).into_iter().collect(),+        None => Vec::new(),+    };+    if sym.get("footprint").map(empty).unwrap_or(false) { out.push(finding(&name, "symbol", "no_footprint", "no footprint is linked".into())); }+    if let Some(lib) = footprints {+        for fpn in &fps {+            let Some(fp) = lib.get(fpn).or_else(|| lib.get(base(fpn))) else {+                out.push(finding(&name, "symbol", "footprint_not_found", format!("footprint {fpn} is not in the footprint libraries checked")));+                continue;+            };+            let pads: BTreeSet<String> = fp["pads"].as_array().map(|a| a.iter().filter(|p| !mechanical(p)).map(|p| text(&p["number"])).filter(|n| !n.is_empty()).collect()).unwrap_or_default();+            let missing: Vec<&String> = numbers.keys().filter(|n| !pads.contains(*n)).collect();+            if !missing.is_empty() { out.push(finding(&name, "symbol", "pin_without_pad", format!("{} no pad on {fpn}", list("pin", &missing)))); }+            let spare: Vec<&String> = pads.iter().filter(|n| !numbers.contains_key(*n)).collect();+            if !spare.is_empty() { out.push(finding(&name, "symbol", "pad_without_pin", format!("{} no pin on {fpn}", list("pad", &spare)))); }+        }+    }+    if sym.get("partNumber").map(empty).unwrap_or(false) { out.push(finding(&name, "symbol", "no_part_number", "no manufacturer part number".into())); }+    out+}++/// lint_library: input {library: {footprints?: [{name, pads: [{number, x, y, w, h, hole?, mechanical?, plated?}],+/// courtyard?, silk?, bodies?, description?}], symbols?: [{name, pins: [{number, name?}], footprint?, partNumber?}],+/// unread?: [{name, error}], findings?: [the bridge's own]}, args: {names?}}. Symbols are checked against the footprints+/// sent (the library's own, or those of footprintLibraries the bridge resolved).+pub fn lint_library(input: &Value) -> Value {+    let lib = &input["library"];+    if !lib.is_object() { return crate::input::refuse("bad_args", "library is required: {footprints?, symbols?, unread?, findings?}"); }+    let names: Option<BTreeSet<String>> = input["args"]["names"].as_array().map(|a| a.iter().map(text).collect());+    let wanted = |v: &Value| names.as_ref().map(|n| n.contains(&text(&v["name"]))).unwrap_or(true);+    let fps = lib["footprints"].as_array().cloned().unwrap_or_default();+    let syms = lib["symbols"].as_array().cloned().unwrap_or_default();+    let by_name: Option<BTreeMap<String, Value>> = lib.get("footprints").filter(|v| v.is_array()).map(|_| fps.iter().map(|fp| (text(&fp["name"]), fp.clone())).flat_map(|(n, fp)| [(base(&n).to_string(), fp.clone()), (n, fp)]).collect());+    let mut findings: Vec<Value> = lib["findings"].as_array().cloned().unwrap_or_default();+    let mut checked = 0;+    for fp in fps.iter().filter(|v| wanted(v)) { checked += 1; findings.extend(lint_footprint(fp)); }+    for s in syms.iter().filter(|v| wanted(v)) { checked += 1; findings.extend(lint_symbol(s, by_name.as_ref())); }+    let count = |sev: &str| findings.iter().filter(|x| x["severity"] == sev).count();+    let (errors, warnings, infos) = (count("error"), count("warning"), count("info"));+    let unread = lib["unread"].as_array().cloned().unwrap_or_default();+    json!({"success": true, "ok": errors == 0 && unread.is_empty(), "checked": checked, "errors": errors, "warnings": warnings, "infos": infos,+        "findings": findings, "unread": unread,+        "rules": RULES.iter().map(|r| json!({"kind": r.0, "rule": r.1, "severity": r.2})).collect::<Vec<_>>(),+        "_hint": "Errors stop a part working; warnings are usually mistakes; infos are gaps. A rule is only checked when the bridge read what it needs, so a missing finding is not a pass for a rule the bridge could not read."})+}++#[cfg(test)]+mod tests {+    use super::*;++    fn pad(n: &str, x: f64, y: f64) -> Value { json!({"number": n, "x": x, "y": y, "w": 0.6, "h": 1.5}) }++    #[test]+    fn a_clean_footprint_and_its_symbol_pass() {+        let r = lint_library(&json!({"library": {+            "footprints": [{"name": "SOT23", "pads": [pad("1", -0.95, -1.1), pad("2", 0.95, -1.1), pad("3", 0.0, 1.1)], "courtyard": [-1.7, -2.0, 1.7, 2.0], "silk": [[0, 0]], "bodies": [{"h": 1.1}], "description": "SOT-23"}],+            "symbols": [{"name": "BJT", "pins": [{"number": "1"}, {"number": "2"}, {"number": "3"}], "footprint": "Lib:SOT23", "partNumber": "MMBT3904"}]}}));+        assert_eq!(r["ok"], true, "{r}");+        assert_eq!(r["checked"], 2);+        assert_eq!(r["findings"], json!([]));+    }++    #[test]+    fn the_shared_rules_fire_with_their_own_severity() {+        // the xcopy bug of altium-bridge#29: a copy 1270 mm off its origin+        let far = json!({"name": "BAT_FP_X", "pads": [pad("1", 1270.0, 0.0), pad("1", 1272.0, 0.0), json!({"number": "", "x": 1271.0, "y": 0.0, "w": 0.0, "h": 0.0})], "courtyard": null, "silk": [], "description": ""});+        let r = lint_library(&json!({"library": {"footprints": [far],+            "symbols": [{"name": "BAT", "pins": [{"number": "1"}, {"number": "2"}], "footprint": "BAT_FP_X", "partNumber": ""}, {"name": "LOST", "pins": [{"number": "1"}], "footprint": "NOPE"}, {"name": "BARE", "pins": [], "footprint": ""}],+            "findings": [{"name": "X", "kind": "library", "rule": "tool_refuses_file", "severity": "error", "detail": "kicad-cli: bad token"}]}}));+        let rules: Vec<&str> = r["findings"].as_array().unwrap().iter().map(|x| x["rule"].as_str().unwrap()).collect();+        for want in ["tool_refuses_file", "zero_size_pad", "unnumbered_pad", "duplicate_pad_number", "no_courtyard", "origin_off_part", "no_silkscreen", "no_description", "pin_without_pad", "no_part_number", "footprint_not_found", "no_pins", "no_footprint"] {+            assert!(rules.contains(&want), "{want} missing from {rules:?}");+        }+        // bodies was not sent, so no_3d_body is not evaluated+        assert!(!rules.contains(&"no_3d_body"));+        assert_eq!(r["ok"], false);+        assert!(r["findings"].as_array().unwrap().iter().all(|x| x["severity"] == severity(x["rule"].as_str().unwrap())));+        let off = r["findings"].as_array().unwrap().iter().find(|x| x["rule"] == "origin_off_part").unwrap();+        assert!(off["detail"].as_str().unwrap().starts_with("the origin is 1268.700 mm"), "{off}");+    }++    #[test]+    fn a_spare_pad_warns_and_a_mechanical_one_does_not() {+        let fp = json!({"name": "USB", "pads": [pad("1", 0.0, 0.0), pad("2", 0.65, 0.0), pad("S1", 3.0, 0.0), json!({"number": "", "x": -2.0, "y": 1.0, "w": 0.0, "h": 0.0, "hole": 0.65, "plated": false})]});+        let r = lint_library(&json!({"library": {"footprints": [fp], "symbols": [{"name": "USB", "pins": [{"number": "1"}, {"number": "2"}], "footprint": "USB"}]}}));+        let f: Vec<(&str, &str)> = r["findings"].as_array().unwrap().iter().map(|x| (x["rule"].as_str().unwrap(), x["detail"].as_str().unwrap())).collect();+        assert_eq!(f, vec![("pad_without_pin", "pad S1 has no pin on USB")], "{r}");+        assert_eq!(r["ok"], true, "a warning does not fail the library");+        // a name filter, and unread items fail ok+        let r = lint_library(&json!({"library": {"footprints": [{"name": "A", "pads": []}, {"name": "B", "pads": [pad("1", 0.0, 0.0)]}], "unread": [{"name": "C", "error": "locked"}]}, "args": {"names": ["B"]}}));+        assert_eq!((r["checked"].clone(), r["errors"].clone(), r["ok"].clone()), (json!(1), json!(0), json!(false)));+    }+}