Fusion - the Fusion 360 Bridge

@@ -3,6 +3,20 @@ 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` +## Next release++From Glenn Jones's reports on a 4-layer board:++`fusion_export_gerbers` takes the layer count from the board's own stack (#142). Inner planes that were only pours read as a 2-layer board, so the inner layers were left out while the reply said success. A count its CAM jobs don't cover is refused (`unsupported_layer_count`).++New `fusion_change_vias` (#145): drill and diameter of existing vias, by position or by a filter, with only the Vias layer displayed while picking, read back, undone on a mismatch.++A failed `fusion_apply_silkscreen` batch is really undone, free texts included, or says it isn't (#144). The undo stopped when the parts' names matched, which left the new texts on the board.++The "driving Fusion" panel comes down when the verb answers (#143). A second message while it was up stopped it ever closing.++A document with no visible tab no longer shifts the tab a board read switches to (#141). The read-back after an EAGLE import waits for the board to load (#139). The Select Library picker names a cloud copy as well as a file (#140).+ ## 1.13.70 (2026-11-04)  `fusion_build_library_3d` re-exports faster: a part already minted on this machine and account, with the same model, footprint, placement and destination, reuses its 3D package when its cloud file still exists, so only new or changed parts mint. Parts say `reused: true`; the reply has `partsReused` and `partsMinted`, and `freshMint: true` makes them again. A deleted cloud file falls back to a fresh mint. The last `_3d` scratch document is closed once the library is open (`scratchClosedAfterOpen`).

@@ -73,6 +73,7 @@     "fusion_cancel_run",     "fusion_capture_library_views",     "fusion_change_pours",+    "fusion_change_vias",     "fusion_check_clearance",     "fusion_check_dialogs",     "fusion_check_orientation",

@@ -681,7 +681,10 @@ _T = [     ("fusion_place_parts", "Footprints from a .lbr onto a board with no schematic (the standard's place_parts), with position, rotation and side, read back. A board linked to a schematic is refused: Fusion takes its parts from the sheet (fusion_sch_place_part, then fusion_move_parts).",      {"parts":"[{library, footprint, ref?, value?, x, y, rotation?, side?}] mm (required)","dryRun":"bool","expectDocument":"the board","expectedRevision":"optional"},      {"results":"[ok|err:...]","placed":"[{ref, x, y, rotation, side}]","revision":"str"},120,"fusion_routing_state",False,{"parts":[{"library":"C:/lib/parts.lbr","footprint":"R0603","ref":"R1","x":10,"y":10}],"dryRun":True}),-    ("fusion_edit_tracks", "Change given tracks by the id routing_state returns: width, layer, ends (the standard's edit_tracks). Read back: only those tracks may differ, or every change is undone. An end moves only along the track's own line: at an angle Fusion bends the track into two segments, so that is undone and refused (end_move_bends). Change a track's layer and its ends in two calls.",+    ("fusion_change_vias", "Change existing vias, and nothing but vias: drill and diameter, by position or by a filter on what they are now. Only the Vias layer is displayed while they're picked, so a track end or pad at the same point can't be taken instead, and the board's layer display goes back after. Read back: only the asked vias may differ, or every change is undone.",+     {"vias":"[{x, y, drill?, diameter?}] mm: the vias at these points","filter":"{drill?, diameter?, net?}: every via matching, with set","set":"{drill?, diameter?} mm","dryRun":"bool","expectDocument":"the board","expectedRevision":"optional","boardId":"optional"},+     {"results":"[ok|err:...]","changes":"[{id, before, after}]","verified":"bool","revision":"str"},120,"fusion_routing_state",False,{}),+    ("fusion_edit_tracks", "Change given tracks by the id routing_state returns: width, layer, ends (the standard's edit_tracks). Read back: only those tracks may differ, or every change is undone. An end moved at an angle draws the track again and deletes the old one, as Fusion's MOVE would bend it into two segments. Change a track's layer and its ends in two calls.",      {"tracks":"[{id, width?, layer?, start?, end?}] mm (required)","dryRun":"bool","expectDocument":"the board","expectedRevision":"optional"},      {"results":"[ok|err:...]","changes":"[{id, before, after}]","verified":"bool","revision":"str"},120,"fusion_routing_state",False,{}),     ("fusion_model_check", "Per part, is there a 3D model and does its cloud file open for this account (the standard's model_check), for a board or a .lbr footprint. Fusion can't say whether one holds geometry without opening it, so hasGeometry is null. Read only.",

@@ -322,6 +322,9 @@ pub fn pass_through(cmd: &str, args: &Value, ctx: &Ctx) -> Value {     if matches!(cmd, "open_board" | "open_schematic") {         return crate::orchestrations::open_file_guarded(ctx, cmd, args, &|v: &str, a: Value| pass_through_checked(v, &a, ctx));     }+    if cmd == "export_gerbers" && !matches!(args["layers"].as_str(), Some("2") | Some("4")) {+        return export_gerbers_counted(args, ctx);+    }     if cmd == "run_modeling_script" {         let watch = crate::small_verbs::watch_for_open_notice(&ctx.caller, &ctx.pids);         return crate::small_verbs::finish_notice_watch(watch, pass_through_checked(cmd, args, ctx));@@ -329,6 +332,34 @@ pub fn pass_through(cmd: &str, args: &Value, ctx: &Ctx) -> Value {     pass_through_checked(cmd, args, ctx) } +/// Gerbers for as many copper layers as the board has. The add-in's detection counts layers carrying traces, so inner+/// planes that are only pours read as a 2-layer board, and the export dropped them and said success (#142). The board's+/// own stack says how many it has. When it can't be read, the add-in's detection still runs, and the reply says so.+fn export_gerbers_counted(args: &Value, ctx: &Ctx) -> Value {+    let pass = |v: &str, a: Value| pass_through_checked(v, &a, ctx);+    let doc = pass("get_app_state", json!({}))["data"]["activeDocument"].clone();+    let layers = crate::routing::call("copper_layers", &json!({"expectDocument": doc}), &pass);+    let count = gerber_layer_count(&layers);+    let mut a = args.clone();+    if !a.is_object() { a = json!({}); }+    match count {+        Some(n @ (2 | 4)) => { a["layers"] = json!(n.to_string()); }+        Some(n) => return json!({"success": false, "errorCode": "unsupported_layer_count", "layerCount": n, "layerSource": "board",+            "error": format!("This board has {n} copper layers and the bridge's Gerber jobs cover 2 and 4, so nothing was exported rather than leave layers out."),+            "_hint": "Export the rest with fusion_export_manufacturing, or Fusion's own CAM processor."}),+        None => {}+    }+    let mut r = pass_through_checked("export_gerbers", &a, ctx);+    if r.is_object() { r["layerSource"] = json!(if count.is_some() { "board" } else { "addin_detection" }); }+    if let (Some(n), Some(d)) = (count, r["data"].as_object_mut()) { d.insert("detectionMethod".into(), json!("board_stack")); d.insert("boardCopperLayers".into(), json!(n)); }+    r+}++fn gerber_layer_count(layers: &Value) -> Option<usize> {+    if layers["success"].as_bool() == Some(false) { return None; }+    layers["copperLayers"].as_array().or(layers["layers"].as_array()).map(|a| a.len()).filter(|n| *n >= 2)+}+ fn pass_through_checked(cmd: &str, args: &Value, ctx: &Ctx) -> Value {     let r = pass_through_inner(cmd, args, ctx);     // Fusion 2706 dropped the Electron.boardInfo text command (live 2026-10-28): the same answer@@ -368,7 +399,14 @@ pub fn cpl_from_board_info(args: &Value, bi: &Value) -> Value { }  fn pass_through_inner(cmd: &str, args: &Value, ctx: &Ctx) -> Value {-    if let Some((title, detail)) = crate::palette::for_verb(cmd, args) { crate::palette::say(&title, &detail, None, crate::palette::eta_for_verb(&ctx.state_dir, cmd)); }+    let spoke = crate::palette::for_verb(cmd, args);+    if let Some((title, detail)) = &spoke { crate::palette::say(title, detail, None, crate::palette::eta_for_verb(&ctx.state_dir, cmd)); }+    let r = pass_through_verb(cmd, args, ctx);+    if spoke.is_some() { crate::palette::verb_finished(); }+    r+}++fn pass_through_verb(cmd: &str, args: &Value, ctx: &Ctx) -> Value {     let sidecar = ctx.sidecar;     let dialogs = ctx.dialogs;     let t0 = Instant::now();@@ -469,6 +507,18 @@ pub fn long_command_active() -> Option<Value> {     LONG_COMMAND.lock().unwrap().clone().map(|(c, at)| json!({"command": c, "startedAt": now_f() - at.elapsed().as_secs_f64()})) } +#[cfg(test)]+mod gerber_tests {+    use super::gerber_layer_count;+    use serde_json::json;+    #[test] fn the_count_comes_from_the_boards_stack() {+        assert_eq!(gerber_layer_count(&json!({"success": true, "copperLayers": ["F.Cu", "In1.Cu", "In2.Cu", "B.Cu"]})), Some(4));+        assert_eq!(gerber_layer_count(&json!({"layers": [{}, {}]})), Some(2));+        assert_eq!(gerber_layer_count(&json!({"success": false, "copperLayers": ["F.Cu", "B.Cu"]})), None);+        assert_eq!(gerber_layer_count(&json!({})), None);+    }+}+ #[cfg(test)] mod tests {     use super::*;

@@ -5,6 +5,12 @@ KIND = {'EcadDesignProductType': 'project', 'SchematicProductType': 'schematic',         'DesignProductType': 'model', 'ElectronLibraryProductType': 'library', 'ElectronicsLibraryProductType': 'library'}  +def _tab_number(app, i):+    """The tab of the document at index i in app.documents. A document with no visible tab (opened by a script+    with visible=False) has no place in the tab bar, so every index after it was off by one (#141)."""+    return sum(1 for k in range(min(int(i), app.documents.count)) if app.documents.item(k).isVisible)++ def _pt(d):     try:         return d.products.item(0).productType if d.products.count else ''@@ -134,7 +140,7 @@ def render_board_3d(app, args):     docs = [app.documents.item(k) for k in range(app.documents.count)]     front = docs.index(app.activeDocument) if app.activeDocument in docs else None     try:-        app.executeTextCommand('UI.SwitchToTab %d' % i)+        app.executeTextCommand('UI.SwitchToTab %d' % _tab_number(app, i))         vp = app.activeViewport         cam = vp.camera         cam.viewOrientation = getattr(adsk.core.ViewOrientations, SIDES[side])@@ -233,7 +239,7 @@ def render_board_3d(app, args):             ok = vp.saveAsImageFileWithOptions(opts)     finally:         if front is not None and front != i:-            app.executeTextCommand('UI.SwitchToTab %d' % front)+            app.executeTextCommand('UI.SwitchToTab %d' % _tab_number(app, front))     if not ok or not os.path.exists(out):         return {'success': False, 'errorCode': 'render_failed', 'error': 'Fusion did not write %s' % out}     return {'success': True, 'path': out, 'side': side, 'width': w, 'height': h, 'format': fmt, 'design': doc.name,@@ -286,7 +292,7 @@ def handle(app, args, action):         docs = [app.documents.item(i) for i in range(app.documents.count)]         return {'success': True, 'index': docs.index(app.activeDocument) if app.activeDocument in docs else None}     if action == 'switch_tab':-        app.executeTextCommand('UI.SwitchToTab %d' % int(args['index']))+        app.executeTextCommand('UI.SwitchToTab %d' % _tab_number(app, int(args['index'])))         return {'success': True}     if action == 'render_board_3d':         return render_board_3d(app, args)

@@ -681,6 +681,25 @@ pub fn board_file_problems(text: &str) -> Vec<String> {     out } +/// The parts on a just-imported board. Fusion answers before the board view has loaded, with no parts or some of+/// them, so a read straight after the import called a good board nothing_instantiated (#139). It's read again until+/// every part is there, or the count has held still, about 30 s at most.+fn read_placed_parts(expected: usize, read: &dyn Fn() -> Value, wait: &dyn Fn()) -> (usize, Vec<Value>) {+    let mut last = None;+    let (mut placed, mut names) = (0, vec![]);+    for _ in 0..10 {+        let bi = read();+        let d = if bi["data"].is_object() { bi["data"].clone() } else { bi.clone() };+        let sm = if d["summary"].is_object() { d["summary"].clone() } else { d.clone() };+        placed = sm["componentCount"].as_u64().map(|n| n as usize).or_else(|| sm["components"].as_array().map(|a| a.len())).unwrap_or(0);+        names = sm["components"].as_array().cloned().unwrap_or_default().iter().take(40).map(|c| c["name"].clone()).collect();+        if placed >= expected || (placed > 0 && last == Some(placed)) { break; }+        last = Some(placed);+        wait();+    }+    (placed, names)+}+ /// fusion_open_board and fusion_open_schematic: a file Fusion would refuse never reaches it, and one it /// refuses anyway is answered as that, not as a hung call or a success with an empty design. pub fn open_file_guarded(ctx: &Ctx, cmd: &str, args: &Value, run: &dyn Fn(&str, Value) -> Value) -> Value {@@ -1625,11 +1644,7 @@ pub fn new_electronics_from_eagle(ctx: &Ctx, args: &Value, pass: &dyn Fn(&str, V     let expected = std::fs::read_to_string(&brd).map(|t| t.matches("<element ").count()).unwrap_or(0);     let (mut placed, mut placed_names): (usize, Vec<Value>) = (0, vec![]);     if ready {-        let bi = pass("board_info", json!({}));-        let d = if bi["data"].is_object() { bi["data"].clone() } else { bi.clone() };-        let sm = if d["summary"].is_object() { d["summary"].clone() } else { d.clone() };-        placed = sm["componentCount"].as_u64().map(|n| n as usize).or_else(|| sm["components"].as_array().map(|a| a.len())).unwrap_or(0);-        placed_names = sm["components"].as_array().cloned().unwrap_or_default().iter().take(40).map(|c| c["name"].clone()).collect();+        (placed, placed_names) = read_placed_parts(expected, &|| pass("board_info", json!({})), &|| std::thread::sleep(Duration::from_secs(3)));     }     let instantiated = expected == 0 || placed > 0;     if let Some(rid) = args["_runId"].as_str() {@@ -1774,6 +1789,21 @@ mod eagle_wait_tests {     } } +#[cfg(test)] mod placed_parts_tests {+    use super::read_placed_parts;+    use serde_json::json;+    fn run(answers: Vec<usize>, expected: usize) -> (usize, usize) {+        let i = std::cell::Cell::new(0);+        let (placed, _) = read_placed_parts(expected, &|| { let n = answers[i.get().min(answers.len() - 1)]; i.set(i.get() + 1); json!({"data": {"summary": {"componentCount": n}}}) }, &|| {});+        (placed, i.get())+    }+    #[test] fn a_board_still_loading_is_read_again() { assert_eq!(run(vec![0, 0, 5], 5), (5, 3)); }+    #[test] fn all_there_answers_at_once() { assert_eq!(run(vec![5], 5), (5, 1)); }+    #[test] fn a_count_that_holds_still_is_the_answer() { assert_eq!(run(vec![0, 3, 3, 5], 5), (3, 3)); }+    #[test] fn nothing_is_given_up_on_in_the_end() { assert_eq!(run(vec![0], 5), (0, 10)); }+    #[test] fn an_empty_board_expects_nothing() { assert_eq!(run(vec![0], 0), (0, 1)); }+}+ #[cfg(test)] mod board_file_tests {     use super::board_file_problems;     const GOOD: &str = r#"<eagle><drawing><board><libraries><library name="L"><packages><package name="R0603"/></packages></library></libraries><elements><element name="R1" library="L" package="r0603"/></elements><signals><signal name="N"><contactref element="R1" pad="1"/></signal></signals></board></drawing></eagle>"#;

@@ -20,6 +20,7 @@ static HIDE: AtomicBool = AtomicBool::new(false); /// repainted in place, so no per-beat creation cost (the add-in retries delivery 3 s on creation). static HOLD: AtomicBool = AtomicBool::new(false); static SEQ: AtomicU64 = AtomicU64::new(0);+static FINISHED_SEQ: AtomicU64 = AtomicU64::new(0); static PAINTED_SEQ: AtomicU64 = AtomicU64::new(0); static LAST: Mutex<Option<(String, String, Option<f64>, Option<f64>, u64)>> = Mutex::new(None); /// What the worker last did, for fusion_interactive: (action, title, success, error, seconds ago).@@ -51,8 +52,12 @@ fn worker() {             } else { std::thread::sleep(Duration::from_secs(2)); }             continue;         }-        if !shown && PAINTED_SEQ.load(Ordering::Relaxed) > painted_seq { shown = true; painted_seq = PAINTED_SEQ.load(Ordering::Relaxed); painted_at = Instant::now(); }-        if shown && !HOLD.load(Ordering::Relaxed) && painted_at.elapsed() > Duration::from_secs(25) && SEQ.load(Ordering::Relaxed) == painted_seq && !run_in_flight() {+        // every paint counts, also one made while the panel was already up: with `!shown &&` here, a second message+        // left painted_seq behind for good, so the test below could never pass and the panel stayed up forever (#143)+        if PAINTED_SEQ.load(Ordering::Relaxed) > painted_seq { shown = true; painted_seq = PAINTED_SEQ.load(Ordering::Relaxed); painted_at = Instant::now(); }+        let finished = FINISHED_SEQ.load(Ordering::Relaxed) == painted_seq;+        let idle_for = if finished { Duration::from_secs(3) } else { Duration::from_secs(25) };+        if shown && !HOLD.load(Ordering::Relaxed) && painted_at.elapsed() > idle_for && SEQ.load(Ordering::Relaxed) == painted_seq && !run_in_flight() {             if send("hide", "", "", None, None)["success"].as_bool() == Some(true) { shown = false; *LAST.lock().unwrap() = None; }             else { painted_at = Instant::now(); }         }@@ -72,6 +77,10 @@ pub fn say(title: &str, detail: &str, percent: Option<f64>, eta: Option<f64>) {     *LAST_RESULT.lock().unwrap() = Some(("show".into(), title.to_string(), r["success"].as_bool() == Some(true), r["error"].as_str().unwrap_or("").chars().take(120).collect(), Instant::now()));     if r["success"].as_bool() == Some(true) { PAINTED_SEQ.store(seq, Ordering::Relaxed); } else { DIRTY.store(true, Ordering::Relaxed); } }+/// The verb that last spoke has answered: nothing is running behind that message any more, so the panel comes down in+/// moments rather than after the idle wait. A newer message or a run in flight keeps it up.+pub fn verb_finished() { FINISHED_SEQ.store(SEQ.load(Ordering::Relaxed), Ordering::Relaxed); }+ /// Keep the palette up between messages (a tour in flight) or let the idle timer take it down. pub fn hold(on: bool) { HOLD.store(on, Ordering::Relaxed); } 

@@ -3,7 +3,7 @@ use serde_json::{json, Value}; const SOURCE: &str = concat!(include_str!("routing_script.py"), "\n", include_str!("routing_planner.py"), "\n", include_str!("board_model.py"), "\n", include_str!("lbr_use.py"),     "\nFUSION_DEFAULT_RULES = r'''", include_str!("fusion_default_designrules.xml"), "'''\n");-pub fn owns(cmd: &str) -> bool { matches!(cmd, "edit_tracks" | "place_parts" | "routing_state" | "route_net" | "routing_drc" | "move_parts" | "place_vias" | "apply_pours" | "pour_state" | "board_source" | "ripup_nets" | "schematic_run" | "board_bom" | "change_pours" | "schematic_plan" | "board_seed" | "remove_pours" | "layer_stack" | "netlist" | "bodies" | "component_data" | "component_pins" | "list_nets" | "net_connections" | "list_designators" | "layers" | "copper_layers" | "layers_in_use" | "read_rules" | "rules_by_kind" | "silk_state" | "net_classes" | "diff_pairs" | "run_drc" | "repour" | "zoom_to" | "export_bom" | "save_document" | "save_to_cloud" | "apply_silkscreen" | "set_layer_visibility" | "select_net" | "set_track_width" | "remove_items" | "set_outline" | "board_shape" | "board_outline" | "run_erc" | "autoroute" | "update_board_from_eagle" | "board_dxf" | "edit_parts" | "align_parts" | "remove_graphics" | "remove_parts" | "check_inputs" | "export_odb" | "export_ipc356" | "export_gencad" | "export_ipc2581" | "import_svg" | "copy_routing" | "set_layer_count" | "board_info_compat" | "footprint_primitives" | "place_planned_vias" | "place_teardrops" | "board_features" | "add_rule" | "read_board") }+pub fn owns(cmd: &str) -> bool { matches!(cmd, "change_vias" | "edit_tracks" | "place_parts" | "routing_state" | "route_net" | "routing_drc" | "move_parts" | "place_vias" | "apply_pours" | "pour_state" | "board_source" | "ripup_nets" | "schematic_run" | "board_bom" | "change_pours" | "schematic_plan" | "board_seed" | "remove_pours" | "layer_stack" | "netlist" | "bodies" | "component_data" | "component_pins" | "list_nets" | "net_connections" | "list_designators" | "layers" | "copper_layers" | "layers_in_use" | "read_rules" | "rules_by_kind" | "silk_state" | "net_classes" | "diff_pairs" | "run_drc" | "repour" | "zoom_to" | "export_bom" | "save_document" | "save_to_cloud" | "apply_silkscreen" | "set_layer_visibility" | "select_net" | "set_track_width" | "remove_items" | "set_outline" | "board_shape" | "board_outline" | "run_erc" | "autoroute" | "update_board_from_eagle" | "board_dxf" | "edit_parts" | "align_parts" | "remove_graphics" | "remove_parts" | "check_inputs" | "export_odb" | "export_ipc356" | "export_gencad" | "export_ipc2581" | "import_svg" | "copy_routing" | "set_layer_count" | "board_info_compat" | "footprint_primitives" | "place_planned_vias" | "place_teardrops" | "board_features" | "add_rule" | "read_board") } /// How many schematic commands one call into Fusion runs. Fusion's main thread is held for the whole /// call, so a long list goes in batches, which lets it answer between them (#137). const SCH_BATCH: usize = 300;@@ -155,7 +155,7 @@ fn call_one(cmd: &str, args: &Value, pass: &dyn Fn(&str, Value) -> Value) -> Val             }             out         }-        None => json!({"success":false,"errorCode":"invalid_routing_response","error":"Fusion did not return a structured routing result", "mutationMayHaveOccurred":matches!(cmd, "route_net" | "move_parts" | "place_vias" | "apply_pours" | "apply_silkscreen" | "set_track_width" | "remove_items" | "set_outline" | "board_shape" | "autoroute" | "update_board_from_eagle" | "edit_parts" | "align_parts" | "remove_graphics" | "remove_parts" | "import_svg" | "copy_routing" | "set_layer_count" | "place_planned_vias" | "place_teardrops" | "board_features" | "add_rule")}),+        None => json!({"success":false,"errorCode":"invalid_routing_response","error":"Fusion did not return a structured routing result", "mutationMayHaveOccurred":matches!(cmd, "change_vias" | "route_net" | "move_parts" | "place_vias" | "apply_pours" | "apply_silkscreen" | "set_track_width" | "remove_items" | "set_outline" | "board_shape" | "autoroute" | "update_board_from_eagle" | "edit_parts" | "align_parts" | "remove_graphics" | "remove_parts" | "import_svg" | "copy_routing" | "set_layer_count" | "place_planned_vias" | "place_teardrops" | "board_features" | "add_rule")}),     } } 

@@ -27,6 +27,12 @@ class SaveError(Exception):         self.code, self.extra = code, extra  +def _tab_number(app, i):+    """The tab of the document at index i in app.documents. A document with no visible tab (opened by a script+    with visible=False) has no place in the tab bar, so every index after it was off by one (#141)."""+    return sum(1 for k in range(min(int(i), app.documents.count)) if app.documents.item(k).isVisible)++ def sd_pt(d):     try:         return d.products.item(0).productType if d.products.count else ''@@ -91,7 +97,7 @@ def sd_activate(app, d):     if i is None:         d.activate()     else:-        app.executeTextCommand('UI.SwitchToTab %d' % i)+        app.executeTextCommand('UI.SwitchToTab %d' % _tab_number(app, i))   def sd_anchor(app, name):

@@ -470,7 +470,8 @@ pub fn watch_for_library_picker(caller: &fusion_core::ab::Caller, fusion_pids: &  /// The files the picker lists: each row reads "name (path)". pub fn library_picker_paths(body: &str) -> Vec<String> {-    let mut out: Vec<String> = regex::Regex::new(r"\(([^()]+\.lbr)\)").unwrap().captures_iter(body).map(|c| c[1].to_string()).collect();+    // a file row names its .lbr, a cloud copy's row its place in the hub: either has a path separator or a colon+    let mut out: Vec<String> = regex::Regex::new(r"\(([^()]*[/\\:][^()]*)\)").unwrap().captures_iter(body).map(|c| c[1].to_string()).collect();     out.dedup();     out }@@ -485,7 +486,7 @@ pub fn finish_picker_watch(watch: Option<PickerWatch>, mut r: Value) -> Value {     r["errorCode"] = json!("library_name_in_use");     r["librariesInUse"] = json!(paths);     r["pickerClosed"] = found["closed"].clone();-    r["error"] = json!(format!("Fusion has two libraries with one name in use ({}) and opened its Select Library picker. The bridge closed it, and that part didn't land.{}", paths.join(" and "), if found["closed"] == true { "" } else { " The picker did not close, so Fusion is still blocked." }));+    r["error"] = json!(format!("Fusion has two libraries with one name in use{} and opened its Select Library picker. The bridge closed it, and that part didn't land.{}", if paths.is_empty() { String::new() } else { format!(" ({})", paths.join(" and ")) }, if found["closed"] == true { "" } else { " The picker did not close, so Fusion is still blocked." }));     r["_hint"] = json!("Give this file another name, or take the other file away and restart Fusion (fusion_restart_for_addin). A restart alone doesn't clear it: Fusion keeps its in-use list until the file is gone.");     r }@@ -798,6 +799,11 @@ mod image_delivery_tests {         let body = "System There are multiple libraries named lane!\nPick one. lane (C:/a/lane.lbr) lane (C:/b/lane.lbr)";         assert_eq!(library_picker_paths(body), vec!["C:/a/lane.lbr".to_string(), "C:/b/lane.lbr".to_string()]);     }+    #[test] fn a_cloud_copys_row_counts_and_plain_words_dont() {+        assert_eq!(library_picker_paths("Pick one. TI772 (C:/x/TI772.lbr) TI772 (urn:adsk.wipprod:dm.lineage:AB) (not this)"), vec!["C:/x/TI772.lbr".to_string(), "urn:adsk.wipprod:dm.lineage:AB".to_string()]);+        let r = finish_picker_watch(watch(Some(json!({"paths": [], "closed": true}))), json!({"success": false}));+        assert!(!r["error"].as_str().unwrap().contains("()"));+    }     #[test] fn a_picker_turns_the_reply_into_the_reason() {         let r = finish_picker_watch(watch(Some(json!({"paths": ["C:/a/l.lbr", "C:/b/l.lbr"], "closed": true}))), json!({"success": false, "errorCode": "fusion_assert", "commands": 3}));         assert_eq!(r["errorCode"], "library_name_in_use");

@@ -292,7 +292,8 @@ t("fusion_project_info", "daily", dict(B), {"ok": True, "fields": ["files", "boa t("fusion_schematic_data", "daily", dict(B, designator="C11", params=True), {"ok": True, "fields": ["components", "count"]}) t("fusion_part_parameters", "daily", dict(B), {"ok": True, "fields": ["names"]}) t("fusion_cross_check", "daily", dict(B), {"ok": True, "fields": ["matched", "onSheetNotOnBoard", "onBoardNotOnSheet"]})-for v in ("fusion_sch_label", "fusion_sch_wire", "fusion_edit_tracks", "fusion_place_parts"):+t("fusion_change_vias#guard", "negative", {"expectDocument": "ZZZ_NoSuchDoc_TEST", "filter": {"drill": 0.2}, "set": {"drill": 0.3}}, {"pred": "must_refuse"}, "same guards as the other edits")+for v in ("fusion_sch_label", "fusion_sch_wire", "fusion_edit_tracks", "fusion_place_parts", "fusion_change_vias"):     t(v, "manual", note="edits a design: run live by tests/sch_drill.py (place_parts and a track's end on a board with no schematic by hand)") t("fusion_model_check", "daily", dict(B), {"ok": True, "fields": ["parts", "checked", "ok"]}, "does each part's cloud 3D model open, read only") t("fusion_extensions", "daily", {}, {"ok": True, "fields": ["extensions", "count"]}, "the add-ins installed for this user")