Fusion - the Fusion 360 Bridge

@@ -3,10 +3,14 @@ All notable changes to the Adom Bridge Fusion 360 bridge, newest first. Canonical: https://wiki.adom.inc/adom/fusion-bridge · GitHub backup: `adom-inc/fusion-bridge` -## Unreleased: mechanical layer, 1.13.0-dev.1 (2026-10-28)+## 1.13.0 (2026-10-28, insiders)++Drew's typed mechanical layer, Fusion 2706 support, his safe-restart work, and library authoring.++### Mechanical layer (merged #22, Drew Owens)  The typed mechanical layer (`fusion_mechanical`, 61 operations; `fusion_mech_capabilities`;-`fusion_mech_operation_status`) on 1.12.8 with the restart fixes of 1.12.9. Development build, not released.+`fusion_mech_operation_status`), with the exe owning validation, the durable journal and replay. Its development history is in [docs/MECHANICAL-HISTORY.md](docs/MECHANICAL-HISTORY.md).  - The exe owns the layer's validation, durable journal and replies, as it does for the rest of the bridge; the@@ -31,37 +35,49 @@ Its development history is in [docs/MECHANICAL-HISTORY.md](docs/MECHANICAL-HISTO - Not yet run live: `joint_origin_*` and `motion_link_*` (their campaign groups were cut off by the restart bug   that 1.12.9 fixes) and `mcmaster_open` (interactive by design). -## 1.12.9 (unreleased)--The bridge no longer restarts Fusion over a busy add-in, and a restart it does need no longer kills Fusion over-unsaved work.+### Fusion 2706, safe restarts (merged #21), library authoring -- A busy add-in is never mistaken for a missing one. While a long native Fusion call holds the add-in's main-  thread, not even `/status` or `/health` answers, and the gate read that silence as "the add-in was installed-  while Fusion was running" and restarted Fusion. On a person's own PC that killed Fusion with their documents-  open six times between 2026-10-14 and 2026-10-28 (a 93 s script was in flight on 10-28). Now silence counts as-  work whenever there is evidence the add-in is loaded: one of the exe's own requests to it is still in flight,-  or it answered earlier inside the same Fusion process and its port still takes connections. The verb gate, the-  timeout diagnosis, the readiness launch observer (which restarted Fusion after about 3 minutes of silence) and-  a warm `fusion_start` all ask for that evidence first and answer `fusion_addin_busy`. `fusion_readiness` and-  `fusion_state` report it as `addinBusy`, and the dashboard no longer restarts over it. A request in flight also-  counts as a long operation for the hang verdict.-- `restartPolicy` `auto` (the default) stops short of losing work. When the add-in cannot save, Fusion is closed-  the way a person closes it instead of killed: it closes at once when nothing is unsaved, and a save prompt for-  a document the bridge did not make (or a never-saved document) ends the restart with `restart_needs_decision`,-  with nothing killed or discarded. For 30 minutes after that the restart is asked for instead of retried. A stop-  that did not finish is no longer escalated to a kill. The old behaviour is `restartPolicy: force`, for a machine-  only an AI drives. The ledger's restart summary now says what happened: it said "Documents were saved first"-  when the save step had failed and Fusion was killed.-- `fusion_stop` waits for heavy designs: up to `closeTimeoutSec` (default 120; it was 15 s). A save prompt for a-  document the bridge made is answered Don't Save; one for anyone else's work is cancelled and the stop fails-  with `unsaved_work`.-- Documents a caller opens are no longer registered as bridge scratch. Any document that appeared during a-  window-raising verb was registered, so a user's assembly reopened with `fusion_open_by_urn` became "the-  bridge's": its save prompt would be answered Don't Save and a restart could discard it. Now only documents a-  verb made (not saved cloud documents, which were opened) and the bridge's own Save As are registered, and-  nothing Fusion opens at launch. The registry evicts its oldest entry when full; it used to evict the-  alphabetically first.+- Fixed for Fusion 2706, which removed the `Electron.boardInfo` text command. On released 1.12.8 that broke+  `fusion_board_info`, `fusion_board_summary`, `fusion_export_cpl` and electronics_read's board fallback. The exe+  now builds the same answer from the board's own export: the summary, plus an XML in boardInfo's layout, so+  every consumer reads it unchanged. It also writes the pick-and-place CSV itself. On older Fusion the add-in+  path is used as before.+- Merged #21 (Drew Owens), in his words:+  The bridge no longer restarts Fusion over a busy add-in, and a restart it does need no longer kills Fusion over+  unsaved work.+  - A busy add-in is never mistaken for a missing one. While a long native Fusion call holds the add-in's main+    thread, not even `/status` or `/health` answers, and the gate read that silence as "the add-in was installed+    while Fusion was running" and restarted Fusion. On a person's own PC that killed Fusion with their documents+    open six times between 2026-10-14 and 2026-10-28 (a 93 s script was in flight on 10-28). Now silence counts as+    work whenever there is evidence the add-in is loaded: one of the exe's own requests to it is still in flight,+    or it answered earlier inside the same Fusion process and its port still takes connections. The verb gate, the+    timeout diagnosis, the readiness launch observer (which restarted Fusion after about 3 minutes of silence) and+    a warm `fusion_start` all ask for that evidence first and answer `fusion_addin_busy`. `fusion_readiness` and+    `fusion_state` report it as `addinBusy`, and the dashboard no longer restarts over it. A request in flight also+    counts as a long operation for the hang verdict.+  - `restartPolicy` `auto` (the default) stops short of losing work. When the add-in cannot save, Fusion is closed+    the way a person closes it instead of killed: it closes at once when nothing is unsaved, and a save prompt for+    a document the bridge did not make (or a never-saved document) ends the restart with `restart_needs_decision`,+    with nothing killed or discarded. For 30 minutes after that the restart is asked for instead of retried. A stop+    that did not finish is no longer escalated to a kill. The old behaviour is `restartPolicy: force`, for a machine+    only an AI drives. The ledger's restart summary now says what happened: it said "Documents were saved first"+    when the save step had failed and Fusion was killed.+  - `fusion_stop` waits for heavy designs: up to `closeTimeoutSec` (default 120; it was 15 s). A save prompt for a+    document the bridge made is answered Don't Save; one for anyone else's work is cancelled and the stop fails+    with `unsaved_work`.+  - Documents a caller opens are no longer registered as bridge scratch. Any document that appeared during a+    window-raising verb was registered, so a user's assembly reopened with `fusion_open_by_urn` became "the+    bridge's": its save prompt would be answered Don't Save and a restart could discard it. Now only documents a+    verb made (not saved cloud documents, which were opened) and the bridge's own Save As are registered, and+    nothing Fusion opens at launch. The registry evicts its oldest entry when full; it used to evict the+    alphabetically first.+- New, offline on .lbr files, each change preflighted before it is written (the old file kept as .bak):+  - `fusion_create_footprint`, `fusion_create_symbol`, `fusion_read_symbol`, `fusion_find_symbol`;+  - `fusion_copy_footprint`, `fusion_rename_footprint`, `fusion_remove_footprint`, `fusion_xcopy_footprint`;+  - `fusion_clone_symbol`, `fusion_rename_symbol`, `fusion_remove_symbol`;+  - `fusion_set_params`: attributes, and joining a symbol's pins to a footprint's pads by number.+- The daily verb suite runs on fusion-lane's copy of BQ25792 (Default Project/fusion-lane-tests), never on the+  owner's design.  ## 1.12.8 (2026-10-28, insiders) 

@@ -918,6 +918,25 @@       "summary": "PRECISELY delete a list of cloud files by lineage urn - SAFE cleanup of AI-created clutter. Deletes ONLY the exact fileIds given (never name-guessing), so it can't touch a teammate's file in a shared folder. Loops server-side. Get the ids from fusion_aps_browse (item .id). Use this to remove f3d files the bridge created. A big list takes minutes (relay may time out at ~60s while deletes continue server-side - re-browse to confirm).",       "timeoutSeconds": 1800     },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "libraryPath": "a .lbr on the Fusion machine",+        "to": "str"+      },+      "longRunning": false,+      "name": "fusion_clone_symbol",+      "output": {+        "from": "str",+        "primitives": "int",+        "to": "str"+      },+      "statusVerb": null,+      "summary": "Copy a component of a .lbr under a new name with copies of its symbols (the standard's clone_symbol).",+      "timeoutSeconds": 30+    },     {       "example": {         "includeScratch": true@@ -1051,6 +1070,25 @@       "summary": "The board's copper layers in stack order (F.Cu, In1.Cu.., B.Cu) with Fusion's layer id, signal or plane, whether displayed, and primitives on each.",       "timeoutSeconds": 60     },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "libraryPath": "a .lbr on the Fusion machine",+        "to": "str"+      },+      "longRunning": false,+      "name": "fusion_copy_footprint",+      "output": {+        "from": "str",+        "primitives": "int",+        "to": "str"+      },+      "statusVerb": null,+      "summary": "Duplicate a footprint inside a .lbr under a new name (the standard's copy_footprint), offline and preflighted.",+      "timeoutSeconds": 30+    },     {       "example": {         "box": [@@ -1119,6 +1157,30 @@       "summary": "Create a subfolder in a cloud project through the signed-in Fusion session's Data API (no APS needed). Idempotent: an existing folder of that name is returned with alreadyExisted:true instead of a duplicate. Folder names are matched case-insensitively. For an APS-side create without Fusion running, use fusion_aps_create_folder.",       "timeoutSeconds": 60     },+    {+      "example": {+        "libraryPath": "C:/libs/new.lbr",+        "name": "SOT-23",+        "pads": "1,-37,-40,24,28,rect,0;2,37,-40,24,28,rect,0;3,0,40,24,28,rect,0"+      },+      "input": {+        "description": "str",+        "dryRun": "bool",+        "footprints": "[{name, pads, ...}]",+        "libraryPath": "a .lbr on the Fusion machine (required; created if missing)",+        "name": "str (required)",+        "pads": "str or list (required)"+      },+      "longRunning": false,+      "name": "fusion_create_footprint",+      "output": {+        "footprints": "[{footprint, pads}]",+        "libraryState": "opened|created"+      },+      "statusVerb": null,+      "summary": "Create a footprint (an EAGLE package) from a pad list in a .lbr, offline (the standard's create_footprint): pads as 'des,x_mil,y_mil,w_mil,h_mil,rect|round,hole_mil;...' (hole 0 = SMD) or [{number, at, sizeMm, shape, drillMm}], with a documentation outline and >NAME/>VALUE. The library is created when the path does not exist; several at once with footprints. Preflighted before writing.",+      "timeoutSeconds": 30+    },     {       "example": {         "libraryPath": "C:/Temp/PART.lbr",@@ -1143,6 +1205,33 @@       "summary": "ONE-CALL library creation for web-control (one call = one consent). EVERY LIBRARY IS MULTI-PART - a single-part library is simply parts:[one entry], and there is no separate single-part verb to choose. Pass parts:[{package, lbrPath, modelPath}] for any number of parts; the older {libraryPath, stepPath} shape still works and is normalised into a one-element parts list, so both run the identical code path and the ETA scales with the part count either way. TWO entry shapes: A) {libraryPath, stepPath} - a ready .lbr plus the 3D; B) {kicadSymbolPath, kicadFootprintPath, stepPath, pinMap?} - KiCad sources; needs adom-lbr, which is Linux-container-only by platform rule, so on Windows/Mac boxes shape B refuses IMMEDIATELY (adom_lbr_unavailable, before any staging or Fusion launch - fusion_readiness reports kicadIngest up front). Convert at AUTHORING time in a container and use shape A. pinMap = explicit {pinName: padName} for when pin numbers do not match pad names (BGA-style). Chains convert -> bind 3D -> prove (four evidence frames + verdict) in the BACKGROUND and returns immediately; poll fusion_prove_result (stage narrates; top-level `verdict` proven/not_proven is the score - `stage:done` only means the chain finished). EVERY PART IS PROVED, not just the first: a 10-component library streams 40 evidence frames, FOUR per component (symbol, footprint, 3d, ganged) in assembly order, each tagged with `part` so a front end can group them as they arrive, and `provedParts[]` reports per-part pass/fail. The library is proven only if EVERY part is - one good part does not vouch for nine unchecked ones. On the FINAL fetch pass {inlineFrames:true} to get each evidence frame as a base64 thumbnailDataUrl a browser can render (plain polls return box paths only). The chain closes its library document on success AND failure - batches need no between-part sweeping. stepPath is required for a PROVEN library - no real 3D body without it.",       "timeoutSeconds": 30     },+    {+      "example": {+        "libraryPath": "C:/libs/new.lbr",+        "name": "LM358",+        "pins": "1,OUTA,right,100,1;2,-INA,left,100,1;3,+INA,left,200,1;8,V+,left,100,0;4,V-,left,200,0"+      },+      "input": {+        "bodyHeightMil": "default 600",+        "bodyWidthMil": "default 800",+        "description": "str",+        "designator": "default U",+        "dryRun": "bool",+        "libraryPath": "a .lbr on the Fusion machine (required; created if missing)",+        "name": "str (required)",+        "pins": "str (required)",+        "symbols": "[{name, pins, ...}]"+      },+      "longRunning": false,+      "name": "fusion_create_symbol",+      "output": {+        "libraryState": "opened|created",+        "symbols": "[{symbol, pins, parts}]"+      },+      "statusVerb": null,+      "summary": "Create a component in a .lbr, offline (the standard's create_symbol): an EAGLE deviceset with one rectangular symbol per part and its pins on the sides asked ('des,name,left|right|top|bottom,offset_mil[,part[,hiddenNet]];...'); part 0 and hidden-net pins go on a power gate placed on request. Pin numbers are kept so set_params {footprint} can join pins to pads.",+      "timeoutSeconds": 30+    },     {       "example": {},       "input": {@@ -2147,6 +2236,27 @@       "summary": "Finish a fusion_export_optimized_glb job: bounded-poll the optimizer by jobId and write the GLB to outputPath when complete. Re-call until status=complete (big boards tessellate a few minutes). No Fusion needed.",       "timeoutSeconds": 150     },+    {+      "example": {+        "folder": "C:/libs",+        "query": "LM358"+      },+      "input": {+        "folder": "a folder of .lbr files",+        "kind": "symbol|footprint",+        "libraries": "[paths]",+        "query": "str (required)"+      },+      "longRunning": false,+      "name": "fusion_find_symbol",+      "output": {+        "best": "{name, library, exact}",+        "matches": "[{name, library, exact}]"+      },+      "statusVerb": null,+      "summary": "Find components (or footprints with kind:'footprint') by part of their name across .lbr files, offline (the standard's find_symbol): the exact match first, else the shortest name that contains the query. Fusion keeps no installed-library list a script can read, so name the libraries or a folder.",+      "timeoutSeconds": 30+    },     {       "example": {         "dimensionsMm": {@@ -17749,6 +17859,27 @@       "summary": "Read a schematic straight from its file, without Fusion running: every part of an EAGLE .sch (or the .sch inside a Fusion .fsch) with its designator, library reference (deviceset + device), value, description, part number, library, sheet, position and orientation, parameters on request, and its pins: number (the pad), name, gate and electrical type (input, output, io, open_collector, passive, hiz, power, supply, not_connected) for a schematic review. Milliseconds. The saved file, not the live sheet.",       "timeoutSeconds": 30     },+    {+      "example": {+        "libraryPath": "C:/libs/new.lbr",+        "symbolName": "LM358"+      },+      "input": {+        "libraryPath": "a .lbr on the Fusion machine (required)",+        "symbolName": "str (required)"+      },+      "longRunning": false,+      "name": "fusion_read_symbol",+      "output": {+        "libref": "str",+        "models": "[{type, name}]",+        "params": "[{name, value}]",+        "pins": "[{des, name, gate, electrical, hidden}]"+      },+      "statusVerb": null,+      "summary": "Read a component of a .lbr back (the standard's read_symbol): description, its pins with number, name, gate and electrical type (0 input, 1 io, 2 output, 3 open collector, 4 passive, 5 hi-z, 7 power), its attributes and its footprints (devices).",+      "timeoutSeconds": 30+    },     {       "example": {},       "input": {},@@ -17781,6 +17912,22 @@       "summary": "Give up the Autodesk seat from THIS machine so another box can claim it with no modal at all: closes Fusion cleanly (documents are NOT discarded; an unsaved one refuses and says so) and leaves the account signed in, so this box can claim the seat straight back. The counterpart of fusion_claim_seat.",       "timeoutSeconds": 180     },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "footprintName": "str",+        "libraryPath": "a .lbr on the Fusion machine"+      },+      "longRunning": false,+      "name": "fusion_remove_footprint",+      "output": {+        "removed": "str"+      },+      "statusVerb": null,+      "summary": "Delete a footprint from a .lbr (the standard's remove_footprint); refused while a component uses it.",+      "timeoutSeconds": 30+    },     {       "example": {         "dryRun": true,@@ -17883,6 +18030,58 @@       "summary": "Delete pours (all of them, or the ones named by net, layer and outline) so a board can be poured again after a refine. Each DELETE picks the outline point farthest from every pad (refused if none is 1 mm clear), and the readback undoes everything if a part or a track changed.",       "timeoutSeconds": 120     },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "libraryPath": "a .lbr on the Fusion machine",+        "symbolName": "str"+      },+      "longRunning": false,+      "name": "fusion_remove_symbol",+      "output": {+        "removed": "str",+        "symbolsRemoved": "[str]"+      },+      "statusVerb": null,+      "summary": "Delete a component from a .lbr, and the symbols no other component uses (the standard's remove_symbol).",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "libraryPath": "a .lbr on the Fusion machine",+        "to": "str"+      },+      "longRunning": false,+      "name": "fusion_rename_footprint",+      "output": {+        "devicesUpdated": "int",+        "renamed": "str"+      },+      "statusVerb": null,+      "summary": "Rename a footprint in a .lbr (the standard's rename_footprint): every device that uses it and its 3D package instances follow.",+      "timeoutSeconds": 30+    },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "libraryPath": "a .lbr on the Fusion machine",+        "to": "str"+      },+      "longRunning": false,+      "name": "fusion_rename_symbol",+      "output": {+        "renamed": "str"+      },+      "statusVerb": null,+      "summary": "Rename a component in a .lbr (the standard's rename_symbol).",+      "timeoutSeconds": 30+    },     {       "example": {         "background": "transparent",@@ -19144,6 +19343,34 @@       "summary": "Set one parameter's expression by name in the ACTIVE 3D Design document (user parameters first, then model parameters). MUTATES the design: the model regenerates and the result carries the post-op dialog array. Requires a Design document to be active (a 2D board or library editor refuses). Read names and current expressions with fusion_get_parameters; units must match the parameter (\"10 mm\", \"5 deg\").",       "timeoutSeconds": 30     },+    {+      "example": {+        "footprint": "SOIC-8",+        "libraryPath": "C:/libs/new.lbr",+        "params": {+          "MPN": "LM358DR"+        },+        "symbolName": "LM358"+      },+      "input": {+        "comment": "str",+        "dryRun": "bool",+        "footprint": "a package in the same library",+        "libraryPath": "a .lbr on the Fusion machine (required)",+        "params": "{MPN: ..., Manufacturer: ...}",+        "symbolName": "default the first component"+      },+      "longRunning": false,+      "name": "fusion_set_params",+      "output": {+        "component": "str",+        "footprint": "str|null",+        "paramsSet": "int"+      },+      "statusVerb": null,+      "summary": "Set attributes on a component of a .lbr (the standard's set_params): params as {key: value} or 'Key=Value;...' on every device, a COMMENT, and with footprint a device on that package whose pins join the pads with the same numbers.",+      "timeoutSeconds": 30+    },     {       "example": {         "theme": "dark"@@ -19729,6 +19956,25 @@       "summary": "Sign a pup browser window into an Autodesk WEB surface (library.io, the hub portal at <hub>.autodesk360.com, Autodesk Account) via Google SSO. Fusion's DESKTOP app being signed in does NOT sign these in - they are separate web sessions. NEVER guesses a credential: a missing password or a 2FA challenge comes back as a typed stop (human_credential_required / second_factor_required / google_sso_unavailable) naming the one-time command the USER runs. The password never passes through this bridge or the AI - it is stored once with ab's credential_set and filled by pup in the background.",       "timeoutSeconds": 240     },+    {+      "example": {},+      "input": {+        "dryRun": "bool",+        "from": "str",+        "fromLib": "source .lbr",+        "to": "default same name",+        "toLib": "destination .lbr (required)"+      },+      "longRunning": false,+      "name": "fusion_xcopy_footprint",+      "output": {+        "primitives": "int",+        "to": "str"+      },+      "statusVerb": null,+      "summary": "Copy a footprint from one .lbr into another (the standard's xcopy_footprint), optionally under a new name; the destination is created when missing.",+      "timeoutSeconds": 30+    },     {       "example": {         "expectDocument": "fusion-routing"

@@ -0,0 +1,464 @@+//! Library authoring on EAGLE .lbr text, offline: the standard's create_footprint, create_symbol,+//! read_symbol, find_symbol, copy/rename/remove/xcopy_footprint, clone/rename/remove_symbol and+//! set_params. In EAGLE a footprint is a <package>; the standard's "symbol" (a component you place)+//! is a <deviceset> with the <symbol>s its gates use. A symbol made here keeps its pin numbers on a+//! package-less device (attribute ADOM_PINMAP, "number:pin;..."), the way EAGLE's own supply+//! symbols carry no package, so set_params {footprint} can join pins to pads later.++use crate::Element;+use serde_json::{json, Value};++const TEMPLATE_HEAD: &str = include_str!("lbr_template_head.xml");+const MIL: f64 = 0.0254;++/// A new, empty library document (the layer table of a Fusion library).+pub fn new_library(description: &str) -> String {+    format!("{TEMPLATE_HEAD}<library>\n<description>{}</description>\n<packages>\n</packages>\n<symbols>\n</symbols>\n<devicesets>\n</devicesets>\n</library>\n</drawing>\n</eagle>\n",+            description.replace('&', "&amp;").replace('<', "&lt;"))+}++fn f(v: f64) -> String { let s = format!("{:.4}", v); let s = s.trim_end_matches('0').trim_end_matches('.').to_string(); if s == "-0" { "0".into() } else { s } }+fn el(tag: &str, attrs: &[(&str, String)]) -> Element { let mut e = Element::new(tag); e.attrs = attrs.iter().map(|(k, v)| (k.to_string(), v.clone())).collect(); e }+fn set(e: &mut Element, k: &str, v: &str) { match e.attrs.iter_mut().find(|(kk, _)| kk == k) { Some(a) => a.1 = v.to_string(), None => e.attrs.push((k.into(), v.into())) } }+fn lib_mut(root: &mut Element) -> Result<&mut Element, String> { root.find_deep_mut("library").ok_or_else(|| "not a library: no <library>".to_string()) }+fn section<'a>(lib: &'a mut Element, tag: &str) -> &'a mut Element {+    if lib.find_child(tag).is_none() {+        // EAGLE order inside <library>: description?, packages, packages3d?, symbols, devicesets+        let order = ["description", "packages", "packages3d", "symbols", "devicesets"];+        let rank = |t: &str| order.iter().position(|o| *o == t).unwrap_or(9);+        let at = lib.children.iter().position(|c| rank(&c.tag) > rank(tag)).unwrap_or(lib.children.len());+        lib.children.insert(at, Element::new(tag));+    }+    lib.find_child_mut(tag).unwrap()+}+fn names(sec: &Element, tag: &str) -> Vec<String> { sec.children.iter().filter(|c| c.tag == tag).filter_map(|c| c.attr("name").map(str::to_string)).collect() }+fn find_ci<'a>(list: &'a [String], want: &str) -> Option<&'a String> { list.iter().find(|n| *n == want).or_else(|| list.iter().find(|n| n.eq_ignore_ascii_case(want))) }++/// Pads as the standard writes them: "des,x_mil,y_mil,w_mil,h_mil,rect|round,hole_mil;..." (hole 0 = SMD),+/// or a JSON list of {number, at:[x,y] mm, sizeMm:[w,h], shape, drillMm}.+fn parse_pads(v: &Value) -> Result<Vec<Element>, String> {+    let mut out = Vec::new();+    let mk = |des: &str, x: f64, y: f64, w: f64, h: f64, round: bool, hole: f64| -> Element {+        if hole > 0.0 {+            let mut e = el("pad", &[("name", des.into()), ("x", f(x)), ("y", f(y)), ("drill", f(hole)), ("diameter", f(w.max(h)))]);+            if !round { e.attrs.push(("shape".into(), "square".into())); }+            if (w - h).abs() > 1e-6 { e.attrs.retain(|a| a.0 != "shape"); e.attrs.push(("shape".into(), "long".into())); if h > w { e.attrs.push(("rot".into(), "R90".into())); } set(&mut e, "diameter", &f(w.min(h))); }+            e+        } else {+            let mut e = el("smd", &[("name", des.into()), ("x", f(x)), ("y", f(y)), ("dx", f(w)), ("dy", f(h)), ("layer", "1".into())]);+            if round { e.attrs.push(("roundness".into(), "100".into())); }+            e+        }+    };+    if let Some(s) = v.as_str() {+        for (i, item) in s.split(';').map(str::trim).filter(|t| !t.is_empty()).enumerate() {+            let p: Vec<&str> = item.split(',').map(str::trim).collect();+            if p.len() < 6 { return Err(format!("pad {}: want des,x_mil,y_mil,w_mil,h_mil,rect|round[,hole_mil], got {item}", i + 1)); }+            let n = |k: usize| p.get(k).and_then(|t| t.parse::<f64>().ok()).unwrap_or(0.0);+            out.push(mk(p[0], n(1) * MIL, n(2) * MIL, n(3) * MIL, n(4) * MIL, p[5].eq_ignore_ascii_case("round"), n(6) * MIL));+        }+    } else if let Some(a) = v.as_array() {+        for (i, p) in a.iter().enumerate() {+            let des = p["number"].as_str().map(str::to_string).or(p["number"].as_u64().map(|n| n.to_string())).ok_or(format!("pad {}: number", i + 1))?;+            let at = p["at"].as_array().ok_or(format!("pad {des}: at [x, y] mm"))?;+            let sz = p["sizeMm"].as_array().ok_or(format!("pad {des}: sizeMm [w, h]"))?;+            let g = |a: &Vec<Value>, k: usize| a.get(k).and_then(|x| x.as_f64()).unwrap_or(0.0);+            out.push(mk(&des, g(at, 0), g(at, 1), g(sz, 0), g(sz, 1), p["shape"].as_str() == Some("round"), p["drillMm"].as_f64().unwrap_or(0.0)));+        }+    } else { return Err("pads is required".into()); }+    if out.is_empty() { return Err("pads is empty".into()); }+    let mut seen = std::collections::HashSet::new();+    for e in &out { let n = e.attr("name").unwrap_or(""); if !seen.insert(n.to_string()) { return Err(format!("two pads are numbered {n}")); } }+    Ok(out)+}++/// The standard's create_footprint: a package from a pad list, with a documentation outline round+/// the pads and >NAME / >VALUE placeholders. Several at once with `footprints`.+pub fn create_footprint(xml: Option<&str>, args: &Value) -> Result<(String, Value), String> {+    let text = xml.map(str::to_string).unwrap_or_else(|| new_library("made by fusion-bridge"));+    let mut root = Element::parse(&text).map_err(|e| e.to_string())?;+    let specs: Vec<Value> = match args["footprints"].as_array() { Some(a) => a.iter().map(|x| { let mut m = args.clone(); for (k, v) in x.as_object().cloned().unwrap_or_default() { m[k] = v; } m }).collect(), None => vec![args.clone()] };+    let mut made = Vec::new();+    {+        let lib = lib_mut(&mut root)?;+        for spec in &specs {+            let name = spec["name"].as_str().filter(|s| !s.is_empty()).ok_or("name is required")?.to_string();+            let pads = parse_pads(&spec["pads"])?;+            let sec = section(lib, "packages");+            if find_ci(&names(sec, "package"), &name).is_some() { return Err(format!("footprint {name} already exists (rename_footprint, remove_footprint, or another name)")); }+            let mut pkg = el("package", &[("name", name.clone())]);+            if let Some(d) = spec["description"].as_str() { let mut de = Element::new("description"); de.text = d.into(); pkg.children.push(de); }+            let ext = |e: &Element| -> (f64, f64, f64, f64) {+                let g = |k: &str| e.attr(k).and_then(|v| v.parse::<f64>().ok()).unwrap_or(0.0);+                let (x, y) = (g("x"), g("y"));+                let (hw, hh) = if e.tag == "smd" { (g("dx") / 2.0, g("dy") / 2.0) } else { let d = g("diameter").max(g("drill") * 1.6) / 2.0; (d, d) };+                (x - hw, y - hh, x + hw, y + hh)+            };+            let (mut x0, mut y0, mut x1, mut y1) = (f64::MAX, f64::MAX, f64::MIN, f64::MIN);+            for p in &pads { let (a, b, c, d) = ext(p); x0 = x0.min(a); y0 = y0.min(b); x1 = x1.max(c); y1 = y1.max(d); }+            let n = pads.len();+            pkg.children.extend(pads);+            let m = 0.25;+            for (a, b) in [((x0 - m, y0 - m), (x1 + m, y0 - m)), ((x1 + m, y0 - m), (x1 + m, y1 + m)), ((x1 + m, y1 + m), (x0 - m, y1 + m)), ((x0 - m, y1 + m), (x0 - m, y0 - m))] {+                pkg.children.push(el("wire", &[("x1", f(a.0)), ("y1", f(a.1)), ("x2", f(b.0)), ("y2", f(b.1)), ("width", "0.1".into()), ("layer", "51".into())]));+            }+            let mut tn = el("text", &[("x", f(x0 - m)), ("y", f(y1 + m + 0.3)), ("size", "1".into()), ("layer", "25".into())]); tn.text = ">NAME".into();+            let mut tv = el("text", &[("x", f(x0 - m)), ("y", f(y0 - m - 1.3)), ("size", "1".into()), ("layer", "27".into())]); tv.text = ">VALUE".into();+            pkg.children.push(tn); pkg.children.push(tv);+            section(lib, "packages").children.push(pkg);+            made.push(json!({"footprint": name, "pads": n}));+        }+    }+    let state = if xml.is_some() { "opened" } else { "created" };+    Ok((root.to_xml_document(), json!({"footprints": made, "libraryState": state})))+}++fn direction_for(name: &str, hidden: bool) -> &'static str {+    let u = name.to_uppercase();+    if hidden || ["GND", "VCC", "VDD", "VSS", "VEE", "V+", "V-", "AGND", "DGND", "PGND", "VIN", "VBAT", "3V3", "5V"].iter().any(|p| u == *p || u.starts_with(&format!("{p}@"))) { "pwr" } else { "pas" }+}++/// The standard's create_symbol: a component (deviceset) with one gate per part, each a+/// rectangular symbol with its pins on the sides asked; part 0 pins and hidden-net pins go on a+/// power gate placed on request. Pin numbers are kept for set_params {footprint}.+pub fn create_symbol(xml: Option<&str>, args: &Value) -> Result<(String, Value), String> {+    let text = xml.map(str::to_string).unwrap_or_else(|| new_library("made by fusion-bridge"));+    let mut root = Element::parse(&text).map_err(|e| e.to_string())?;+    let specs: Vec<Value> = match args["symbols"].as_array() { Some(a) => a.iter().map(|x| { let mut m = args.clone(); for (k, v) in x.as_object().cloned().unwrap_or_default() { m[k] = v; } m }).collect(), None => vec![args.clone()] };+    let mut made = Vec::new();+    {+        let lib = lib_mut(&mut root)?;+        for spec in &specs {+            let name = spec["name"].as_str().filter(|s| !s.is_empty()).ok_or("name is required")?.to_string();+            if find_ci(&names(section(lib, "devicesets"), "deviceset"), &name).is_some() { return Err(format!("symbol {name} already exists")); }+            let pins_s = spec["pins"].as_str().ok_or("pins is required: 'des,name,left|right|top|bottom,offset_mil[,part[,hiddenNet]];...'")?;+            let bw = spec["bodyWidthMil"].as_f64().unwrap_or(800.0) * MIL;+            let bh = spec["bodyHeightMil"].as_f64().unwrap_or(600.0) * MIL;+            // part -> [(des, name, side, offset_mm, hidden)]+            let mut parts: std::collections::BTreeMap<i64, Vec<(String, String, String, f64, bool)>> = Default::default();+            for (i, item) in pins_s.split(';').map(str::trim).filter(|t| !t.is_empty()).enumerate() {+                let p: Vec<&str> = item.split(',').map(str::trim).collect();+                if p.len() < 4 { return Err(format!("pin {}: want des,name,side,offset_mil, got {item}", i + 1)); }+                let side = p[2].to_lowercase();+                if !["left", "right", "top", "bottom"].contains(&side.as_str()) { return Err(format!("pin {}: side is left, right, top or bottom", p[0])); }+                let part: i64 = p.get(4).and_then(|v| v.parse().ok()).unwrap_or(1);+                let hidden = p.get(5).map(|v| !v.is_empty()).unwrap_or(false);+                let pname = if hidden { p[5].to_string() } else { p[1].to_string() };+                let key = if part == 0 || hidden { 0 } else { part };+                parts.entry(key).or_default().push((p[0].to_string(), pname, side, p[3].parse::<f64>().unwrap_or(0.0) * MIL, hidden));+            }+            if parts.is_empty() { return Err("pins is empty".into()); }+            let real: Vec<i64> = parts.keys().cloned().filter(|k| *k != 0).collect();+            let multi = real.len() > 1;+            let mut gates = Element::new("gates");+            let mut pinmap: Vec<String> = Vec::new();+            let mut sym_count = 0;+            for (k, pins) in &parts {+                let suffix = if *k == 0 { "_PWR".to_string() } else if multi { format!("_{}", (b'A' + (*k as u8 - 1)) as char) } else { String::new() };+                let sname = format!("{name}{suffix}");+                let mut sym = el("symbol", &[("name", sname.clone())]);+                let (hw, hh) = (bw / 2.0, bh / 2.0);+                for (a, b) in [((-hw, -hh), (hw, -hh)), ((hw, -hh), (hw, hh)), ((hw, hh), (-hw, hh)), ((-hw, hh), (-hw, -hh))] {+                    sym.children.push(el("wire", &[("x1", f(a.0)), ("y1", f(a.1)), ("x2", f(b.0)), ("y2", f(b.1)), ("width", "0.254".into()), ("layer", "94".into())]));+                }+                let mut tn = el("text", &[("x", f(-hw)), ("y", f(hh + 0.8)), ("size", "1.778".into()), ("layer", "95".into())]); tn.text = ">NAME".into();+                let mut tv = el("text", &[("x", f(-hw)), ("y", f(-hh - 2.5)), ("size", "1.778".into()), ("layer", "96".into())]); tv.text = ">VALUE".into();+                sym.children.push(tn); sym.children.push(tv);+                let mut used: std::collections::HashMap<String, usize> = Default::default();+                let len = 5.08;+                for (des, pname, side, off, hidden) in pins {+                    let c = used.entry(pname.to_uppercase()).or_insert(0); *c += 1;+                    let unique = if *c > 1 { format!("{pname}@{c}") } else { pname.clone() };+                    let (x, y, rot) = match side.as_str() {+                        "left" => (-hw - len, hh - off, "R0"), "right" => (hw + len, hh - off, "R180"),+                        "top" => (-hw + off, hh + len, "R270"), _ => (-hw + off, -hh - len, "R90"),+                    };+                    let mut pe = el("pin", &[("name", unique.clone()), ("x", f(x)), ("y", f(y)), ("length", "middle".into()), ("direction", direction_for(&unique, *hidden).into())]);+                    if rot != "R0" { pe.attrs.push(("rot".into(), rot.into())); }+                    if *hidden { pe.attrs.push(("visible".into(), "off".into())); }+                    sym.children.push(pe);+                    let gname = if *k == 0 { "P".to_string() } else if multi { ((b'A' + (*k as u8 - 1)) as char).to_string() } else { "G$1".into() };+                    pinmap.push(format!("{des}:{gname}.{unique}"));+                }+                section(lib, "symbols").children.push(sym); sym_count += 1;+                let gname = if *k == 0 { "P".to_string() } else if multi { ((b'A' + (*k as u8 - 1)) as char).to_string() } else { "G$1".into() };+                let mut g = el("gate", &[("name", gname), ("symbol", sname), ("x", f((gates.children.len() as f64) * (bw + 15.24))), ("y", "0".into())]);+                if *k == 0 { g.attrs.push(("addlevel".into(), "request".into())); }+                gates.children.push(g);+            }+            let mut ds = el("deviceset", &[("name", name.clone()), ("prefix", spec["designator"].as_str().unwrap_or("U").to_string())]);+            if let Some(d) = spec["description"].as_str() { let mut de = Element::new("description"); de.text = d.into(); ds.children.push(de); }+            ds.children.push(gates);+            let mut devs = Element::new("devices");+            let mut dev = el("device", &[("name", "".into())]);+            let mut techs = Element::new("technologies");+            let mut tech = el("technology", &[("name", "".into())]);+            tech.children.push(el("attribute", &[("name", "ADOM_PINMAP".into()), ("value", pinmap.join(";")), ("constant", "no".into())]));+            techs.children.push(tech); dev.children.push(techs); devs.children.push(dev); ds.children.push(devs);+            section(lib, "devicesets").children.push(ds);+            made.push(json!({"symbol": name, "pins": pinmap.len(), "parts": real.len().max(1), "symbols": sym_count}));+        }+    }+    let state = if xml.is_some() { "opened" } else { "created" };+    Ok((root.to_xml_document(), json!({"symbols": made, "libraryState": state})))+}++fn pin_number_map(ds: &Element) -> Vec<(String, String, String)> {+    // (number, gate, pin) from a device's connects, else from ADOM_PINMAP+    let mut out = Vec::new();+    if let Some(devs) = ds.find_child("devices") {+        for d in devs.children.iter().filter(|c| c.tag == "device") {+            if let Some(cs) = d.find_child("connects") {+                for c in cs.children.iter().filter(|c| c.tag == "connect") {+                    for pad in c.attr("pad").unwrap_or("").split(' ').filter(|p| !p.is_empty()) { out.push((pad.to_string(), c.attr("gate").unwrap_or("").to_string(), c.attr("pin").unwrap_or("").to_string())); }+                }+                if !out.is_empty() { return out; }+            }+        }+        for d in devs.children.iter().filter(|c| c.tag == "device") {+            fn walk(e: &Element, out: &mut Vec<(String, String, String)>) {+                if e.tag == "attribute" && e.attr("name") == Some("ADOM_PINMAP") {+                    for item in e.attr("value").unwrap_or("").split(';').filter(|s| !s.is_empty()) {+                        if let Some((num, gp)) = item.split_once(':') { if let Some((g, p)) = gp.split_once('.') { out.push((num.into(), g.into(), p.into())); } }+                    }+                }+                for c in &e.children { walk(c, out); }+            }+            walk(d, &mut out);+            if !out.is_empty() { return out; }+        }+    }+    out+}++fn electrical(dir: &str) -> u8 { match dir { "in" => 0, "io" => 1, "out" => 2, "oc" => 3, "hiz" => 5, "pwr" | "sup" => 7, _ => 4 } }++/// The standard's read_symbol for a deviceset.+pub fn read_symbol(xml: &str, name: &str) -> Result<Value, String> {+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let dss = section(lib, "devicesets").children.clone();+    let ds = dss.iter().find(|d| d.tag == "deviceset" && d.attr("name") == Some(name)).or_else(|| dss.iter().find(|d| d.tag == "deviceset" && d.attr("name").map(|n| n.eq_ignore_ascii_case(name)).unwrap_or(false)))+        .ok_or_else(|| format!("no symbol {name}; the library has {}", dss.iter().filter_map(|d| d.attr("name")).collect::<Vec<_>>().join(", ")))?;+    let syms = section(lib, "symbols").children.clone();+    let map = pin_number_map(ds);+    let mut pins = Vec::new();+    let gates: Vec<&Element> = ds.find_child("gates").map(|g| g.children.iter().filter(|c| c.tag == "gate").collect()).unwrap_or_default();+    for g in &gates {+        if let Some(sym) = syms.iter().find(|s| s.attr("name") == g.attr("symbol")) {+            for p in sym.children.iter().filter(|c| c.tag == "pin") {+                let pname = p.attr("name").unwrap_or("");+                let des: Vec<&str> = map.iter().filter(|(_, gg, pp)| gg == g.attr("name").unwrap_or("") && pp == pname).map(|(n, _, _)| n.as_str()).collect();+                pins.push(json!({"des": des.join(" "), "name": pname.split('@').next().unwrap_or(pname), "pin": pname, "gate": g.attr("name"), "electrical": electrical(p.attr("direction").unwrap_or("io")), "hidden": p.attr("visible") == Some("off")}));+            }+        }+    }+    let mut params = Vec::new();+    let mut models = Vec::new();+    if let Some(devs) = ds.find_child("devices") {+        for d in devs.children.iter().filter(|c| c.tag == "device") {+            if let Some(pk) = d.attr("package").filter(|p| !p.is_empty()) { models.push(json!({"type": "PCBLIB", "name": pk, "device": d.attr("name"), "isCurrent": models.is_empty()})); }+            fn walk(e: &Element, out: &mut Vec<Value>) { if e.tag == "attribute" && e.attr("name") != Some("ADOM_PINMAP") { out.push(json!({"name": e.attr("name"), "value": e.attr("value").unwrap_or(""), "hidden": e.attr("display") == Some("off")})); } for c in &e.children { walk(c, out); } }+            walk(d, &mut params);+        }+    }+    params.dedup_by(|a, b| a["name"] == b["name"]);+    Ok(json!({"libref": ds.attr("name"), "description": ds.find_child("description").map(|d| d.text.trim().to_string()).unwrap_or_default(),+              "displayModeCount": 1, "parts": gates.len(), "pinsMode0": pins.len(), "pins": pins, "params": params, "models": models, "prefix": ds.attr("prefix")}))+}++/// The standard's find_symbol over library texts: (library label, text) pairs.+pub fn find_symbol(libs: &[(String, String)], query: &str, footprints: bool) -> Value {+    let q = query.to_lowercase();+    let mut matches = Vec::new();+    for (label, text) in libs {+        let Ok(mut root) = Element::parse(text) else { continue };+        let Ok(lib) = lib_mut(&mut root) else { continue };+        let (sec, tag) = if footprints { ("packages", "package") } else { ("devicesets", "deviceset") };+        for n in names(section(lib, sec), tag) { if n.to_lowercase().contains(&q) { matches.push(json!({"name": n, "library": label, "exact": n.eq_ignore_ascii_case(query)})); } }+    }+    let best = matches.iter().find(|m| m["exact"] == true).cloned().or_else(|| matches.iter().min_by_key(|m| m["name"].as_str().map(|s| s.len()).unwrap_or(usize::MAX)).cloned());+    json!({"matches": matches, "best": best})+}++fn primitives(e: &Element) -> usize { e.children.iter().filter(|c| c.tag != "description").count() }++/// copy_footprint (within a library) and xcopy_footprint (from another library's text).+pub fn copy_footprint(xml: &str, from_xml: Option<&str>, from: &str, to: &str) -> Result<(String, Value), String> {+    let src_text = from_xml.unwrap_or(xml);+    let mut src = Element::parse(src_text).map_err(|e| e.to_string())?;+    let pk = {+        let lib = lib_mut(&mut src)?;+        let sec = section(lib, "packages");+        let n = find_ci(&names(sec, "package"), from).cloned().ok_or_else(|| format!("no footprint {from}"))?;+        sec.children.iter().find(|p| p.tag == "package" && p.attr("name") == Some(n.as_str())).cloned().unwrap()+    };+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let sec = section(lib, "packages");+    if find_ci(&names(sec, "package"), to).is_some() { return Err(format!("footprint {to} already exists in the destination")); }+    let mut c = pk; set(&mut c, "name", to); c.attrs.retain(|(k, _)| k != "urn" && k != "library_version");+    let n = primitives(&c);+    sec.children.push(c);+    Ok((root.to_xml_document(), json!({"from": from, "to": to, "primitives": n})))+}++/// rename_footprint: the package, every device that uses it, and its 3D package instances.+pub fn rename_footprint(xml: &str, from: &str, to: &str) -> Result<(String, Value), String> {+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let sec = section(lib, "packages");+    let n = find_ci(&names(sec, "package"), from).cloned().ok_or_else(|| format!("no footprint {from}"))?;+    if find_ci(&names(sec, "package"), to).is_some() && !n.eq_ignore_ascii_case(to) { return Err(format!("footprint {to} already exists")); }+    for p in sec.children.iter_mut().filter(|p| p.tag == "package" && p.attr("name") == Some(n.as_str())) { set(p, "name", to); }+    let mut devices = 0;+    fn walk(e: &mut Element, old: &str, new: &str, devices: &mut usize) {+        if e.tag == "device" && e.attr("package") == Some(old) { set(e, "package", new); *devices += 1; }+        if e.tag == "packageinstance" && e.attr("name") == Some(old) { set(e, "name", new); }+        for c in e.children.iter_mut() { walk(c, old, new, devices); }+    }+    walk(lib, &n, to, &mut devices);+    Ok((root.to_xml_document(), json!({"renamed": to, "from": n, "devicesUpdated": devices})))+}++/// remove_footprint: refused while a device uses it, so no symbol is left pointing at nothing.+pub fn remove_footprint(xml: &str, name: &str) -> Result<(String, Value), String> {+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let n = find_ci(&names(section(lib, "packages"), "package"), name).cloned().ok_or_else(|| format!("no footprint {name}"))?;+    let users: Vec<String> = section(lib, "devicesets").children.iter().filter(|d| d.find_child("devices").map(|ds| ds.children.iter().any(|x| x.attr("package") == Some(n.as_str()))).unwrap_or(false)).filter_map(|d| d.attr("name").map(str::to_string)).collect();+    if !users.is_empty() { return Err(format!("footprint {n} is used by {}: remove or relink those first", users.join(", "))); }+    section(lib, "packages").children.retain(|p| !(p.tag == "package" && p.attr("name") == Some(n.as_str())));+    Ok((root.to_xml_document(), json!({"removed": n})))+}++/// clone_symbol: the deviceset copied under a new name with copies of its symbols.+pub fn clone_symbol(xml: &str, from: &str, to: &str) -> Result<(String, Value), String> {+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let dsn = find_ci(&names(section(lib, "devicesets"), "deviceset"), from).cloned().ok_or_else(|| format!("no symbol {from}"))?;+    if find_ci(&names(section(lib, "devicesets"), "deviceset"), to).is_some() { return Err(format!("symbol {to} already exists")); }+    let mut ds = section(lib, "devicesets").children.iter().find(|d| d.tag == "deviceset" && d.attr("name") == Some(dsn.as_str())).cloned().unwrap();+    set(&mut ds, "name", to); ds.attrs.retain(|(k, _)| k != "urn" && k != "library_version");+    let syms = section(lib, "symbols").children.clone();+    let mut new_syms = Vec::new();+    let mut prims = 0;+    if let Some(g) = ds.find_child_mut("gates") {+        for gate in g.children.iter_mut().filter(|c| c.tag == "gate") {+            let old = gate.attr("symbol").unwrap_or("").to_string();+            if let Some(s) = syms.iter().find(|s| s.attr("name") == Some(old.as_str())) {+                let nn = if old.starts_with(&dsn) { format!("{to}{}", &old[dsn.len()..]) } else { format!("{to}_{old}") };+                let mut c = s.clone(); set(&mut c, "name", &nn); c.attrs.retain(|(k, _)| k != "urn" && k != "library_version");+                prims += primitives(&c);+                if !syms.iter().any(|x| x.attr("name") == Some(nn.as_str())) && !new_syms.iter().any(|x: &Element| x.attr("name") == Some(nn.as_str())) { new_syms.push(c); }+                set(gate, "symbol", &nn);+            }+        }+    }+    section(lib, "symbols").children.extend(new_syms);+    section(lib, "devicesets").children.push(ds);+    Ok((root.to_xml_document(), json!({"from": dsn, "to": to, "primitives": prims, "displayModeCount": 1})))+}++pub fn rename_symbol(xml: &str, from: &str, to: &str) -> Result<(String, Value), String> {+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let sec = section(lib, "devicesets");+    let n = find_ci(&names(sec, "deviceset"), from).cloned().ok_or_else(|| format!("no symbol {from}"))?;+    if find_ci(&names(sec, "deviceset"), to).is_some() && !n.eq_ignore_ascii_case(to) { return Err(format!("symbol {to} already exists")); }+    for d in sec.children.iter_mut().filter(|d| d.tag == "deviceset" && d.attr("name") == Some(n.as_str())) { set(d, "name", to); }+    Ok((root.to_xml_document(), json!({"renamed": to, "from": n})))+}++/// remove_symbol: the deviceset, and the symbols no other deviceset uses.+pub fn remove_symbol(xml: &str, name: &str) -> Result<(String, Value), String> {+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let n = find_ci(&names(section(lib, "devicesets"), "deviceset"), name).cloned().ok_or_else(|| format!("no symbol {name}"))?;+    let used_by = |sec: &Element, skip: &str| -> std::collections::HashSet<String> {+        sec.children.iter().filter(|d| d.tag == "deviceset" && d.attr("name") != Some(skip)).flat_map(|d| d.find_child("gates").map(|g| g.children.iter().filter_map(|x| x.attr("symbol").map(str::to_string)).collect::<Vec<_>>()).unwrap_or_default()).collect()+    };+    let mine: Vec<String> = section(lib, "devicesets").children.iter().filter(|d| d.attr("name") == Some(n.as_str())).flat_map(|d| d.find_child("gates").map(|g| g.children.iter().filter_map(|x| x.attr("symbol").map(str::to_string)).collect::<Vec<_>>()).unwrap_or_default()).collect();+    let others = used_by(section(lib, "devicesets"), &n);+    section(lib, "devicesets").children.retain(|d| !(d.tag == "deviceset" && d.attr("name") == Some(n.as_str())));+    let gone: Vec<String> = mine.into_iter().filter(|s| !others.contains(s)).collect();+    section(lib, "symbols").children.retain(|s| !(s.tag == "symbol" && s.attr("name").map(|x| gone.iter().any(|g| g == x)).unwrap_or(false)));+    Ok((root.to_xml_document(), json!({"removed": n, "symbolsRemoved": gone})))+}++/// The standard's set_params: attributes on every device of the symbol (EAGLE keeps them per+/// technology), a COMMENT attribute, and with `footprint` a device on that package whose connects+/// come from the pin numbers (pad name = pin number).+pub fn set_params(xml: &str, symbol: Option<&str>, params: &Value, comment: Option<&str>, footprint: Option<&str>) -> Result<(String, Value), String> {+    let mut root = Element::parse(xml).map_err(|e| e.to_string())?;+    let lib = lib_mut(&mut root)?;+    let pk_names = names(section(lib, "packages"), "package");+    let pk_pads: Vec<String> = match footprint {+        Some(fp) => {+            let n = find_ci(&pk_names, fp).cloned().ok_or_else(|| format!("no footprint {fp} in this library"))?;+            section(lib, "packages").children.iter().find(|p| p.attr("name") == Some(n.as_str())).map(|p| p.children.iter().filter(|c| c.tag == "smd" || c.tag == "pad").filter_map(|c| c.attr("name").map(str::to_string)).collect()).unwrap_or_default()+        }+        None => vec![],+    };+    let fp_name = footprint.and_then(|fp| find_ci(&pk_names, fp).cloned());+    let sec = section(lib, "devicesets");+    let all = names(sec, "deviceset");+    let n = match symbol { Some(s) => find_ci(&all, s).cloned().ok_or_else(|| format!("no symbol {s}"))?, None => all.first().cloned().ok_or("the library has no symbols")? };+    let ds = sec.children.iter_mut().find(|d| d.tag == "deviceset" && d.attr("name") == Some(n.as_str())).unwrap();+    let mut kv: Vec<(String, String)> = match params {+        Value::Object(m) => m.iter().map(|(k, v)| (k.to_uppercase(), v.as_str().map(str::to_string).unwrap_or(v.to_string()))).collect(),+        Value::String(s) => s.split(';').filter_map(|p| p.split_once('=')).map(|(k, v)| (k.trim().to_uppercase(), v.trim().to_string())).collect(),+        _ => vec![],+    };+    if let Some(c) = comment { kv.push(("COMMENT".into(), c.to_string())); }+    let mut linked = Value::Null;+    if let (Some(fp), false) = (&fp_name, pk_pads.is_empty()) {+        let map = pin_number_map(ds);+        if map.is_empty() { return Err(format!("{n} has no pin numbers to join to {fp}'s pads")); }+        let missing: Vec<&String> = map.iter().map(|(num, _, _)| num).filter(|num| !pk_pads.contains(num)).collect();+        if !missing.is_empty() { return Err(format!("{fp} has no pad {}", missing.iter().map(|s| s.as_str()).collect::<Vec<_>>().join(", "))); }+        let devs = match ds.find_child_mut("devices") { Some(d) => d, None => { ds.children.push(Element::new("devices")); ds.find_child_mut("devices").unwrap() } };+        // the package-less device that held the pin numbers becomes the footprint's device+        let idx = devs.children.iter().position(|d| d.tag == "device" && d.attr("package").map(|p| p.is_empty()).unwrap_or(true));+        let mut dev = match idx { Some(i) => devs.children.remove(i), None => el("device", &[("name", if devs.children.is_empty() { "".into() } else { format!("-{}", fp) })]) };+        set(&mut dev, "package", fp);+        dev.children.retain(|c| c.tag != "connects");+        let mut cs = Element::new("connects");+        let mut by_pin: std::collections::BTreeMap<(String, String), Vec<String>> = Default::default();+        for (num, g, p) in &map { by_pin.entry((g.clone(), p.clone())).or_default().push(num.clone()); }+        for ((g, p), pads) in &by_pin { cs.children.push(el("connect", &[("gate", g.clone()), ("pin", p.clone()), ("pad", pads.join(" "))])); }+        dev.children.insert(0, cs);+        devs.children.push(dev);+        linked = json!(fp);+    }+    let mut set_n = 0;+    if let Some(devs) = ds.find_child_mut("devices") {+        if devs.children.is_empty() { devs.children.push(el("device", &[("name", "".into())])); }+        for d in devs.children.iter_mut().filter(|c| c.tag == "device") {+            let techs = match d.find_child_mut("technologies") { Some(t) => t, None => { d.children.push(Element::new("technologies")); d.find_child_mut("technologies").unwrap() } };+            if techs.children.is_empty() { techs.children.push(el("technology", &[("name", "".into())])); }+            for t in techs.children.iter_mut().filter(|c| c.tag == "technology") {+                for (k, v) in &kv {+                    match t.children.iter_mut().find(|a| a.tag == "attribute" && a.attr("name") == Some(k.as_str())) {+                        Some(a) => set(a, "value", v),+                        None => t.children.push(el("attribute", &[("name", k.clone()), ("value", v.clone()), ("constant", "no".into())])),+                    }+                }+            }+        }+        set_n = kv.len();+    }+    Ok((root.to_xml_document(), json!({"component": n, "paramsSet": set_n, "footprint": linked})))+}++/// The preflight a library under construction must pass: every check of fusion_preflight_lbr+/// except the ones only a finished library meets (has symbols, devicesets, packages, connects):+/// a footprint-only library is fine to write; opening a component in it is what needs them.+pub fn preflight_text(path: &std::path::Path) -> (bool, Vec<String>) {+    let pf = crate::preflight_lbr(path);+    // also fine mid-build: a symbol not yet joined to a footprint (no connects anywhere yet), and a+    // library whose last footprint was just removed+    let errs: Vec<String> = pf.errors.into_iter().filter(|e| !e.starts_with("symbols-present") && !e.starts_with("devicesets-present")+        && !e.starts_with("connects-resolve: no connects at all") && !e.starts_with("packages-nonempty")).collect();+    (errs.is_empty(), errs)+}