fix(bin-diff): show side B filename instead of its md5

parseRestfulPath decoded `collection` but left `coll_b` percent-encoded, so a
collection name containing a space produced a `{coll}:file:{md5}:meta` lookup
miss for side B; the strip then fell back to rendering the raw md5. Decode
coll_b in all three `vs` branches.

While tracing it: get_bin_sim returned the stored pair's own A/B ordering
(canonical md5 sort, or pool build order) rather than the requested one, so
opening a pair "backwards" swapped file metadata, unique_to_a/b and func_a/b.
Re-orient the doc to the caller's order after loading it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: rdmmf

bsimvis/app/routes/bin_sim.py

@@ -198,6 +198,29 @@ def rebuild_bin_sim():
     }
 
 
+def _swap_side_keys(d):
+    """Swap every `<x>_a`/`<x>_b` (and `_1`/`_2`) pair in a dict, in place."""
+    for key in list(d):
+        if key.endswith("_a") and key[:-1] + "b" in d:
+            twin = key[:-1] + "b"
+        elif key.endswith("_1") and key[:-1] + "2" in d:
+            twin = key[:-1] + "2"
+        else:
+            continue
+        d[key], d[twin] = d[twin], d[key]
+
+
+def _flip_diff_sides(diff_data):
+    """Mirror a stored bin_sim doc so side A becomes side B and vice versa."""
+    _swap_side_keys(diff_data)
+    diff = diff_data.get("diff")
+    if not isinstance(diff, dict):
+        return
+    _swap_side_keys(diff)
+    for row in diff.get("matched", []):
+        _swap_side_keys(row)
+
+
 def get_bin_sim(collection=None, md5_a=None, md5_b=None, coll_b=None, pool_id=None):
     """Retrieve binary similarity diff for a pair."""
     if collection is None:
@@ -217,6 +240,9 @@ def get_bin_sim(collection=None, md5_a=None, md5_b=None, coll_b=None, pool_id=No
 
     r = get_redis()
     coll_a = collection
+    # What the caller asked for. Lookup below may reorder these to reach the
+    # stored doc; the response must still come back in the caller's order.
+    req_coll_a, req_md5_a, req_coll_b, req_md5_b = coll_a, md5_a, coll_b, md5_b
 
     if pool_id:
         # For pool pairs, look up the SID via the 'involves' index to avoid
@@ -256,12 +282,14 @@ def get_bin_sim(collection=None, md5_a=None, md5_b=None, coll_b=None, pool_id=No
 
     diff_data = json.loads(data_raw) if not isinstance(data_raw, dict) else data_raw
 
-    # Resolve actual coll_a/coll_b from the stored doc for metadata lookups
-    if pool_id:
-        coll_a = diff_data.get("coll_1") or coll_a
-        coll_b = diff_data.get("coll_2") or coll_b
-        md5_a = diff_data.get("md5_1") or md5_a
-        md5_b = diff_data.get("md5_2") or md5_b
+    # A pair is stored once, in whatever order it was built (canonical md5 sort for
+    # collection pairs, build order for pools). Re-orient the doc to the requested
+    # order so every "_a"/"_b" — file metadata, unique_to_b, func_b — describes the
+    # binary the caller called A/B.
+    stored_a = diff_data.get("md5_1") or diff_data.get("md5_a")
+    if stored_a and stored_a != req_md5_a:
+        _flip_diff_sides(diff_data)
+    coll_a, md5_a, coll_b, md5_b = req_coll_a, req_md5_a, req_coll_b, req_md5_b
 
     # Extract all unique function IDs
     fids = set()

bsimvis/app/static/js/utils.js

@@ -187,7 +187,7 @@ function parseRestfulPath() {
                 params.view = 'file';
             } else if (parts[pIdx] === 'vs') {
                 params.view = 'bin_sim';
-                params.coll_b = parts[pIdx + 1];
+                params.coll_b = decodeURIComponent(parts[pIdx + 1] || '');
                 params.md5_b = parts[pIdx + 2];
             } else if (parts[pIdx] === 'functions' || parts[pIdx] === 'function') {
                 pIdx++;
@@ -202,7 +202,7 @@ function parseRestfulPath() {
                         params.view = 'function_features';
                     } else if (parts[pIdx] === 'vs') {
                         params.view = 'diff';
-                        params.coll_b = parts[pIdx + 1];
+                        params.coll_b = decodeURIComponent(parts[pIdx + 1] || '');
                         params.md5_b = parts[pIdx + 2];
                         params.addr_b = parts[pIdx + 3];
                         params.id1 = `${stripPoolPrefix(params.collection || '')}:func:${params.md5}:${params.address}`;
@@ -234,7 +234,7 @@ function parseRestfulPath() {
                 } else if (parts[pIdx] === 'vs') {
                     params.view = 'diff';
                     params.id1 = `${stripPoolPrefix(params.collection || '')}:func:${params.md5}:${params.address}`;
-                    params.coll_b = stripPoolPrefix(parts[pIdx + 1]) || '';
+                    params.coll_b = stripPoolPrefix(decodeURIComponent(parts[pIdx + 1] || '')) || '';
                     params.md5_b = parts[pIdx + 2];
                     params.addr_b = parts[pIdx + 3];
                     params.id2 = `${stripPoolPrefix(params.coll_b || '')}:func:${params.md5_b}:${params.addr_b}`;

test_bin_sim_orientation.py

@@ -0,0 +1,40 @@
+"""A bin_sim pair is stored once, in one order; the API must serve it in the
+order the caller asked for. Guards the side-flip used by get_bin_sim()."""
+
+from bsimvis.app.routes.bin_sim import _flip_diff_sides
+
+
+def test_flip_diff_sides():
+    doc = {
+        "md5_a": "x",
+        "md5_b": "y",
+        "coverage_a": 1,
+        "coverage_b": 2,
+        "score": 9,
+        "diff": {
+            "unique_to_a": ["ua"],
+            "unique_to_b": ["ub1", "ub2"],
+            "matched": [{"func_a": "fa", "func_b": "fb", "similarity": 0.5}],
+        },
+    }
+
+    _flip_diff_sides(doc)
+    assert (doc["md5_a"], doc["md5_b"]) == ("y", "x")
+    assert (doc["coverage_a"], doc["coverage_b"]) == (2, 1)
+    assert doc["score"] == 9
+    assert doc["diff"]["unique_to_a"] == ["ub1", "ub2"]
+    assert doc["diff"]["unique_to_b"] == ["ua"]
+    assert doc["diff"]["matched"][0] == {
+        "func_a": "fb",
+        "func_b": "fa",
+        "similarity": 0.5,
+    }
+
+    _flip_diff_sides(doc)
+    assert doc["md5_a"] == "x"
+    assert doc["diff"]["unique_to_b"] == ["ub1", "ub2"]
+
+
+if __name__ == "__main__":
+    test_flip_diff_sides()
+    print("ok")