macltok

public

Star0

Fork 0

Watch0

96 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `b34c2df6d896`

tarball

atagen <boss@atagen.co>2026-10-25 13:52 UTC

5 files changed+173-6

mentions: give inbox rows sender profiles and settled replies

Inbox rows came straight from normalise_observed, so they showed raw user ids and left every reply Pending for good. Observing now settles a row from what the client already holds, since the commit hook must not wait on the network, and a later capture's fetched profile and reply replace the offline ones.

Modified file: src/engine/context.rs+47 additions−1 deletions@@ -18,7 +18,7 @@ use crate::{
     engine::MediaService,
     normalise::{
         MediaRegistration, MediaScope, apply_profiles, member_sender, normalise_context,
-        normalise_observed, resolve_replies,
+        normalise_observed, resolve_replies, stored_member_sender,
     },
     transport::EventSender,
 };
@@ -540,6 +540,52 @@ async fn fetch_reply(
     }
 }
 
+/// settles an event built outside any page from what the client already holds, so it never
+/// waits on the network. the sender gets its stored profile and the reply comes from `known`
+/// or the event cache, or is unavailable
+pub(crate) async fn settle_offline(
+    room: &Room,
+    current_user_id: Option<&ruma::UserId>,
+    item: &mut TimelineItem,
+    known: impl Fn(&ruma::EventId) -> Option<TimelineEvent>,
+) {
+    let TimelineItem::Event(event) = item else {
+        return;
+    };
+    if let Some(sender) = stored_member_sender(room, &event.sender.user_id).await {
+        event.sender = sender;
+    }
+    let Some(reply) = &event.reply_to else {
+        return;
+    };
+    let target_id = reply.event_id.clone();
+    let mut target = known(&target_id);
+    if target.is_none()
+        && let Ok((cache, _handles)) = room.event_cache().await
+        && let Ok(Some(cached)) = cache.find_event(&target_id).await
+    {
+        target = serde_json::from_str::<Value>(cached.raw().json().get())
+            .ok()
+            .and_then(|value| {
+                let identity = format!("{}\n{target_id}", room.room_id());
+                match normalise_observed(&value, current_user_id, &identity)? {
+                    (TimelineItem::Event(event), _) => Some(*event),
+                    _ => None,
+                }
+            });
+    }
+    if let Some(target) = &mut target
+        && let Some(sender) = stored_member_sender(room, &target.sender.user_id).await
+    {
+        target.sender = sender;
+    }
+    let targets: HashMap<_, _> = target
+        .map(|target| (target_id, target))
+        .into_iter()
+        .collect();
+    resolve_replies(std::iter::once(&mut **event), &targets);
+}
+
 /// under lazy-loaded members a sender may be unknown locally, and `get_member` fetches the
 /// member list once for the room when it is
 async fn profiles<'a>(

Modified file: src/mentions/service.rs+39 additions−1 deletions@@ -893,9 +893,23 @@ impl Service {
                 .or_insert_with(|| Candidate::new(room_id.clone(), value, 0));
             return;
         }
-        let Some((item, media)) = normalise_observed(&value, Some(&self.account), &identity) else {
+        let Some((mut item, media)) = normalise_observed(&value, Some(&self.account), &identity)
+        else {
             return;
         };
+        if let Some(room) = self.client.get_room(room_id) {
+            let known = |event_id: &ruma::EventId| {
+                let key = id(&MentionKey {
+                    room_id: room_id.clone(),
+                    event_id: event_id.to_owned(),
+                });
+                match &data.events.get(&key)?.item {
+                    TimelineItem::Event(event) => Some((**event).clone()),
+                    _ => None,
+                }
+            };
+            context::settle_offline(&room, Some(&self.account), &mut item, known).await;
+        }
         self.supplement(data, &key, &item, &media, &value);
         let (reasons, suppressed, unresolved) = self.classify(data, room_id, &value).await;
         if unresolved {
@@ -1543,7 +1557,9 @@ impl Service {
                         raw: None,
                     };
                     if let Some(existing) = data.events.get(&event_key) {
+                        let captured = saved.item;
                         saved = existing.clone();
+                        improve(&mut saved.item, &captured);
                     }
                     if data.redacted.contains_key(&event_key) {
                         redact(&mut saved);
@@ -1556,6 +1572,7 @@ impl Service {
                     .into_iter()
                     .filter_map(&mut insert)
                     .collect();
+                let captured_target = context.event.clone();
                 let target = insert(context.event);
                 let mut after: Vec<_> = context
                     .events_after
@@ -1579,6 +1596,7 @@ impl Service {
                 after.dedup();
                 after.truncate(10);
                 let entry = data.entries.get_mut(&key).unwrap();
+                improve(&mut entry.event, &captured_target);
                 entry.capture = if target.is_none() {
                     MentionCaptureState::Unavailable
                 } else if after.len() < 10 || (before.len() < 10 && context.start_token.is_some()) {
@@ -1657,6 +1675,26 @@ fn retry_at(error: &Error, fallback_ms: u64) -> u64 {
     now().saturating_add(fallback_ms)
 }
 
+/// the capture fetched what observing at sync time couldn't, so its profile and reply win
+/// over the saved ones, while the saved content keeps its own edits and redactions
+fn improve(saved: &mut TimelineItem, captured: &TimelineItem) {
+    let (TimelineItem::Event(saved), TimelineItem::Event(captured)) = (saved, captured) else {
+        return;
+    };
+    if saved.event_id != captured.event_id {
+        return;
+    }
+    if captured.sender.display_name.is_some() || captured.sender.avatar.is_some() {
+        saved.sender = captured.sender.clone();
+    }
+    if let (Some(reply), Some(fetched)) = (&mut saved.reply_to, &captured.reply_to)
+        && !matches!(reply.details, crate::ReplyDetails::Ready { .. })
+        && matches!(fetched.details, crate::ReplyDetails::Ready { .. })
+    {
+        reply.details = fetched.details.clone();
+    }
+}
+
 fn redact(event: &mut SavedEvent) {
     if let TimelineItem::Event(item) = &mut event.item {
         item.content = TimelineContent::Redacted;

Modified file: src/normalise/member.rs+16 additions−3 deletions@@ -24,12 +24,25 @@ pub(crate) fn member_summary(member: RoomMember) -> MemberSummary {
     }
 }
 
+/// fetches the member list when it isn't synced yet, and settles for the store when that fails
 pub(crate) async fn member_sender(room: &Room, user_id: &OwnedUserId) -> Option<Sender> {
-    let member = room.get_member(user_id).await.ok().flatten()?;
-    Some(Sender {
+    match room.get_member(user_id).await {
+        Ok(Some(member)) => Some(sender(user_id, &member)),
+        _ => stored_member_sender(room, user_id).await,
+    }
+}
+
+/// what the state store already knows, without asking the server
+pub(crate) async fn stored_member_sender(room: &Room, user_id: &OwnedUserId) -> Option<Sender> {
+    let member = room.get_member_no_sync(user_id).await.ok().flatten()?;
+    Some(sender(user_id, &member))
+}
+
+fn sender(user_id: &OwnedUserId, member: &RoomMember) -> Sender {
+    Sender {
         user_id: user_id.clone(),
         display_name: member.display_name().map(str::to_owned),
         avatar: member.avatar_url().map(MediaId::plain),
         name_ambiguous: member.name_ambiguous(),
-    })
+    }
 }

Modified file: src/normalise/mod.rs+1−1

@@ -15,7 +15,7 @@ pub(crate) use image_pack::{

1515 };

1616 pub(crate) use link_preview::{ROOM_PREVIEW_URLS, server_preview, url_previews_allowed};

1717 pub(crate) use media::{MediaRegistration, MediaScope, MediaSourceInfo};

18-pub(crate) use member::{member_sender, member_summary};

18+pub(crate) use member::{member_sender, member_summary, stored_member_sender};

1919 pub(crate) use observed::{normalise_observed, poll_question};

2020 pub(crate) use room::notification_mode;

2121 pub(crate) use room::{room_summaries, space_child, stored_space_order};

Modified file: tests/mentions_inbox.rs+70 additions@@ -1106,3 +1106,73 @@ fn mentions_command_and_page_round_trip_through_serde() {
     let decoded_page: MentionsPage = serde_json::from_value(encoded_page).unwrap();
     assert_eq!(decoded_page, page);
 }
+
+#[tokio::test]
+async fn inbox_rows_carry_sender_profiles_and_never_leave_replies_pending() {
+    let server = MatrixMockServer::new().await;
+    let room_id = room_id!("!inbox-profiles:localhost");
+    let (client, own_user) = joined_client(&server, room_id).await;
+    let sender = user_id!("@alice:localhost");
+    let feed = SlidingFeed::new(
+        room_id.to_owned(),
+        vec![message("$parent", sender.as_str(), 1_000, "parent", None)],
+    );
+    feed.set_required_state(
+        room_id,
+        vec![json!({
+            "type": "m.room.member",
+            "state_key": sender,
+            "sender": sender,
+            "event_id": "$alice-member",
+            "origin_server_ts": 1,
+            "content": { "membership": "join", "displayname": "Alice" },
+        })],
+    );
+    feed.mount(&server).await;
+    let (engine, handle, mut events) = Engine::from_client(
+        client,
+        EngineConfig::default()
+            .with_initial_history_limit(0)
+            .with_search_backfill_pages_per_room(0),
+    )
+    .await
+    .unwrap();
+    let running = tokio::spawn(engine.run());
+    wait_for_requests(&feed, 2).await;
+
+    let reply = |event_id: &str, target: &str, timestamp| {
+        let mut event = message(
+            event_id,
+            sender.as_str(),
+            timestamp,
+            "reply",
+            Some(own_user.as_str()),
+        );
+        event["content"]["m.relates_to"] = json!({ "m.in_reply_to": { "event_id": target } });
+        event
+    };
+    feed.replace(
+        room_id,
+        vec![
+            reply("$answer", "$parent", 2_000),
+            reply("$orphan", "$missing", 2_100),
+        ],
+    );
+    let page = mentions_page(&mut events, room_id, |page| page.entries.len() == 2).await;
+    for entry in &page.entries {
+        let macltok::TimelineItem::Event(event) = &entry.event else {
+            panic!("a mention should be an event");
+        };
+        assert_eq!(event.sender.display_name.as_deref(), Some("Alice"));
+        let details = &event
+            .reply_to
+            .as_ref()
+            .expect("both mentions reply")
+            .details;
+        match entry.key.event_id.as_str() {
+            "$answer" => assert!(matches!(details, macltok::ReplyDetails::Ready { .. })),
+            _ => assert_eq!(details, &macltok::ReplyDetails::Unavailable),
+        }
+    }
+    shut_down(&handle, &mut events, running).await;
+}

macltok

Commit b34c2df6d896

Commit `b34c2df6d896`