Fusion - the Fusion 360 Bridge

@@ -3944,6 +3944,33 @@ def _build_in_flight():     # 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 _publish_run_state(run_id: str, state: dict):+    """Write a run's state to the SAME per-run store fusion_prove_result already reads.++    Colby, PR #58 / page issue #65: the detached fusion_build_library_3d swallowed its+    core result in the background thread, so callers had to grep the bound .lbr for+    wip_urns to find out what happened. Reusing this store means the build becomes+    pollable with NO new verb and NO new poll surface - fusion_prove_result {runId}+    already knows how to read it.+    """+    import tempfile as _tf+    try:+        _PROVE_LAST[0] = dict(state)+        open(os.path.join(_tf.gettempdir(), "fusion-prove-last.json"), "w",+             encoding="utf-8").write(json.dumps(state))+        _p = os.path.join(_tf.gettempdir(), "fusion-prove-runs.json")+        try:+            _runs = json.loads(open(_p, encoding="utf-8").read())+        except Exception:+            _runs = {}+        _runs[run_id] = dict(state)+        while len(_runs) > 20:+            _runs.pop(next(iter(_runs)))+        open(_p, "w", encoding="utf-8").write(json.dumps(_runs))+    except Exception:+        pass++ 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.@@ -3965,21 +3992,41 @@ 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+        import time as _tt, uuid as _uu         _BUILD_IN_FLIGHT[out_path] = _tt.time()+        _parts = args.get("parts") or []+        _run_id = _uu.uuid4().hex[:12]+        _bstate = {"runId": _run_id, "verb": "fusion_build_library_3d",+                   "stage": "starting", "boundLbr": out_path,+                   "partsTotal": len(_parts), "partsDone": 0, "parts": []}+        _publish_run_state(_run_id, _bstate)++        def _on_part(entry, i, total):+            # PER-PART PROGRESS (Colby, PR #58): a 7-part build was a silent 10 minutes.+            _bstate["stage"] = "minting %s (%d/%d)" % (entry.get("package") or "part", i, total)+            _bstate["partsDone"] = i+            _bstate["parts"] = (_bstate.get("parts") or []) + [entry]+            _publish_run_state(_run_id, _bstate)          def _run():             try:-                _build_library_3d_core(args)-            except Exception:-                pass+                _res = _build_library_3d_core(dict(args, _onPart=_on_part)) or {}+                # KEEP THE REPORT. The thread used to swallow it, so callers had to grep+                # the bound .lbr for urns to learn what happened (PR #58).+                _bstate.update(stage="done", success=bool(_res.get("success")),+                               result=_res, partsDone=len(_bstate.get("parts") or []))+            except Exception as _e:+                _bstate.update(stage="failed", success=False,+                               error="%s: %s" % (type(_e).__name__, _e))             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)+                _publish_run_state(_run_id, _bstate)         _th.Thread(target=_run, daemon=True).start()         return {             "success": True, "status": "started", "async": True,+            "runId": _run_id, "statusVerb": "fusion_prove_result",             "boundLbr": out_path, "partsTotal": len(args.get("parts") or []),             "_hint": (                 "⏳ 3D bind runs DETACHED (survives AD's 60s relay cap, which used to kill it + lose "@@ -4014,6 +4061,17 @@ def _build_library_3d_core(args: dict) -> dict:     """     combined = (args.get("lbrPath") or "").replace("\\", "/")     parts = args.get("parts") or []+    # PER-PART PROGRESS CALLBACK (Colby, PR #58). Passed IN-PROCESS by the detached+    # wrapper, never over the relay. A no-op in sync mode, so the sync contract is+    # unchanged - a 7-part build simply stops being a silent ten minutes.+    _cb = args.get("_onPart") if callable(args.get("_onPart")) else None++    def _emit_part(entry, i, total):+        if _cb:+            try:+                _cb(entry, i, total)+            except Exception:+                pass     if not combined or not parts:         return {"success": False,                 "error": "lbrPath (combined .lbr) and parts[] are required.",@@ -4036,6 +4094,7 @@ def _build_library_3d_core(args: dict) -> dict:         if not pkg or not per_lbr or not step:             results.append({"package": pkg, "success": False,                             "error": "package, lbrPath (per-part .lbr) and modelPath (.step) all required"})+            _emit_part(results[-1], len(results), len(parts))             continue         mk_args = {             "lbrPath": per_lbr, "modelPath": step,@@ -4065,6 +4124,7 @@ def _build_library_3d_core(args: dict) -> dict:         if mk.get("after"):             shots.append({"package": pkg, "stage": "after", "path": mk["after"]})         results.append(entry)+        _emit_part(entry, len(results), len(parts))     # inject every binding in ONE pass, write the bound library. Read the ALREADY-BOUND output if it     # exists so a re-run ACCUMULATES (merge-aware) onto prior successes instead of starting clean.     bound = None@@ -12109,7 +12169,13 @@ def _dispatch_command_inner(command: str, args: dict, caller_identity: dict = No                 # show_3d_board machinery which switches the board editor to 3D.         return _handle_open_with_screenshot(fusion_info, args, command)     if command == "open_lbr":-        return _orchestrate_open_lbr(args)+        # DIALOG-GUARDED LIKE EVERY NEIGHBOUR (Colby, PR #58 / page issue #65).+        # This was the ONE dispatch here returning raw while show_symbol,+        # show_footprint, show_3d_package, make_test_project and bind_library_3d all+        # ride _merge_dialog_array. So a malformed .lbr reported SUCCESS: Fusion opens+        # an empty design named like the file and puts the real failure in an OWNED+        # Error popup that a plain response never sees. Same false-pass class as #65.+        return _merge_dialog_array(_orchestrate_open_lbr(args))     if command == "show_symbol":         return _merge_dialog_array(_orchestrate_show_symbol(args))     if command == "show_footprint":