EDA Bridge Standard: one way for an AI to drive every PCB tool

@@ -473,10 +473,39 @@ pub fn plan_fanout(input: &Value) -> Value {         calls.entry(n.to_string()).or_default().push(json!(path));         rows.push(row);     }+    // the board's routed copper: (net, layer or "" for every layer, shape, kind). Net-less tracks and arcs are a hatched+    // pour's pieces, which re-pour round new copper (altium-lane #22: a plan with "0 conflicts" shorted U4's routing)+    let mut routed: Vec<(String, String, Shape, &'static str)> = Vec::new();+    for t in st["tracks"].as_array().into_iter().flatten().filter(|t| !net(t).is_empty()) {+        routed.push((net(t), t["layer"].as_str().unwrap_or("").to_string(), Shape::Cap((f(&t["start"]["x"]), f(&t["start"]["y"])), (f(&t["end"]["x"]), f(&t["end"]["y"])), f(&t["width"]) / 2.0), "track"));+    }+    for a in st["arcs"].as_array().into_iter().flatten().filter(|a| !net(a).is_empty()) {+        let (c, rad) = ((f(&a["center"]["x"]), f(&a["center"]["y"])), f(&a["radius"]));+        let (a1, mut a2) = (f(&a["startAngle"]), f(&a["endAngle"]));+        if a2 <= a1 { a2 += 360.0; }+        let k = ((a2 - a1) / 10.0).ceil().max(1.0) as usize;+        let p = |deg: f64| (c.0 + rad * deg.to_radians().cos(), c.1 + rad * deg.to_radians().sin());+        for i in 0..k { routed.push((net(a), a["layer"].as_str().unwrap_or("").to_string(), Shape::Cap(p(a1 + (a2 - a1) * i as f64 / k as f64), p(a1 + (a2 - a1) * (i + 1) as f64 / k as f64), f(&a["width"]) / 2.0), "arc")); }+    }+    let holes: Vec<(P, f64)> = st["vias"].as_array().into_iter().flatten().map(|v| ((f(&v["position"]["x"]), f(&v["position"]["y"])), f(&v["size"]) / 2.0))+        .chain(st["pads"].as_array().into_iter().flatten().filter(|p| f(&p["drill"]) > 0.0).map(|p| (at(p), f(&p["sizeX"]).max(f(&p["sizeY"])).max(f(&p["drill"])) / 2.0))).collect();+    for v in st["vias"].as_array().into_iter().flatten().filter(|v| !net(v).is_empty()) {+        let c = (f(&v["position"]["x"]), f(&v["position"]["y"]));+        routed.push((net(v), String::new(), Shape::Cap(c, c, f(&v["size"]) / 2.0), "via"));+    }+    let include_routed = args["includeRouted"].as_bool().unwrap_or(false);     for &i in &signal {         let p = pads[i];         let (pa, n) = (at(p), net(p));         if n.is_empty() { rows.push(json!({"pad": name(p), "net": "", "action": "skip", "why": "no net"})); continue; }+        // a pin its net's copper already reaches is routed: a stub from it would run into that routing+        if !include_routed {+            let ps = pad_shape(p);+            if routed.iter().any(|(rn, l, s, _)| *rn == n && (l.is_empty() || l == side) && ps.gap(s) <= 1e-6) {+                rows.push(json!({"pad": name(p), "net": n, "action": "skip", "why": "already routed"}));+                continue;+            }+        }         if kind == "bga" {             let ring = ((pa.0 - bx.0) / pitch).round().min(((bx.2 - pa.0) / pitch).round()).min(((pa.1 - bx.1) / pitch).round()).min(((bx.3 - pa.1) / pitch).round()) as i64;             if ring == 0 && args["surfaceOuterRing"].as_bool() != Some(false) {@@ -519,16 +548,18 @@ pub fn plan_fanout(input: &Value) -> Value {         let (w, h) = if (f(&p["rotation"]).rem_euclid(180.0) - 90.0).abs() < 1.0 { (h, w) } else { (w, h) };         let vp = (via_size + 0.5).max(1.0);         let (nx, ny) = ((((w - via_size) / vp).floor() as i64 + 1).max(1), (((h - via_size) / vp).floor() as i64 + 1).max(1));-        let mut grid = Vec::new();+        let (mut grid, mut kept_clear) = (Vec::new(), 0);         for a in 0..nx {             for b in 0..ny {                 let v = (pa.0 + (a as f64 - (nx - 1) as f64 / 2.0) * vp, pa.1 + (b as f64 - (ny - 1) as f64 / 2.0) * vp);+                // clear of the holes already there, as thermal_vias keeps them (a grid on U4's 9 GND vias was hole-to-hole)+                if holes.iter().any(|(c, r)| ((c.0 - v.0).powi(2) + (c.1 - v.1).powi(2)).sqrt() < r + via_size / 2.0 + clearance - 1e-9) { kept_clear += 1; continue; }                 pieces.push((name(p), n.clone(), "via", Shape::Cap(v, v, via_size / 2.0)));                 calls.entry(n.clone()).or_default().push(json!([wp(v, side), wp(v, &escape)]));                 grid.push(json!([r3(v.0), r3(v.1)]));             }         }-        rows.push(json!({"pad": name(p), "net": n, "action": "thermal-via-grid", "layer": escape, "vias": grid, "viaPitchMm": vp}));+        rows.push(json!({"pad": name(p), "net": n, "action": "thermal-via-grid", "layer": escape, "vias": grid, "viaPitchMm": vp, "keptClearOfHoles": kept_clear}));     }     // each via and stub against every other net's pad on the board (vias on every layer, stubs on the part's side)     let all: Vec<(Value, Shape)> = st["pads"].as_array().cloned().unwrap_or_default().into_iter().map(|p| { let s = pad_shape(&p); (p, s) }).collect();@@ -540,9 +571,29 @@ pub fn plan_fanout(input: &Value) -> Value {             let g = s.gap(ps);             if *what == "via" { worst = worst.min(g); }             if g < clearance - 1e-9 {-                conflicts.push(json!({"from": from, "what": what, "pad": format!("{}.{}", p["ref"].as_str().unwrap_or(""), p["name"].as_str().unwrap_or("")), "padNet": p["net"], "gapMm": r3(g)}));+                conflicts.push(json!({"from": from, "what": what, "with": "pad", "pad": format!("{}.{}", p["ref"].as_str().unwrap_or(""), p["name"].as_str().unwrap_or("")), "padNet": p["net"], "gapMm": r3(g)}));             }         }+        // and against other nets' tracks, arcs and vias: on every layer for a via, on the part's side for a stub+        for (rn, l, rs, kind) in &routed {+            if rn == n || (*what == "stub" && !l.is_empty() && l != side) { continue; }+            let g = s.gap(rs);+            if g < clearance - 1e-9 {+                let (x0, y0, x1, y1) = rs.bounds();+                conflicts.push(json!({"from": from, "what": what, "with": kind, "net": rn, "layer": if l.is_empty() { "every" } else { l.as_str() }, "near": [r3((x0 + x1) / 2.0), r3((y0 + y1) / 2.0)], "gapMm": r3(g)}));+            }+        }+    }+    // other nets' pours the plan runs into: not conflicts (a pour re-pours round new copper), but until the repour the+    // tool's DRC sees the pour's pieces as shorts (altium-lane #22), and a stub across a pour can cut it in two+    let mut crosses: Vec<Value> = Vec::new();+    for p in st["polygons"].as_array().into_iter().flatten() {+        let (pn, pl) = (net(p), p["layer"].as_str().unwrap_or("").to_string());+        let ring: Vec<P> = p["points"].as_array().into_iter().flatten().map(|q| (f(&q[0]), f(&q[1]))).collect();+        if pn.is_empty() || ring.len() < 3 { continue; }+        let poly = Shape::Poly(ring);+        let hit = pieces.iter().any(|(_, n, what, s)| *n != pn && (*what == "via" || pl == side) && s.gap(&poly) <= 1e-9);+        if hit && !crosses.iter().any(|c| c["net"] == json!(pn) && c["layer"] == json!(pl)) { crosses.push(json!({"net": pn, "layer": pl})); }     }     let via_count = pieces.iter().filter(|x| x.2 == "via").count();     let calls: Vec<Value> = calls.into_iter().map(|(n, paths)| json!({"net": n, "layer": side, "width": width, "viaSize": via_size, "viaDrill": via_drill, "paths": paths})).collect();@@ -550,8 +601,8 @@ pub fn plan_fanout(input: &Value) -> Value {         "style": if kind == "bga" { style } else { "stubs" }, "requestedStyle": want, "dogboneRoomMm": room, "dogboneFits": fits,         "via": {"size": via_size, "drill": via_drill}, "widthMm": width, "clearanceMm": clearance,         "pads": rows, "calls": calls, "callCount": calls.len(), "viaCount": via_count,-        "minViaToPadMm": if worst < f64::MAX { json!(r3(worst)) } else { Value::Null }, "conflicts": conflicts, "warnings": warnings, "revision": st["revision"],-        "_hint": "A plan only: send each call to route_net with expectedRevision: revision. conflicts lists vias and stubs closer than clearanceMm to another net's pad on the board (vias on every layer, stubs on the part's side): drop or shorten those before routing. Tracks and pours are not checked: run DRC after. Via-in-pad needs filled and capped vias: tell the user first."})+        "minViaToPadMm": if worst < f64::MAX { json!(r3(worst)) } else { Value::Null }, "conflicts": conflicts, "crossesPours": crosses, "warnings": warnings, "revision": st["revision"],+        "_hint": "A plan only: send each call to route_net with expectedRevision: revision. conflicts lists vias and stubs closer than clearanceMm to another net's pad, track, arc or via (vias on every layer, stubs on the part's side): apply nothing while it is not empty. Pins already reached by their net's copper are skipped (includeRouted plans them anyway); the exposed-pad grid steps round holes already there. crossesPours names other nets' pours the plan runs into: repour BEFORE running DRC (until then the pour's pieces read as shorts), then check that none of them split (splitNets). Via-in-pad needs filled and capped vias: tell the user first."}) }  #[cfg(test)]@@ -718,6 +769,19 @@ mod tests {         assert_eq!(r["pads"][0]["stubEnd"], json!([-2.8, 0.75]));         assert_eq!(r["conflicts"].as_array().unwrap().iter().map(|c| c["pad"].as_str().unwrap()).collect::<Vec<_>>(), vec!["R1.1"], "{r}");         assert_eq!(plan_fanout(&json!({"board": b, "args": {"ref": "R1"}}))["errorCode"], "not_a_package");+        // on a routed board (altium-lane #22): U2.1 already has its track, so it is skipped; another net's track across+        // U2.2's stub is a conflict; a via in the exposed pad's centre keeps the grid off it+        let mut routed = b.clone();+        routed["tracks"] = json!([{"net": "S0", "layer": "F.Cu", "width": 0.2, "start": {"x": -2.0, "y": 0.75}, "end": {"x": -4.0, "y": 0.75}},+                                  {"net": "Q", "layer": "F.Cu", "width": 0.2, "start": {"x": -2.6, "y": -2.0}, "end": {"x": -2.6, "y": 0.4}}]);+        routed["vias"] = json!([{"net": "GND", "size": 0.6, "drill": 0.3, "position": {"x": 0.0, "y": 0.0}}]);+        let r = plan_fanout(&json!({"board": routed, "args": {"ref": "U2"}}));+        assert_eq!(r["pads"][0]["why"], "already routed", "{r}");+        assert!(r["conflicts"].as_array().unwrap().iter().any(|c| c["with"] == "track" && c["net"] == "Q" && c["from"] == "U2.2"), "{r}");+        let grid = r["pads"].as_array().unwrap().iter().find(|p| p["action"] == "thermal-via-grid").unwrap();+        assert!(grid["keptClearOfHoles"].as_u64().unwrap() >= 1, "{grid}");+        assert!(grid["vias"].as_array().unwrap().iter().all(|v| (f(&v[0]).powi(2) + f(&v[1]).powi(2)).sqrt() >= 0.3 + 0.3 + 0.1 - 1e-9));+        assert_eq!(plan_fanout(&json!({"board": routed, "args": {"ref": "U2", "includeRouted": true}}))["pads"][0]["action"], "surface");         assert_eq!(plan_fanout(&json!({"board": b, "args": {"ref": "U2", "escapeLayer": "In3.Cu"}}))["errorCode"], "no_such_layer");     }