macltok

public

Star0

Fork 0

Watch0

101 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `97fb5720d881`

tarball

atagen <boss@atagen.co>2026-10-25 14:19 UTC

3 files changed+149-7

threads: date an entry from the cache when its latest has no time

continuwuity 26.9's bare-content latest_event leaves a page entry undated, and the replies already in the event cache never arrive again, so latest_activity_ms fell back to the root's timestamp and the list sorted threads by their roots. build_entry now takes the newest reply the event cache holds for that root when the bundled latest is unusable.

Modified file: docs/design-decisions.md+2 additions−1 deletions@@ -144,7 +144,8 @@ corrected timestamp. the latest alone can't date a count. a summary from the
 event cache names its latest reply without the event, and continuwuity 26.9
 bundles the latest as bare content, so with only that check every reply the
 cache re-inserted read as new and a page's count doubled. a newer reply that
-doesn't count still becomes the latest. replays, reloads from the store and
+doesn't count still becomes the latest, and an entry built without a dated
+latest takes the newest reply the event cache holds. replays, reloads from the store and
 back pagination never count. a reply sync brings to a thread the list hasn't
 got fetches its root, four at a time, and adds it. one from anywhere else
 doesn't, since that

Modified file: src/engine/thread_list.rs+34 additions−4 deletions@@ -12,7 +12,9 @@ use matrix_sdk::{
     serde_helpers::extract_thread_root,
 };
 use matrix_sdk_ui::eyeball_im::VectorDiff;
-use ruma::{OwnedEventId, OwnedRoomId, OwnedUserId, UInt, push::Action};
+use ruma::{
+    OwnedEventId, OwnedRoomId, OwnedUserId, UInt, events::relation::RelationType, push::Action,
+};
 use tokio::sync::{broadcast::error::RecvError, mpsc};
 
 use super::{
@@ -801,11 +803,16 @@ async fn build_entry(
         Some(latest) => normalise(room, &latest, current_user_id, media_prefix).await,
         None => None,
     };
+    let latest = match latest {
+        Some(latest) => Some(latest),
+        None => cached_latest(room, &root.event_id, current_user_id, media_prefix).await,
+    };
     let summary = ThreadSummary {
         reply_count: summary.as_ref().map_or(0, |summary| summary.num_replies),
-        latest_event_id: summary
-            .and_then(|summary| summary.latest_reply)
-            .or_else(|| latest.as_ref().map(|latest| latest.event_id.clone())),
+        latest_event_id: latest
+            .as_ref()
+            .map(|latest| latest.event_id.clone())
+            .or_else(|| summary.and_then(|summary| summary.latest_reply)),
         latest_event_timestamp_ms: latest.as_ref().map(|latest| latest.timestamp_ms),
     };
     let mut media = root.media;
@@ -829,6 +836,29 @@ async fn build_entry(
     })
 }
 
+/// the newest reply the event cache holds, for a summary with no usable latest event.
+/// continuwuity 26.9 bundles only the latest's content, which dates nothing
+async fn cached_latest(
+    room: &Room,
+    root_event_id: &OwnedEventId,
+    current_user_id: Option<&ruma::UserId>,
+    media_prefix: &str,
+) -> Option<Normalised> {
+    let (cache, _drop_handles) = room.event_cache().await.ok()?;
+    let replies = cache
+        .find_event_relations(root_event_id, Some(vec![RelationType::Thread]))
+        .await
+        .inspect_err(
+            |error| tracing::debug!(%root_event_id, %error, "reading a thread's replies failed"),
+        )
+        .ok()?;
+    let newest = replies
+        .iter()
+        .filter(|reply| extract_thread_root(reply.raw()).as_ref() == Some(root_event_id))
+        .max_by_key(|reply| reply.timestamp())?;
+    normalise(room, newest, current_user_id, media_prefix).await
+}
+
 fn now_ms() -> u64 {
     u64::from(ruma::MilliSecondsSinceUnixEpoch::now().get())
 }

Modified file: tests/state.rs+113 additions−2 deletions@@ -4,12 +4,12 @@ use std::time::Duration;
 
 use macltok::{
     ConnectionState, Engine, EngineConfig, EngineError, Event, PackUsage, Retain, RoomMembership,
-    Termination, ThreadUnread,
+    Termination, ThreadListEntry, ThreadUnread,
 };
 use matrix_sdk::{
     ThreadingSupport,
     ruma::{
-        MilliSecondsSinceUnixEpoch, RoomId,
+        EventId, MilliSecondsSinceUnixEpoch, RoomId,
         api::client::sync::sync_events::v5,
         event_id,
         events::{
@@ -493,3 +493,114 @@ async fn a_thread_list_page_keeps_the_servers_count() {
 
     support::shut_down(&handle, &mut events, running).await;
 }
+
+/// with continuwuity's undated latest, the page has to date each thread from the replies the
+/// cache already holds, or it sorts by the root
+#[tokio::test]
+async fn a_thread_list_page_dates_threads_from_cached_replies() {
+    let server = MatrixMockServer::new().await;
+    server
+        .mock_sliding_sync()
+        .ok(v5::Response::new("1".to_owned()))
+        .mount()
+        .await;
+    let client = server
+        .client_builder()
+        .on_builder(|builder| {
+            builder.with_threading_support(ThreadingSupport::Enabled {
+                with_subscriptions: false,
+            })
+        })
+        .build()
+        .await;
+    let room_id = room_id!("!thread-dates:localhost");
+    let own = client.user_id().unwrap().to_owned();
+    server.mock_room_state_encryption().plain().mount().await;
+    client.event_cache().subscribe().unwrap();
+    let factory = EventFactory::new().room(room_id).sender(&ALICE);
+    let (early, first, second, late) = (
+        event_id!("$dates-early"),
+        event_id!("$dates-first"),
+        event_id!("$dates-second"),
+        event_id!("$dates-late"),
+    );
+    server
+        .sync_room(
+            &client,
+            JoinedRoomBuilder::new(room_id)
+                .add_state_event(EventFactory::new().room(room_id).member(&own))
+                .add_timeline_event(factory.text_msg("early").event_id(early).server_ts(1_000))
+                .add_timeline_event(
+                    factory
+                        .text_msg("one")
+                        .in_thread(early, early)
+                        .event_id(first)
+                        .server_ts(5_000),
+                )
+                .add_timeline_event(factory.text_msg("late").event_id(late).server_ts(7_000))
+                .add_timeline_event(
+                    factory
+                        .text_msg("two")
+                        .in_thread(early, first)
+                        .event_id(second)
+                        .server_ts(9_000),
+                ),
+        )
+        .await;
+    let listed = |root: &EventId, timestamp: u64, count: u64| -> Raw<AnyTimelineEvent> {
+        serde_json::from_value(json!({
+            "type": "m.room.message",
+            "event_id": root,
+            "room_id": room_id,
+            "sender": &*ALICE,
+            "origin_server_ts": timestamp,
+            "content": { "msgtype": "m.text", "body": "root" },
+            "unsigned": { "m.relations": { "m.thread": {
+                "latest_event": { "msgtype": "m.text", "body": "latest" },
+                "count": count,
+                "current_user_participated": false,
+            } } },
+        }))
+        .unwrap()
+    };
+    server
+        .mock_room_threads()
+        .ok(vec![listed(late, 7_000, 1), listed(early, 1_000, 2)], None)
+        .mount()
+        .await;
+    let config = EngineConfig::default().with_initial_history_limit(0);
+    let (engine, handle, mut events) = Engine::from_client(client.clone(), config).await.unwrap();
+    let running = tokio::spawn(engine.run());
+
+    handle.open_thread_list(room_id.to_owned()).await.unwrap();
+    handle
+        .paginate_thread_list(room_id.to_owned(), 20)
+        .await
+        .unwrap();
+    let changed = support::receive_until(&mut events, |event| {
+        matches!(event, Event::ThreadListChanged { .. })
+    })
+    .await;
+    let Event::ThreadListChanged { upserts, .. } = changed else {
+        unreachable!()
+    };
+    let mut entries = macltok::imbl::Vector::new();
+    for entry in upserts {
+        ThreadListEntry::upsert(&mut entries, entry);
+    }
+    let order: Vec<_> = entries
+        .iter()
+        .map(|entry| (entry.root_event_id.as_str(), entry.latest_activity_ms))
+        .collect();
+    assert_eq!(
+        order,
+        [(early.as_str(), 9_000), (late.as_str(), 7_000)],
+        "a thread was dated by its root rather than its newest cached reply"
+    );
+    let dated = &entries[0];
+    assert_eq!(dated.summary.latest_event_id.as_deref(), Some(second));
+    assert_eq!(dated.summary.latest_event_timestamp_ms, Some(9_000));
+    assert_eq!(dated.summary.reply_count, 2);
+
+    support::shut_down(&handle, &mut events, running).await;
+}

macltok

Commit 97fb5720d881

Commit `97fb5720d881`