Fusion - the Fusion 360 Bridge

@@ -3157,7 +3157,24 @@ def _orchestrate_open_lbr(args: dict) -> dict:     import tempfile     import time -    file_path = args.get("filePath", "")+    # ACCEPT EVERY NAME A CALLER COULD REASONABLY USE (page issue #61, 2026-08-26).+    # This read ONLY "filePath" while docs/electronics-libraries.md and the sibling verb+    # fusion_build_library_3d both use "lbrPath". A caller passed lbrPath, we silently saw+    # an empty string, and then blamed THEIR file ("file-readable: [WinError 3] ... path+    # specified: <empty>"), sending them to re-stage a perfectly good 7682-byte library.+    # A caller should never have to guess our parameter spelling, and an empty path must+    # never be reported as a bad file.+    file_path = (args.get("filePath") or args.get("lbrPath") or args.get("libraryPath")+                 or args.get("path") or "")+    if not str(file_path).strip():+        return {"success": False, "errorCode": "no_path_argument",+                "error": "No library path was given, so nothing was opened. This verb "+                         "accepts filePath, lbrPath, libraryPath or path - the file itself "+                         "was never examined, so do NOT re-stage it.",+                "acceptedArgs": ["filePath", "lbrPath", "libraryPath", "path"],+                "receivedArgs": sorted(args.keys()),+                "_hint": "Re-call with a Windows-local path, e.g. fusion_open_lbr "+                         "{\"lbrPath\": \"C:/tmp/rayparts/tja1050.lbr\"}."}     # ⛔ 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@@ -3909,6 +3926,24 @@ def _orchestrate_make_3d_package(args: dict) -> dict:     }  +_BUILD_IN_FLIGHT = {}          # lbrPath -> epoch started; page issue #62+++def _build_in_flight():+    """Paths whose async 3D build is still running (page issue #62, 2026-08-26).++    fusion_build_library_3d returns status:"started" and keeps working in a daemon thread.+    Nothing recorded that, so fusion_capture_library_views had no way to know a build was+    holding the 3D-package editor on screen - it captured that editor for every view and+    marked one ok:true with no chip in the frame. Evidence produced during a build is not+    evidence, so the capture path needs to be able to SEE the build.+    """+    import time as _t+    now = _t.time()+    # A build that has run absurdly long is treated as finished rather than blocking+    # captures forever - a stuck marker must not become a permanent refusal.+    return {k: v for k, v in _BUILD_IN_FLIGHT.items() if now - v < 3600}+ def _orchestrate_build_library_3d(args: dict) -> dict:     """Bind real 3D onto a multi-part library. Runs DETACHED by default (async=True) so it     SURVIVES AD's 60s relay cap.@@ -3930,11 +3965,18 @@ def _orchestrate_build_library_3d(args: dict) -> dict:     if args.get("async", True) and args.get("parts"):         import threading as _th +        import time as _tt+        _BUILD_IN_FLIGHT[out_path] = _tt.time()+         def _run():             try:                 _build_library_3d_core(args)             except Exception:                 pass+            finally:+                # ALWAYS clear, even on failure: a marker that outlives its build would+                # refuse every later capture (page issue #62).+                _BUILD_IN_FLIGHT.pop(out_path, None)         _th.Thread(target=_run, daemon=True).start()         return {             "success": True, "status": "started", "async": True,@@ -4217,6 +4259,27 @@ def _orchestrate_capture_library_views(args: dict) -> dict:     # who did not do anything, and dismissal is a RACE we lose whenever Fusion is slow.     # The .lbr on disk already knows every symbol/package/deviceset name, so a name that     # would prompt is knowable in milliseconds without Fusion. Resolve here; never ask.+    # REFUSE TO MANUFACTURE EVIDENCE DURING A BUILD (page issue #62, 2026-08-26).+    # fusion_build_library_3d is async; while it runs it holds the 3D-package editor on+    # screen, so EDIT <name>.sym/.pac land on that editor and every capture shows the part+    # being built rather than the view it is labelled with. One came back ok:true with no+    # chip in the frame. A false pass is worse than a refusal: it is evidence that lies.+    _flight = _build_in_flight()+    if _flight and not args.get("ignoreBuildInProgress"):+        import time as _ft+        return {"success": False, "errorCode": "build_in_progress",+                "error": "A 3D build is still running for %s - refusing to capture, because "+                         "the build holds the 3D-package editor on screen and every view "+                         "would show that editor instead of the view it is labelled with."+                         % ", ".join(sorted(_flight)),+                "buildsInFlight": [{"lbrPath": k, "runningSec": int(_ft.time() - v)}+                                   for k, v in sorted(_flight.items())],+                "_hint": "Wait for the build to finish, then re-capture - the same call "+                         "returns correct content once it is done. Detect completion by "+                         "polling fusion_get_app_state until the <part>_3d document reports "+                         "isSaved:true, or read the bound .lbr until it has one <package3d "+                         "wip_urn=...> per part. Pass ignoreBuildInProgress:true only if you "+                         "genuinely want a mid-build frame."}     lbr_path = (args.get("libraryPath") or "").replace("\\", "/") or _remembered_open_library()     resolved_names = {}     name_errors = []@@ -4271,9 +4334,31 @@ def _orchestrate_capture_library_views(args: dict) -> dict:             _proxy_to_addin("electron_run", {"command": "WINDOW FIT"}, timeout=20)             _t.sleep(0.6)             shot = _capture_labeled(f"{pkg}_{label_of.get(ext, ext)}")-            out.append({"package": pkg, "view": label_of.get(ext, ext), "path": shot,-                        "dialogDismissed": dismissed or None,-                        "ok": bool(er.get("success", True)) and bool(shot) and not dismissed})+            # ok MUST MEAN "the frame shows the view it is labelled with", not "a file was+            # written" (page issue #62). The reported failure captured the 3D-package+            # editor for every view and still marked one ok:true. We cannot read the pixels+            # from here, but we CAN ask Fusion which editor was actually on screen at+            # capture time, which is exactly what went wrong - so a frame taken outside the+            # Electronics Library editor is never reported as a pass.+            editor_ws, editor_ok = None, True+            try:+                _st = _proxy_to_addin("get_app_state", {}, timeout=15) or {}+                editor_ws = _st.get("activeWorkspace")+                if editor_ws and "electronics library" not in str(editor_ws).lower():+                    editor_ok = False+            except Exception:+                editor_ws = None          # unknown, not a pass and not a failure+            entry = {"package": pkg, "view": label_of.get(ext, ext), "path": shot,+                     "dialogDismissed": dismissed or None,+                     "capturedInWorkspace": editor_ws,+                     "ok": (bool(er.get("success", True)) and bool(shot)+                            and not dismissed and editor_ok)}+            if not editor_ok:+                entry["errorCode"] = "wrong_editor_captured"+                entry["error"] = ("Captured while %r was active, not the Electronics Library "+                                  "editor - the frame does not show the %s view it is "+                                  "labelled with." % (editor_ws, label_of.get(ext, ext)))+            out.append(entry)     n_ok = sum(1 for o in out if o.get("ok"))     return {         "success": n_ok > 0,