@@ -487,39 +487,34 @@ def stop(self) -> None:
         """
         self._iter.stop()
 
-    def get_last_seq_newer_than(self, last_persisted_seq: str) -> str:
+    def latest_sequence_from(self, checkpoint_sequence_id: str) -> str:
         """
-        Return the newest sequence ID that is safe to use as a checkpoint
-        after the given persisted sequence ID.
-
-        Use this after fully processing a ``ChangesResultItem`` to determine
-        whether this ``ChangesFollower`` has observed a later safe checkpoint.
-        This is useful for filtered or sparse changes feeds, where the feed
-        can advance across pages even when no additional user-processable
-        change rows are returned.
-
-        The supplied sequence ID must be the ``seq`` of a
-        ``ChangesResultItem`` that your application has fully processed and
-        already persisted. This method returns a newer sequence only when
-        doing so does not advance past later change rows that might not yet
-        have been processed by your application.
-
-        :param str last_persisted_seq: The ``seq`` of the last
-            ``ChangesResultItem`` that your application has fully processed
-            and persisted.
-        :raises ValueError: If the provided sequence ID is null or empty.
-        :return: The newest safe sequence ID to persist as
-            ``PostChangesParams.since``. Returns the supplied ID unchanged
-            if no newer safe checkpoint is available, the feed has not
-            started yet, or the supplied ID is not present in this
-            ``ChangesFollower`` instance's retained sequence history.
+        Returns the most recent sequence ID that is safe to use as a
+        checkpoint, advancing beyond the supplied checkpoint sequence ID
+        where possible.
+
+        With highly filtered changes feeds, multiple pages can pass through
+        the follower without returning any changes. Using only the ``seq``
+        of the last processed ``ChangesResultItem`` in those cases causes a
+        long changes feed rewind on the next run. To avoid this, call this
+        method after fully processing each ``ChangesResultItem`` with a
+        non-``None`` ``seq`` and persist the returned value to use as the
+        ``since`` parameter for the next run.
+
+        :param str checkpoint_sequence_id: The last checkpoint sequence ID
+            — either the non-``None`` ``seq`` of the last ``ChangesResultItem``
+            fully processed, or a value previously returned by this method.
+        :return: The most recent safe sequence ID to use as a checkpoint,
+            or the supplied value if no newer sequence is available.
         :rtype: str
+
+        Throws ValueError if ``checkpoint_sequence_id`` is ``None`` or empty.
         """
-        if not last_persisted_seq:
-            raise ValueError('The provided sequence ID cannot be null or empty.')
+        if not checkpoint_sequence_id:
+            raise ValueError('Provided sequence ID must be a non-empty string.')
         if self._iter is None:
-            return last_persisted_seq
-        return self._iter.last_seq_since(last_persisted_seq)
+            return checkpoint_sequence_id
+        return self._iter.last_seq_since(checkpoint_sequence_id)
 
     def _run(self, mode: _Mode):
         if self._iter is not None:
 
@@ -940,40 +940,40 @@ def test_last_seq_since_none_last_seq_advances_beyond(self):
 
 
 # ---------------------------------------------------------------------------
-# TestGetLastSeqNewerThan — unit tests for ChangesFollower.get_last_seq_newer_than
+# TestLatestSequenceFrom — unit tests for ChangesFollower.latest_sequence_from
 # ---------------------------------------------------------------------------
 
-class TestGetLastSeqNewerThan(ChangesFollowerBaseCase):
+class TestLatestSequenceFrom(ChangesFollowerBaseCase):
 
-    def test_get_last_seq_newer_than_with_none(self):
+    def test_latest_sequence_from_with_none(self):
         """Raises ValueError when passed None."""
         follower = ChangesFollower(self.client, db='db')
-        with self.assertRaisesRegex(ValueError, 'The provided sequence ID cannot be null or empty'):
-            follower.get_last_seq_newer_than(None)
+        with self.assertRaisesRegex(ValueError, 'Provided sequence ID must be a non-empty string'):
+            follower.latest_sequence_from(None)
 
-    def test_get_last_seq_newer_than_with_empty_string(self):
+    def test_latest_sequence_from_with_empty_string(self):
         """Raises ValueError when passed an empty string."""
         follower = ChangesFollower(self.client, db='db')
-        with self.assertRaisesRegex(ValueError, 'The provided sequence ID cannot be null or empty'):
-            follower.get_last_seq_newer_than('')
+        with self.assertRaisesRegex(ValueError, 'Provided sequence ID must be a non-empty string'):
+            follower.latest_sequence_from('')
 
-    def test_get_last_seq_newer_than_before_feed_starts(self):
+    def test_latest_sequence_from_before_feed_starts(self):
         """Returns the input seq unchanged when the feed has not started yet."""
         follower = ChangesFollower(self.client, db='db')
-        self.assertEqual(follower.get_last_seq_newer_than('seq-a'), 'seq-a')
+        self.assertEqual(follower.latest_sequence_from('seq-a'), 'seq-a')
 
     @responses.activate
-    def test_get_last_seq_newer_than_unknown_seq(self):
+    def test_latest_sequence_from_unknown_seq(self):
         """Returns the input seq unchanged when it was never seen by this follower."""
         self.prepare_mock_changes(batches=1)
         follower = ChangesFollower(self.client, db='db')
         changes = follower.start_one_off()
         for _ in changes:
             pass
-        self.assertEqual(follower.get_last_seq_newer_than('seq-unknown'), 'seq-unknown')
+        self.assertEqual(follower.latest_sequence_from('seq-unknown'), 'seq-unknown')
 
     @responses.activate
-    def test_get_last_seq_newer_than_middle_of_batch(self):
+    def test_latest_sequence_from_middle_of_batch(self):
         """
         Returns the input seq unchanged when querying with a seq from the
         middle of a batch — only the last item's seq is stored in seq_markers.
@@ -985,18 +985,18 @@ def test_get_last_seq_newer_than_middle_of_batch(self):
         # seq-a and seq-b are middle items — not stored in seq_markers
         seq_a = items[0].seq
         seq_b = items[1].seq
-        self.assertEqual(follower.get_last_seq_newer_than(seq_a), seq_a)
-        self.assertEqual(follower.get_last_seq_newer_than(seq_b), seq_b)
+        self.assertEqual(follower.latest_sequence_from(seq_a), seq_a)
+        self.assertEqual(follower.latest_sequence_from(seq_b), seq_b)
 
     @responses.activate
-    def test_get_last_seq_newer_than_end_to_end(self):
+    def test_latest_sequence_from_end_to_end(self):
         """Returns the correct last_seq through a completed stream."""
         self.prepare_mock_changes(batches=1)
         follower = ChangesFollower(self.client, db='db')
         changes = follower.start_one_off()
         items = list(changes)
         # Last item's seq should map to the page's last_seq
         last_item_seq = items[-1].seq
-        result = follower.get_last_seq_newer_than(last_item_seq)
+        result = follower.latest_sequence_from(last_item_seq)
         # The last item seq IS the last_seq for a normal page (type 1 equivalent)
         self.assertEqual(result, last_item_seq)