KiCad - the KiCad Bridge

@@ -330,6 +330,7 @@ KiCad 10 has no schematic API, so these verbs edit the `.kicad_sch` file on disk | `kicad_sch_place_symbol` | Place a library symbol with its pins and instances block; returns the new `uuid` | `filePath`, `libId` ("Device:R"), `reference`, `at` [x, y] mm, `rotation`?, `unit`?, `value`?, `footprint`?, `libraryPath`? | | `kicad_sch_wire` | A polyline wire | `filePath`, `points` [[x, y], ...] | | `kicad_sch_label` | A label | `filePath`, `text`, `at`, `kind` local, global, hierarchical, power, `rotation`? |+| `kicad_sch_no_connect` | A no-connect flag on an open pin, so ERC stops reporting it | `filePath`, `pin` (`U1.12` or `U1.PA10`) or `at` | | `kicad_sch_move` | Move a placed symbol by reference | `filePath`, `reference`, `to` [x, y] | | `kicad_sch_set_property` | Change or add a property (Value, Footprint, ...) | `filePath`, `reference`, `name`, `value` | | `kicad_sch_delete` | Delete any item by uuid | `filePath`, `uuid` |

@@ -150,7 +150,8 @@     "kicad_copper_layers",     "kicad_layers_in_use",     "kicad_component_data",-    "kicad_component_pins"+    "kicad_component_pins",+    "kicad_sch_no_connect"   ],   "statusVerb": "kicad_status",   "timeouts": {

@@ -116,6 +116,20 @@ pub static VERBS: &[Verb] = &[             "Reference must stay unique on the sheet; the verb refuses a name already in use",         ],     },+    Verb {+        name: "kicad_sch_no_connect",+        summary: "Put a no-connect flag on a pin of a .kicad_sch (an intentionally open pin: a spare GPIO, an unused connector pin), so ERC stops reporting it (edits the file on disk).",+        mechanism: Mechanism::File, risk: "write", timeout_sec: 120,+        input: "{\"filePath\": \"C:/.../x.kicad_sch\", \"pin\": \"U1.PA10\" | \"U1.12\" | \"at\": [x_mm, y_mm]}",+        example: "kicad_sch_no_connect {\"filePath\":\"C:/Users/john/proj/board.kicad_sch\",\"pin\":\"U1.12\"}",+        hint: "pin names the symbol and its pin number (or pin name), and the flag lands on that pin's connection point, worked out from the symbol's position, angle and mirror; at places it at a point you already know. Writes (no_connect (at x y) (uuid ..)) as eeschema does. On disk only: reload the editor to see it. .bak written; the ERC delta shows the pin_not_connected error gone.",+        related: &["kicad_sch_label", "kicad_sch_wire", "kicad_run_erc", "kicad_netlist"],+        pitfalls: &[+            "the edit is on disk: an open Schematic Editor does not see it until reloaded (kicad_close, then kicad_open_schematic); saving from the stale editor overwrites the edit",+            "a flag on a pin that is wired is an ERC error of its own (no_connect_connected): flag only open pins",+            "a flag must sit exactly on the pin's connection point; with at, a point off the pin is a dangling flag (ERC warns)",+        ],+    }, ];  pub fn dispatch(state: &mut State, command: &str, args: &Value) -> Option<Value> {@@ -123,6 +137,7 @@ pub fn dispatch(state: &mut State, command: &str, args: &Value) -> Option<Value>         "kicad_sch_place_symbol" => edit(state, args, place_symbol),         "kicad_sch_wire" => edit(state, args, wire),         "kicad_sch_label" => edit(state, args, label),+        "kicad_sch_no_connect" => edit(state, args, no_connect),         "kicad_sch_move" => edit(state, args, move_symbol),         "kicad_sch_delete" => edit(state, args, delete),         "kicad_sch_set_property" => edit(state, args, set_property),@@ -323,6 +338,29 @@ fn label(ctx: &mut Ctx) -> Result<Done, Value> {     }) } +/// `kicad_sch_no_connect` (wiki #131): a flag on a pin's connection point, by pin or by point.+fn no_connect(ctx: &mut Ctx) -> Result<Done, Value> {+    let (at, pin) = if let Some(spec) = arg_any(ctx.args, &["pin", "pins"]) {+        let (reference, want) = spec.trim().split_once('.').ok_or_else(|| fail("bad_arg", format!("pin {spec} is not Ref.Pin"), "Name the symbol and its pin: U1.12 or U1.PA10."))?;+        let points = ctx.sch.pin_points(reference).map_err(|e| op_fail("not_found", e, "kicad_netlist {parts:true} lists every part with its pins."))?;+        // the pin by number, else by name+        let hit = points.iter().find(|(n, _)| n == want).map(|(_, p)| *p).or_else(|| {+            let names = ctx.sch.pin_names(reference);+            names.iter().find(|(_, name)| name.eq_ignore_ascii_case(want)).and_then(|(num, _)| points.iter().find(|(n, _)| n == num).map(|(_, p)| *p))+        });+        let at = hit.ok_or_else(|| fail("pin_not_found", format!("{reference} has no pin {want}"), "Pins are matched by number first, then by name; kicad_netlist {parts:true} lists them."))?;+        (at, Some(spec.trim().to_string()))+    } else {+        (point(ctx.args, "at")?, None)+    };+    let uuid = ctx.sch.add_no_connect(at).map_err(|e| op_fail("edit_failed", e, "Nothing was written."))?;+    Ok(Done {+        output: format!("Added a no-connect flag{} at ({}, {}) in {}", pin.as_ref().map(|p| format!(" on {p}")).unwrap_or_default(), schematic::fmt_num(at.0), schematic::fmt_num(at.1), file_name(ctx.path)),+        uuid,+        extra: json!({"at": [at.0, at.1], "pin": pin}),+    })+}+ fn move_symbol(ctx: &mut Ctx) -> Result<Done, Value> {     let reference = arg_any(ctx.args, &["reference", "ref"]).ok_or_else(|| fail("missing_arg", "reference is required", "Pass the designator of the symbol to move, e.g. R5."))?.trim().to_string();     let to = point(ctx.args, "to")?;

@@ -455,12 +455,21 @@ pub fn expand_kicad_uri(uri: &str, ctx: &LibCtx) -> Option<String> {     if let Some(docs) = &ctx.user_dir {         subs.push(("KICAD_USER_TEMPLATE_DIR".into(), Some(norm_path(&docs.join("template")))));     }-    if let Some(cfg) = &ctx.config_dir {-        if !ctx.version.is_empty() {-            subs.push(("KICAD_3RD_PARTY".into(), Some(norm_path(&cfg.join("3rdparty")))));-        }+    // Where the Plugin and Content Manager installs (wiki #130): KICAD<n>_3RD_PARTY, or the older+    // KICAD_3RD_PARTY spelling, from Configure Paths; else Documents/KiCad/<ver>/3rdparty, KiCad's own+    // default (the same order model_check uses).+    let third = ctx.env_overrides.get(&format!("KICAD{major}_3RD_PARTY")).cloned()+        .or_else(|| ctx.env_overrides.get("KICAD_3RD_PARTY").cloned())+        .or_else(|| ctx.user_dir.as_ref().map(|u| norm_path(&u.join("3rdparty"))))+        .or_else(|| ctx.config_dir.as_ref().filter(|_| !ctx.version.is_empty()).map(|c| norm_path(&c.join("3rdparty"))));+    if let Some(t) = third {+        subs.push((format!("KICAD{major}_3RD_PARTY"), Some(t.clone())));+        subs.push(("KICAD_3RD_PARTY".into(), Some(t)));     }     for (k, v) in &ctx.env_overrides {+        if k.ends_with("3RD_PARTY") {+            continue; // resolved above, so either spelling reaches both names+        }         subs.retain(|(name, _)| name != k);         subs.push((k.clone(), Some(v.clone())));     }@@ -1047,6 +1056,17 @@ mod tests {         }     } +    #[test]+    fn pcm_libraries_expand_to_the_3rdparty_folder() {+        // wiki #130: KiCad 10's PCM writes ${KICAD10_3RD_PARTY} into the global sym-lib-table+        let uri = "${KICAD10_3RD_PARTY}/symbols/inc_adom_wiki_x/lib.kicad_sym";+        assert_eq!(expand_kicad_uri(uri, &ctx()).unwrap(), "C:/Users/john/Documents/KiCad/10.0/3rdparty/symbols/inc_adom_wiki_x/lib.kicad_sym");+        assert_eq!(expand_kicad_uri("${KICAD_3RD_PARTY}/a.kicad_sym", &ctx()).unwrap(), "C:/Users/john/Documents/KiCad/10.0/3rdparty/a.kicad_sym");+        let mut c = ctx();+        c.env_overrides.insert("KICAD_3RD_PARTY".into(), "D:/pcm".into());+        assert_eq!(expand_kicad_uri(uri, &c).unwrap(), "D:/pcm/symbols/inc_adom_wiki_x/lib.kicad_sym", "the older spelling from Configure Paths applies to both");+    }+     #[test]     fn tokenizer_handles_quotes_and_nesting() {         let s = parse_sexp(r#"(a "b c" (d "e\"f") g)"#).unwrap();@@ -1143,8 +1163,9 @@ mod tests {             Some("C:/Users/john/Documents/KiCad/10.0/template/t")         );         assert_eq!(+            // Documents/KiCad/<ver>/3rdparty, where KiCad's PCM installs (checked on a KiCad 10.0.4 box, wiki #130)             expand_kicad_uri("${KICAD_3RD_PARTY}/footprints/x.pretty", &c).as_deref(),-            Some("C:/Users/john/AppData/Roaming/kicad/10.0/3rdparty/footprints/x.pretty")+            Some("C:/Users/john/Documents/KiCad/10.0/3rdparty/footprints/x.pretty")         );         // Plain paths pass through normalised.         assert_eq!(expand_kicad_uri("C:\\a\\.\\b\\..\\c.kicad_sym", &c).as_deref(), Some("C:/a/c.kicad_sym"));

@@ -208,17 +208,26 @@ fn on_boundary(pt: (f64, f64), edges: &[Edge]) -> bool {     }) } -/// Points that sample an outline's region: its corners, the middle of each edge, and the-/// centre of its corners.+/// Points that sample an outline's region: its corners, the middle of each edge, and a point a hair+/// inside the outline beside each edge's middle (wiki #133). Not the centre of the corners: a ring+/// courtyard's centre is in its hole, and a ray from there skims the polygon's vertices. fn probes(e: &[Edge]) -> Vec<(f64, f64)> {-    let mut v: Vec<(f64, f64)> = Vec::with_capacity(e.len() * 2 + 1);+    const D: f64 = 1e-4;+    let mut v: Vec<(f64, f64)> = Vec::with_capacity(e.len() * 3);     for &(a, b) in e {+        let m = ((a.0 + b.0) / 2.0, (a.1 + b.1) / 2.0);         v.push(a);-        v.push(((a.0 + b.0) / 2.0, (a.1 + b.1) / 2.0));-    }-    if !e.is_empty() {-        let n = e.len() as f64;-        v.push((e.iter().map(|(a, _)| a.0).sum::<f64>() / n, e.iter().map(|(a, _)| a.1).sum::<f64>() / n));+        v.push(m);+        let (dx, dy) = (b.0 - a.0, b.1 - a.1);+        let l = (dx * dx + dy * dy).sqrt();+        if l > 1e-9 {+            let n = (-dy / l * D, dx / l * D);+            for q in [(m.0 + n.0, m.1 + n.1), (m.0 - n.0, m.1 - n.1)] {+                if inside(q, e) {+                    v.push(q);+                }+            }+        }     }     v }

@@ -722,6 +722,74 @@ impl Schematic {         Ok(uuid)     } +    /// Where each pin of a placed symbol connects, in sheet millimetres (y down), every unit placed+    /// under that reference: [(pin number, (x, y))]. Library pins are y up; the symbol's angle turns+    /// them counterclockwise as seen, then its mirror flips them (KiCad's order).+    pub fn pin_points(&self, reference: &str) -> Result<Vec<(String, (f64, f64))>, String> {+        let mut out = Vec::new();+        let mut found = false;+        for inst in self.top().iter().filter(|n| is_symbol_instance(n) && symbol_property(n, "Reference").as_deref() == Some(reference)) {+            found = true;+            let lib_key = inst.child_value("lib_name").or_else(|| inst.child_value("lib_id")).unwrap_or_default();+            let Some(lib) = self.lib_symbol(&lib_key) else { return Err(format!("{reference}: its library symbol {lib_key} is not in the sheet's lib_symbols")) };+            let base = lib_key.rsplit(':').next().unwrap_or(&lib_key).to_string();+            let unit = inst.child("unit").and_then(|u| u.num(0)).unwrap_or(1.0) as u32;+            let at = inst.child("at").ok_or("symbol has no (at ...)")?;+            let (sx, sy, rot) = (at.num(0).unwrap_or(0.0), at.num(1).unwrap_or(0.0), at.num(2).unwrap_or(0.0));+            let mirror = inst.child_value("mirror");+            let (sin, cos) = rot.to_radians().sin_cos();+            for sub in lib.children().iter().filter(|n| n.head() == Some("symbol")) {+                let Some(name) = sub.arg(0) else { continue };+                let Some(u) = sub_unit(&name, &base) else { continue };+                if u != 0 && u != unit {+                    continue;+                }+                for pin in sub.children().iter().filter(|n| n.head() == Some("pin")) {+                    let (Some(num), Some(pat)) = (pin.child_value("number"), pin.child("at")) else { continue };+                    let (px, py) = (pat.num(0).unwrap_or(0.0), pat.num(1).unwrap_or(0.0));+                    let (mut qx, mut qy) = (px * cos - py * sin, px * sin + py * cos);+                    match mirror.as_deref() {+                        Some("x") => qy = -qy,+                        Some("y") => qx = -qx,+                        _ => {}+                    }+                    let r = |v: f64| (v * 1e4).round() / 1e4 + 0.0;+                    out.push((num, (r(sx + qx), r(sy - qy))));+                }+            }+        }+        if !found {+            return Err(format!("no symbol with reference {reference} on this sheet"));+        }+        Ok(out)+    }++    /// A placed symbol's pins as (number, name), from its library symbol.+    pub fn pin_names(&self, reference: &str) -> Vec<(String, String)> {+        let mut out = Vec::new();+        for inst in self.top().iter().filter(|n| is_symbol_instance(n) && symbol_property(n, "Reference").as_deref() == Some(reference)) {+            let lib_key = inst.child_value("lib_name").or_else(|| inst.child_value("lib_id")).unwrap_or_default();+            let Some(lib) = self.lib_symbol(&lib_key) else { continue };+            for sub in lib.children().iter().filter(|n| n.head() == Some("symbol")) {+                for pin in sub.children().iter().filter(|n| n.head() == Some("pin")) {+                    if let (Some(num), Some(name)) = (pin.child_value("number"), pin.child_value("name")) {+                        if !out.iter().any(|(n, _): &(String, String)| *n == num) {+                            out.push((num, name));+                        }+                    }+                }+            }+        }+        out+    }++    /// A no-connect flag at `at` (on a pin's connection point): `(no_connect (at x y) (uuid ..))`.+    pub fn add_no_connect(&mut self, at: (f64, f64)) -> Result<String, String> {+        let uuid = new_uuid();+        self.insert_item(Node::list("no_connect", vec![Node::list("at", vec![Node::number(at.0), Node::number(at.1)]), Node::list("uuid", vec![Node::quoted(&uuid)])]));+        Ok(uuid)+    }+     /// Move a symbol (and its fields with it) so its anchor lands on `to`.     pub fn move_symbol(&mut self, reference: &str, to: (f64, f64)) -> Result<(String, (f64, f64)), String> {         let idx = self.find_symbol_index(reference).ok_or_else(|| format!("no symbol with reference {reference} on this sheet"))?;

@@ -0,0 +1,51 @@+//! Wiki #131: pin connection points, checked against KiCad's own demo sheets: every no-connect flag+//! KiCad placed sits on a pin the bridge computes (rotated and mirrored symbols included).+use kicad_core::schematic::Schematic;+use std::path::PathBuf;++#[test]+fn every_demo_no_connect_flag_lands_on_a_computed_pin() {+    let dir = PathBuf::from(std::env::var("KICAD_DEMO_SCH").unwrap_or_else(|_| format!("{}/../../../../fixtures/sch", env!("CARGO_MANIFEST_DIR"))));+    let Ok(rd) = std::fs::read_dir(&dir) else { eprintln!("no demo sheets at {}; skipped", dir.display()); return };+    let (mut flags, mut hit) = (0, 0);+    let mut misses = Vec::new();+    for e in rd.flatten().filter(|e| e.path().extension().map_or(false, |x| x == "kicad_sch")) {+        let text = std::fs::read_to_string(e.path()).unwrap();+        let sch = Schematic::parse(&text).unwrap();+        let refs: std::collections::BTreeSet<String> = sch.symbols().into_iter().map(|s| s.reference).collect();+        let mut pins = Vec::new();+        for r in &refs {+            if let Ok(p) = sch.pin_points(r) {+                pins.extend(p.into_iter().map(|(n, at)| (r.clone(), n, at)));+            }+        }+        for line in text.lines().collect::<Vec<_>>().windows(2) {+            if line[0].trim() == "(no_connect" {+                let nums: Vec<f64> = line[1].trim().trim_start_matches("(at").trim_end_matches(')').split_whitespace().filter_map(|t| t.parse().ok()).collect();+                if nums.len() < 2 { continue }+                flags += 1;+                if pins.iter().any(|(_, _, (x, y))| (x - nums[0]).abs() < 1e-3 && (y - nums[1]).abs() < 1e-3) {+                    hit += 1;+                } else {+                    misses.push(format!("{}: ({}, {})", e.file_name().to_string_lossy(), nums[0], nums[1]));+                }+            }+        }+    }+    eprintln!("{hit} of {flags} no-connect flags on a computed pin");+    assert!(flags == 0 || hit == flags, "{} missed: {:?}", misses.len(), &misses[..misses.len().min(8)]);+}++#[test]+fn a_flag_lands_on_a_named_pin_of_the_fixture_sheet() {+    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../tour-pack-rp2040/template/rp2040-breakout.kicad_sch");+    let mut sch = Schematic::parse(&std::fs::read_to_string(&path).unwrap()).unwrap();+    let pins = sch.pin_points("U1").unwrap();+    let (_, at) = pins.iter().find(|(n, _)| n == "1").expect("U1 pin 1");+    let uuid = sch.add_no_connect(*at).unwrap();+    let text = sch.to_text();+    let again = Schematic::parse(&text).unwrap();+    assert!(text.contains(&format!("(uuid \"{uuid}\")")));+    assert!(again.pin_points("U1").unwrap().iter().any(|(_, p)| p == at));+    assert!(text.contains("(no_connect"));+}

@@ -0,0 +1,38 @@+//! Wiki #133: concentric ring courtyards (two F.CrtYd circles each, an annulus) do not overlap, and a+//! board edge drawn as one large arc bounds the outline by its real extent.+use kicad_core::{pcb, placement};++fn ring(reference: &str, d_in: f64, d_out: f64) -> String {+    format!("(footprint \"x:{reference}\" (layer \"F.Cu\") (at 100 100) (property \"Reference\" \"{reference}\")\+        (fp_circle (center 0 0) (end {} 0) (layer \"F.CrtYd\") (stroke (width 0.05)))\+        (fp_circle (center 0 0) (end {} 0) (layer \"F.CrtYd\") (stroke (width 0.05))))", d_in / 2.0, d_out / 2.0)+}++#[test]+fn nested_ring_courtyards_do_not_overlap() {+    // the sensor from the report: electrodes and guards, all on one centre+    let fps = [ring("E2", 23.0, 31.95), ring("G2", 43.8, 47.7), ring("E4", 48.0, 56.95), ring("G3", 57.25, 59.25)].concat();+    let text = format!("(kicad_pcb (version 20241229) (layers (0 \"F.Cu\" signal)) {fps})");+    let board = pcb::parse_pcb_text(&text, "t.kicad_pcb").unwrap();+    let o = placement::overlaps(&placement::placements(&board));+    assert!(o.is_empty(), "{o:?}");+}++#[test]+fn a_large_edge_arc_bounds_the_outline_by_its_bulge() {+    // a 146 mm ring edge drawn as one arc of about 340 degrees: start and end low, mid at the top+    let r = 73.0_f64;+    let (cx, cy) = (100.0, 110.0);+    let a = |deg: f64| (cx + r * deg.to_radians().cos(), cy + r * deg.to_radians().sin());+    let (s, e, m) = (a(100.0), a(80.0), a(270.0));+    let text = format!("(kicad_pcb (version 20241229) (layers (0 \"F.Cu\" signal) (25 \"Edge.Cuts\" user))\+        (gr_arc (start {} {}) (mid {} {}) (end {} {}) (layer \"Edge.Cuts\") (stroke (width 0.1)))\+        (gr_line (start {} {}) (end {} {}) (layer \"Edge.Cuts\") (stroke (width 0.1)))\+        (gr_circle (center {cx} {cy}) (end {} {cy}) (layer \"Edge.Cuts\") (stroke (width 0.1))))",+        s.0, s.1, m.0, m.1, e.0, e.1, e.0, e.1, s.0, s.1, cx + 22.5);+    let board = pcb::parse_pcb_text(&text, "t.kicad_pcb").unwrap();+    let o = placement::outline(&board).unwrap();+    assert!((o.min_x - (cx - r)).abs() < 0.01 && (o.max_x - (cx + r)).abs() < 0.01, "{o:?}");+    assert!((o.min_y - (cy - r)).abs() < 0.01, "{o:?}");+}+

@@ -24,10 +24,11 @@ KiCad), which AI Flow reads: both stay. |---|---| | Millimetres, absolute, **y up** | KiCad's y is negated. `frame:"kicad"` keeps KiCad's y down. Angles are KiCad's own (counterclockwise as seen) in both frames | | KiCad layer names | `F.Cu`, `In1.Cu`..`In30.Cu`, `B.Cu`; `*.Cu` is a pad on every copper layer (a partial set adds `layers`) |-| Custom pads are their bounding rectangle | `shape:"rect"`, rotation 0, `kicadShape:"custom"`, `anchor` = KiCad's anchor (where tracks land) |+| Pad shapes | `circle`, `round` (KiCad's oval: a stadium), `rect`, `roundrect`; `kicadShape` keeps KiCad's own name when it differs |+| Custom pads are their bounding rectangle | `shape:"rect"`, rotation 0, `kicadShape:"custom"`, `anchor` = KiCad's anchor (where tracks land), and `copperPoints` (the real outline) when the copper is one drawn polygon over the anchor; pads drawn from several shapes keep only the rectangle | | Net-less copper is kept | `net:""`: free copper shapes, pours on no net; footprint copper carries `ref` | | Outline with arcs | `outlineEdges` (line, or arc with center, radius, angle1 to angle2 counterclockwise), `outline` = their start points, `cutouts` for inner loops, `keepouts` for rule areas |-| `unconnected` from the copper | pads, tracks, arcs, vias and the poured copper joined where they touch on a shared layer. `splitNets` names each piece's pads (what to join). An isolated pour island is `isolatedCopper`, not a connection to make (KiCad warns about it the same way) |+| `unconnected` from the copper | pads, tracks, arcs, vias and the poured copper joined where they touch on a shared layer. `splitNets` names each piece's pads (what to join). An isolated pour island is `isolatedCopper` (`{net, layer, at, areaMm2}`), not a connection to make (KiCad's DRC warns about it the same way) | | `revision` moves only with copper, parts or outline | silkscreen, text and refills leave it alone; the order KiCad lists items in does not matter |  Checked against KiCad's own DRC on six of KiCad 10's demo boards (StickHub, CM5 Minima, RoyalBlue54L

@@ -103,6 +103,8 @@ CHECKS = {                              and any(p.get("pins") for p in (r.get("parts") or [])),     "board_summary": lambda r: ok(r) and (r.get("summary") or {}).get("components", 0) > 0,     "count_list": lambda r: ok(r) and (r.get("count") or 0) > 0,+    "no_connect_placed": lambda r: ok(r) and bool(r.get("uuid")) and isinstance(r.get("at"), list) and r.get("pin") == "U1.1",+    "net_list": lambda r: ok(r) and isinstance(r.get("nets"), list) and r.get("count") == len(r["nets"]),     "layers_in_use": lambda r: ok(r) and len(r.get("copperLayersInUse") or []) > 0,     "component_data": lambda r: ok(r) and (r.get("component") or {}).get("pads", 0) > 0,     "component_pins": lambda r: ok(r) and (r.get("count") or 0) > 0,@@ -175,7 +177,8 @@ def matrix(w: dict) -> dict:                                   note="3D model bounds from the files the footprints name; every part is a body or in noBody"),         "netlist":           dict(phase=2, args={"filePath": S, "parts": True}, check="std_netlist", timeout=120),         "board_summary":     dict(phase=2, args={"filePath": B, "source": "file"}, check="board_summary"),-        "list_nets":         dict(phase=2, args={"filePath": B, "source": "file"}, check="count_list"),+        "list_nets":         dict(phase=2, args={"filePath": B, "source": "file"}, check="net_list",+                                  note="the rp2040 fixture board carries no nets: an empty list is the right answer"),         "list_designators":  dict(phase=2, args={"filePath": B, "source": "file"}, check="count_list"),         "copper_layers":     dict(phase=2, args={"filePath": B, "source": "file"}, check="count_list"),         "layers_in_use":     dict(phase=2, args={"filePath": B, "source": "file"}, check="layers_in_use"),@@ -203,6 +206,8 @@ def matrix(w: dict) -> dict:                                   note="fixture copy only; the .bak is removed with the fixture dir"),         "sch_wire":          dict(phase=2.2, args={"filePath": S, "points": [[200, 146.19], [200, 140]]}, timeout=150),         "sch_label":         dict(phase=2.2, args={"filePath": S, "text": "VERBTEST_NET", "at": [200, 140], "kind": "local"}, timeout=150),+        "sch_no_connect":    dict(phase=2.2, args={"filePath": S, "pin": "U1.1"}, check="no_connect_placed", timeout=150,+                                  note="wiki #131: the flag lands on U1 pin 1's connection point, worked out from the symbol"),         "sch_set_property":  dict(phase=2.3, args={"filePath": S, "reference": "R_VERBTEST", "name": "Value", "value": "2k2"}, timeout=150),         "sch_move":          dict(phase=2.4, args={"filePath": S, "reference": "R_VERBTEST", "to": [210, 150]}, timeout=150),         "sch_delete":        dict(phase=2.5, args={"__special": "sch_delete"}, timeout=150,