matrix-rust-sdk

public

Star0

Fork 0

Watch0

36 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `0f2f98298976`

tarball

atagen <boss@atagen.co>2026-10-26 05:28 UTC

2 files changed+48-6

event-cache: claim the start of a room only at its creation event

load_more_events_backwards reported StartOfTimeline whenever the store had nothing older and any event was retained. A sync that drops its prev_batch (not limited, or all duplicates) leaves retained events with no gap before them, so a quiet room showed Beginning of history with its history unloaded. It now paginates from the live end until /messages runs out or the creation event is retained, and a known-only page from the end keeps its token instead of ending pagination.

Modified file: crates/matrix-sdk/src/event_cache/caches/room/pagination.rs+15 additions−6 deletions@@ -199,10 +199,15 @@ impl PaginatedCache for Arc<RoomEventCacheInner> {
                 // sync for that room, because every room must have *at least* a room creation
                 // event. Otherwise, we have reached the start of the timeline.
 
-                if state.room_linked_chunk().events().next().is_some() {
-                    // If there's at least one event, this means we've reached the start of the
-                    // timeline, since the chunk is fully loaded.
-                    trace!("chunk is fully loaded and non-empty: reached_start=true");
+                // a sync that drops its prev_batch (not limited, or every event a duplicate)
+                // leaves retained events with no gap before them, so only the creation event
+                // proves the start. otherwise paginate from the end, which dedups what we hold
+                let created = state.room_linked_chunk().events().next().is_some_and(|(_, event)| {
+                    event.raw().get_field::<String>("type").ok().flatten().as_deref()
+                        == Some("m.room.create")
+                });
+                if created {
+                    trace!("chunk is fully loaded and starts at creation: reached_start=true");
                     return Ok(LoadMoreEventsBackwardsOutcome::StartOfTimeline);
                 }
 
@@ -349,6 +354,7 @@ impl PaginatedCache for Arc<RoomEventCacheInner> {
             return Ok(None);
         }
 
+        let from_end = prev_token.is_none();
         // Check that the previous token still exists; otherwise it's a sign that the
         // room's timeline has been cleared.
         let prev_gap_id = if let Some(token) = prev_token {
@@ -410,8 +416,11 @@ impl PaginatedCache for Arc<RoomEventCacheInner> {
             // All new events are duplicated, they can all be ignored.
             events.clear();
             // The gap can be ditched too, as it won't be useful to backpaginate any
-            // further.
-            new_token = None;
+            // further. Not from the end though, where a known page only means we hold the
+            // newest events, so the token still leads somewhere new.
+            if !from_end {
+                new_token = None;
+            }
         }
 
         // `/messages` has been called with `dir=b` (backwards), so the events are in

Modified file: crates/matrix-sdk/tests/recent_history.rs+33 additions@@ -610,3 +610,36 @@ async fn test_recent_history_joins_on_any_retained_event() {
     assert_eq!(outcome.continuity, RecentHistoryContinuity::Joined);
     assert!(cache.history_gaps().await.unwrap().is_empty());
 }
+
+#[async_test]
+async fn test_retained_events_without_a_gap_paginate_from_the_end_until_creation() {
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().build().await;
+    client.event_cache().subscribe().unwrap();
+    let room_id = room_id!("!quiet:example.org");
+    let room = server.sync_joined_room(&client, room_id).await;
+    let (cache, _handles) = room.event_cache().await.unwrap();
+    let f = event_factory(room_id);
+    server
+        .sync_room(
+            &client,
+            JoinedRoomBuilder::new(room_id)
+                .add_timeline_event(f.text_msg("quiet").event_id(event_id!("$quiet"))),
+        )
+        .await;
+    server
+        .mock_room_messages()
+        .ok(RoomMessagesResponseTemplate::default().end_token("older").events(vec![
+            f.text_msg("quiet").event_id(event_id!("$quiet")),
+            f.text_msg("days ago").event_id(event_id!("$days-ago")),
+        ]))
+        .mock_once()
+        .mount()
+        .await;
+
+    let outcome = cache.pagination().run_backwards_once(20).await.unwrap();
+    assert!(!outcome.reached_start);
+    let ids: Vec<_> =
+        cache.events().await.unwrap().iter().filter_map(|event| event.event_id()).collect();
+    assert_eq!(ids, [event_id!("$days-ago"), event_id!("$quiet")]);
+}

matrix-rust-sdk

Commit 0f2f98298976

Commit `0f2f98298976`