Fusion - the Fusion 360 Bridge

@@ -3000,6 +3000,34 @@ def _orchestrate_open_lbr(args: dict) -> dict:     import time      file_path = args.get("filePath", "")+    # ⛔ PARSE BEFORE FUSION EVER SEES IT (John caught the dialog live, 2026-08-21): a+    # 77-byte garbage .lbr staged by a caller sailed straight into Fusion, which raised+    # its blocking "has errors and cannot be opened" Error modal ON EVERY RETRY and left+    # an empty Untitled design behind each time. The file's validity is knowable offline+    # in milliseconds - an unparseable library must NEVER reach Fusion's parser.+    try:+        _pf = file_path.replace("\\", "/")+        if _pf and os.path.exists(_pf):+            import xml.etree.ElementTree as _ETpre+            _rootpre = _ETpre.parse(_pf).getroot()+            if _rootpre.tag != "eagle":+                raise ValueError("root element is <%s>, not <eagle>" % _rootpre.tag)+    except Exception as _epre:+        try:+            _sz = os.path.getsize(_pf)+            _head = open(_pf, "rb").read(48)+        except Exception:+            _sz, _head = None, b""+        return {"success": False, "errorCode": "lbr_invalid",+                "error": "%s is not a parseable EAGLE library (%s) - refusing to hand it to "+                         "Fusion, whose only response is a blocking Error modal plus an "+                         "orphaned empty design." % (file_path, str(_epre)[:120]),+                "fileSize": _sz,+                "fileHead": repr(_head[:32]),+                "_hint": ("The file on THIS box is bad (size %s bytes). Re-stage it from the "+                          "source and compare sizes/hashes - a transfer that truncates or "+                          "re-encodes is the usual culprit. Nothing was opened and no dialog "+                          "was raised." % _sz)}     # PRE-CLOSE a stale dirty copy of this same library (deterministic-close rule): opening     # over an unsaved same-name document is how duplicate docs piled up (15 at peak) and how     # later closes rained Save-As prompts. If a dirty copy is open, resolve it NOW - it is@@ -7040,7 +7068,19 @@ def _resolve_artifact_name(name: str, suffix: str, lbr_path: str):     """     have = _library_artifact_names(lbr_path).get(suffix if suffix in ("sym", "pac", "dev") else "", [])     if not have:-        return name, None                      # cannot read the library -> do not block the call+        # REFUSE, do not wave it through (reversed 2026-08-21, John caught the prompt+        # live): "cannot read the library -> do not block" meant a corrupt .lbr let the+        # EDIT reach Fusion, which popped "Create new footprint 'X'?" - the exact modal+        # this resolver exists to prevent. An unreadable or artifact-less library makes+        # the prompt CERTAIN, so certainty of a prompt is exactly when to block.+        return None, {+            "success": False, "errorCode": "library_unreadable",+            "error": "Cannot read any %s names from %s - the library is unparseable or "+                     "empty, so EDIT was NOT issued (it would certainly raise Fusion's "+                     "Create-new prompt)." % (suffix, lbr_path),+            "_hint": "Validate the .lbr first (fusion_open_lbr now refuses garbage with "+                     "lbr_invalid + the file size/head). Re-stage the file from its source "+                     "and compare hashes."}     if name in have:         return name, None     ci = [h for h in have if h.lower() == str(name).lower()]@@ -10102,20 +10142,37 @@ def dispatch_command(command: str, args: dict, caller_identity: dict = None) ->                     res["savePromptCleared"] = _sw.get("why")             except Exception:                 pass-            # Same chokepoint, second standing modal (John caught it on screen,-            # 2026-08-21): the Hub "packages are being uploaded... sure you want to-            # close?" confirm. "No" is ALWAYS the work-preserving answer - it cancels-            # the close, loses nothing, and the upload gates added today keep the-            # close from being re-raised until app.hasActiveJobs drains.+            # Same chokepoint, the other standing modals (John caught each on screen,+            # 2026-08-21). All are answered with their work-preserving choice - a raw+            # electron_run EDIT from ANY caller can raise the Create prompt, and no+            # verb-level pre-check reaches those, so the answer lives HERE:+            #   upload_in_progress -> No  (cancels the close; the upload survives)+            #   create_confirm     -> No  (never fabricate an empty artifact)+            #   lbr open Error     -> OK  (dismiss; its orphan Untitled design gets+            #                              closed by the doc janitor)             try:                 for _d in (classify_blocking_dialogs() or []):-                    if _d.get("category") == "upload_in_progress":+                    _cat = _d.get("category")+                    if _cat == "upload_in_progress":                         _unwrap(_ad_call("desktop_ui_click",                                          {"hwnd": _d.get("hwnd"), "name": "No"}, timeout=12))                         if isinstance(res, dict):                             res["uploadCloseDeclined"] = True                         print("[Fusion Bridge] answered the Hub upload-close confirm with "                               "No (work-preserving; close retried after jobs drain)")+                    elif _cat == "create_confirm":+                        _unwrap(_ad_call("desktop_ui_click",+                                         {"hwnd": _d.get("hwnd"), "name": "No"}, timeout=12))+                        if isinstance(res, dict):+                            res["createPromptDeclined"] = True+                        print("[Fusion Bridge] declined a standing Create-new prompt at the "+                              "chokepoint (raised by a raw EDIT; Yes would fabricate an "+                              "empty artifact)")+                    elif _cat in ("launch_error", "lbr_open_error"):+                        _unwrap(_ad_call("desktop_ui_click",+                                         {"hwnd": _d.get("hwnd"), "name": "OK"}, timeout=12))+                        print("[Fusion Bridge] dismissed a standing %s dialog at the "+                              "chokepoint" % _cat)             except Exception:                 pass     except Exception: