fix(gfql): resident-index gate — no float-collapsing id promotes, cudf device path, polars-gpu tags, serve-asserted tests

Review findings (plans/review-pr-1768/review.md):
B1 int64<->uint64 promotes to float64 and collapses ids >= 2^53 into
false matches (repro'd: seed 2^62+1 matched node 2^62) — integral pairs
whose promote is float now DECLINE to the exact-compare scan path.
M2 spies count SERVES (non-None), not calls, so a gate regression that
declines everything fails the suite. M1 native-chain hop indexed branch
+ reverse/EDGE_IN_ADJ now tested (serve-asserted, parity). M3 cudf ids
via .dropna().values (device array; to_numpy raised on nulls and
round-tripped host). M4 polars frames also accept polars-gpu-tagged
indexes (same numpy sidecars + polars gather).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y6dQEcjdazEnzuvuwf73ZL

Author: lmeyerov

graphistry/compute/chain_fast_paths.py

@@ -66,8 +66,17 @@ def _resident_seed_indexes(
     else:
         return None
     kind = EDGE_OUT_ADJ if direction == "forward" else EDGE_IN_ADJ
-    adj = registry.get_valid(kind, edges_df, (src, dst), engine)
-    nid = registry.get_valid(NODE_ID, nodes_df, (node,), engine)
+    engines = [engine]
+    if engine == Engine.POLARS:
+        # an index built with explicit engine='polars-gpu' serves the same eager
+        # polars frames (same numpy sidecars + polars row-gather)
+        engines.append(Engine.POLARS_GPU)
+    adj = nid = None
+    for eng_try in engines:
+        adj = registry.get_valid(kind, edges_df, (src, dst), eng_try)
+        nid = registry.get_valid(NODE_ID, nodes_df, (node,), eng_try)
+        if adj is not None and nid is not None:
+            break
     if adj is None or nid is None:
         return None
     xp, _ = array_namespace(engine)
@@ -80,13 +89,24 @@ def _ids_to_key_array(vals: Any, keys: Any, xp: Any) -> Optional[Any]:
     dropna semantics). None when the cast is not value-safe (mismatched families
     like str-vs-int decline to the scan path rather than risk false matches)."""
     try:
-        arr = xp.asarray(vals.to_numpy() if hasattr(vals, "to_numpy") else vals)
+        if 'cudf' in str(type(vals).__module__):
+            vals = vals.dropna()
+            raw = vals.values  # device array; to_numpy() raises on nulls + round-trips host
+        elif hasattr(vals, "to_numpy"):
+            raw = vals.to_numpy()
+        else:
+            raw = vals
+        arr = xp.asarray(raw)
         if arr.dtype.kind == "f":
             arr = arr[~xp.isnan(arr)]
         if arr.dtype.kind not in "iuf" or keys.dtype.kind not in "iuf":
             return None  # numeric id families only: object/str ids keep the scan path (null-object semantics)
         if arr.dtype != keys.dtype:
             common = xp.promote_types(arr.dtype, keys.dtype)
+            if arr.dtype.kind in "iu" and keys.dtype.kind in "iu" and common.kind == "f":
+                # int64<->uint64 promotes to float64, which collapses distinct ids
+                # >= 2^53 into false matches; the scan path compares exactly -> decline.
+                return None
             arr = arr.astype(common)
         return xp.unique(arr)
     except (TypeError, ValueError):

graphistry/tests/compute/gfql/test_seeded_typed_hop_fastpath.py

@@ -647,11 +647,17 @@ def _canon(self, res):
         return df[cols].sort_values(cols).reset_index(drop=True)
 
     def _spied(self, g, q, engine, monkeypatch):
+        # counts SERVES (non-None returns), not calls: a gate regression that
+        # declines everything must fail these tests, not silently pass them
         import graphistry.compute.chain_fast_paths as cfp
         counts = {"n": 0}
         on = cfp._index_node_rows
-        monkeypatch.setattr(cfp, "_index_node_rows",
-                            lambda *a, **k: (counts.__setitem__("n", counts["n"] + 1), on(*a, **k))[1])
+
+        def spy(*a, **k):
+            out = on(*a, **k)
+            counts["n"] += out is not None
+            return out
+        monkeypatch.setattr(cfp, "_index_node_rows", spy)
         res = g.gfql(q, engine=engine)
         monkeypatch.setattr(cfp, "_index_node_rows", on)
         return res, counts["n"]
@@ -701,3 +707,54 @@ def test_stale_index_declines_to_scan(self, monkeypatch):
         plain = graphistry.nodes(ndf, "id").edges(edf2, "src", "dst").gfql(self.Q, engine="pandas")
         assert counts["n"] == 0, "stale index must not serve"
         pd.testing.assert_frame_equal(self._canon(got), self._canon(plain))
+
+
+    def test_native_chain_hop_indexed_parity_forward_and_reverse(self, monkeypatch):
+        """M1 pin: the native-chain hop helper's indexed branch (only reachable via
+        chain ops, never Cypher) — forward (EDGE_OUT_ADJ) and reverse (EDGE_IN_ADJ),
+        serve-asserted, parity vs the un-indexed graph."""
+        from graphistry.compute.ast import n, e_forward, e_reverse
+        import graphistry.compute.chain_fast_paths as cfp
+        ndf, edf = self._frames()
+        mk = lambda: graphistry.nodes(ndf, "id").edges(edf, "src", "dst")  # noqa: E731
+        for ops in (
+            [n({"id": 33}), e_forward(edge_match={"type": "KNOWS"}), n({"type": "Person"})],
+            [n({"id": 33}), e_reverse(edge_match={"type": "KNOWS"}), n({"type": "Person"})],
+        ):
+            serves = {"n": 0}
+            oe = cfp._index_edge_rows
+
+            def spy(*a, **k):
+                out = oe(*a, **k)
+                serves["n"] += out is not None
+                return out
+            monkeypatch.setattr(cfp, "_index_edge_rows", spy)
+            got = mk().gfql_index_all().gfql(ops, engine="pandas")
+            monkeypatch.setattr(cfp, "_index_edge_rows", oe)
+            assert serves["n"] > 0, f"indexed hop branch did not serve for {ops[1].direction}"
+            plain = mk().gfql(ops, engine="pandas")
+            pd.testing.assert_frame_equal(self._canon(got), self._canon(plain))
+
+    def test_uint64_int64_id_mix_declines_not_collapses(self, monkeypatch):
+        """B1 pin: int64<->uint64 promotes to float64, which collapses ids >= 2**53
+        into false matches; the gate must DECLINE (scan path compares exactly)."""
+        import graphistry.compute.chain_fast_paths as cfp
+        big = np.uint64(2**62)
+        ndf = pd.DataFrame({"id": np.array([big, big + np.uint64(1), np.uint64(7)], dtype=np.uint64),
+                            "type": ["Person"] * 3})
+        edf = pd.DataFrame({"src": np.array([int(big) + 1], dtype=np.int64),
+                            "dst": np.array([7], dtype=np.int64), "type": ["KNOWS"]})
+        g = graphistry.nodes(ndf, "id").edges(edf, "src", "dst").gfql_index_all()
+        q = f"MATCH (m {{id: {int(big) + 1}}})-[:KNOWS]->(p) RETURN p"
+        serves = {"n": 0}
+        on = cfp._index_node_rows
+
+        def spy(*a, **k):
+            out = on(*a, **k)
+            serves["n"] += out is not None
+            return out
+        monkeypatch.setattr(cfp, "_index_node_rows", spy)
+        got = g.gfql(q, engine="pandas")
+        monkeypatch.setattr(cfp, "_index_node_rows", on)
+        plain = graphistry.nodes(ndf, "id").edges(edf, "src", "dst").gfql(q, engine="pandas")
+        pd.testing.assert_frame_equal(self._canon(got), self._canon(plain))