macltok

public

Star0

Fork 0

Watch0

4 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `960ac0721079`

tarball

atagen <boss@atagen.co>2026-09-25 00:24 UTC

14 files changed+710-314

timeline: say what each event is instead of flattening it into a message

Every event used to arrive as a message whose body read [m.room.member] or <message redacted>, so clients had to parse English strings to tell a redaction from a real message. TimelineContent now carries messages with their msgtype, membership and profile changes, room state and undecryptable events with their cause. Replies fetch their target, since the SDK leaves it Unavailable until asked, and edit, redact and react take an EventRef so local echoes can be targeted.

Modified file: docs/design-decisions.md+29 additions@@ -75,6 +75,20 @@ out, so no stale diff can land after it
 
 `TimelineId` tells a room from a thread by its root event
 
+every item is an event, a day divider, the read marker or the start. an event
+carries its sender with avatar and name ambiguity, and a `TimelineContent`
+saying what it actually is. messages keep their msgtype, membership and profile
+changes and the common room state changes get their own variants, and anything
+else is `OtherState` or `Other` with its type. nothing is flattened into english
+in a body field
+
+replies carry the replied-to event once it's loaded. the watcher asks the sdk
+for any it hasn't got, once per event, since the sdk won't on its own
+
+edit, redact and react take an `EventRef`, so your own message can be edited or
+reacted to before the server has echoed it back. redacting an unsent one just
+cancels it
+
 ## mutations
 
 membership, moderation, power levels, room creation and account data writes go
@@ -116,6 +130,21 @@ replace it atomically with `ClientHandle::session_record()` on every
 store. a soft logout keeps the store for a same-device login, or the e2ee keys
 go with it. a bare `Stopped` kills nothing. one store directory per login
 
+## room lists, spaces and profiles
+
+`RoomSummary` has what a room list row needs without a second query. topic,
+alias, member counts, heroes for nameless rooms, the inviter, where an upgraded
+room went, a latest event preview, the joined spaces listing it, and for a
+space the children it lists
+
+parents come from one lazily built `SpaceService` shared by every handle.
+children come straight from the space's local state, joined or not.
+`space_hierarchy` pages through the server's view for browsing rooms you
+haven't joined, and holds its place between pages
+
+`own_profile` and `user_profile` read profiles. name and avatar changes are
+commands, and uploading an avatar gets the same byte cap as any upload
+
 ## notifications and room data
 
 the notification client is built lazily and shares the engine's sync service.

Modified file: docs/review-2026-09-24.md+3 additions−3 deletions@@ -210,7 +210,7 @@ fetch changes no state, yet it is a `MediaCommand` whose bytes arrive as a
 other frontend's image bytes, up to 20 MiB each, and the requester has to
 filter by `MediaId`.
 
-### A3. Every timeline item is a `Message`, with presentation strings in `body`. open, q3
+### A3. Every timeline item is a `Message`, with presentation strings in `body`. done
 
 `normalise_timeline_item` (`src/normalise/timeline.rs`) flattens every event
 into `TimelineMessage`. The consequences for a client are these.
@@ -235,7 +235,7 @@ This needs a content enum, for example `Message { msgtype, ... }`, `Redacted`,
 `UnableToDecrypt`, `Membership`, `ProfileChange`, `RoomState`, `Poll` and
 `Other { event_type }`. It is the largest single rendering gap.
 
-### A4. Timeline commands cannot target local echoes. open, lands with q3
+### A4. Timeline commands cannot target local echoes. done
 
 `Edit`, `Redact` and `ToggleReaction` take an `OwnedEventId` and wrap it in
 `TimelineEventItemId::EventId`. The SDK accepts transaction ids for all three,
@@ -243,7 +243,7 @@ but a client cannot edit, redact or react to a message it sent until the
 server echo arrives. The commands should take the identifier that the model
 already exposes.
 
-### A5. `RoomSummary` is too thin for a room list. open, lands with the malice queries and q2
+### A5. `RoomSummary` is too thin for a room list. done
 
 Missing fields, all cheap SDK reads. Topic, canonical alias, joined and invited
 member counts, heroes, tombstone and successor, inviter for invites, a latest

Modified file: examples/headless.rs+6 additions−4 deletions@@ -1,6 +1,6 @@
 use macltok::{
-    EngineConfig, Event, PasswordLogin, RoomMembership, Session, StoreConfig, TimelineId,
-    TimelineItem,
+    EngineConfig, Event, PasswordLogin, RoomMembership, Session, StoreConfig, TimelineContent,
+    TimelineId, TimelineItem,
 };
 
 #[tokio::main]
@@ -82,8 +82,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
 fn print_messages(items: &[TimelineItem]) {
     for item in items {
-        if let TimelineItem::Message(message) = item {
-            println!("{}  {}", message.sender_name, message.body);
+        if let TimelineItem::Event(event) = item
+            && let TimelineContent::Message(message) = &event.content
+        {
+            println!("{}  {}", event.sender.name(), message.body);
         }
     }
 }

Modified file: src/engine/timeline.rs+53 additions−12 deletions@@ -1,4 +1,4 @@
-use std::{future::Future, panic::AssertUnwindSafe, pin::Pin, sync::Arc};
+use std::{collections::HashSet, future::Future, panic::AssertUnwindSafe, pin::Pin, sync::Arc};
 
 use futures_util::{FutureExt, StreamExt};
 use matrix_sdk::{
@@ -22,8 +22,8 @@ use tokio::{
 };
 
 use crate::{
-    Error, ErrorKind, Event, HistoryState, MessageContent, MessageEditContent, MessageMentions,
-    RichText, TimelineCommand, TimelineId,
+    Error, ErrorKind, Event, EventRef, HistoryState, MessageContent, MessageEditContent,
+    MessageMentions, RichText, TimelineCommand, TimelineId,
     engine::MediaService,
     normalise::{MediaScope, normalise_timeline, normalise_timeline_diffs},
     transport::{EventSender, Responder, SendEventError},
@@ -163,17 +163,15 @@ impl TimelineSession {
         let background: Pin<Box<dyn Future<Output = Result<(), Error>> + Send>> = match command {
             TimelineCommand::Paginate { limit, .. } => return self.paginate(limit, Some(reply)),
             // network-bound, so it runs beside the actor instead of queueing the room behind it
-            TimelineCommand::Redact {
-                event_id, reason, ..
-            } => Box::pin(async move {
+            TimelineCommand::Redact { target, reason, .. } => Box::pin(async move {
                 timeline
-                    .redact(&TimelineEventItemId::EventId(event_id), reason.as_deref())
+                    .redact(&item_id(target), reason.as_deref())
                     .await
                     .map_err(timeline_error)
             }),
-            TimelineCommand::ToggleReaction { event_id, key, .. } => Box::pin(async move {
+            TimelineCommand::ToggleReaction { target, key, .. } => Box::pin(async move {
                 timeline
-                    .toggle_reaction(&TimelineEventItemId::EventId(event_id), &key)
+                    .toggle_reaction(&item_id(target), &key)
                     .await
                     .map(drop)
                     .map_err(timeline_error)
@@ -235,7 +233,7 @@ impl TimelineSession {
                     .map_err(timeline_error)
             }
             TimelineCommand::Edit {
-                event_id, content, ..
+                target, content, ..
             } => {
                 let (content, mentions, emote) = match content {
                     MessageEditContent::Text { content, mentions } => (content, mentions, false),
@@ -246,7 +244,7 @@ impl TimelineSession {
                 }
                 timeline
                     .edit(
-                        &TimelineEventItemId::EventId(event_id),
+                        &item_id(target),
                         EditedContent::RoomMessage(message_content(content, mentions, emote)),
                     )
                     .await
@@ -312,6 +310,35 @@ impl Drop for TimelineSession {
     }
 }
 
+fn item_id(target: EventRef) -> TimelineEventItemId {
+    match target {
+        EventRef::Remote(event_id) => TimelineEventItemId::EventId(event_id),
+        EventRef::Local(transaction_id) => TimelineEventItemId::TransactionId(transaction_id),
+    }
+}
+
+/// the sdk leaves a reply's target unloaded until someone asks, so the watcher asks, once per event
+struct ReplyFetcher {
+    timeline: Arc<Timeline>,
+    asked: HashSet<OwnedEventId>,
+    fetches: JoinSet<()>,
+}
+
+impl ReplyFetcher {
+    fn fetch(&mut self, missing: Vec<OwnedEventId>) {
+        for event_id in missing {
+            if self.asked.insert(event_id.clone()) {
+                let timeline = self.timeline.clone();
+                self.fetches.spawn(async move {
+                    if let Err(error) = timeline.fetch_details_for_event(&event_id).await {
+                        tracing::debug!(%event_id, %error, "fetching reply details failed");
+                    }
+                });
+            }
+        }
+    }
+}
+
 async fn start_watcher(
     id: &TimelineId,
     timeline: &Arc<Timeline>,
@@ -329,14 +356,28 @@ async fn start_watcher(
             items: normalised.items,
         })
         .await?;
+    let mut replies = ReplyFetcher {
+        timeline: timeline.clone(),
+        asked: HashSet::new(),
+        fetches: JoinSet::new(),
+    };
+    replies.fetch(normalised.missing_replies);
     let id = id.clone();
     let events = context.events.clone();
     let media = context.media.clone();
     let scope = scope.clone();
     Ok(context.supervisor.spawn("timeline watcher", async move {
-        while let Some(diffs) = stream.next().await {
+        loop {
+            let diffs = tokio::select! {
+                diffs = stream.next() => match diffs {
+                    Some(diffs) => diffs,
+                    None => return,
+                },
+                Some(_) = replies.fetches.join_next(), if !replies.fetches.is_empty() => continue,
+            };
             let normalised = normalise_timeline_diffs(diffs, current_user_id.as_deref(), &scope);
             media.register(normalised.media).await;
+            replies.fetch(normalised.missing_replies);
             let event = Event::TimelineChanged {
                 timeline_id: id.clone(),
                 diffs: normalised.diffs,

Modified file: src/lib.rs+13 additions−11 deletions@@ -21,18 +21,20 @@ pub use account::{
 pub use engine::{Engine, EngineConfig, EngineError};
 pub use error::{Error, ErrorKind};
 pub use model::{
-    AccountCommand, AttachmentUpload, Command, CommandOutput, ConnectionState, CreateRoomOptions,
-    EncryptionCommand, EncryptionState, EngineErrorKind, EngineFailure, Event, HistoryState,
-    KeyBackupState, LatestEvent, LifecycleCommand, Media, MediaCommand, MediaDescriptor, MediaId,
-    MediaKind, MediaSize, MemberFilter, MemberMembership, MemberSummary, MessageContent,
-    MessageEditContent, MessageMentions, NotificationCommand, OwnDevice, PowerLevelChanges,
-    Profile, PushNotification, PushNotificationEvent, PushNotificationRoom, PushNotificationSender,
-    PushNotificationStatus, Reaction, RecoveryState, ReplyReference, RichText, RoomCategory,
-    RoomCommand, RoomHero, RoomListFilter, RoomMatcher, RoomMembership, RoomNotificationMode,
+    AccountCommand, AttachmentUpload, Change, Command, CommandOutput, ConnectionState,
+    CreateRoomOptions, EncryptionCommand, EncryptionState, EngineErrorKind, EngineFailure, Event,
+    EventRef, HistoryState, KeyBackupState, LatestEvent, LifecycleCommand, Media, MediaCommand,
+    MediaDescriptor, MediaId, MediaKind, MediaSize, MemberFilter, MemberMembership, MemberSummary,
+    MembershipChange, Message, MessageContent, MessageEditContent, MessageKind, MessageMentions,
+    NotificationCommand, OwnDevice, PowerLevelChanges, Profile, PushNotification,
+    PushNotificationEvent, PushNotificationRoom, PushNotificationSender, PushNotificationStatus,
+    Reaction, RecoveryState, ReplyDetails, ReplyReference, RichText, RoomCategory, RoomCommand,
+    RoomHero, RoomListFilter, RoomMatcher, RoomMembership, RoomNotificationMode,
     RoomNotificationSettings, RoomPowerLevels, RoomPreset, RoomSummary, RoomVisibility, SendState,
-    SpaceChild, ThreadSummary, TimelineCommand, TimelineDiff, TimelineDiffError, TimelineId,
-    TimelineItem, TimelineItemId, TimelineMessage, TypingState, UploadDetails, UploadThumbnail,
-    VerificationAction, VerificationFailure, VerificationState, VerificationTarget,
+    Sender, SpaceChild, ThreadSummary, TimelineCommand, TimelineContent, TimelineDiff,
+    TimelineDiffError, TimelineEvent, TimelineId, TimelineItem, TimelineItemId, TypingState,
+    UploadDetails, UploadThumbnail, UtdCause, VerificationAction, VerificationFailure,
+    VerificationState, VerificationTarget,
 };
 pub use transport::{ClientHandle, EventStream, Pending, SpaceHierarchy};
 pub use uiaa::{

Modified file: src/model.rs+188 additions−17 deletions@@ -219,17 +219,18 @@ pub enum TimelineCommand {
     },
     Edit {
         timeline_id: TimelineId,
-        event_id: OwnedEventId,
+        target: EventRef,
         content: MessageEditContent,
     },
+    /// redacting your own unsent message just cancels it
     Redact {
         timeline_id: TimelineId,
-        event_id: OwnedEventId,
+        target: EventRef,
         reason: Option<String>,
     },
     ToggleReaction {
         timeline_id: TimelineId,
-        event_id: OwnedEventId,
+        target: EventRef,
         key: String,
     },
     /// works on a closed room too, it just can't refuse to move the marker backwards
@@ -1041,7 +1042,7 @@ pub struct OwnDevice {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[non_exhaustive]
 pub enum TimelineItem {
-    Message(Box<TimelineMessage>),
+    Event(Box<TimelineEvent>),
     DayDivider { timestamp_ms: u64 },
     ReadMarker,
     TimelineStart,
@@ -1220,26 +1221,183 @@ impl TimelineItemId {
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[non_exhaustive]
-pub struct TimelineMessage {
+pub struct TimelineEvent {
     pub item_id: TimelineItemId,
     pub event_id: Option<OwnedEventId>,
     pub transaction_id: Option<OwnedTransactionId>,
-    pub sender_id: OwnedUserId,
-    pub sender_name: String,
-    pub body: String,
-    pub formatted_body: Option<String>,
-    pub mentions: Option<MessageMentions>,
-    pub thread_root: Option<OwnedEventId>,
-    pub thread_summary: Option<ThreadSummary>,
+    pub sender: Sender,
     pub timestamp_ms: u64,
     pub own: bool,
     pub send_state: SendState,
-    pub edited: bool,
-    pub unable_to_decrypt: bool,
-    pub media: Option<MediaDescriptor>,
+    pub content: TimelineContent,
     pub reply_to: Option<ReplyReference>,
+    pub thread_root: Option<OwnedEventId>,
+    pub thread_summary: Option<ThreadSummary>,
     pub reactions: Vec<Reaction>,
     pub read_by: Vec<OwnedUserId>,
+    pub editable: bool,
+}
+
+impl TimelineEvent {
+    /// what to hand edit, redact and react. works before the server has echoed it back
+    #[must_use]
+    pub fn target(&self) -> Option<EventRef> {
+        self.event_id
+            .clone()
+            .map(EventRef::Remote)
+            .or_else(|| self.transaction_id.clone().map(EventRef::Local))
+    }
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum EventRef {
+    Remote(OwnedEventId),
+    /// a local echo, by the transaction id it was queued under
+    Local(OwnedTransactionId),
+}
+
+impl From<OwnedEventId> for EventRef {
+    fn from(event_id: OwnedEventId) -> Self {
+        Self::Remote(event_id)
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct Sender {
+    pub user_id: OwnedUserId,
+    pub display_name: Option<String>,
+    pub avatar: Option<OwnedMxcUri>,
+    /// someone else in the room goes by the same name, so show the user id too
+    pub name_ambiguous: bool,
+}
+
+impl Sender {
+    #[must_use]
+    pub fn name(&self) -> &str {
+        self.display_name
+            .as_deref()
+            .unwrap_or_else(|| self.user_id.as_str())
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum TimelineContent {
+    Message(Message),
+    Sticker {
+        body: String,
+        media: MediaDescriptor,
+    },
+    Poll {
+        question: String,
+    },
+    Redacted,
+    UnableToDecrypt(UtdCause),
+    Membership {
+        user_id: OwnedUserId,
+        display_name: Option<String>,
+        change: MembershipChange,
+    },
+    Profile {
+        user_id: OwnedUserId,
+        display_name: Option<Change<Option<String>>>,
+        avatar: Option<Change<Option<OwnedMxcUri>>>,
+    },
+    /// `None` means it was cleared
+    RoomName(Option<String>),
+    RoomTopic(Option<String>),
+    RoomAvatar(Option<OwnedMxcUri>),
+    EncryptionEnabled,
+    RoomCreated,
+    RoomUpgraded {
+        successor: OwnedRoomId,
+    },
+    OtherState {
+        event_type: String,
+        state_key: String,
+    },
+    Other {
+        event_type: String,
+    },
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct Message {
+    pub kind: MessageKind,
+    pub body: String,
+    pub formatted_body: Option<String>,
+    pub mentions: Option<MessageMentions>,
+    pub edited: bool,
+    pub media: Option<MediaDescriptor>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum MessageKind {
+    Text,
+    Emote,
+    Notice,
+    ServerNotice,
+    Image,
+    Video,
+    Audio,
+    File,
+    Location,
+    VerificationRequest,
+    Other(String),
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum MembershipChange {
+    Joined,
+    Left,
+    Banned,
+    Unbanned,
+    Kicked,
+    KickedAndBanned,
+    Invited,
+    InvitationAccepted,
+    InvitationRejected,
+    InvitationRevoked,
+    Knocked,
+    KnockAccepted,
+    KnockRetracted,
+    KnockDenied,
+    /// nothing a person would call a change, or something the sdk couldn't make sense of
+    Other,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct Change<T> {
+    pub old: T,
+    pub new: T,
+}
+
+/// why a message couldn't be read, worth telling the user since some of these they can fix
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum UtdCause {
+    Unknown,
+    SentBeforeWeJoined,
+    VerificationViolation,
+    UnsignedDevice,
+    UnknownDevice,
+    HistoricalMessageAndBackupIsDisabled,
+    WithheldForUnverifiedOrInsecureDevice,
+    WithheldBySender,
+    HistoricalMessageAndDeviceIsUnverified,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1266,8 +1424,21 @@ pub enum SendState {
 #[non_exhaustive]
 pub struct ReplyReference {
     pub event_id: OwnedEventId,
-    pub sender_id: Option<OwnedUserId>,
-    pub sender_name: Option<String>,
+    pub details: ReplyDetails,
+}
+
+/// the replied-to event. macltok asks for it when it isn't loaded, `Pending` then turns into one of the others
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum ReplyDetails {
+    Pending,
+    Ready {
+        sender: Sender,
+        content: Box<TimelineContent>,
+        timestamp_ms: u64,
+    },
+    Unavailable,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]

Modified file: src/normalise/timeline.rs+354 additions−222 deletions@@ -1,21 +1,27 @@
 use std::sync::Arc;
 
+use matrix_sdk_crypto::types::events::UtdCause as SdkUtdCause;
 use matrix_sdk_ui::{
     eyeball_im::VectorDiff,
     timeline::{
-        EventSendState, MsgLikeKind, TimelineDetails, TimelineEventItemId,
-        TimelineItem as SdkTimelineItem, TimelineItemContent, TimelineItemKind,
-        VirtualTimelineItem,
+        AnyOtherStateEventContentChange, EncryptedMessage, EventSendState, EventTimelineItem,
+        MembershipChange as SdkMembershipChange, MsgLikeContent, MsgLikeKind, Profile,
+        TimelineDetails, TimelineEventItemId, TimelineItem as SdkTimelineItem, TimelineItemContent,
+        TimelineItemKind, VirtualTimelineItem,
     },
 };
 use ruma::{
-    UserId,
-    events::room::message::{MessageFormat, MessageType},
+    OwnedEventId, UserId,
+    events::{
+        StateEventContentChange,
+        room::message::{MessageFormat, MessageType},
+    },
 };
 
 use crate::{
-    MessageMentions, Reaction, ReplyReference, SendState, ThreadSummary, TimelineDiff,
-    TimelineItem, TimelineItemId, TimelineMessage,
+    Change, MembershipChange, Message, MessageKind, MessageMentions, Reaction, ReplyDetails,
+    ReplyReference, SendState, Sender, ThreadSummary, TimelineContent, TimelineDiff, TimelineEvent,
+    TimelineItem, TimelineItemId, UtdCause,
 };
 
 use super::media::{
@@ -23,9 +29,98 @@ use super::media::{
     media_identity, media_registration_for_item,
 };
 
+#[derive(Default)]
 pub(crate) struct NormalisedTimeline {
     pub(crate) items: Vec<TimelineItem>,
     pub(crate) media: Vec<MediaRegistration>,
+    /// replies whose target isn't loaded, so somebody should go and ask for it
+    pub(crate) missing_replies: Vec<OwnedEventId>,
+}
+
+pub(crate) struct NormalisedTimelineDiffs {
+    pub(crate) diffs: Vec<TimelineDiff>,
+    pub(crate) media: Vec<MediaRegistration>,
+    pub(crate) missing_replies: Vec<OwnedEventId>,
+}
+
+struct Normaliser<'a> {
+    current_user_id: Option<&'a UserId>,
+    scope: &'a MediaScope,
+    media: Vec<MediaRegistration>,
+    missing_replies: Vec<OwnedEventId>,
+}
+
+impl Normaliser<'_> {
+    fn item(&mut self, item: &SdkTimelineItem) -> TimelineItem {
+        if let Some(media) = media_registration_for_item(item, self.scope) {
+            self.media.push(media);
+        }
+        match item.kind() {
+            TimelineItemKind::Event(event) => {
+                TimelineItem::Event(Box::new(self.event(item, event)))
+            }
+            TimelineItemKind::Virtual(VirtualTimelineItem::DateDivider(timestamp)) => {
+                TimelineItem::DayDivider {
+                    timestamp_ms: timestamp.get().into(),
+                }
+            }
+            TimelineItemKind::Virtual(VirtualTimelineItem::ReadMarker) => TimelineItem::ReadMarker,
+            TimelineItemKind::Virtual(VirtualTimelineItem::TimelineStart) => {
+                TimelineItem::TimelineStart
+            }
+        }
+    }
+
+    fn event(&mut self, item: &SdkTimelineItem, event: &EventTimelineItem) -> TimelineEvent {
+        let msg_like = match event.content() {
+            TimelineItemContent::MsgLike(content) => Some(content),
+            _ => None,
+        };
+        let reply_to = msg_like
+            .and_then(|content| content.in_reply_to.as_ref())
+            .map(|reply| {
+                let details = match &reply.event {
+                    TimelineDetails::Ready(embedded) => ReplyDetails::Ready {
+                        sender: sender(&embedded.sender, &embedded.sender_profile),
+                        content: Box::new(content(&embedded.content, None)),
+                        timestamp_ms: embedded.timestamp.get().into(),
+                    },
+                    TimelineDetails::Unavailable => {
+                        self.missing_replies.push(reply.event_id.clone());
+                        ReplyDetails::Pending
+                    }
+                    TimelineDetails::Pending => ReplyDetails::Pending,
+                    TimelineDetails::Error(_) => ReplyDetails::Unavailable,
+                };
+                ReplyReference {
+                    event_id: reply.event_id.clone(),
+                    details,
+                }
+            });
+        let mut read_by: Vec<_> = event
+            .read_receipts()
+            .keys()
+            .filter(|user_id| *user_id != event.sender())
+            .cloned()
+            .collect();
+        read_by.sort();
+        TimelineEvent {
+            item_id: TimelineItemId::new(item.unique_id().0.clone()),
+            event_id: event.event_id().map(ToOwned::to_owned),
+            transaction_id: event.transaction_id().map(ToOwned::to_owned),
+            sender: sender(event.sender(), event.sender_profile()),
+            timestamp_ms: event.timestamp().get().into(),
+            own: event.is_own(),
+            send_state: send_state(event.send_state()),
+            content: content(event.content(), Some(&media_identity(item, self.scope))),
+            reply_to,
+            thread_root: msg_like.and_then(|content| content.thread_root.clone()),
+            thread_summary: msg_like.and_then(thread_summary),
+            reactions: reactions(event, self.current_user_id),
+            read_by,
+            editable: event.is_editable(),
+        }
+    }
 }
 
 pub(crate) fn normalise_timeline<'a>(
@@ -33,19 +128,18 @@ pub(crate) fn normalise_timeline<'a>(
     current_user_id: Option<&UserId>,
     scope: &MediaScope,
 ) -> NormalisedTimeline {
-    let mut normalised = NormalisedTimeline {
-        items: Vec::new(),
+    let mut normaliser = Normaliser {
+        current_user_id,
+        scope,
         media: Vec::new(),
+        missing_replies: Vec::new(),
     };
-    for item in items {
-        if let Some(media) = media_registration_for_item(item, scope) {
-            normalised.media.push(media);
-        }
-        normalised
-            .items
-            .push(normalise_timeline_item(item, current_user_id, scope));
+    let items = items.map(|item| normaliser.item(item)).collect();
+    NormalisedTimeline {
+        items,
+        media: normaliser.media,
+        missing_replies: normaliser.missing_replies,
     }
-    normalised
 }
 
 pub(crate) fn normalise_timeline_diffs(
@@ -53,171 +147,265 @@ pub(crate) fn normalise_timeline_diffs(
     current_user_id: Option<&UserId>,
     scope: &MediaScope,
 ) -> NormalisedTimelineDiffs {
-    let mut media = Vec::new();
+    let mut normaliser = Normaliser {
+        current_user_id,
+        scope,
+        media: Vec::new(),
+        missing_replies: Vec::new(),
+    };
     let diffs = diffs
         .into_iter()
-        .map(|diff| {
-            let diff = diff.map(|item| {
-                if let Some(registration) = media_registration_for_item(&item, scope) {
-                    media.push(registration);
-                }
-                normalise_timeline_item(&item, current_user_id, scope)
-            });
-            match diff {
-                VectorDiff::Append { values } => TimelineDiff::Append {
-                    values: values.into_iter().collect(),
-                },
-                VectorDiff::Clear => TimelineDiff::Clear,
-                VectorDiff::PushFront { value } => TimelineDiff::PushFront { value },
-                VectorDiff::PushBack { value } => TimelineDiff::PushBack { value },
-                VectorDiff::PopFront => TimelineDiff::PopFront,
-                VectorDiff::PopBack => TimelineDiff::PopBack,
-                VectorDiff::Insert { index, value } => TimelineDiff::Insert { index, value },
-                VectorDiff::Set { index, value } => TimelineDiff::Set { index, value },
-                VectorDiff::Remove { index } => TimelineDiff::Remove { index },
-                VectorDiff::Truncate { length } => TimelineDiff::Truncate { length },
-                VectorDiff::Reset { values } => TimelineDiff::Reset {
-                    values: values.into_iter().collect(),
-                },
-            }
+        .map(|diff| match diff.map(|item| normaliser.item(&item)) {
+            VectorDiff::Append { values } => TimelineDiff::Append {
+                values: values.into_iter().collect(),
+            },
+            VectorDiff::Clear => TimelineDiff::Clear,
+            VectorDiff::PushFront { value } => TimelineDiff::PushFront { value },
+            VectorDiff::PushBack { value } => TimelineDiff::PushBack { value },
+            VectorDiff::PopFront => TimelineDiff::PopFront,
+            VectorDiff::PopBack => TimelineDiff::PopBack,
+            VectorDiff::Insert { index, value } => TimelineDiff::Insert { index, value },
+            VectorDiff::Set { index, value } => TimelineDiff::Set { index, value },
+            VectorDiff::Remove { index } => TimelineDiff::Remove { index },
+            VectorDiff::Truncate { length } => TimelineDiff::Truncate { length },
+            VectorDiff::Reset { values } => TimelineDiff::Reset {
+                values: values.into_iter().collect(),
+            },
         })
         .collect();
-    NormalisedTimelineDiffs { diffs, media }
+    NormalisedTimelineDiffs {
+        diffs,
+        media: normaliser.media,
+        missing_replies: normaliser.missing_replies,
+    }
 }
 
-pub(crate) struct NormalisedTimelineDiffs {
-    pub(crate) diffs: Vec<TimelineDiff>,
-    pub(crate) media: Vec<MediaRegistration>,
+/// `media_identity` is `None` for embedded reply content, which never gets fetchable media of its own
+fn content(content: &TimelineItemContent, media_identity: Option<&str>) -> TimelineContent {
+    match content {
+        TimelineItemContent::MsgLike(content) => msg_like(content, media_identity),
+        TimelineItemContent::MembershipChange(change) => TimelineContent::Membership {
+            user_id: change.user_id().to_owned(),
+            display_name: change.display_name(),
+            change: change
+                .change()
+                .map_or(MembershipChange::Other, membership_change),
+        },
+        TimelineItemContent::ProfileChange(change) => TimelineContent::Profile {
+            user_id: change.user_id().to_owned(),
+            display_name: change.displayname_change().map(|change| Change {
+                old: change.old.clone(),
+                new: change.new.clone(),
+            }),
+            avatar: change.avatar_url_change().map(|change| Change {
+                old: change.old.clone(),
+                new: change.new.clone(),
+            }),
+        },
+        TimelineItemContent::OtherState(state) => match state.content() {
+            AnyOtherStateEventContentChange::RoomName(change) => {
+                TimelineContent::RoomName(original(change).map(|content| content.name.clone()))
+            }
+            AnyOtherStateEventContentChange::RoomTopic(change) => {
+                TimelineContent::RoomTopic(original(change).map(|content| content.topic.clone()))
+            }
+            AnyOtherStateEventContentChange::RoomAvatar(change) => TimelineContent::RoomAvatar(
+                original(change).and_then(|content| content.url.clone()),
+            ),
+            AnyOtherStateEventContentChange::RoomEncryption(_) => {
+                TimelineContent::EncryptionEnabled
+            }
+            AnyOtherStateEventContentChange::RoomCreate(_) => TimelineContent::RoomCreated,
+            AnyOtherStateEventContentChange::RoomTombstone(change) => match original(change) {
+                Some(content) => TimelineContent::RoomUpgraded {
+                    successor: content.replacement_room.clone(),
+                },
+                None => other_state(state.content().event_type().to_string(), state.state_key()),
+            },
+            other => other_state(other.event_type().to_string(), state.state_key()),
+        },
+        TimelineItemContent::FailedToParseMessageLike { event_type, .. } => {
+            TimelineContent::Other {
+                event_type: event_type.to_string(),
+            }
+        }
+        TimelineItemContent::FailedToParseState {
+            event_type,
+            state_key,
+            ..
+        } => other_state(event_type.to_string(), state_key),
+        TimelineItemContent::CallInvite => TimelineContent::Other {
+            event_type: "m.call.invite".to_owned(),
+        },
+        TimelineItemContent::RtcNotification { .. } => TimelineContent::Other {
+            event_type: "org.matrix.msc4075.rtc.notification".to_owned(),
+        },
+    }
 }
 
-fn normalise_timeline_item(
-    item: &SdkTimelineItem,
-    current_user_id: Option<&UserId>,
-    scope: &MediaScope,
-) -> TimelineItem {
-    match item.kind() {
-        TimelineItemKind::Event(event) => TimelineItem::Message(Box::new(timeline_message(
-            item,
-            event,
-            current_user_id,
-            scope,
-        ))),
-        TimelineItemKind::Virtual(VirtualTimelineItem::DateDivider(timestamp)) => {
-            TimelineItem::DayDivider {
-                timestamp_ms: timestamp.get().into(),
+fn other_state(event_type: String, state_key: &str) -> TimelineContent {
+    TimelineContent::OtherState {
+        event_type,
+        state_key: state_key.to_owned(),
+    }
+}
+
+fn original<C>(change: &StateEventContentChange<C>) -> Option<&C>
+where
+    C: ruma::events::StaticStateEventContent + ruma::events::RedactContent,
+{
+    match change {
+        StateEventContentChange::Original { content, .. } => Some(content),
+        StateEventContentChange::Redacted(_) => None,
+    }
+}
+
+fn msg_like(content: &MsgLikeContent, media_identity: Option<&str>) -> TimelineContent {
+    match &content.kind {
+        MsgLikeKind::Message(message) => TimelineContent::Message(Message {
+            kind: message_kind(message.msgtype()),
+            body: message.body().to_owned(),
+            formatted_body: formatted_body(message.msgtype()),
+            mentions: message.mentions().map(|mentions| MessageMentions {
+                user_ids: mentions.user_ids.iter().cloned().collect(),
+                room: mentions.room,
+            }),
+            edited: message.is_edited(),
+            media: media_identity
+                .and_then(|identity| media_from_message(identity, message.msgtype())),
+        }),
+        MsgLikeKind::Sticker(sticker) => {
+            let sticker = sticker.content();
+            match media_identity {
+                Some(identity) => TimelineContent::Sticker {
+                    body: sticker.body.clone(),
+                    media: media_descriptor_for_sticker(identity, sticker),
+                },
+                None => TimelineContent::Other {
+                    event_type: "m.sticker".to_owned(),
+                },
             }
         }
-        TimelineItemKind::Virtual(VirtualTimelineItem::ReadMarker) => TimelineItem::ReadMarker,
-        TimelineItemKind::Virtual(VirtualTimelineItem::TimelineStart) => {
-            TimelineItem::TimelineStart
+        MsgLikeKind::Poll(poll) => TimelineContent::Poll {
+            question: poll.results().question,
+        },
+        MsgLikeKind::Redacted => TimelineContent::Redacted,
+        MsgLikeKind::UnableToDecrypt(encrypted) => {
+            TimelineContent::UnableToDecrypt(match encrypted {
+                EncryptedMessage::MegolmV1AesSha2 { cause, .. } => utd_cause(*cause),
+                _ => UtdCause::Unknown,
+            })
         }
+        MsgLikeKind::Other(other) => TimelineContent::Other {
+            event_type: other.event_type().to_string(),
+        },
+        MsgLikeKind::LiveLocation(_) => TimelineContent::Other {
+            event_type: "m.beacon_info".to_owned(),
+        },
     }
 }
 
-fn timeline_message(
-    item: &SdkTimelineItem,
-    event: &matrix_sdk_ui::timeline::EventTimelineItem,
-    current_user_id: Option<&UserId>,
-    scope: &MediaScope,
-) -> TimelineMessage {
-    let (body, formatted_body, mentions, edited, unable_to_decrypt, media) = match event.content() {
-        TimelineItemContent::MsgLike(content) => match &content.kind {
-            MsgLikeKind::Message(message) => (
-                message.body().to_owned(),
-                formatted_body(message.msgtype()),
-                message.mentions().map(message_mentions),
-                message.is_edited(),
-                false,
-                media_from_message(&media_identity(item, scope), message.msgtype()),
-            ),
-            MsgLikeKind::Sticker(sticker) => {
-                let content = sticker.content();
-                (
-                    content.body.clone(),
-                    None,
-                    None,
-                    false,
-                    false,
-                    Some(media_descriptor_for_sticker(
-                        &media_identity(item, scope),
-                        content,
-                    )),
-                )
-            }
-            MsgLikeKind::Redacted => ("<message redacted>".into(), None, None, false, false, None),
-            MsgLikeKind::UnableToDecrypt(_) => (
-                "<unable to decrypt message>".into(),
-                None,
-                None,
-                false,
-                true,
-                None,
-            ),
-            MsgLikeKind::Poll(_) => ("[poll]".into(), None, None, false, false, None),
-            MsgLikeKind::LiveLocation(_) => {
-                ("[live location]".into(), None, None, false, false, None)
-            }
-            MsgLikeKind::Other(other) => (
-                format!("[{}]", other.event_type()),
-                None,
-                None,
-                false,
-                false,
-                None,
-            ),
-        },
-        other => (
-            format!(
-                "[{}]",
-                other.event_type_str().unwrap_or_else(|| "event".into())
-            ),
-            None,
-            None,
-            false,
-            false,
-            None,
-        ),
-    };
-    let reply_to = match event.content() {
-        TimelineItemContent::MsgLike(content) => content.in_reply_to.as_ref().map(|reply| {
-            let event_id = reply.event_id.to_owned();
-            let embedded_sender = match &reply.event {
-                TimelineDetails::Ready(event) => Some((
-                    event.sender.clone(),
-                    sender_name(&event.sender, &event.sender_profile),
-                )),
-                _ => None,
-            };
-            ReplyReference {
-                event_id,
-                sender_id: embedded_sender.as_ref().map(|(id, _)| id.clone()),
-                sender_name: embedded_sender.map(|(_, name)| name),
-            }
-        }),
+fn message_kind(message: &MessageType) -> MessageKind {
+    match message {
+        MessageType::Text(_) => MessageKind::Text,
+        MessageType::Emote(_) => MessageKind::Emote,
+        MessageType::Notice(_) => MessageKind::Notice,
+        MessageType::ServerNotice(_) => MessageKind::ServerNotice,
+        MessageType::Image(_) => MessageKind::Image,
+        MessageType::Video(_) => MessageKind::Video,
+        MessageType::Audio(_) => MessageKind::Audio,
+        MessageType::File(_) => MessageKind::File,
+        MessageType::Location(_) => MessageKind::Location,
+        MessageType::VerificationRequest(_) => MessageKind::VerificationRequest,
+        other => MessageKind::Other(other.msgtype().to_owned()),
+    }
+}
+
+const fn membership_change(change: SdkMembershipChange) -> MembershipChange {
+    match change {
+        SdkMembershipChange::Joined => MembershipChange::Joined,
+        SdkMembershipChange::Left => MembershipChange::Left,
+        SdkMembershipChange::Banned => MembershipChange::Banned,
+        SdkMembershipChange::Unbanned => MembershipChange::Unbanned,
+        SdkMembershipChange::Kicked => MembershipChange::Kicked,
+        SdkMembershipChange::KickedAndBanned => MembershipChange::KickedAndBanned,
+        SdkMembershipChange::Invited => MembershipChange::Invited,
+        SdkMembershipChange::InvitationAccepted => MembershipChange::InvitationAccepted,
+        SdkMembershipChange::InvitationRejected => MembershipChange::InvitationRejected,
+        SdkMembershipChange::InvitationRevoked => MembershipChange::InvitationRevoked,
+        SdkMembershipChange::Knocked => MembershipChange::Knocked,
+        SdkMembershipChange::KnockAccepted => MembershipChange::KnockAccepted,
+        SdkMembershipChange::KnockRetracted => MembershipChange::KnockRetracted,
+        SdkMembershipChange::KnockDenied => MembershipChange::KnockDenied,
+        SdkMembershipChange::None
+        | SdkMembershipChange::Error
+        | SdkMembershipChange::NotImplemented => MembershipChange::Other,
+    }
+}
+
+const fn utd_cause(cause: SdkUtdCause) -> UtdCause {
+    match cause {
+        SdkUtdCause::Unknown => UtdCause::Unknown,
+        SdkUtdCause::SentBeforeWeJoined => UtdCause::SentBeforeWeJoined,
+        SdkUtdCause::VerificationViolation => UtdCause::VerificationViolation,
+        SdkUtdCause::UnsignedDevice => UtdCause::UnsignedDevice,
+        SdkUtdCause::UnknownDevice => UtdCause::UnknownDevice,
+        SdkUtdCause::HistoricalMessageAndBackupIsDisabled => {
+            UtdCause::HistoricalMessageAndBackupIsDisabled
+        }
+        SdkUtdCause::WithheldForUnverifiedOrInsecureDevice => {
+            UtdCause::WithheldForUnverifiedOrInsecureDevice
+        }
+        SdkUtdCause::WithheldBySender => UtdCause::WithheldBySender,
+        SdkUtdCause::HistoricalMessageAndDeviceIsUnverified => {
+            UtdCause::HistoricalMessageAndDeviceIsUnverified
+        }
+    }
+}
+
+fn sender(user_id: &UserId, profile: &TimelineDetails<Profile>) -> Sender {
+    let profile = match profile {
+        TimelineDetails::Ready(profile) => Some(profile),
         _ => None,
     };
-    let (thread_root, thread_summary) = match event.content() {
-        TimelineItemContent::MsgLike(content) => (
-            content.thread_root.clone(),
-            content.thread_summary.as_ref().map(|summary| {
-                let latest_event = match &summary.latest_event {
-                    TimelineDetails::Ready(event) => Some(event.as_ref()),
-                    _ => None,
-                };
-                ThreadSummary {
-                    reply_count: summary.num_replies,
-                    latest_event_id: latest_event.and_then(|event| match &event.identifier {
-                        TimelineEventItemId::EventId(event_id) => Some(event_id.clone()),
-                        TimelineEventItemId::TransactionId(_) => None,
-                    }),
-                    latest_event_timestamp_ms: latest_event
-                        .map(|event| event.timestamp.get().into()),
-                }
+    Sender {
+        user_id: user_id.to_owned(),
+        display_name: profile.and_then(|profile| profile.display_name.clone()),
+        avatar: profile.and_then(|profile| profile.avatar_url.clone()),
+        name_ambiguous: profile.is_some_and(|profile| profile.display_name_ambiguous),
+    }
+}
+
+fn send_state(state: Option<&EventSendState>) -> SendState {
+    match state {
+        None | Some(EventSendState::Sent { .. }) => SendState::Sent,
+        Some(EventSendState::NotSentYet { progress: Some(_) }) => SendState::Sending,
+        Some(EventSendState::NotSentYet { progress: None }) => SendState::Queued,
+        Some(EventSendState::SendingFailed { is_recoverable, .. }) => SendState::Failed {
+            retriable: *is_recoverable,
+        },
+    }
+}
+
+fn thread_summary(content: &MsgLikeContent) -> Option<ThreadSummary> {
+    content.thread_summary.as_ref().map(|summary| {
+        let latest_event = match &summary.latest_event {
+            TimelineDetails::Ready(event) => Some(event.as_ref()),
+            _ => None,
+        };
+        ThreadSummary {
+            reply_count: summary.num_replies,
+            latest_event_id: latest_event.and_then(|event| match &event.identifier {
+                TimelineEventItemId::EventId(event_id) => Some(event_id.clone()),
+                TimelineEventItemId::TransactionId(_) => None,
             }),
-        ),
-        _ => (None, None),
-    };
-    let reactions = event
+            latest_event_timestamp_ms: latest_event.map(|event| event.timestamp.get().into()),
+        }
+    })
+}
+
+fn reactions(event: &EventTimelineItem, current_user_id: Option<&UserId>) -> Vec<Reaction> {
+    event
         .content()
         .reactions()
         .into_iter()
@@ -228,56 +416,7 @@ fn timeline_message(
             own: current_user_id.is_some_and(|user_id| senders.contains_key(user_id)),
             senders: senders.keys().cloned().collect(),
         })
-        .collect();
-    let mut read_by: Vec<_> = event
-        .read_receipts()
-        .keys()
-        .filter(|user_id| *user_id != event.sender())
-        .cloned()
-        .collect();
-    read_by.sort();
-
-    TimelineMessage {
-        item_id: TimelineItemId::new(item.unique_id().0.clone()),
-        event_id: event.event_id().map(ToOwned::to_owned),
-        transaction_id: event.transaction_id().map(ToOwned::to_owned),
-        sender_id: event.sender().to_owned(),
-        sender_name: sender_name(event.sender(), event.sender_profile()),
-        body,
-        formatted_body,
-        mentions,
-        thread_root,
-        thread_summary,
-        timestamp_ms: event.timestamp().get().into(),
-        own: event.is_own(),
-        send_state: match event.send_state() {
-            None | Some(EventSendState::Sent { .. }) => SendState::Sent,
-            Some(EventSendState::NotSentYet { progress: Some(_) }) => SendState::Sending,
-            Some(EventSendState::NotSentYet { progress: None }) => SendState::Queued,
-            Some(EventSendState::SendingFailed { is_recoverable, .. }) => SendState::Failed {
-                retriable: *is_recoverable,
-            },
-        },
-        edited,
-        unable_to_decrypt,
-        media,
-        reply_to,
-        reactions,
-        read_by,
-    }
-}
-
-fn sender_name(
-    sender: &UserId,
-    sender_profile: &TimelineDetails<matrix_sdk_ui::timeline::Profile>,
-) -> String {
-    match sender_profile {
-        TimelineDetails::Ready(profile) => profile
-            .display_name
-            .clone()
-            .unwrap_or_else(|| sender.to_string()),
-        _ => sender.to_string(),
-    }
+        .collect()
 }
 
 fn formatted_body(message: &MessageType) -> Option<String> {
@@ -293,10 +432,3 @@ fn formatted_body(message: &MessageType) -> Option<String> {
     }?;
     (formatted.format == MessageFormat::Html).then(|| formatted.body.clone())
 }
-
-fn message_mentions(mentions: &ruma::events::Mentions) -> MessageMentions {
-    MessageMentions {
-        user_ids: mentions.user_ids.iter().cloned().collect(),
-        room: mentions.room,
-    }
-}

Modified file: src/transport.rs+7 additions−7 deletions@@ -27,7 +27,7 @@ use tokio::sync::{OnceCell, mpsc, oneshot, watch};
 
 use crate::{
     AccountCommand, AttachmentUpload, Command, CommandOutput, ConnectionState, CreateRoomOptions,
-    EncryptionCommand, EncryptionState, Error, ErrorKind, Event, InteractiveAuth,
+    EncryptionCommand, EncryptionState, Error, ErrorKind, Event, EventRef, InteractiveAuth,
     InteractiveAuthOutcome, LifecycleCommand, Media, MediaCommand, MediaId, MediaSize,
     MemberFilter, MemberSummary, MessageContent, MessageEditContent, NotificationCommand,
     OwnDevice, PowerLevelChanges, Profile, PushNotification, PushNotificationEvent,
@@ -303,12 +303,12 @@ impl ClientHandle {
     pub async fn edit_message(
         &self,
         timeline_id: TimelineId,
-        event_id: OwnedEventId,
+        target: impl Into<EventRef>,
         content: MessageEditContent,
     ) -> Result<(), Error> {
         self.run(Command::Timeline(TimelineCommand::Edit {
             timeline_id,
-            event_id,
+            target: target.into(),
             content,
         }))
         .await
@@ -317,12 +317,12 @@ impl ClientHandle {
     pub async fn redact(
         &self,
         timeline_id: TimelineId,
-        event_id: OwnedEventId,
+        target: impl Into<EventRef>,
         reason: Option<String>,
     ) -> Result<(), Error> {
         self.run(Command::Timeline(TimelineCommand::Redact {
             timeline_id,
-            event_id,
+            target: target.into(),
             reason,
         }))
         .await
@@ -331,12 +331,12 @@ impl ClientHandle {
     pub async fn toggle_reaction(
         &self,
         timeline_id: TimelineId,
-        event_id: OwnedEventId,
+        target: impl Into<EventRef>,
         key: impl Into<String>,
     ) -> Result<(), Error> {
         self.run(Command::Timeline(TimelineCommand::ToggleReaction {
             timeline_id,
-            event_id,
+            target: target.into(),
             key: key.into(),
         }))
         .await

Modified file: tests/commands.rs+1−1

@@ -38,7 +38,7 @@ async fn empty_message_bodies_fail_with_empty_body() {

3838 },

3939 TimelineCommand::Edit {

4040 timeline_id: room_id.to_owned().into(),

41- event_id: event_id!("$edit:localhost").to_owned(),

41+ target: event_id!("$edit:localhost").to_owned().into(),

4242 content: MessageEditContent::text("\t"),

4343 },

4444 ];

Modified file: tests/engine.rs+21 additions−19 deletions@@ -91,12 +91,12 @@ async fn opens_a_room_and_sends_messages() {
     let media_event = receive_until(&mut events, |event| {
         event_messages(event)
             .into_iter()
-            .any(|message| message.media.is_some())
+            .any(|event| support::media_of(event).is_some())
     })
     .await;
     let media_id = event_messages(&media_event)
         .into_iter()
-        .find_map(|message| message.media.as_ref().map(|media| media.id.clone()))
+        .find_map(|event| support::media_of(event).map(|media| media.id.clone()))
         .unwrap();
     let media = handle.media(&media_id, MediaSize::Full).await.unwrap();
     assert!(!media.bytes.is_empty());
@@ -164,13 +164,15 @@ async fn keeps_open_room_timelines_independent() {
             let event = events.recv().await.expect("event stream closed");
             if let Event::TimelineChanged { timeline_id, .. } = &event {
                 first_updated |= timeline_id.room_id() == first_id
-                    && event_messages(&event)
-                        .into_iter()
-                        .any(|message| message.body == "first update");
+                    && event_messages(&event).into_iter().any(|event| {
+                        support::message(event)
+                            .is_some_and(|message| message.body == "first update")
+                    });
                 second_updated |= timeline_id.room_id() == second_id
-                    && event_messages(&event)
-                        .into_iter()
-                        .any(|message| message.body == "second update");
+                    && event_messages(&event).into_iter().any(|event| {
+                        support::message(event)
+                            .is_some_and(|message| message.body == "second update")
+                    });
             }
         }
     })
@@ -187,9 +189,9 @@ async fn keeps_open_room_timelines_independent() {
         .await;
     receive_until(&mut events, |event| {
         matches!(event, Event::TimelineChanged { timeline_id, .. } if timeline_id.room_id() == second_id)
-            && event_messages(event)
-                .into_iter()
-                .any(|message| message.body == "still live")
+            && event_messages(event).into_iter().any(|event| {
+                support::message(event).is_some_and(|message| message.body == "still live")
+            })
     })
     .await;
 
@@ -228,16 +230,16 @@ async fn resync_replaces_timeline_before_ack_and_preserves_following_diffs() {
         )
         .await;
     receive_until(&mut events, |event| {
-        event_messages(event)
-            .into_iter()
-            .any(|message| message.body == "before reset")
+        event_messages(event).into_iter().any(|event| {
+            support::message(event).is_some_and(|message| message.body == "before reset")
+        })
     })
     .await;
 
     let mut items =
         resync_and_confirm_reset_first(&handle, &mut events, room_id.to_owned().into()).await;
     assert!(items.iter().any(|item| matches!(item,
-        TimelineItem::Message(message) if message.body == "before reset"
+        TimelineItem::Event(event) if support::message(event).is_some_and(|message| message.body == "before reset")
     )));
 
     server
@@ -259,7 +261,7 @@ async fn resync_replaces_timeline_before_ack_and_preserves_following_diffs() {
                 }
                 if items.iter().any(|item| {
                     matches!(item,
-                        TimelineItem::Message(message) if message.body == "after reset"
+                        TimelineItem::Event(event) if support::message(event).is_some_and(|message| message.body == "after reset")
                     )
                 }) {
                     break;
@@ -462,9 +464,9 @@ async fn pagination_reports_and_remembers_start_of_history() {
         .await;
     receive_until(&mut events, |event| {
         matches!(event, Event::TimelineChanged { timeline_id: changed, .. } if changed.room_id() == room_id)
-            && event_messages(event)
-                .into_iter()
-                .any(|message| message.body == "latest")
+            && event_messages(event).into_iter().any(|event| {
+                support::message(event).is_some_and(|message| message.body == "latest")
+            })
     })
     .await;
 

Modified file: tests/media.rs+8 additions−11 deletions@@ -292,20 +292,17 @@ async fn queued_offline_attachment_exposes_fetchable_local_media() {
     });
     harness.handle.upload(upload).await.unwrap();
     let event = support::receive_until(&mut harness.events, |event| {
-        support::event_messages(event).into_iter().any(|message| {
-            message.own
-                && message.transaction_id.is_some()
-                && message
-                    .media
-                    .as_ref()
-                    .is_some_and(|media| media.filename == "pending.png")
+        support::event_messages(event).into_iter().any(|event| {
+            event.own
+                && event.transaction_id.is_some()
+                && support::media_of(event).is_some_and(|media| media.filename == "pending.png")
         })
     })
     .await;
     let media = support::event_messages(&event)
         .into_iter()
-        .find(|message| message.own && message.media.is_some())
-        .and_then(|message| message.media.as_ref())
+        .find(|event| event.own && support::media_of(event).is_some())
+        .and_then(support::media_of)
         .unwrap();
     assert_eq!((media.width, media.height), (Some(32), Some(16)));
     assert_eq!(media.size_bytes, Some(original.len() as u64));
@@ -714,12 +711,12 @@ async fn start_with_config(content: RoomMessageEventContent, config: EngineConfi
     let event = support::receive_until(&mut events, |event| {
         support::event_messages(event)
             .into_iter()
-            .any(|message| message.media.is_some())
+            .any(|event| support::media_of(event).is_some())
     })
     .await;
     let media_id = support::event_messages(&event)
         .into_iter()
-        .find_map(|message| message.media.as_ref().map(|media| media.id.clone()))
+        .find_map(|event| support::media_of(event).map(|media| media.id.clone()))
         .unwrap();
 
     MediaHarness {

Modified file: tests/nonblocking.rs+2 additions−2 deletions@@ -53,12 +53,12 @@ async fn delayed_media_fetch_does_not_block_timeline_command() {
     let media_event = receive_until(&mut events, |event| {
         event_messages(event)
             .into_iter()
-            .any(|message| message.media.is_some())
+            .any(|event| support::media_of(event).is_some())
     })
     .await;
     let media_id = event_messages(&media_event)
         .into_iter()
-        .find_map(|message| message.media.as_ref().map(|media| media.id.clone()))
+        .find_map(|event| support::media_of(event).map(|media| media.id.clone()))
         .unwrap();
 
     let delayed_image = || {

Modified file: tests/send_queue.rs+4 additions−2 deletions@@ -175,8 +175,10 @@ async fn queue_message(
                 let event = events.recv().await.expect("event stream closed");
                 let transaction = support::event_messages(&event)
                     .into_iter()
-                    .find(|message| message.body == body)
-                    .and_then(|message| message.transaction_id.clone());
+                    .find(|event| {
+                        support::message(event).is_some_and(|message| message.body == body)
+                    })
+                    .and_then(|event| event.transaction_id.clone());
                 if let Some(transaction) = transaction {
                     return transaction;
                 }

Modified file: tests/support/mod.rs+21 additions−3 deletions@@ -2,7 +2,10 @@
 
 use std::time::Duration;
 
-use macltok::{ClientHandle, Event, EventStream, TimelineDiff, TimelineItem, TimelineMessage};
+use macltok::{
+    ClientHandle, Event, EventStream, MediaDescriptor, Message, TimelineContent, TimelineDiff,
+    TimelineEvent, TimelineItem,
+};
 
 pub async fn receive_until(events: &mut EventStream, predicate: impl Fn(&Event) -> bool) -> Event {
     tokio::time::timeout(Duration::from_secs(5), async {
@@ -30,7 +33,7 @@ pub async fn shut_down(
     running.await.unwrap().unwrap();
 }
 
-pub fn event_messages(event: &Event) -> Vec<&TimelineMessage> {
+pub fn event_messages(event: &Event) -> Vec<&TimelineEvent> {
     let items = match event {
         Event::TimelineReset { items, .. } => items.iter().collect::<Vec<_>>(),
         Event::TimelineChanged { diffs, .. } => diffs.iter().flat_map(diff_items).collect(),
@@ -39,12 +42,27 @@ pub fn event_messages(event: &Event) -> Vec<&TimelineMessage> {
     items
         .into_iter()
         .filter_map(|item| match item {
-            TimelineItem::Message(message) => Some(message.as_ref()),
+            TimelineItem::Event(event) => Some(event.as_ref()),
             _ => None,
         })
         .collect()
 }
 
+pub fn message(event: &TimelineEvent) -> Option<&Message> {
+    match &event.content {
+        TimelineContent::Message(message) => Some(message),
+        _ => None,
+    }
+}
+
+pub fn media_of(event: &TimelineEvent) -> Option<&MediaDescriptor> {
+    match &event.content {
+        TimelineContent::Message(message) => message.media.as_ref(),
+        TimelineContent::Sticker { media, .. } => Some(media),
+        _ => None,
+    }
+}
+
 pub fn diff_items(diff: &TimelineDiff) -> Vec<&TimelineItem> {
     match diff {
         TimelineDiff::Append { values } | TimelineDiff::Reset { values } => values.iter().collect(),

macltok

Commit 960ac0721079

Commit `960ac0721079`