Fusion - the Fusion 360 Bridge

@@ -9282,6 +9282,47 @@ def _install_adom_lbr_windows() -> str:         return ""  ++def _apply_pin_map(lbr_path: str, pin_map: dict) -> dict:+    """Rewrite <connects> from an EXPLICIT {pinName: padName} map, then re-verify.++    The identity join (pin number == pad name) is convention, and when it breaks no+    converter can know the truth - it is datasheet knowledge. The caller supplies it here;+    a deterministic XML rewrite applies it; _check_connects validates the result. Refuses+    (and changes nothing) if the map references pins or pads that do not exist.+    """+    try:+        text = open(lbr_path, "r", encoding="utf-8", errors="replace").read()+    except Exception as e:+        return {"ok": False, "why": "unreadable: %s" % str(e)[:80]}+    import re as _re+    import xml.etree.ElementTree as _ET+    try:+        root = _ET.fromstring(text)+    except Exception:+        return {"ok": False, "why": "library is not valid XML"}+    pins = {p.get("name") for p in root.iter("pin") if p.get("name")}+    pads = {p.get("name") for p in root.iter("smd") if p.get("name")}+    pads |= {p.get("name") for p in root.iter("pad") if p.get("name")}+    bad = [(k, v) for k, v in pin_map.items() if k not in pins or v not in pads]+    if bad:+        return {"ok": False, "why": "map references missing pins/pads",+                "bad": bad[:8], "pins": sorted(pins)[:20], "pads": sorted(pads)[:20]}+    gate = ( _re.findall(r'<gate name="([^"]+)"', text) or ["G$1"])[0]+    conns = "\n".join('<connect gate="%s" pin="%s" pad="%s"/>' % (gate, k, v)+                      for k, v in pin_map.items())+    joined = "<connects>\n%s\n</connects>" % conns+    if _re.search(r"<connects>.*?</connects>", text, _re.S):+        text = _re.sub(r"<connects>.*?</connects>", joined, text, count=1, flags=_re.S)+    elif "<connects/>" in text:+        text = text.replace("<connects/>", joined, 1)+    else:+        return {"ok": False, "why": "no <connects> element to rewrite"}+    open(lbr_path, "w", encoding="utf-8").write(text)+    chk = _check_connects(lbr_path)+    return {"ok": bool(chk.get("ok")), "applied": len(pin_map), "verify": chk}++ def _handle_import_kicad(fusion_info: dict, args: dict) -> dict:     """Ingest KiCad symbol/footprint files and produce a valid .lbr (issue #43) - by     DELEGATING to adom-lbr, the ecosystem's canonical converter.@@ -9340,7 +9381,18 @@ def _handle_import_kicad(fusion_info: dict, args: dict) -> dict:                 "_hint": "adom-lbr auto-lints its output and exits 2 on lint failure - the "                          "message above names the exact check that failed."}     names = _library_artifact_names(lbr_p)+    pin_map = args.get("pinMap")+    pm_result = None+    if isinstance(pin_map, dict) and pin_map:+        pm_result = _apply_pin_map(lbr_p, {str(k): str(v) for k, v in pin_map.items()})+        if not pm_result.get("ok"):+            return {"success": False, "errorCode": "pin_map_invalid",+                    "error": "The explicit pinMap could not be applied: %s" % pm_result.get("why"),+                    "pinMapDetail": pm_result,+                    "_hint": "pinMap must be {pinName: padName} using names that exist - the "+                             "detail lists the symbol's pins and the package's pads."}     return {"success": True, "libraryPath": lbr_p, "converter": "adom-lbr",+            "pinMapApplied": (pm_result or {}).get("applied"),             "symbols": names.get("sym", []), "packages": names.get("pac", []),             "devicesets": names.get("dev", []), "has3d": bool(names.get("p3d")),             "toolOutput": (r.stdout or "").strip()[-300:],@@ -9386,6 +9438,93 @@ def _handle_prove_result(fusion_info: dict, args: dict) -> dict: COMMAND_HANDLERS["prove_result"] = _handle_prove_result  ++def _handle_create_library(fusion_info: dict, args: dict) -> dict:+    """ONE verb for the whole "create a Fusion library" task - one call, one consent.++    John, 2026-08-21: web-control needs to hand the bridge EITHER a ready .lbr + .step, OR+    KiCad sources (+ optional pinMap) - two entry shapes, one contract. And ab measured what+    multi-verb flows cost a browser caller: every cross-origin call is a human consent+    (#30's nine-prompt incident). So this verb accepts both shapes and runs the whole chain+    itself: [convert via adom-lbr] -> [bind the STEP] -> [prove: four frames + verdict].++    Entry shapes:+      A: {libraryPath, stepPath?}                                - .lbr given, bind + prove+      B: {kicadSymbolPath?, kicadFootprintPath?, stepPath?,+          pinMap?, libraryPath?}                                 - convert, then bind + prove++    The chain outlives ab's relay window by design, so it returns IMMEDIATELY with+    statusVerb fusion_prove_result (the #32 pollable pattern): fire once, poll one verb,+    both results (progress and final) come from state the bridge persists.+    """+    import threading as _th+    import tempfile as _tf+    lbr_p = (args.get("libraryPath") or "").replace("\\", "/")+    sym_p = (args.get("kicadSymbolPath") or "").replace("\\", "/")+    mod_p = (args.get("kicadFootprintPath") or "").replace("\\", "/")+    step_p = (args.get("stepPath") or "").replace("\\", "/")+    if not lbr_p and not (sym_p or mod_p):+        return {"success": False, "errorCode": "no_input",+                "error": "Give me EITHER libraryPath (a ready .lbr) OR kicadSymbolPath / "+                         "kicadFootprintPath (KiCad sources).",+                "_hint": "Shape A: {libraryPath, stepPath}. Shape B: {kicadSymbolPath, "+                         "kicadFootprintPath, stepPath, pinMap?}. stepPath is required for "+                         "a PROVEN library - without it there is no real 3D body."}++    def _chain():+        state = {"stage": "starting", "success": None, "libraryPath": lbr_p or None}+        def _save():+            try:+                _PROVE_LAST[0] = dict(state)+                open(os.path.join(_tf.gettempdir(), "fusion-prove-last.json"), "w",+                     encoding="utf-8").write(json.dumps(state))+            except Exception:+                pass+        try:+            target_lbr = lbr_p+            if sym_p or mod_p:+                state["stage"] = "converting (adom-lbr)"; _save()+                conv = _handle_import_kicad(fusion_info, {+                    "kicadSymbolPath": sym_p, "kicadFootprintPath": mod_p,+                    "libraryPath": lbr_p, "pinMap": args.get("pinMap"),+                    "name": args.get("name")})+                state["convert"] = {k: conv.get(k) for k in+                                    ("success", "errorCode", "error", "libraryPath",+                                     "packages", "symbols", "pinMapApplied")}+                if not conv.get("success"):+                    state.update(stage="failed", success=False); _save(); return+                target_lbr = conv.get("libraryPath")+            state["libraryPath"] = target_lbr+            if step_p:+                state["stage"] = "binding 3D (STEP -> f3d -> package3d)"; _save()+                bind = dispatch_command("bind_library_3d",+                                        {"libraryPath": target_lbr, "stepPath": step_p})+                state["bind"] = {k: bind.get(k) for k in+                                 ("success", "error", "wip_urn")}+                if not bind.get("success"):+                    state.update(stage="failed", success=False); _save(); return+            state["stage"] = "proving (four evidence frames)"; _save()+            prove = _handle_prove_library(fusion_info, {"libraryPath": target_lbr,+                                                        "name": args.get("name")})+            state.update(stage="done", success=bool(prove.get("proven")), prove=prove)+            _save()+        except Exception as e:+            state.update(stage="failed", success=False, error=str(e)[:200]); _save()++    _th.Thread(target=_chain, daemon=True).start()+    return {"success": True, "started": True,+            "statusVerb": "fusion_prove_result",+            "shape": "A (.lbr direct)" if (lbr_p and not (sym_p or mod_p)) else "B (KiCad sources)",+            "_hint": ("The chain runs in the background (it outlives the relay window by "+                      "design). Poll fusion_prove_result every ~15s: `stage` narrates "+                      "(converting -> binding 3D -> proving), and on stage:'done' the "+                      "`prove` block carries the four evidence frames and the verdict. "+                      "ONE call, ONE consent, ONE poll verb.")}+++COMMAND_HANDLERS["create_library"] = _handle_create_library++ def dispatch_command(command: str, args: dict, caller_identity: dict = None) -> dict:     """Thin wrapper: run the verb, then guarantee the windowEtiquette annotation lands on     EVERY backgrounded window-raising result - the inner dispatcher's closure only covered