Fusion - the Fusion 360 Bridge

@@ -4631,12 +4631,65 @@ def _banner(action, title="", detail="", percent=None, eta_sec=None, tone="worki     maximised in front of them. It must never slow or fail the work it describes, so it is     short-timeout and swallows every error. Same text the wiki sees.     """-    try:-        _proxy_to_addin("activity_banner",-                        {"action": action, "title": title, "detail": detail,-                         "percent": percent, "etaSec": eta_sec, "tone": tone}, timeout=8)-    except Exception:-        pass+    # OFF THE CHAIN'S THREAD, WITH RETRIES (John, 2026-08-29, watching a ten-part run: "I don't+    # see the palette"). During bind and prove the add-in's main thread is busy almost all the+    # time, so an 8s fire-and-forget call mostly timed out and the palette was never even+    # created. Each call now runs in its own thread and retries with a longer window; the+    # chain never waits on it. _BANNER_STATE remembers the last message so the watchdog+    # (below) can re-assert it every few seconds for as long as a run is in flight.+    import threading as _bth+    if action in ("show", "update"):+        _BANNER_STATE.update(title=title, detail=detail, percent=percent, etaSec=eta_sec,+                             tone=tone, active=True)+    elif action == "hide":+        _BANNER_STATE["active"] = False++    def _send():+        for _to in (8, 20, 30):+            try:+                r = _proxy_to_addin("activity_banner",+                                    {"action": action, "title": title, "detail": detail,+                                     "percent": percent, "etaSec": eta_sec, "tone": tone}, timeout=_to)+                if r.get("success"):+                    return+            except Exception:+                pass+    _bth.Thread(target=_send, daemon=True).start()+++_BANNER_STATE = {"active": False, "title": "", "detail": "", "percent": None, "etaSec": None,+                 "tone": "working", "watchdog": None}+++def _banner_watchdog_start(run_id: str):+    """Re-assert the in-Fusion palette every 10s while a run is in flight.++    A palette can be lost mid-run (a sibling add-in copy's stop() tears it down, a busy main+    thread drops an update); a user looking at Fusion during a 15-minute import must never+    find it missing. The watchdog resends the last state until the run's terminal hide.+    """+    import threading as _bth, time as _bt++    def _loop():+        while _BANNER_STATE.get("watchdog") == run_id:+            if _BANNER_STATE.get("active"):+                try:+                    _proxy_to_addin("activity_banner",+                                    {"action": "update", "title": _BANNER_STATE.get("title"),+                                     "detail": _BANNER_STATE.get("detail"),+                                     "percent": _BANNER_STATE.get("percent"),+                                     "etaSec": _BANNER_STATE.get("etaSec"),+                                     "tone": _BANNER_STATE.get("tone")}, timeout=20)+                except Exception:+                    pass+            _bt.sleep(10)+    _BANNER_STATE["watchdog"] = run_id+    _bth.Thread(target=_loop, daemon=True).start()+++def _banner_watchdog_stop(run_id: str):+    if _BANNER_STATE.get("watchdog") == run_id:+        _BANNER_STATE["watchdog"] = None   def _taskbar_progress(pct=None):@@ -8430,7 +8483,9 @@ def _show_library_view(name, suffix, lbr_path=None):             _tra.sleep(8)             try:                 _lstem = lbr_path.replace("\\", "/").rsplit("/", 1)[-1].rsplit(".", 1)[0].lower()-                if _lstem not in {n.rstrip("*").strip().lower() for n in _open_doc_names()}:+                _ln = _open_doc_names()+                _lb = {re.sub(r"\s*\([^)]*\)\s*$", "", n.replace("*", "")).strip().lower() for n in _ln}+                if _ln and _lstem not in _lb:      # known-closed only; never reopen on "unknown"                     _orchestrate_open_lbr({"filePath": lbr_path})             except Exception:                 pass@@ -11017,10 +11072,25 @@ def _close_docs_opened_since(before: set, keep: set = None) -> list:     every open doc. Never touches a doc that pre-dates the chain (the user's own work)."""     closed = []     keep = {str(k).lower() for k in (keep or ())}++    def _bare(n):+        # "adom-ten* (jlauerhub)" -> "adom-ten": drop the modified star and any hub suffix+        return re.sub(r"\s*\([^)]*\)\s*$", "", str(n or "").replace("*", "")).strip().lower()     try:+        # NEVER CLOSE THE LAST DOCUMENT (ten-part run 2026-08-29): Fusion replaces a closed+        # last document with a fresh 'Untitled', so a sweep that closed the last one spawned+        # Untitled(2)..Untitled(8), one per loop pass, while the library it was meant to keep+        # was gone. A lone Untitled is Fusion's floor, not ours to clear.         for n in sorted(_open_doc_names() - set(before or ())):-            if n.rstrip("*").strip().lower() in keep:+            if _bare(n) in keep:                 continue                 # the finished library stays open for the user+            try:+                _cnt = len(((_proxy_to_addin("document_info", {}, timeout=8).get("data") or {})+                            .get("openDocuments") or []))+            except Exception:+                _cnt = 0+            if _cnt <= 1:+                break             _note_bridge_doc(n)          # so the save-prompt sentinel owns any prompt it raises             r = _close_bridge_doc_verified(n)             if r.get("closed"):@@ -11031,9 +11101,15 @@ def _close_docs_opened_since(before: set, keep: set = None) -> list:         # UNMODIFIED Untitleds directly, one per pass, until none remain: an unmodified         # Untitled is an empty tab by definition (any real content flips isModified), so         # this can never eat user work. Bounded, and only ever runs at chain end.+        _last_count = None         for _ in range(12):             st = _proxy_to_addin("document_info", {}, timeout=8)             docs = (st.get("data") or {}).get("openDocuments") or []+            if len(docs) <= 1:+                break                     # a lone document is Fusion's floor+            if _last_count is not None and len(docs) >= _last_count:+                break                     # closing is not reducing the count: stop, do not spin+            _last_count = len(docs)             u = next((dd for dd in docs                       if str(dd.get("name") or "").startswith("Untitled")                       and not (dd.get("isModified") or dd.get("modified"))), None)@@ -12166,7 +12242,11 @@ def _publish_library_to_cloud(lbr_path: str, name: str, folder: str = "Adom Libr     # The prove stage closes the library behind itself, so it is usually NOT open here; open it     # from disk (the bound file is the truth) before trying to activate it.     try:-        if stem.lower() not in {n.rstrip("*").strip().lower() for n in _open_doc_names()}:+        _names = _open_doc_names()+        _bare_names = {re.sub(r"\s*\([^)]*\)\s*$", "", n.replace("*", "")).strip().lower() for n in _names}+        # Only reopen when the document list is KNOWN and the library is not in it; an empty+        # list under a busy main thread means "unknown", and reopening then stacks a copy.+        if _names and stem.lower() not in _bare_names:             _op = _orchestrate_open_lbr({"filePath": lbr_path})             out["reopened"] = bool(_op.get("success"))             if not _op.get("success"):@@ -12372,6 +12452,7 @@ def _handle_create_library(fusion_info: dict, args: dict) -> dict:         # Register with the hang gate: while this chain runs (and is under the 900s         # ceiling) a non-pumping main thread is WORK, not a hang (#49 mid-mint kills).         _LONG_OP["name"] = "create_library:" + run_id+        _banner_watchdog_start(run_id)   # keep the in-Fusion palette present for the whole run         _LONG_OP["since"] = __import__("time").time()         _docs_before = _open_doc_names()   # chain hygiene: everything opened after this is ours         def _save():@@ -12746,6 +12827,7 @@ def _handle_create_library(fusion_info: dict, args: dict) -> dict:             except Exception:                 pass         finally:+            _banner_watchdog_stop(run_id)             if _LONG_OP.get("name") == "create_library:" + run_id:                 _LONG_OP["name"] = None                 _LONG_OP["since"] = 0.0