--- a/rust/hg-cpython/src/revlog.rs	Thu Sep 26 01:52:09 2024 +0200
+++ b/rust/hg-cpython/src/revlog.rs	Fri Sep 27 03:55:40 2024 +0200
@@ -27,7 +27,10 @@
     revlog::{nodemap::NodeMap, Graph, NodePrefix, RevlogError, RevlogIndex},
     BaseRevision, Node, Revision, UncheckedRevision, NULL_REVISION,
 };
-use std::{cell::RefCell, collections::HashMap};
+use std::{
+    cell::RefCell,
+    collections::{HashMap, HashSet},
+};
 use vcsgraph::graph::Graph as VCSGraph;
 
 pub struct PySharedIndex {
@@ -305,12 +308,13 @@
 
     /// get head revisions
     def headrevs(&self, *args, **_kw) -> PyResult<PyObject> {
-        let filtered_revs = match &args.len(py) {
-             0 => Ok(py.None()),
-             1 => Ok(args.get_item(py, 0)),
+        let (filtered_revs, stop_rev) = match &args.len(py) {
+             0 => Ok((py.None(), py.None())),
+             1 => Ok((args.get_item(py, 0), py.None())),
+             2 => Ok((args.get_item(py, 0), args.get_item(py, 1))),
              _ => Err(PyErr::new::<cpython::exc::TypeError, _>(py, "too many arguments")),
         }?;
-        self.inner_headrevs(py, &filtered_revs)
+        self.inner_headrevs(py, &filtered_revs, &stop_rev)
     }
 
     /// get head nodeids
@@ -821,29 +825,62 @@
         &self,
         py: Python,
         filtered_revs: &PyObject,
+        stop_rev: &PyObject,
     ) -> PyResult<PyObject> {
         let index = &*self.index(py).borrow();
-
-        let from_core = match filtered_revs.is_none(py) {
-            true => index.head_revs_shortcut(),
+        let stop_rev = match stop_rev.is_none(py) {
             false => {
+                let rev = stop_rev.extract::<i32>(py)?;
+                if 0 <= rev && rev < index.len() as BaseRevision {
+                    Some(Revision(rev))
+                } else {
+                    None
+                }
+            }
+            true => None,
+        };
+        let from_core = match (filtered_revs.is_none(py), stop_rev.is_none()) {
+            (true, true) => index.head_revs_shortcut(),
+            (true, false) => {
+                index.head_revs_advanced(&HashSet::new(), stop_rev, false)
+            }
+            _ => {
                 let filtered_revs =
                     rev_pyiter_collect(py, filtered_revs, index)?;
-                index.head_revs_filtered(&filtered_revs, true)
+                index.head_revs_advanced(
+                    &filtered_revs,
+                    stop_rev,
+                    stop_rev.is_none(),
+                )
             }
         };
 
-        if let Some(new_heads) = from_core.map_err(|e| graph_error(py, e))? {
-            self.cache_new_heads_py_list(&new_heads, py);
-        }
+        if stop_rev.is_some() {
+            // we don't cache result for now
+            let new_heads = from_core
+                .map_err(|e| graph_error(py, e))?
+                .expect("this case should not be cached yet");
 
-        Ok(self
-            .head_revs_py_list(py)
-            .borrow()
-            .as_ref()
-            .expect("head revs should be cached")
-            .clone_ref(py)
-            .into_object())
+            let as_vec: Vec<PyObject> = new_heads
+                .iter()
+                .map(|r| PyRevision::from(*r).into_py_object(py).into_object())
+                .collect();
+            Ok(PyList::new(py, &as_vec).into_object())
+        } else {
+            if let Some(new_heads) =
+                from_core.map_err(|e| graph_error(py, e))?
+            {
+                self.cache_new_heads_py_list(&new_heads, py);
+            }
+
+            Ok(self
+                .head_revs_py_list(py)
+                .borrow()
+                .as_ref()
+                .expect("head revs should be cached")
+                .clone_ref(py)
+                .into_object())
+        }
     }
 
     fn check_revision(