Adom Fields

@@ -0,0 +1,273 @@+//! Fix and verify (0.9.3): apply fix-plan steps to a copy of the board file, solve the copy, and report what changed.+//! Only copper edits the plan spells out are applied, and only where they fit:+//!   add-vias  a through via at each point of the action (else near `at`, `count` of them), placed only where it lands+//!             on the net's own copper on two or more layers and keeps 0.2 mm from every other net's copper;+//!   widen     the net's segments within 2.5 mm of `at` (on `layer` when given) to `toMm` (else twice as wide),+//!             each grown only as far as 0.2 mm clearance to other nets allows.+//! Everything else (add a part, reroute, move, review) is refused with the reason: those need a person or the AI's+//! layout pass. The copy is not refilled: zone fills stay as saved, so refill and run DRC in KiCad before adopting it.+use crate::board::Board;+use serde_json::{json, Value};+use sha2::{Digest, Sha256};+use std::path::Path;++const CLR: f64 = 0.2;++fn r2(v: f64) -> f64 { (v * 100.0).round() / 100.0 }+fn seg_dist(p: (f64, f64), a: (f64, f64), b: (f64, f64)) -> f64 {+    let (dx, dy) = (b.0 - a.0, b.1 - a.1); let l2 = dx * dx + dy * dy;+    let t = if l2 == 0.0 { 0.0 } else { (((p.0 - a.0) * dx + (p.1 - a.1) * dy) / l2).clamp(0.0, 1.0) };+    (p.0 - a.0 - t * dx).hypot(p.1 - a.1 - t * dy)+}+fn seg_seg(a: (f64, f64), b: (f64, f64), c: (f64, f64), d: (f64, f64)) -> f64 {+    let cross = |o: (f64, f64), p: (f64, f64), q: (f64, f64)| (p.0 - o.0) * (q.1 - o.1) - (p.1 - o.1) * (q.0 - o.0);+    let (d1, d2, d3, d4) = (cross(c, d, a), cross(c, d, b), cross(a, b, c), cross(a, b, d));+    if d1 * d2 < 0.0 && d3 * d4 < 0.0 { return 0.0; }+    seg_dist(a, c, d).min(seg_dist(b, c, d)).min(seg_dist(c, a, b)).min(seg_dist(d, a, b))+}+fn inside(p: (f64, f64), poly: &[(f64, f64)]) -> bool {+    let mut c = false; let n = poly.len();+    for i in 0..n { let (a, b) = (poly[i], poly[(i + n - 1) % n]); if (a.1 > p.1) != (b.1 > p.1) && p.0 < (b.0 - a.0) * (p.1 - a.1) / (b.1 - a.1) + a.0 { c = !c; } }+    c+}+/// distance from a segment (a, b) to a filled polygon: 0 inside+fn poly_dist(a: (f64, f64), b: (f64, f64), poly: &[(f64, f64)]) -> f64 {+    if inside(a, poly) || inside(b, poly) { return 0.0; }+    let n = poly.len(); (0..n).map(|i| seg_seg(a, b, poly[i], poly[(i + 1) % n])).fold(f64::MAX, f64::min)+}++/// The clearance from a stroke (a to b, width w) on `layer` (None: every layer, a via) to the nearest copper of another net.+fn room(b: &Board, net: &str, layer: Option<&str>, a: (f64, f64), bb: (f64, f64), w: f64, soft: bool) -> f64 {+    let on = |l: &str| layer.map_or(true, |x| x == l || l == "*.Cu");+    let mut m = f64::MAX;+    for t in &b.tracks { if t.net != net && on(&t.layer) { m = m.min(seg_seg(a, bb, t.a, t.b) - t.w / 2.0); } }+    for v in &b.vias { if v.net != net { m = m.min(seg_dist((v.x, v.y), a, bb) - v.size / 2.0); } }+    for v in &b.plated_holes { if v.net != net { m = m.min(seg_dist((v.x, v.y), a, bb) - v.size / 2.0); } }+    // a pour's fill retreats from the new copper when the zones are refilled (soft); a pad does not+    for p in b.polys.iter().filter(|_| !soft).chain(b.pad_polys.iter()) { if p.net != net && on(&p.layer) && p.pts.len() > 2 { m = m.min(poly_dist(a, bb, &p.pts)); } }+    // unconnected copper (net "") still conducts, so it counts; holes without copper are kept clear the same way+    m - w / 2.0+}++/// the layers where the net's own copper is at p+fn own_layers(b: &Board, net: &str, p: (f64, f64)) -> Vec<String> {+    let mut v: Vec<String> = Vec::new();+    for t in &b.tracks { if t.net == net && seg_dist(p, t.a, t.b) <= t.w / 2.0 { v.push(t.layer.clone()); } }+    for q in b.polys.iter().chain(b.pad_polys.iter()) { if q.net == net && q.pts.len() > 2 && inside(p, &q.pts) { v.push(q.layer.clone()); } }+    v.sort(); v.dedup(); v+}++/// one top-level s-expression block per (start, end) byte span, for the heads asked+fn blocks(text: &str, head: &str) -> Vec<(usize, usize)> {+    let pat = format!("({head}"); let bytes = text.as_bytes(); let mut out = Vec::new(); let mut i = 0;+    while let Some(k) = text[i..].find(&pat) {+        let s = i + k; let after = bytes.get(s + pat.len()).copied().unwrap_or(b' ');+        if !(after.is_ascii_whitespace() || after == b')') { i = s + pat.len(); continue; }+        let (mut depth, mut j, mut q) = (0i32, s, false);+        while j < bytes.len() { let c = bytes[j]; if c == b'"' && bytes[j.saturating_sub(1)] != b'\\' { q = !q; } else if !q { if c == b'(' { depth += 1; } else if c == b')' { depth -= 1; if depth == 0 { break; } } } j += 1; }+        out.push((s, j + 1)); i = j + 1;+    }+    out+}++fn uuid(seed: &str) -> String { let h = format!("{:x}", Sha256::digest(seed.as_bytes())); format!("{}-{}-4{}-a{}-{}", &h[0..8], &h[8..12], &h[13..16], &h[17..20], &h[20..32]) }++pub struct Edit { pub step: u64, pub kind: String, pub net: String, pub kind_action: String, pub applied: Vec<Value>, pub refused: Option<String> }++/// Apply the selected steps of a fix plan to the board text; returns the new text and what happened per step.+pub fn apply(text: &str, b0: &Board, plan: &[Value], soft: bool) -> (String, Vec<Edit>) {+    let mut text = text.to_string();+    // each edit sees the ones before it: the vias added and the segments widened go into this copy of the board+    let mut b = b0.clone();+    // the board's own via size (the most common), and how it names nets: `(net "GND")` (KiCad 9 and later) or `(net 3)`+    let mut sizes: std::collections::BTreeMap<(i64, i64), usize> = Default::default();+    for v in &b.vias { *sizes.entry(((v.size * 1000.0).round() as i64, (v.drill * 1000.0).round() as i64)).or_default() += 1; }+    let (vs, vd) = sizes.iter().max_by_key(|e| e.1).map(|(k, _)| (k.0 as f64 / 1000.0, k.1 as f64 / 1000.0)).unwrap_or((0.6, 0.3));+    let numbered: std::collections::BTreeMap<String, String> = {+        let root = crate::sexp::parse(&text); root.kids("net").iter().filter_map(|n| Some((n.atom(2)?.to_string(), match n.list().get(1)? { crate::sexp::Sx::Num(x) => format!("{}", *x as i64), crate::sexp::Sx::Atom(a) => a.clone(), _ => return None }))).collect()+    };+    let net_tok = |n: &str| match numbered.get(n) { Some(id) => format!("(net {id})"), None => format!("(net \"{}\")", n.replace('"', "\\\"")) };+    let (top, bot) = (b.copper.first().cloned().unwrap_or("F.Cu".into()), b.copper.last().cloned().unwrap_or("B.Cu".into()));+    let mut placed: Vec<(f64, f64)> = Vec::new();+    let mut new_vias = String::new();+    let mut widths: Vec<(usize, usize, String)> = Vec::new();+    let mut edits = Vec::new();+    for st in plan {+        let a = &st["action"]; let ty = a["type"].as_str().unwrap_or("").to_string();+        let mut e = Edit { step: st["step"].as_u64().unwrap_or(0), kind: st["kind"].as_str().unwrap_or("").into(), net: a["net"].as_str().unwrap_or("").into(), kind_action: ty.clone(), applied: Vec::new(), refused: None };+        let net = a["net"].as_str().unwrap_or("").to_string();+        let at = a["at"].as_array().or_else(|| st["at"].as_array()).and_then(|v| Some((v.first()?.as_f64()?, v.get(1)?.as_f64()?)));+        match ty.as_str() {+            "add-vias" if !net.is_empty() => {+                let fits = |p: (f64, f64), placed: &[(f64, f64)]| p.0 > b.x0 + 0.5 && p.0 < b.x1 - 0.5 && p.1 > b.y0 + 0.5 && p.1 < b.y1 - 0.5+                    && own_layers(&b, &net, p).len() >= 2 && room(&b, &net, None, p, p, vs, soft) >= CLR+                    && b.vias.iter().filter(|v| v.net == net).chain(std::iter::empty()).all(|v| (v.x - p.0).hypot(v.y - p.1) >= vs + CLR)+                    && placed.iter().all(|q| (q.0 - p.0).hypot(q.1 - p.1) >= vs + CLR);+                // the nearest spot that fits, within r of p, on a 0.1 mm spiral of rings+                let near = |p: (f64, f64), r: f64, placed: &[(f64, f64)]| -> Option<(f64, f64)> {+                    if fits(p, placed) { return Some(p); }+                    let mut rr = 0.1; while rr <= r + 1e-9 { let n = ((2.0 * std::f64::consts::PI * rr / 0.1).ceil() as usize).max(8); for k in 0..n { let t = k as f64 / n as f64 * std::f64::consts::TAU; let q = (p.0 + rr * t.cos(), p.1 + rr * t.sin()); if fits(q, placed) { return Some(q); } } rr += 0.1; } None+                };+                let pts: Vec<(f64, f64)> = a["points"].as_array().map(|v| v.iter().filter_map(|p| Some((p.get(0)?.as_f64()?, p.get(1)?.as_f64()?))).collect()).unwrap_or_default();+                let mut miss = 0;+                if !pts.is_empty() { for p in pts { match near(p, 1.0, &placed) { Some(q) => placed.push(q), None => { miss += 1; continue; } } let q = *placed.last().unwrap(); e.applied.push(json!({"via": [r2(q.0), r2(q.1)], "movedMm": r2((q.0 - p.0).hypot(q.1 - p.1))})); } }+                else if let Some(p) = at {+                    let want = a["count"].as_u64().unwrap_or(match e.kind.as_str() { "thermal-vias" => 4, "ground-offset" => 3, _ => 1 }) as usize;+                    for _ in 0..want { match near(p, 2.5, &placed) { Some(q) => { placed.push(q); e.applied.push(json!({"via": [r2(q.0), r2(q.1)], "movedMm": r2((q.0 - p.0).hypot(q.1 - p.1))})); } None => { miss += 1; } } }+                } else { e.refused = Some("the action has no points and no `at`".into()); }+                for v in &e.applied { let q = &v["via"]; let (x, y) = (q[0].as_f64().unwrap(), q[1].as_f64().unwrap());+                    b.vias.push(crate::board::Via { net: net.clone(), x, y, size: vs, drill: vd, drill_long: None, drill_angle: 0.0 });+                    new_vias.push_str(&format!("\t(via\n\t\t(at {x} {y})\n\t\t(size {vs})\n\t\t(drill {vd})\n\t\t(layers \"{top}\" \"{bot}\")\n\t\t{}\n\t\t(uuid \"{}\")\n\t)\n", net_tok(&net), uuid(&format!("adom-fields verify {net} {x} {y}")))); }+                if e.applied.is_empty() && e.refused.is_none() { e.refused = Some(format!("no spot near the point(s) lands on {net}'s copper on two layers with {CLR} mm clearance to other nets")); }+                else if miss > 0 { e.applied.push(json!({"skipped": miss, "why": format!("no spot within reach lands on {net}'s copper on two layers with {CLR} mm to other nets' copper")})); }+            }+            "widen" if !net.is_empty() => {+                let Some(p) = at else { e.refused = Some(if a["target"].is_number() { "an impedance width change: use the review's `impedance` rows for the width (not applied automatically yet)".into() } else { "the action has no `at`".into() }); edits.push(e); continue };+                let layer = a["layer"].as_str();+                let mut hit = 0;+                for (s, t) in blocks(&text, "segment") {+                    let sg = crate::sexp::parse(&text[s..t]);+                    let n = sg.kid("net").and_then(|n| match n.list().get(1)? { crate::sexp::Sx::Num(x) => Some(format!("{}", *x as i64)), crate::sexp::Sx::Atom(a) => Some(a.clone()), _ => None }).map(|x| numbered.iter().find(|(_, id)| **id == x).map(|(k, _)| k.clone()).unwrap_or(x)).unwrap_or_default();+                    let ly = sg.kid("layer").and_then(|l| l.atom(1)).unwrap_or("");+                    if n != net || layer.is_some_and(|l| l != ly) { continue; }+                    let (Some(st0), Some(en)) = (sg.kid("start"), sg.kid("end")) else { continue };+                    let (pa, pb) = ((st0.num(1).unwrap_or(0.0), st0.num(2).unwrap_or(0.0)), (en.num(1).unwrap_or(0.0), en.num(2).unwrap_or(0.0)));+                    if seg_dist(p, pa, pb) > 2.5 { continue; }+                    let w0 = sg.kid("width").and_then(|w| w.num(1)).unwrap_or(0.2);+                    let goal = a["toMm"].as_f64().unwrap_or(w0 * 2.0).max(w0);+                    // the widest that keeps the clearance, in 0.05 mm steps down from the goal+                    let mut w = goal; while w > w0 + 1e-9 && room(&b, &net, Some(ly), pa, pb, w, soft) < CLR { w -= 0.05; }+                    if w <= w0 + 0.01 { continue; }+                    let w = r2(w);+                    if let Some(k) = text[s..t].find("(width ") { let ws = s + k; let we = ws + text[ws..t].find(')').unwrap() + 1; widths.push((ws, we, format!("(width {w})"))); hit += 1;+                        for tr in b.tracks.iter_mut().filter(|tr| tr.net == net && tr.layer == ly && tr.a == pa && tr.b == pb) { tr.w = w; }+                        e.applied.push(json!({"segment": [[r2(pa.0), r2(pa.1)], [r2(pb.0), r2(pb.1)]], "layer": ly, "fromMm": w0, "toMm": w, "short": w + 1e-9 < goal})); }+                }+                if hit == 0 { e.refused = Some(format!("no {net} segment within 2.5 mm of ({:.1}, {:.1}){} could grow and keep {CLR} mm to other nets{}", p.0, p.1, layer.map(|l| format!(" on {l}")).unwrap_or_default(), if soft { " (a neck in a pour needs the pour reshaped, which is a layout change)" } else { " (other nets' pours count as fixed: --refill lets them retreat, as KiCad's refill would)" })); }+            }+            "add-vias" | "widen" => e.refused = Some("the action names no net".into()),+            "" => e.refused = Some("no action".into()),+            t => e.refused = Some(format!("`{t}` is a layout or part change, not a copper edit: the AI or a person makes it, then `verify --board` the edited file")),+        }+        edits.push(e);+    }+    widths.sort_by_key(|w| std::cmp::Reverse(w.0));+    for (s, t, r) in widths { text.replace_range(s..t, &r); }+    if !new_vias.is_empty() { if let Some(end) = text.rfind(')') { text.insert_str(end, &new_vias); } }+    (text, edits)+}++fn n(v: &Value) -> Option<f64> { v.as_f64() }+fn delta(name: &str, a: Option<f64>, b: Option<f64>, unit: &str, better_low: bool) -> Option<Value> {+    let (a, b) = (a?, b?); if r2(a) == r2(b) { return None; }+    Some(json!({"metric": name, "before": r2(a), "after": r2(b), "unit": unit, "better": if better_low { b < a } else { b > a }}))+}++/// The before/after comparison of two solves.+pub fn compare(before: &Value, after: &Value, edits: &[Edit]) -> Value {+    let key = |i: &Value| format!("{}|{}|{}", i["kind"].as_str().unwrap_or(""), i["net"].as_str().unwrap_or(""), i["reference"].as_str().unwrap_or(""));+    let bi = before["issues"].as_array().cloned().unwrap_or_default(); let ai = after["issues"].as_array().cloned().unwrap_or_default();+    let bk: Vec<String> = bi.iter().map(key).collect(); let ak: Vec<String> = ai.iter().map(key).collect();+    let cleared: Vec<Value> = bi.iter().filter(|i| !ak.contains(&key(i))).map(|i| json!({"severity": i["severity"], "kind": i["kind"], "what": i["what"]})).collect();+    let new: Vec<Value> = ai.iter().filter(|i| !bk.contains(&key(i))).map(|i| json!({"severity": i["severity"], "kind": i["kind"], "what": i["what"]})).collect();+    let mut m: Vec<Value> = Vec::new();+    let bn = before["nets"].as_array().cloned().unwrap_or_default();+    for x in after["nets"].as_array().into_iter().flatten() {+        let nm = x["net"].as_str().unwrap_or(""); let Some(y) = bn.iter().find(|y| y["net"] == nm) else { continue };+        if let Some(d) = delta(&format!("{nm} peak current density"), n(&y["peakJ"]), n(&x["peakJ"]), "A/mm²", true) { m.push(d); }+        if let Some(d) = delta(&format!("{nm} Joule loss"), n(&y["jouleW"]), n(&x["jouleW"]), "W", true) { m.push(d); }+    }+    let r = |v: &Value, p: &[&str]| { let mut c = v; for k in p { c = &c[*k]; } c.as_f64() };+    for (nm, p, u, lo) in [("peak rise, still air", &["heat", "peakRiseC"][..], "°C", true), ("peak rise, moving air", &["heat", "peakRiseMovingC"], "°C", true), ("ground offset", &["review", "ground", "offsetMv"], "mV", true), ("hot-loop emissions margin", &["review", "converter", "emissions", "worstMarginDb"], "dB", false), ("conducted emissions margin", &["review", "conductedEmissions", "worstMarginDb"], "dB", false), ("ground edge stitched", &["review", "ground", "stitching", "edgeCoveredPct"], "%", false)] {+        if let Some(d) = delta(nm, r(before, p), r(after, p), u, lo) { m.push(d); }+    }+    for c in after["review"]["cableEmissions"]["connectors"].as_array().into_iter().flatten() {+        let cj = c["connector"].as_str().unwrap_or(""); let b0 = before["review"]["cableEmissions"]["connectors"].as_array().and_then(|a| a.iter().find(|x| x["connector"] == cj).cloned());+        if let Some(d) = delta(&format!("{cj} cable emissions margin"), b0.and_then(|x| x["worstMarginDb"].as_f64()), c["worstMarginDb"].as_f64(), "dB", false) { m.push(d); }+    }+    for x in after["chips"].as_array().into_iter().flatten() {+        let rf = x["reference"].as_str().unwrap_or(""); let y = before["chips"].as_array().and_then(|a| a.iter().find(|y| y["reference"] == rf).cloned());+        if let Some(d) = delta(&format!("{rf} rise"), y.and_then(|y| y["riseC"].as_f64()), x["riseC"].as_f64(), "°C", true) { m.push(d); }+    }+    let steps: Vec<Value> = edits.iter().map(|e| {+        let still = ai.iter().any(|i| i["kind"].as_str() == Some(e.kind.as_str()) && (e.net.is_empty() || i["net"].as_str() == Some(e.net.as_str())));+        json!({"step": e.step, "kind": e.kind, "action": e.kind_action, "applied": e.applied, "refused": e.refused, "issueCleared": if e.refused.is_some() || e.applied.is_empty() { Value::Null } else { json!(!still) }})+    }).collect();+    let (up, down) = (m.iter().filter(|x| x["better"] == true).count(), m.iter().filter(|x| x["better"] == false).count());+    json!({"steps": steps, "cleared": cleared, "new": new, "issuesBefore": bi.len(), "issuesAfter": ai.len(), "metrics": m, "better": up, "worse": down,+        "readNote": "a net's peak current density is one cell: a widened trace can move it to a new corner where wide meets narrow; Joule loss, temperatures and drops are the robust measures"})+}++/// KiCad's own zone refill and DRC (errors only), saving the refilled board in place; the shim runs it on service-kicad or+/// the user's desktop. Returns the violations.+fn refill_drc(board: &Path, report: &Path) -> Result<Vec<Value>, String> {+    let o = std::process::Command::new("kicad-cli").args(["pcb", "drc", "--refill-zones", "--save-board", "--format", "json", "--severity-error", "-o"]).arg(report).arg(board).output().map_err(|e| format!("kicad-cli: {e} (--refill needs kicad-cli: service-kicad, or KiCad through Adom Bridge)"))?;+    let v: Value = std::fs::read_to_string(report).ok().and_then(|t| serde_json::from_str(&t).ok()).ok_or_else(|| format!("kicad-cli pcb drc gave no report: {}", String::from_utf8_lossy(&o.stderr).lines().last().unwrap_or("")))?;+    Ok(v["violations"].as_array().cloned().unwrap_or_default())+}+fn drc_key(v: &Value) -> String { format!("{}|{}", v["type"].as_str().unwrap_or(""), v["items"].as_array().into_iter().flatten().map(|i| format!("{:.1},{:.1}", i["pos"]["x"].as_f64().unwrap_or(0.0), i["pos"]["y"].as_f64().unwrap_or(0.0))).collect::<Vec<_>>().join(";")) }++/// The verify command: solve (or reuse) the original, apply the steps to a copy, solve the copy, compare. With refill,+/// both the original and the copy are refilled and DRC'd by KiCad first, so the two solves differ only by the fix.+pub fn run(board: &str, spec: &str, out: &Path, steps: &[u64], pitch: f64, reuse: Option<&Path>, refill: bool) -> Result<Value, String> {+    if !board.ends_with(".kicad_pcb") { return Err("verify edits a KiCad .kicad_pcb (it writes the fixed copy beside the solve)".into()); }+    std::fs::create_dir_all(out).map_err(|e| e.to_string())?;+    let text = std::fs::read_to_string(board).map_err(|e| format!("{board}: {e}"))?;+    let sha = format!("{:x}", Sha256::digest(text.as_bytes()));+    let given = match reuse.map(|d| d.join("fields.json")).and_then(|p| std::fs::read_to_string(p).ok()).and_then(|t| serde_json::from_str::<Value>(&t).ok()) {+        Some(v) if v["inputIdentity"]["board"].as_str() == Some(sha.as_str()) => Some(v),+        Some(_) => return Err("--fields is a solve of a different board file (its inputIdentity does not match); drop --fields to solve it here".into()),+        None => None,+    };+    let name = Path::new(board).file_name().unwrap().to_string_lossy().to_string();+    let orig_path = out.join(format!("original-{name}"));+    let mut before = match &given { Some(v) if !refill => v.clone(), _ => Value::Null };+    if before.is_null() && !refill { before = crate::run_analyze(board, spec, &out.join("before"), pitch, 60.0, None, true)?; }+    let plan_src = given.clone().unwrap_or_else(|| before.clone());+    let b = Board::load(board)?;+    // with refill and no plan yet, the plan comes from the refilled original's solve (below); edits need it first, so+    // solve the board as saved for the plan when nothing else gives one+    let plan_src = if plan_src.is_null() { crate::run_analyze(board, spec, &out.join("plan"), pitch, 60.0, None, true)? } else { plan_src };+    let plan: Vec<Value> = plan_src["fixPlan"].as_array().cloned().unwrap_or_default().into_iter().filter(|s| steps.is_empty() || steps.contains(&s["step"].as_u64().unwrap_or(0))).collect();+    if plan.is_empty() { return Err(if steps.is_empty() { "the fix plan is empty: nothing to verify".into() } else { format!("no fix-plan step {:?} (the plan has {})", steps, plan_src["fixPlan"].as_array().map_or(0, |a| a.len())) }); }+    let (fixed, edits) = apply(&text, &b, &plan, refill);+    let fixed_path = out.join(&name);+    if edits.iter().all(|e| e.applied.is_empty()) {+        return Ok(json!({"applied": 0, "board": Value::Null, "report": compare(&plan_src, &plan_src, &edits)}));+    }+    std::fs::write(&fixed_path, &fixed).map_err(|e| e.to_string())?;+    let mut drc = Value::Null;+    if refill {+        std::fs::write(&orig_path, &text).map_err(|e| e.to_string())?;+        // the two KiCad runs at once (each is a round trip to the desktop or the service)+        let (o2, f2) = (orig_path.clone(), fixed_path.clone()); let (r1p, r2p) = (out.join("drc-before.json"), out.join("drc-after.json"));+        let h = std::thread::spawn(move || refill_drc(&o2, &r1p));+        let va = refill_drc(&f2, &r2p)?; let vb = h.join().map_err(|_| "kicad-cli thread")??;+        let kb: Vec<String> = vb.iter().map(drc_key).collect();+        let new: Vec<Value> = va.iter().filter(|v| !kb.contains(&drc_key(v))).map(|v| json!({"type": v["type"], "description": v["description"], "items": v["items"].as_array().into_iter().flatten().map(|i| json!({"what": i["description"], "at": [i["pos"]["x"], i["pos"]["y"]]})).collect::<Vec<_>>()})).collect();+        drc = json!({"errorsBefore": vb.len(), "errorsAfter": va.len(), "new": new});+        before = crate::run_analyze(orig_path.to_str().unwrap(), spec, &out.join("before"), pitch, 60.0, None, true)?;+    }+    let after = crate::run_analyze(fixed_path.to_str().unwrap(), spec, &out.join("after"), pitch, 60.0, None, true)?;+    let report = compare(&before, &after, &edits);+    let v = json!({"applied": edits.iter().filter(|e| !e.applied.is_empty()).count(), "board": fixed_path.display().to_string(), "refilled": refill, "drc": drc, "before": out.join("before").display().to_string(), "after": out.join("after").display().to_string(),+        "note": if refill { "both boards refilled by KiCad before solving; `drc.new` lists errors the fix introduced (none: it is clean to adopt)" } else { "zone fills are as saved: refill the zones and run DRC in KiCad before adopting the fixed board (or run verify with --refill)" }, "report": report});+    std::fs::write(out.join("verify.json"), serde_json::to_string_pretty(&v).unwrap()).map_err(|e| e.to_string())?;+    Ok(v)+}++#[cfg(test)] mod tests {+    use super::*;+    #[test] fn geometry() {+        assert!((seg_dist((0.0, 1.0), (-1.0, 0.0), (1.0, 0.0)) - 1.0).abs() < 1e-12);+        assert_eq!(seg_seg((0.0, -1.0), (0.0, 1.0), (-1.0, 0.0), (1.0, 0.0)), 0.0);+        let sq = [(0.0, 0.0), (2.0, 0.0), (2.0, 2.0), (0.0, 2.0)];+        assert!(inside((1.0, 1.0), &sq) && !inside((3.0, 1.0), &sq));+        assert!((poly_dist((3.0, 1.0), (4.0, 1.0), &sq) - 1.0).abs() < 1e-12);+    }+    #[test] fn block_spans() {+        let t = "(kicad_pcb (segment (start 0 0) (end 1 0) (width 0.2) (net \"A\")) (segments x) (segment (start 1 0) (end 2 0) (width 0.3)))";+        let b = blocks(t, "segment"); assert_eq!(b.len(), 2); assert!(t[b[1].0..b[1].1].contains("0.3"));+        let sg = crate::sexp::parse(&t[b[0].0..b[0].1]); assert_eq!(sg.head(), "segment"); assert!(sg.kid("start").is_some());+    }+}