KiCad - the KiCad Bridge

@@ -32,6 +32,16 @@ pub static VERBS: &[Verb] = &[         related: &["kicad_fp_info", "kicad_fp_create", "kicad_lint_library"],         pitfalls: &["boards that already use the footprint keep their own copy: update them from the library in KiCad (Update Footprints from Library)", "graphics replace/delete touch shapes only, never text on that layer"],     },+    Verb {+        name: "kicad_plate_vias",+        summary: "Make every drilled pad in a footprint library a plated hole through every copper layer (thru_hole, *.Cu *.Mask): a thru_hole pad on only some copper layers, or an smd pad with a drill (thermal vias written as surface pads). Numbered unplated holes are listed, and plated only with includeNpth.",+        mechanism: Mechanism::File, risk: "write", timeout_sec: 120,+        input: "{\"libraryPath\": \"C:/.../Mine.pretty\" | \"C:/.../x.kicad_mod\", \"footprintName\"?: \"QFN-16\", \"includeNpth\"?: false, \"dryRun\"?: false}",+        example: "kicad_plate_vias {\"libraryPath\":\"C:/Users/john/kicad/Mine.pretty\"}",+        hint: "fixed is Footprint:Pad;... (fixedPads has what each pad was and its old layers); holes counts the drilled pads seen, plated the ones changed. Each file changed is written once with a .bak beside it. unplated lists numbered np_thru_hole pads left alone (a mounting hole is meant to be unplated): includeNpth:true plates them too. Running it again changes nothing.",+        related: &["kicad_fp_info", "kicad_fp_edit", "kicad_lint_library"],+        pitfalls: &["Edits the library files in place: a board that already uses the footprint takes the change through kicad_update_footprints_from_library."],+    },     Verb {         name: "kicad_fp_info",         summary: "Full details of one footprint: pads (number, type, shape, position, size, drill, layers), layers used, courtyard box, graphics per layer, attributes, properties and 3D models.",@@ -187,6 +197,7 @@ pub fn dispatch(state: &mut State, command: &str, args: &Value) -> Option<Value>         "kicad_fp_create" => fp_create(args),         "kicad_fp_edit" => fp_edit(state, args),         "kicad_fp_info" => fp_info(state, args),+        "kicad_plate_vias" => plate_vias(args),         "kicad_sym_create" => sym_create(args),         "kicad_sym_delete" => sym_delete(args),         "kicad_sym_info" => sym_info(state, args),@@ -573,6 +584,60 @@ mod tests { // Library housekeeping (the standard's core tier) // --------------------------------------------------------------------------- +/// `kicad_plate_vias`: the standard's plate_vias over a .pretty (or one .kicad_mod).+fn plate_vias(args: &Value) -> Value {+    let Some(lib) = arg_any(args, &["libraryPath", "filePath"]).map(PathBuf::from) else {+        return fail("missing_arg", "libraryPath is required", "A .pretty folder or one .kicad_mod.");+    };+    let only = arg_str(args, "footprintName");+    let files: Vec<PathBuf> = if lib.is_dir() {+        let mut v: Vec<PathBuf> = std::fs::read_dir(&lib).into_iter().flatten().flatten().map(|e| e.path()).filter(|p| p.extension().map(|x| x == "kicad_mod").unwrap_or(false)).collect();+        v.sort();+        v+    } else if lib.is_file() {+        vec![lib.clone()]+    } else {+        return fail("file_not_found", format!("{} does not exist", norm(&lib)), "A .pretty folder or one .kicad_mod.");+    };+    let files: Vec<PathBuf> = files.into_iter().filter(|f| only.is_none_or(|n| f.file_stem().map(|s| s.to_string_lossy() == n).unwrap_or(false))).collect();+    if files.is_empty() {+        return fail("footprint_not_found", format!("no footprint {} in {}", only.unwrap_or("*"), norm(&lib)), "footprintName is the .kicad_mod's name.");+    }+    let dry = args.get("dryRun") == Some(&json!(true));+    let npth = args.get("includeNpth") == Some(&json!(true));+    let (mut fixed, mut rows, mut unplated, mut written) = (Vec::new(), Vec::new(), Vec::new(), Vec::new());+    let mut holes = 0;+    for f in &files {+        let name = f.file_stem().map(|s| s.to_string_lossy().into_owned()).unwrap_or_default();+        let Ok(text) = std::fs::read_to_string(f) else { continue };+        let (new, fx, h, un) = match kicad_core::fpedit::plate_vias(&text, npth) {+            Ok(r) => r,+            Err(e) => return fail("parse_failed", format!("{}: {e}", norm(f)), "kicad_lint_library says what is wrong with the file."),+        };+        holes += h;+        unplated.extend(un.iter().map(|n| format!("{name}:{n}")));+        if fx.is_empty() {+            continue;+        }+        for x in &fx {+            fixed.push(format!("{name}:{}", x["pad"].as_str().unwrap_or("")));+            let mut x = x.clone();+            x["footprint"] = json!(name);+            rows.push(x);+        }+        if !dry {+            let bak = f.with_extension("kicad_mod.bak");+            if let Err(e) = std::fs::copy(f, &bak).map_err(|e| e.to_string()).and_then(|_| kicad_core::libraries::write_atomic(f, new.as_bytes())) {+                return fail("write_failed", format!("{}: {e}", norm(f)), "Check the library is writable; .bak files hold the previous content of any already written.");+            }+            written.push(norm(f));+        }+    }+    json!({"success": true, "dryRun": dry, "fixed": fixed.join(";"), "fixedPads": rows, "holes": holes, "plated": fixed.len(), "unplated": unplated, "files": written,+        "output": format!("{} drilled pad(s) plated through every copper layer, of {holes} drilled pad(s) in {} footprint(s){}", fixed.len(), files.len(), if dry { " (dry run: nothing written)" } else { "" }),+        "_hint": "Boards already using these footprints take the change through kicad_update_footprints_from_library."})+}+ fn pretty_dir(args: &Value, key: &str) -> Result<PathBuf, Value> {     let Some(l) = arg_str(args, key) else {         return Err(fail("missing_arg", format!("{key} is required"), "Pass the .pretty folder's absolute path."));

@@ -142,6 +142,16 @@ pub static VERBS: &[Verb] = &[         related: &["kicad_select_net", "kicad_select_items", "kicad_render_board", "kicad_screenshot_all"],         pitfalls: &["KiCad frames the selection with its own margin; there is no margin to set.", "A rectangle is refused (not_supported): KiCad's API zooms to a selection, so name the parts in it."],     },+    Verb {+        name: "kicad_normalize_bodies",+        summary: "Move each 3D model of a footprint library (or one footprint) onto its pad cluster when its body sits more than minShiftMm from the pads' centre, by its offset; models already on their pads are left alone.",+        mechanism: Mechanism::File, risk: "write", timeout_sec: 120,+        input: "{\"libraryPath\": \"C:/.../Mine.pretty\" | \"C:/.../x.kicad_mod\", \"footprintName\"?: \"SOIC-8\", \"minShiftMm\"?: 2, \"dryRun\"?: false}",+        example: "kicad_normalize_bodies {\"libraryPath\":\"C:/Users/john/kicad/Mine.pretty\"}",+        hint: "moved[{footprint, path, shiftMm, offsetBefore, offsetAfter}] are the models moved (offset in mm, KiCad's 3D frame, y up); kept says why each other model stayed (within minShiftMm, hidden, or its file could not be read). Each file changed is written once with a .bak beside it. Running it again changes nothing.",+        related: &["kicad_footprint_models", "kicad_bodies", "kicad_fp_info"],+        pitfalls: &["It centres the body on the pads in the plane: a body offset on purpose further than minShiftMm (a connector overhanging the edge) is moved too, so raise minShiftMm or name the footprint.", "Model paths resolve through KiCad's path variables (Preferences > Configure Paths) and the library folder."],+    },     Verb {         name: "kicad_animate_view",         summary: "Camera choreography on the open board, run inside the bridge so the timing is tight enough to narrate over: zooms on the PCB editor (KiCad's own actions through its API), and in the 3D Viewer orbits, rolls, views, pans and flips (its View-menu commands), all in the background.",@@ -181,6 +191,7 @@ pub fn dispatch(state: &mut State, command: &str, args: &Value) -> Option<Value>         "kicad_set_layer_visibility" => set_layer_visibility(state, args),         "kicad_zoom_to" => zoom_to(state, args),         "kicad_animate_view" => animate_view(state, args),+        "kicad_normalize_bodies" => normalize_bodies(state, args),         _ => return None,     }) }@@ -563,6 +574,61 @@ fn kicad_vars(state: &mut State) -> std::collections::HashMap<String, String> {     doc["environment"]["vars"].as_object().map(|m| m.iter().filter_map(|(k, v)| Some((k.clone(), v.as_str()?.to_string()))).collect()).unwrap_or_default() } +/// `kicad_normalize_bodies`: the standard's normalize_bodies over a .pretty (or one .kicad_mod).+fn normalize_bodies(state: &mut State, args: &Value) -> Value {+    let Some(lib) = arg_any(args, &["libraryPath", "filePath"]).map(std::path::PathBuf::from) else {+        return fail("missing_arg", "libraryPath is required", "A .pretty folder or one .kicad_mod.");+    };+    let only = arg_str(args, "footprintName");+    let mut files: Vec<std::path::PathBuf> = if lib.is_dir() {+        std::fs::read_dir(&lib).into_iter().flatten().flatten().map(|e| e.path()).filter(|p| p.extension().map(|x| x == "kicad_mod").unwrap_or(false)).collect()+    } else if lib.is_file() {+        vec![lib.clone()]+    } else {+        return fail("file_not_found", format!("{} does not exist", norm(&lib)), "A .pretty folder or one .kicad_mod.");+    };+    files.sort();+    files.retain(|f| only.is_none_or(|n| f.file_stem().map(|s| s.to_string_lossy() == n).unwrap_or(false)));+    if files.is_empty() {+        return fail("footprint_not_found", format!("no footprint {} in {}", only.unwrap_or("*"), norm(&lib)), "footprintName is the .kicad_mod's name.");+    }+    let min_shift = args.get("minShiftMm").and_then(Value::as_f64).unwrap_or(2.0).max(0.0);+    let dry = args.get("dryRun") == Some(&json!(true));+    let models = models_dir(state);+    let vars = kicad_vars(state);+    let (mut moved, mut kept, mut written) = (Vec::new(), Vec::new(), Vec::new());+    for f in &files {+        let name = f.file_stem().map(|s| s.to_string_lossy().into_owned()).unwrap_or_default();+        let dir = f.parent().map(|p| p.to_path_buf()).unwrap_or_default();+        let Ok(text) = std::fs::read_to_string(f) else { continue };+        let mut resolve = |path: &str| -> Result<kicad_core::bodies::Bounds, String> {+            let expanded = kicad_core::bodies::expand(path, models.as_deref(), &dir, &vars).ok_or_else(|| format!("a path variable in {path} is not set (KiCad: Preferences > Configure Paths)"))?;+            let file = kicad_core::bodies::find_model(&expanded, &dir).ok_or_else(|| format!("model file not found: {expanded}"))?;+            kicad_core::bodies::file_bounds(&file)+        };+        let (new, mv, kp) = match kicad_core::fpedit::normalize_bodies(&text, min_shift, &mut resolve) {+            Ok(r) => r,+            Err(e) => return fail("parse_failed", format!("{}: {e}", norm(f)), "kicad_lint_library says what is wrong with the file."),+        };+        kept.extend(kp.into_iter().map(|mut k| { k["footprint"] = json!(name); k }));+        if mv.is_empty() {+            continue;+        }+        moved.extend(mv.into_iter().map(|mut m| { m["footprint"] = json!(name); m }));+        if !dry {+            let bak = f.with_extension("kicad_mod.bak");+            if let Err(e) = std::fs::copy(f, &bak).map_err(|e| e.to_string()).and_then(|_| kicad_core::libraries::write_atomic(f, new.as_bytes())) {+                return fail("write_failed", format!("{}: {e}", norm(f)), "Check the library is writable; .bak files hold the previous content of any already written.");+            }+            written.push(norm(f));+        }+    }+    json!({"success": true, "dryRun": dry, "moved": moved, "kept": kept, "files": written,+        "data": {"moved": moved.len(), "shifts": moved.iter().map(|m| format!("{}:{} {} mm", m["footprint"].as_str().unwrap_or(""), m["index"], m["shiftMm"])).collect::<Vec<_>>().join("; ")},+        "output": format!("{} model(s) moved onto their pads in {} footprint(s){}", moved.len(), files.len(), if dry { " (dry run: nothing written)" } else { "" }),+        "_hint": "Boards already using these footprints take the change through kicad_update_footprints_from_library."})+}+ /// `kicad_bodies`: each part's 3D bodies as boxes, from the model files. fn bodies(state: &mut State, args: &Value) -> Value {     let o = match opts(args) { Ok(o) => o, Err(e) => return e };

@@ -0,0 +1,191 @@+//! The standard's verbs KiCad has no form of (EDA Bridge Standard #29: every standard verb answered on every bridge).+//! Each answers `not_supported` with the reason and what to call instead, so an AI that calls one learns why rather+//! than meeting `unknown_verb`.++use serde_json::{json, Value};++use crate::catalog::{Mechanism, Verb};+use crate::util::*;++/// (verb, why KiCad has no form of it, what to call instead).+const WHY: &[(&str, &str, &str)] = &[+    ("kicad_add_symbol_art", "The chip outline is baked into the KiCad symbol itself by adom-symbol: KiCad shows it with no second copy to draw (Altium needs this because its symbol is rebuilt from KiCad's).", "kicad_symbol_mode or kicad_library_views (see the symbol as KiCad draws it)"),+    ("kicad_cleanup_libs", "A new KiCad library starts empty, so there is no factory-default stray to remove.", "kicad_sym_delete / kicad_lint_library"),+    ("kicad_build_symbol_modes", "KiCad symbols have two body styles (standard and De Morgan), not N display modes, and nothing in KiCad reads Altium's symbol_modes spec.", "kicad_sym_create (the standard body), kicad_symbol_mode (see either body style)"),+    ("kicad_license", "KiCad is GPL-3.0-or-later and has no licence page to drive.", "kicad_license_status"),+    ("kicad_signin", "KiCad has no account to sign in to.", "kicad_license_status"),+    ("kicad_connect_workspace", "KiCad has no cloud workspace to connect to.", "kicad_install_library (KiCad's libraries are local files and PCM packages)"),+    ("kicad_agent_start", "KiCad has no resident script agent to manage: the bridge reaches KiCad through kicad-cli, its built-in IPC API and KiCad's own Python per call, so there is nothing to start, stop, check or recover.", "kicad_readiness (is KiCad usable), kicad_eval (run KiCad's Python)"),+    ("kicad_agent_stop", "KiCad has no resident script agent to manage: the bridge reaches KiCad through kicad-cli, its built-in IPC API and KiCad's own Python per call, so there is nothing to start, stop, check or recover.", "kicad_readiness (is KiCad usable), kicad_eval (run KiCad's Python)"),+    ("kicad_agent_status", "KiCad has no resident script agent to manage: the bridge reaches KiCad through kicad-cli, its built-in IPC API and KiCad's own Python per call, so there is nothing to start, stop, check or recover.", "kicad_readiness (is KiCad usable), kicad_eval (run KiCad's Python)"),+    ("kicad_agent_recover", "KiCad has no resident script agent to manage: the bridge reaches KiCad through kicad-cli, its built-in IPC API and KiCad's own Python per call, so there is nothing to start, stop, check or recover.", "kicad_readiness (is KiCad usable), kicad_eval (run KiCad's Python)"),+    ("kicad_selftest_script_error", "KiCad runs no resident script engine to test: a failing kicad_eval snippet already comes back as eval_failed with its traceback.", "kicad_eval"),+    ("kicad_extension_ping", "KiCad needs no extension installed inside it: its IPC API is built in, so there is nothing to install, ping or keep a receipt for.", "kicad_readiness (ipcApi says whether the PCB editor's API is on)"),+    ("kicad_install_extension", "KiCad needs no extension installed inside it: its IPC API is built in, so there is nothing to install, ping or keep a receipt for.", "kicad_readiness (ipcApi says whether the PCB editor's API is on)"),+    ("kicad_install_receipt", "KiCad needs no extension installed inside it: its IPC API is built in, so there is nothing to install, ping or keep a receipt for.", "kicad_readiness (ipcApi says whether the PCB editor's API is on)"),+];++pub static VERBS: &[Verb] = &[+    Verb {+        name: "kicad_add_symbol_art",+        summary: "Draw adom-symbol's chip outline into a symbol (the standard's add_symbol_art). Not in KiCad: The chip outline is baked into the KiCad symbol itself by adom-symbol: KiCad shows it with no second copy to draw (Altium needs this because its symbol is rebuilt from KiCad's).",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_add_symbol_art {}",+        hint: "Answers not_supported with why and instead: kicad_symbol_mode or kicad_library_views (see the symbol as KiCad draws it).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_cleanup_libs",+        summary: "Remove a new library's factory-default stray part (the standard's cleanup_libs). Not in KiCad: A new KiCad library starts empty, so there is no factory-default stray to remove.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_cleanup_libs {}",+        hint: "Answers not_supported with why and instead: kicad_sym_delete / kicad_lint_library.",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_build_symbol_modes",+        summary: "Build a symbol with N display modes from a symbol_modes spec (the standard's build_symbol_modes). Not in KiCad: KiCad symbols have two body styles (standard and De Morgan), not N display modes, and nothing in KiCad reads Altium's symbol_modes spec.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_build_symbol_modes {}",+        hint: "Answers not_supported with why and instead: kicad_sym_create (the standard body), kicad_symbol_mode (see either body style).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_license",+        summary: "Drive the tool's licence page (the standard's license). Not in KiCad: KiCad is GPL-3.0-or-later and has no licence page to drive.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_license {}",+        hint: "Answers not_supported with why and instead: kicad_license_status.",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_signin",+        summary: "Sign in to the tool's account (the standard's signin). Not in KiCad: KiCad has no account to sign in to.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_signin {}",+        hint: "Answers not_supported with why and instead: kicad_license_status.",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_connect_workspace",+        summary: "Connect the tool to a cloud workspace (the standard's connect_workspace). Not in KiCad: KiCad has no cloud workspace to connect to.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_connect_workspace {}",+        hint: "Answers not_supported with why and instead: kicad_install_library (KiCad's libraries are local files and PCM packages).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_agent_start",+        summary: "Start the tool's resident script agent (the standard's agent_start). Not in KiCad: KiCad has no resident script agent to manage: the bridge reaches KiCad through kicad-cli, its built-in IPC API and KiCad's own Python per call, so there is nothing to start, stop, check or recover.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_agent_start {}",+        hint: "Answers not_supported with why and instead: kicad_readiness (is KiCad usable), kicad_eval (run KiCad's Python).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_agent_stop",+        summary: "Stop the tool's resident script agent (the standard's agent_stop). Not in KiCad: KiCad has no resident script agent to manage: the bridge reaches KiCad through kicad-cli, its built-in IPC API and KiCad's own Python per call, so there is nothing to start, stop, check or recover.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_agent_stop {}",+        hint: "Answers not_supported with why and instead: kicad_readiness (is KiCad usable), kicad_eval (run KiCad's Python).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_agent_status",+        summary: "Report the tool's resident script agent (the standard's agent_status). Not in KiCad: KiCad has no resident script agent to manage: the bridge reaches KiCad through kicad-cli, its built-in IPC API and KiCad's own Python per call, so there is nothing to start, stop, check or recover.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_agent_status {}",+        hint: "Answers not_supported with why and instead: kicad_readiness (is KiCad usable), kicad_eval (run KiCad's Python).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_agent_recover",+        summary: "Recover a halted script agent (the standard's agent_recover). Not in KiCad: KiCad has no resident script agent to manage: the bridge reaches KiCad through kicad-cli, its built-in IPC API and KiCad's own Python per call, so there is nothing to start, stop, check or recover.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_agent_recover {}",+        hint: "Answers not_supported with why and instead: kicad_readiness (is KiCad usable), kicad_eval (run KiCad's Python).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_selftest_script_error",+        summary: "Self-test the script-error safety net (the standard's selftest_script_error). Not in KiCad: KiCad runs no resident script engine to test: a failing kicad_eval snippet already comes back as eval_failed with its traceback.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_selftest_script_error {}",+        hint: "Answers not_supported with why and instead: kicad_eval.",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_extension_ping",+        summary: "Ping the bridge's extension inside the tool (the standard's extension_ping). Not in KiCad: KiCad needs no extension installed inside it: its IPC API is built in, so there is nothing to install, ping or keep a receipt for.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_extension_ping {}",+        hint: "Answers not_supported with why and instead: kicad_readiness (ipcApi says whether the PCB editor's API is on).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_install_extension",+        summary: "Install the bridge's extension into the tool (the standard's install_extension). Not in KiCad: KiCad needs no extension installed inside it: its IPC API is built in, so there is nothing to install, ping or keep a receipt for.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_install_extension {}",+        hint: "Answers not_supported with why and instead: kicad_readiness (ipcApi says whether the PCB editor's API is on).",+        related: &[],+        pitfalls: &[],+    },+    Verb {+        name: "kicad_install_receipt",+        summary: "The last extension install's receipt (the standard's install_receipt). Not in KiCad: KiCad needs no extension installed inside it: its IPC API is built in, so there is nothing to install, ping or keep a receipt for.",+        mechanism: Mechanism::Local, risk: "read", timeout_sec: 5,+        input: "{}",+        example: "kicad_install_receipt {}",+        hint: "Answers not_supported with why and instead: kicad_readiness (ipcApi says whether the PCB editor's API is on).",+        related: &[],+        pitfalls: &[],+    },+];++pub fn dispatch(_state: &mut State, command: &str, _args: &Value) -> Option<Value> {+    let (_, why, instead) = WHY.iter().find(|(v, _, _)| *v == command)?;+    let mut v = fail("not_supported", *why, &format!("Instead: {instead}."));+    v["instead"] = json!(instead);+    Some(v)+}++#[cfg(test)]+mod tests {+    use super::*;++    #[test]+    fn every_unsupported_verb_explains_itself() {+        assert_eq!(VERBS.len(), WHY.len());+        for v in VERBS {+            let r = dispatch(&mut State::new(), v.name, &json!({})).unwrap();+            assert_eq!(r["errorCode"], "not_supported", "{}", v.name);+            assert!(r["error"].as_str().unwrap().len() > 20 && r["instead"].as_str().unwrap().starts_with("kicad_"), "{}", v.name);+        }+    }+}

@@ -446,6 +446,115 @@ pub fn info(text: &str) -> Result<Value, String> {     })) } +/// The standard's plate_vias on one footprint: every drilled pad becomes a plated hole through every copper layer+/// (`thru_hole`, layers `*.Cu` `*.Mask`) when it is not one already: a `thru_hole` pad on only some copper layers, or an+/// `smd` pad with a drill. A numbered unplated hole (`np_thru_hole`) is plated too when `include_npth`; otherwise it is+/// listed in `unplated` (a mounting hole is meant to be unplated). Returns the new text, the pads fixed (with what each+/// was), the holes seen and the unplated numbered holes left alone.+pub fn plate_vias(text: &str, include_npth: bool) -> Result<(String, Vec<Value>, usize, Vec<String>), String> {+    let mut doc = Document::parse(text)?;+    let mut fixed = Vec::new();+    let mut unplated = Vec::new();+    let mut holes = 0;+    for c in doc.root.children_mut().into_iter().flatten().filter(|c| c.head() == Some("pad")) {+        if c.child("drill").is_none() {+            continue;+        }+        holes += 1;+        let num = c.arg(0).unwrap_or_default();+        let kind = c.arg(1).unwrap_or_default();+        let layers: Vec<String> = c.child("layers").map(|l| l.children().iter().skip(1).filter_map(Node::value).collect()).unwrap_or_default();+        let through = layers.iter().any(|l| l == "*.Cu") || (layers.iter().any(|l| l == "F.Cu") && layers.iter().any(|l| l == "B.Cu"));+        let fix = match kind.as_str() {+            "thru_hole" => !through,+            "smd" | "connect" => true,+            "np_thru_hole" => {+                if num.is_empty() {+                    false+                } else if include_npth {+                    true+                } else {+                    unplated.push(num.clone());+                    false+                }+            }+            _ => false,+        };+        if !fix {+            continue;+        }+        c.set_arg(1, Node::atom("thru_hole"));+        let mut l = Node::list("layers", vec![Node::quoted("*.Cu"), Node::quoted("*.Mask")]);+        if let Some(old) = c.child_mut("layers") {+            l.lead = old.lead.clone();+            *old = l;+        }+        fixed.push(json!({"pad": num, "was": kind, "layers": layers}));+    }+    Ok((doc.to_text(), fixed, holes, unplated))+}++/// The standard's normalize_bodies on one footprint: a 3D model whose body sits more than `min_shift` mm from the+/// footprint's pad cluster (centre to centre, in the plane) is moved onto it by its offset. `resolve` gives a model+/// file's bounds. Returns the new text, the models moved ({index, path, shiftMm, offsetBefore, offsetAfter}) and the+/// models left as they are (with why).+pub fn normalize_bodies(text: &str, min_shift: f64, resolve: &mut dyn FnMut(&str) -> Result<crate::bodies::Bounds, String>) -> Result<(String, Vec<Value>, Vec<Value>), String> {+    let inf = info(text)?;+    let mut pb: Option<(f64, f64, f64, f64)> = None;+    for p in inf["pads"].as_array().into_iter().flatten() {+        let (x, y) = (p["at"][0].as_f64().unwrap_or(0.0), p["at"][1].as_f64().unwrap_or(0.0));+        let (w, h) = (p["size"][0].as_f64().unwrap_or(0.0) / 2.0, p["size"][1].as_f64().unwrap_or(0.0) / 2.0);+        let e = (x - w, y - h, x + w, y + h);+        pb = Some(pb.map_or(e, |o| (o.0.min(e.0), o.1.min(e.1), o.2.max(e.2), o.3.max(e.3))));+    }+    let Some(pb) = pb else { return Ok((text.to_string(), vec![], vec![json!({"why": "the footprint has no pads to centre on"})])) };+    // the 3D frame is y up; the footprint file's y is down+    let (pcx, pcy) = ((pb.0 + pb.2) / 2.0, -(pb.1 + pb.3) / 2.0);+    let sx = crate::model_check::parse_sexpr(text).ok_or("empty footprint text")?;+    let refs = crate::bodies::model_refs(&sx);+    let mut doc = Document::parse(text)?;+    let (mut moved, mut kept) = (Vec::new(), Vec::new());+    let r4 = |v: f64| (v * 1e4).round() / 1e4 + 0.0;+    let mut model_nodes: Vec<&mut Node> = doc.root.children_mut().into_iter().flatten().filter(|c| c.head() == Some("model")).collect();+    for (i, m) in refs.iter().enumerate() {+        if m.hidden {+            kept.push(json!({"index": i, "path": m.path, "why": "hidden"}));+            continue;+        }+        let b = match resolve(&m.path) {+            Ok(b) => b,+            Err(e) => {+                kept.push(json!({"index": i, "path": m.path, "why": e}));+                continue;+            }+        };+        let local = crate::bodies::in_footprint(&b, m);+        let (bcx, bcy) = ((local.min[0] + local.max[0]) / 2.0, (local.min[1] + local.max[1]) / 2.0);+        let (dx, dy) = (pcx - bcx, pcy - bcy);+        let dist = dx.hypot(dy);+        if dist <= min_shift {+            kept.push(json!({"index": i, "path": m.path, "why": format!("its body is {:.3} mm from the pads' centre (within {min_shift} mm)", dist)}));+            continue;+        }+        let after = [r4(m.offset[0] + dx), r4(m.offset[1] + dy), m.offset[2]];+        let Some(node) = model_nodes.get_mut(i) else { continue };+        let mut off = Node::list("offset", vec![Node::list("xyz", vec![Node::number(after[0]), Node::number(after[1]), Node::number(after[2])])]);+        pretty(&mut off, 2);+        match node.child_mut("offset") {+            Some(o) => {+                *o = off;+            }+            None => {+                if let Some(c) = node.children_mut() {+                    c.insert(1.min(c.len()) + 1, off);+                }+            }+        }+        moved.push(json!({"index": i, "path": m.path, "shiftMm": r4(dist), "offsetBefore": m.offset, "offsetAfter": after}));+    }+    Ok((doc.to_text(), moved, kept))+}+ // --------------------------------------------------------------------------- // Edit // ---------------------------------------------------------------------------@@ -853,5 +962,40 @@ mod tests {         assert_eq!(i["models"].as_array().unwrap().len(), 1);         assert!(info("(kicad_symbol_lib)").is_err());     }++    #[test]+    fn plate_vias_plates_drilled_pads_through_every_copper_layer() {+        let fp = "(footprint \"QFN_vias\"\n\t(layer \"F.Cu\")\n\t(pad \"17\" smd rect (at 0 0) (size 3 3) (layers \"F.Cu\" \"F.Paste\" \"F.Mask\"))\n\t(pad \"17\" thru_hole circle (at 0.5 0.5) (size 0.6 0.6) (drill 0.3) (layers \"F.Cu\"))\n\t(pad \"17\" smd circle (at -0.5 0.5) (size 0.6 0.6) (drill 0.3) (layers \"F.Cu\" \"F.Mask\"))\n\t(pad \"1\" thru_hole circle (at 2 2) (size 1.6 1.6) (drill 0.8) (layers \"*.Cu\" \"*.Mask\"))\n\t(pad \"\" np_thru_hole circle (at 3 3) (size 3 3) (drill 3) (layers \"*.Cu\" \"*.Mask\"))\n\t(pad \"5\" np_thru_hole circle (at 4 4) (size 1 1) (drill 1) (layers \"*.Cu\" \"*.Mask\"))\n)\n";+        let (t, fixed, holes, unplated) = plate_vias(fp, false).unwrap();+        assert_eq!(holes, 5);+        assert_eq!(fixed.len(), 2, "{fixed:?}");+        assert_eq!(fixed[0]["was"], "thru_hole");+        assert_eq!(fixed[1]["was"], "smd");+        assert_eq!(unplated, vec!["5".to_string()]);+        let info = info(&t).unwrap();+        let vias: Vec<&Value> = info["pads"].as_array().unwrap().iter().filter(|p| p["drill"].is_array() && p["number"] == "17").collect();+        assert!(vias.iter().all(|p| p["type"] == "thru_hole" && p["layers"] == json!(["*.Cu", "*.Mask"])), "{vias:?}");+        let (_, fixed2, _, unplated2) = plate_vias(fp, true).unwrap();+        assert_eq!((fixed2.len(), unplated2.len()), (3, 0));+        let (_, again, _, _) = plate_vias(&t, false).unwrap();+        assert!(again.is_empty(), "plating is idempotent");+    }++    #[test]+    fn normalize_bodies_moves_a_far_body_onto_the_pads_and_leaves_a_close_one() {+        // a 2-pad part centred at (1, 0) mm; its model's offset puts the body 50 mm away+        let fp = "(footprint \"R_test\"\n\t(layer \"F.Cu\")\n\t(pad \"1\" smd rect (at 0 0) (size 1 1) (layers \"F.Cu\"))\n\t(pad \"2\" smd rect (at 2 0) (size 1 1) (layers \"F.Cu\"))\n\t(model \"far.step\"\n\t\t(offset\n\t\t\t(xyz 51 0 0)\n\t\t)\n\t\t(scale\n\t\t\t(xyz 1 1 1)\n\t\t)\n\t\t(rotate\n\t\t\t(xyz 0 0 0)\n\t\t)\n\t)\n\t(model \"near.step\"\n\t\t(offset\n\t\t\t(xyz 1.5 0 0)\n\t\t)\n\t)\n)\n";+        let b = crate::bodies::Bounds { min: [-1.0, -0.5, 0.0], max: [1.0, 0.5, 0.5] };+        let mut resolve = |_: &str| -> Result<crate::bodies::Bounds, String> { Ok(b) };+        let (t, moved, kept) = normalize_bodies(fp, 2.0, &mut resolve).unwrap();+        assert_eq!(moved.len(), 1, "{moved:?}");+        assert_eq!(moved[0]["path"], "far.step");+        assert_eq!(moved[0]["offsetAfter"], json!([1.0, 0.0, 0.0]));+        assert_eq!(moved[0]["shiftMm"], 50.0);+        assert_eq!(kept[0]["path"], "near.step");+        assert!(t.contains("(xyz 1 0 0)") && t.contains("(xyz 1.5 0 0)"), "{t}");+        let (_, again, _) = normalize_bodies(&t, 2.0, &mut resolve).unwrap();+        assert!(again.is_empty());+    } }