macltok

public

Star0

Fork 0

Watch0

46 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `9bd34e25bb86`

tarball

atagen <boss@atagen.co>2026-10-24 07:35 UTC

15 files changed+897-73

commands: add favourites, msc3230 space order, room profile, mute, ignore, notices and plain media mxc

Every one of these is protocol policy malice would otherwise reimplement. reorder_spaces keeps the longest run of existing orders that already sorts right and only rebalances when no string fits between neighbours, and it remembers its own writes until sync echoes them so a quick second drag doesn't plan against stale orders. Room profile changes rewrite the member event from the server's copy, because the store lags a sync behind and would drop a change made just before. Ignoring reads the list from the server for the same reason, unlike Account::ignore_user.

Modified file: Cargo.toml+1 additions−1 deletions@@ -33,6 +33,7 @@ matrix-sdk-store-encryption = { git = "ssh://brewery@pls.lobotomise.me:33/atagen
 matrix-sdk-ui = { git = "ssh://brewery@pls.lobotomise.me:33/atagen/matrix-rust-sdk", rev = "cc2b13ea185c0f694523a3a48d8aadfe366dd767", default-features = false }
 ruma = { version = "0.16.0", default-features = false, features = ["unstable-msc2545", "unstable-msc4095"] }
 serde = { version = "1.0.219", features = ["derive", "rc"], optional = true }
+serde_json = "1.0.143"
 thiserror = "2.0.16"
 mime = "0.3.17"
 sha2 = "0.10.9"
@@ -64,7 +65,6 @@ web-sys = { version = "0.3.105", optional = true, features = [
 [dev-dependencies]
 matrix-sdk = { git = "ssh://brewery@pls.lobotomise.me:33/atagen/matrix-rust-sdk", rev = "cc2b13ea185c0f694523a3a48d8aadfe366dd767", default-features = false, features = ["testing"] }
 matrix-sdk-test = { git = "ssh://brewery@pls.lobotomise.me:33/atagen/matrix-rust-sdk", rev = "cc2b13ea185c0f694523a3a48d8aadfe366dd767" }
-serde_json = "1.0.143"
 tokio = { version = "1.47.1", features = ["macros", "rt-multi-thread", "signal", "time"] }
 wiremock = "0.6.5"
 

Modified file: src/engine/commands.rs+24 additions−1 deletions@@ -6,7 +6,7 @@ use matrix_sdk::{
     Client,
     notification_settings::{IsEncrypted, IsOneToOne, RoomNotificationMode as SdkMode},
     ruma::{
-        OwnedDeviceId, OwnedEventId, RoomId, TransactionId,
+        OwnedDeviceId, OwnedEventId, OwnedMxcUri, RoomId, TransactionId,
         api::client::receipt::create_receipt::v3::ReceiptType, events::receipt::ReceiptThread,
     },
     send_queue::{LocalEchoContent, SendHandle},
@@ -288,6 +288,29 @@ pub(super) async fn upload_avatar(
         .map_err(|source| Error::from_sdk("uploading avatar failed", source))
 }
 
+pub(super) async fn upload_media(
+    client: &Client,
+    mimetype: &str,
+    bytes: Vec<u8>,
+    max_bytes: usize,
+) -> Result<OwnedMxcUri, Error> {
+    if bytes.len() > max_bytes {
+        return Err(Error::new(
+            ErrorKind::MediaTooLarge,
+            "media exceeds the configured byte limit",
+        ));
+    }
+    let mimetype: mime::Mime = mimetype
+        .parse()
+        .map_err(|_| Error::new(ErrorKind::Invalid, "media MIME type is invalid"))?;
+    client
+        .media()
+        .upload(&mimetype, bytes, None)
+        .await
+        .map(|response| response.content_uri)
+        .map_err(|source| Error::from_sdk("uploading media failed", source))
+}
+
 pub(super) async fn rename_device(
     client: &Client,
     device_id: &OwnedDeviceId,

Modified file: src/engine/media.rs+4 additions−1 deletions@@ -710,7 +710,10 @@ async fn check_reply_thread(
     thread_root: &OwnedEventId,
 ) -> Result<(), Error> {
     let content = room
-        .make_reply_event(RoomMessageEventContentWithoutRelation::text_plain(""), reply)
+        .make_reply_event(
+            RoomMessageEventContentWithoutRelation::text_plain(""),
+            reply,
+        )
         .await
         .map_err(|source| {
             Error::with_source(ErrorKind::Timeline, "reply operation failed", source)

Modified file: src/engine/mod.rs+39 additions−3 deletions@@ -39,9 +39,9 @@ use self::{
     timeline::{SessionContext, Supervisor},
 };
 use crate::{
-    AccountCommand, ClientHandle, Command, ConnectionState, EncryptionCommand, EngineErrorKind,
-    EngineFailure, Error, ErrorKind, Event, EventStream, LifecycleCommand, MediaCommand,
-    NotificationCommand, RoomCommand, Termination, TimelineCommand,
+    AccountCommand, ClientHandle, Command, CommandOutput, ConnectionState, EncryptionCommand,
+    EngineErrorKind, EngineFailure, Error, ErrorKind, Event, EventStream, LifecycleCommand,
+    MediaCommand, NotificationCommand, RoomCommand, Termination, TimelineCommand,
     normalise::{ROOM_PACKS, ROOM_PREVIEW_URLS},
     transport::{DriverPort, Request, Responder, transport_pair},
 };
@@ -653,6 +653,42 @@ impl Engine {
                     commands::upload_avatar(&client, &mimetype, bytes, max_bytes).await
                 });
             }
+            Command::Account(AccountCommand::UploadMedia { mimetype, bytes }) => {
+                let max_bytes = self.config.max_media_bytes;
+                self.tasks
+                    .spawn(TaskContext::Command("upload media"), async move {
+                        let uploaded =
+                            commands::upload_media(&client, &mimetype, bytes, max_bytes).await;
+                        reply.send(uploaded.map(CommandOutput::Mxc));
+                    });
+            }
+            Command::Account(AccountCommand::IgnoreUser(user_id)) => enqueue(
+                &self.mutations,
+                Job {
+                    command: Mutation::Ignore {
+                        user_id,
+                        ignored: true,
+                    },
+                    reply,
+                },
+            ),
+            Command::Account(AccountCommand::UnignoreUser(user_id)) => enqueue(
+                &self.mutations,
+                Job {
+                    command: Mutation::Ignore {
+                        user_id,
+                        ignored: false,
+                    },
+                    reply,
+                },
+            ),
+            Command::Account(AccountCommand::ReorderSpaces(order)) => enqueue(
+                &self.mutations,
+                Job {
+                    command: Mutation::ReorderSpaces(order),
+                    reply,
+                },
+            ),
             Command::Account(AccountCommand::RenameDevice {
                 device_id,
                 display_name,

Modified file: src/engine/mutations.rs+285 additions−19 deletions@@ -7,25 +7,32 @@ use matrix_sdk::{
     Client, Room,
     ruma::{
         Int,
-        api::client::room::{
-            Visibility as SdkVisibility,
-            create_room::v3::{Request as CreateRoomRequest, RoomPreset as SdkPreset},
+        api::client::{
+            profile::{AvatarUrl, DisplayName},
+            room::{
+                Visibility as SdkVisibility,
+                create_room::v3::{Request as CreateRoomRequest, RoomPreset as SdkPreset},
+            },
+            state::get_state_event_for_key,
         },
         events::{
             AnyGlobalAccountDataEventContent, GlobalAccountDataEventType, MessageLikeEventType,
-            StateEventType, room::power_levels::RoomPowerLevelsEventContent,
+            StateEventType,
+            ignored_user_list::{IgnoredUser, IgnoredUserListEventContent},
+            room::power_levels::RoomPowerLevelsEventContent,
         },
-        serde::Raw,
+        serde::{JsonObject, Raw},
     },
 };
 use ruma::{OwnedRoomId, OwnedUserId};
+use serde_json::Value as JsonValue;
 use tokio::sync::mpsc;
 
 use super::commands::{Job, guarded};
 use super::executor::TaskSet;
 use crate::{
     CommandOutput, CreateRoomOptions, Error, ErrorKind, PowerLevelChanges, RoomCommand, RoomPreset,
-    RoomVisibility,
+    RoomVisibility, normalise::stored_space_order, space_order,
 };
 
 /// state changes that must not race each other. same room, same alias, same dm
@@ -36,6 +43,11 @@ pub(super) enum Mutation {
         event_type: GlobalAccountDataEventType,
         content: Raw<AnyGlobalAccountDataEventContent>,
     },
+    Ignore {
+        user_id: OwnedUserId,
+        ignored: bool,
+    },
+    ReorderSpaces(Vec<OwnedRoomId>),
 }
 
 pub(super) type MutationJob = Job<Mutation>;
@@ -54,7 +66,7 @@ pub(super) async fn run_scheduler(
     mut jobs: mpsc::Receiver<MutationJob>,
     queue_limit: usize,
 ) {
-    let fresh_dms = FreshDms::default();
+    let fresh = Fresh::default();
     let mut waiting = HashMap::<Key, VecDeque<MutationJob>>::new();
     let mut running = HashSet::<Key>::new();
     let mut tasks = TaskSet::<Key>::new();
@@ -74,7 +86,7 @@ pub(super) async fn run_scheduler(
                 match next {
                     Some(job) => {
                         queued -= 1;
-                        spawn(&mut tasks, &client, &fresh_dms, key, job);
+                        spawn(&mut tasks, &client, &fresh, key, job);
                     }
                     None => {
                         running.remove(&key);
@@ -91,7 +103,7 @@ pub(super) async fn run_scheduler(
                     Key::Independent(independent)
                 });
                 if running.insert(key.clone()) {
-                    spawn(&mut tasks, &client, &fresh_dms, key, job);
+                    spawn(&mut tasks, &client, &fresh, key, job);
                 } else if queued < queue_limit {
                     waiting.entry(key).or_default().push_back(job);
                     queued += 1;
@@ -112,6 +124,14 @@ fn key(mutation: &Mutation, server: Option<&ruma::ServerName>) -> Option<Key> {
         Mutation::GlobalAccountData { event_type, .. } => {
             return Some(Key::AccountData(event_type.to_string()));
         }
+        Mutation::Ignore { .. } => {
+            return Some(Key::AccountData(
+                GlobalAccountDataEventType::IgnoredUserList.to_string(),
+            ));
+        }
+        Mutation::ReorderSpaces(_) => {
+            return Some(Key::AccountData(space_order::EVENT_TYPE.to_owned()));
+        }
         Mutation::Room(RoomCommand::Join { room, .. }) => {
             return Some(match OwnedRoomId::try_from(room.clone()) {
                 Ok(room_id) => Key::Room(room_id),
@@ -139,6 +159,10 @@ fn key(mutation: &Mutation, server: Option<&ruma::ServerName>) -> Option<Key> {
             | RoomCommand::UnbanUser { room_id, .. }
             | RoomCommand::SetPowerLevels { room_id, .. }
             | RoomCommand::SetUserPowerLevel { room_id, .. }
+            | RoomCommand::MuteUser { room_id, .. }
+            | RoomCommand::SetFavourite { room_id, .. }
+            | RoomCommand::SetOwnDisplayName { room_id, .. }
+            | RoomCommand::SetOwnAvatar { room_id, .. }
             | RoomCommand::SetAccountData { room_id, .. },
         ) => room_id,
         Mutation::Room(_) => return None,
@@ -150,25 +174,28 @@ fn key(mutation: &Mutation, server: Option<&ruma::ServerName>) -> Option<Key> {
 /// only knows `m.direct` once it comes back round
 type FreshDms = Arc<std::sync::Mutex<HashMap<OwnedUserId, OwnedRoomId>>>;
 
-fn spawn(
-    tasks: &mut TaskSet<Key>,
-    client: &Client,
-    fresh_dms: &FreshDms,
-    key: Key,
-    job: MutationJob,
-) {
+/// space orders written here that sync hasn't echoed into the store yet
+type FreshOrders = Arc<std::sync::Mutex<HashMap<OwnedRoomId, String>>>;
+
+#[derive(Clone, Default)]
+struct Fresh {
+    dms: FreshDms,
+    orders: FreshOrders,
+}
+
+fn spawn(tasks: &mut TaskSet<Key>, client: &Client, fresh: &Fresh, key: Key, job: MutationJob) {
     let client = client.clone();
-    let fresh_dms = fresh_dms.clone();
+    let fresh = fresh.clone();
     tasks.spawn(async move {
         let Job { command, reply } = job;
-        reply.send(guarded("room command", execute(&client, &fresh_dms, command)).await);
+        reply.send(guarded("room command", execute(&client, &fresh, command)).await);
         key
     });
 }
 
 async fn execute(
     client: &Client,
-    fresh_dms: &FreshDms,
+    fresh: &Fresh,
     mutation: Mutation,
 ) -> Result<CommandOutput, Error> {
     let command = match mutation {
@@ -183,8 +210,15 @@ async fn execute(
                 .map_err(|source| Error::from_sdk("writing account data failed", source))?;
             return Ok(CommandOutput::Done);
         }
+        Mutation::Ignore { user_id, ignored } => {
+            return set_ignored(client, user_id, ignored).await.map(done);
+        }
+        Mutation::ReorderSpaces(order) => {
+            return reorder_spaces(client, &fresh.orders, order).await.map(done);
+        }
         Mutation::Room(command) => command,
     };
+    let fresh_dms = &fresh.dms;
     let room = |room_id: &OwnedRoomId| client.get_room(room_id).ok_or_else(Error::room_unknown);
     let joined = |room: Room| CommandOutput::Room(room.room_id().to_owned());
     let sdk = |message: &'static str| move |source| Error::from_sdk(message, source);
@@ -260,6 +294,31 @@ async fn execute(
             .await
             .map(done)
             .map_err(sdk("updating user power level failed")),
+        RoomCommand::MuteUser {
+            room_id,
+            user_id,
+            muted,
+        } => mute_user(client, &room(&room_id)?, &user_id, muted)
+            .await
+            .map(done),
+        RoomCommand::SetFavourite { room_id, favourite } => room(&room_id)?
+            .set_is_favourite(favourite, None)
+            .await
+            .map(done)
+            .map_err(sdk("setting favourite failed")),
+        RoomCommand::SetOwnDisplayName { room_id, name } => {
+            set_own_member_field(client, &room(&room_id)?, ProfileField::DisplayName, name)
+                .await
+                .map(done)
+        }
+        RoomCommand::SetOwnAvatar { room_id, avatar } => set_own_member_field(
+            client,
+            &room(&room_id)?,
+            ProfileField::Avatar,
+            avatar.map(String::from),
+        )
+        .await
+        .map(done),
         RoomCommand::SetAccountData {
             room_id,
             event_type,
@@ -345,6 +404,213 @@ async fn apply_power_level_changes(room: &Room, changes: PowerLevelChanges) -> R
         .map_err(|source| Error::from_sdk("updating power levels failed", source))
 }
 
+/// reads the list from the server, since the store only catches up on the next sync
+async fn set_ignored(client: &Client, user_id: OwnedUserId, ignored: bool) -> Result<(), Error> {
+    if ignored && client.user_id() == Some(&*user_id) {
+        return Err(Error::new(ErrorKind::Invalid, "you can't ignore yourself"));
+    }
+    let account = client.account();
+    let mut list = account
+        .fetch_account_data_static::<IgnoredUserListEventContent>()
+        .await
+        .map_err(|source| Error::from_sdk("reading the ignore list failed", source))?
+        .map(|raw| raw.deserialize())
+        .transpose()
+        .map_err(|source| {
+            Error::with_source(ErrorKind::Invalid, "the ignore list is malformed", source)
+        })?
+        .unwrap_or_default();
+    let changed = if ignored {
+        list.ignored_users
+            .insert(user_id, IgnoredUser::new())
+            .is_none()
+    } else {
+        list.ignored_users.remove(&user_id).is_some()
+    };
+    if !changed {
+        return Ok(());
+    }
+    account
+        .set_account_data(list)
+        .await
+        .map(drop)
+        .map_err(|source| Error::from_sdk("writing the ignore list failed", source))
+}
+
+async fn reorder_spaces(
+    client: &Client,
+    fresh: &FreshOrders,
+    order: Vec<OwnedRoomId>,
+) -> Result<(), Error> {
+    if order.iter().collect::<HashSet<_>>().len() != order.len() {
+        return Err(Error::new(ErrorKind::Invalid, "a space is listed twice"));
+    }
+    let mut rooms = HashMap::new();
+    let mut spaces = Vec::with_capacity(order.len());
+    for room_id in order {
+        let room = client.get_room(&room_id).ok_or_else(Error::room_unknown)?;
+        let stored = stored_space_order(&room).await;
+        let current = {
+            let mut fresh = fresh.lock().expect("nothing panics holding this");
+            match fresh.get(&room_id) {
+                Some(written) if stored.as_ref() != Some(written) => Some(written.clone()),
+                Some(_) => fresh.remove(&room_id),
+                None => stored,
+            }
+        };
+        rooms.insert(room_id.clone(), room);
+        spaces.push((room_id, current));
+    }
+    for (room_id, order) in space_order::plan(&spaces) {
+        let content = Raw::new(&serde_json::json!({ "order": order }))
+            .expect("a string map always serialises")
+            .cast_unchecked();
+        rooms[&room_id]
+            .set_account_data_raw(space_order::EVENT_TYPE.into(), content)
+            .await
+            .map_err(|source| Error::from_sdk("writing a space order failed", source))?;
+        fresh
+            .lock()
+            .expect("nothing panics holding this")
+            .insert(room_id, order);
+    }
+    Ok(())
+}
+
+/// below the cheapest of the levels a message could need, so neither plain nor encrypted
+/// sends get through
+async fn mute_user(
+    client: &Client,
+    room: &Room,
+    user_id: &OwnedUserId,
+    muted: bool,
+) -> Result<(), Error> {
+    let own_user_id = client
+        .user_id()
+        .ok_or_else(|| Error::new(ErrorKind::Unauthenticated, "the client is not logged in"))?;
+    let mut levels = room
+        .power_levels()
+        .await
+        .map_err(|source| Error::from_sdk("reading power levels failed", source.into()))?;
+    if !levels.user_can_change_user_power_level(own_user_id, user_id) {
+        return Err(Error::new(
+            ErrorKind::Forbidden,
+            "you can't change this user's power level",
+        ));
+    }
+    let speaking = [
+        levels.events_default,
+        levels.for_message(MessageLikeEventType::RoomMessage),
+        levels.for_message(MessageLikeEventType::RoomEncrypted),
+    ]
+    .into_iter()
+    .min()
+    .expect("the list isn't empty");
+    let current = levels
+        .users
+        .get(user_id)
+        .copied()
+        .unwrap_or(levels.users_default);
+    match (muted, current < speaking) {
+        (true, true) | (false, false) => return Ok(()),
+        (true, false) => {
+            let level = speaking.checked_sub(Int::from(1)).ok_or_else(|| {
+                Error::new(
+                    ErrorKind::Invalid,
+                    "there's no power level below this room's lowest",
+                )
+            })?;
+            levels.users.insert(user_id.clone(), level);
+        }
+        (false, true) => {
+            levels.users.remove(user_id);
+        }
+    }
+    let content = RoomPowerLevelsEventContent::try_from(levels).map_err(|source| {
+        Error::with_source(
+            ErrorKind::Invalid,
+            "normalising power levels failed",
+            source,
+        )
+    })?;
+    room.send_state_event(content)
+        .await
+        .map(drop)
+        .map_err(|source| Error::from_sdk("updating power levels failed", source))
+}
+
+#[derive(Clone, Copy)]
+enum ProfileField {
+    DisplayName,
+    Avatar,
+}
+
+/// rewrites your member event from the server's copy so membership and unknown keys survive,
+/// and an earlier change this sync hasn't delivered yet isn't lost
+async fn set_own_member_field(
+    client: &Client,
+    room: &Room,
+    field: ProfileField,
+    value: Option<String>,
+) -> Result<(), Error> {
+    let own_user_id = client
+        .user_id()
+        .ok_or_else(|| Error::new(ErrorKind::Unauthenticated, "the client is not logged in"))?
+        .to_owned();
+    let key = match field {
+        ProfileField::DisplayName => "displayname",
+        ProfileField::Avatar => "avatar_url",
+    };
+    let value = match value {
+        Some(value) => Some(value),
+        None => {
+            let profile = client
+                .account()
+                .fetch_user_profile()
+                .await
+                .map_err(|source| Error::from_sdk("fetching the profile failed", source))?;
+            let global = match field {
+                ProfileField::DisplayName => profile.get_static::<DisplayName>(),
+                ProfileField::Avatar => profile
+                    .get_static::<AvatarUrl>()
+                    .map(|avatar| avatar.map(String::from)),
+            };
+            global.map_err(|source| {
+                Error::with_source(
+                    ErrorKind::Server,
+                    "the server sent a malformed profile",
+                    source,
+                )
+            })?
+        }
+    };
+    let request = get_state_event_for_key::v3::Request::new(
+        room.room_id().to_owned(),
+        StateEventType::RoomMember,
+        own_user_id.to_string(),
+    );
+    let response = client
+        .send(request)
+        .await
+        .map_err(|source| Error::from_http("reading your member event failed", source))?;
+    let mut content: JsonObject =
+        serde_json::from_str(response.event_or_content.get()).map_err(|source| {
+            Error::with_source(ErrorKind::Invalid, "your member event is malformed", source)
+        })?;
+    match value {
+        Some(value) => content.insert(key.to_owned(), JsonValue::String(value)),
+        None => content.remove(key),
+    };
+    room.send_state_event_raw(
+        "m.room.member",
+        own_user_id.as_str(),
+        JsonValue::Object(content),
+    )
+    .await
+    .map(drop)
+    .map_err(|source| Error::from_sdk("updating your member event failed", source))
+}
+
 fn done<T>(_: T) -> CommandOutput {
     CommandOutput::Done
 }

Modified file: src/engine/timeline.rs+32 additions−17 deletions@@ -223,6 +223,7 @@ impl TimelineSession {
                 let body = match &content {
                     MessageContent::Text { content, .. }
                     | MessageContent::Emote { content, .. }
+                    | MessageContent::Notice { content, .. }
                     | MessageContent::Reply { content, .. } => &content.body,
                 };
                 if body.trim().is_empty() {
@@ -230,10 +231,13 @@ impl TimelineSession {
                 }
                 let content = match content {
                     MessageContent::Text { content, mentions } => {
-                        message_content(content, mentions, false).with_relation(None)
+                        message_content(content, mentions, Msgtype::Text).with_relation(None)
                     }
                     MessageContent::Emote { content, mentions } => {
-                        message_content(content, mentions, true).with_relation(None)
+                        message_content(content, mentions, Msgtype::Emote).with_relation(None)
+                    }
+                    MessageContent::Notice { content, mentions } => {
+                        message_content(content, mentions, Msgtype::Notice).with_relation(None)
                     }
                     MessageContent::Reply {
                         event_id,
@@ -254,9 +258,13 @@ impl TimelineSession {
             TimelineCommand::Edit {
                 target, content, ..
             } => {
-                let (content, mentions, emote) = match content {
-                    MessageEditContent::Text { content, mentions } => (content, mentions, false),
-                    MessageEditContent::Emote { content, mentions } => (content, mentions, true),
+                let (content, mentions, msgtype) = match content {
+                    MessageEditContent::Text { content, mentions } => {
+                        (content, mentions, Msgtype::Text)
+                    }
+                    MessageEditContent::Emote { content, mentions } => {
+                        (content, mentions, Msgtype::Emote)
+                    }
                 };
                 if content.body.trim().is_empty() {
                     return Err(Error::new(ErrorKind::EmptyBody, "message body is empty"));
@@ -264,7 +272,7 @@ impl TimelineSession {
                 timeline
                     .edit(
                         &item_id(target),
-                        EditedContent::RoomMessage(message_content(content, mentions, emote)),
+                        EditedContent::RoomMessage(message_content(content, mentions, msgtype)),
                     )
                     .await
                     .map_err(timeline_error)
@@ -288,7 +296,7 @@ impl TimelineSession {
             .timeline
             .room()
             .make_reply_event(
-                message_content(content, mentions, false),
+                message_content(content, mentions, Msgtype::Text),
                 SdkReply {
                     event_id,
                     enforce_thread: if thread_root.is_some() {
@@ -438,20 +446,27 @@ async fn run_pagination(
     }
 }
 
+#[derive(Clone, Copy)]
+enum Msgtype {
+    Text,
+    Emote,
+    Notice,
+}
+
 fn message_content(
     content: RichText,
     mentions: MessageMentions,
-    emote: bool,
+    msgtype: Msgtype,
 ) -> RoomMessageEventContentWithoutRelation {
-    let content = match content.formatted_body {
-        Some(formatted_body) if emote => {
-            RoomMessageEventContentWithoutRelation::emote_html(content.body, formatted_body)
-        }
-        Some(formatted_body) => {
-            RoomMessageEventContentWithoutRelation::text_html(content.body, formatted_body)
-        }
-        None if emote => RoomMessageEventContentWithoutRelation::emote_plain(content.body),
-        None => RoomMessageEventContentWithoutRelation::text_plain(content.body),
+    type Content = RoomMessageEventContentWithoutRelation;
+    let (body, formatted_body) = (content.body, content.formatted_body);
+    let content = match (msgtype, formatted_body) {
+        (Msgtype::Text, Some(html)) => Content::text_html(body, html),
+        (Msgtype::Text, None) => Content::text_plain(body),
+        (Msgtype::Emote, Some(html)) => Content::emote_html(body, html),
+        (Msgtype::Emote, None) => Content::emote_plain(body),
+        (Msgtype::Notice, Some(html)) => Content::notice_html(body, html),
+        (Msgtype::Notice, None) => Content::notice_plain(body),
     };
     content.add_mentions(sdk_mentions(mentions))
 }

Modified file: src/engine/watchers.rs+20 additions−4 deletions@@ -14,7 +14,7 @@ use matrix_sdk_base::RoomInfoNotableUpdateReasons;
 use matrix_sdk_ui::sync_service::{State as SyncState, SyncService};
 use ruma::{
     OwnedRoomId, OwnedTransactionId,
-    events::{AnyGlobalAccountDataEvent, AnySyncStateEvent},
+    events::{AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent, AnySyncStateEvent},
     serde::Raw,
     time::Instant,
 };
@@ -26,6 +26,7 @@ use crate::{
     encryption::encryption_state,
     error::classify_sdk_error,
     normalise::{ENABLED_ROOMS, ROOM_PACKS, USER_PACK},
+    space_order,
     transport::EventSender,
 };
 
@@ -400,22 +401,37 @@ pub(super) async fn encryption(client: Client, events: EventSender) {
     }
 }
 
+/// space orders are room account data, which never touches room info
 pub(super) async fn rooms(client: Client, events: EventSender) {
     let (_, mut rooms) = client.rooms_stream();
     let mut info = client.room_info_notable_update_receiver();
+    let order_changed = Arc::new(Notify::new());
+    let handler = client.add_event_handler({
+        let order_changed = order_changed.clone();
+        move |event: Raw<AnyRoomAccountDataEvent>| {
+            let order_changed = order_changed.clone();
+            async move {
+                if event_type(&event).as_deref() == Some(space_order::EVENT_TYPE) {
+                    order_changed.notify_one();
+                }
+            }
+        }
+    });
     loop {
         if events.send(Event::RoomsChanged).await.is_err() {
-            return;
+            break;
         }
         tokio::select! {
-            update = rooms.next() => if update.is_none() { return },
-            update = info.recv() => if matches!(update, Err(RecvError::Closed)) { return },
+            update = rooms.next() => if update.is_none() { break },
+            update = info.recv() => if matches!(update, Err(RecvError::Closed)) { break },
+            () = order_changed.notified() => {}
         }
         // a sync touching fifty rooms is one invalidation, not fifty
         while let Ok(_) | Err(tokio::sync::broadcast::error::TryRecvError::Lagged(_)) =
             info.try_recv()
         {}
     }
+    client.remove_event_handler(handler);
 }
 
 /// packs live in room state and account data, and leaving a room takes its packs with it

Modified file: src/error.rs+2

@@ -49,6 +49,8 @@ pub enum ErrorKind {

4949 Unauthenticated,

5050 InteractiveAuthRequired,

5151 Invalid,

52+ /// the room's power levels don't let you

53+ Forbidden,

5254 RoomUnknown,

5355 RoomNotOpen,

5456 TimelineNotOpen,

Modified file: src/lib.rs+1

@@ -7,6 +7,7 @@ mod error;

77 mod mirror;

88 mod model;

99 mod normalise;

10+mod space_order;

1011 mod transport;

1112 mod uiaa;

1213 mod upload;

Modified file: src/model.rs+46 additions@@ -45,6 +45,15 @@ pub enum AccountCommand {
         mimetype: String,
         bytes: Vec<u8>,
     },
+    /// unencrypted, answers with `CommandOutput::Mxc`. same byte cap as any upload
+    UploadMedia {
+        mimetype: String,
+        bytes: Vec<u8>,
+    },
+    IgnoreUser(OwnedUserId),
+    UnignoreUser(OwnedUserId),
+    /// writes msc3230 orders so these spaces sort in exactly this sequence, touching as few as it can
+    ReorderSpaces(Vec<OwnedRoomId>),
     RenameDevice {
         device_id: OwnedDeviceId,
         display_name: String,
@@ -98,6 +107,28 @@ pub enum RoomCommand {
         user_id: OwnedUserId,
         level: i64,
     },
+    /// muting drops them below what sending a message takes, unmuting puts a muted user back
+    /// at users_default and leaves anyone else alone
+    MuteUser {
+        room_id: OwnedRoomId,
+        user_id: OwnedUserId,
+        muted: bool,
+    },
+    /// adding m.favourite drops m.lowpriority, the way Element does
+    SetFavourite {
+        room_id: OwnedRoomId,
+        favourite: bool,
+    },
+    /// your name in one room. None goes back to your global name
+    SetOwnDisplayName {
+        room_id: OwnedRoomId,
+        name: Option<String>,
+    },
+    /// your avatar in one room. None goes back to your global avatar
+    SetOwnAvatar {
+        room_id: OwnedRoomId,
+        avatar: Option<OwnedMxcUri>,
+    },
     Create(CreateRoomOptions),
     /// hands back the existing dm if there is one
     CreateDirect(OwnedUserId),
@@ -479,6 +510,7 @@ pub enum LifecycleCommand {
 pub enum CommandOutput {
     Done,
     Room(OwnedRoomId),
+    Mxc(OwnedMxcUri),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -493,6 +525,11 @@ pub enum MessageContent {
         content: RichText,
         mentions: MessageMentions,
     },
+    /// m.notice, for bots. clients render it muted and never answer it automatically
+    Notice {
+        content: RichText,
+        mentions: MessageMentions,
+    },
     Reply {
         event_id: OwnedEventId,
         content: RichText,
@@ -524,6 +561,11 @@ impl MessageContent {
     }
 
     #[must_use]
+    pub fn notice(content: RichText, mentions: MessageMentions) -> Self {
+        Self::Notice { content, mentions }
+    }
+
+    #[must_use]
     pub fn reply(event_id: OwnedEventId, content: RichText, mentions: MessageMentions) -> Self {
         Self::Reply {
             event_id,
@@ -814,6 +856,8 @@ pub struct RoomSummary {
     pub parent_spaces: Vec<OwnedRoomId>,
     /// for a space, the children it lists, joined or not
     pub children: Vec<OwnedRoomId>,
+    /// a space's msc3230 order. ordered spaces sort first by (order, room id), the rest by room id
+    pub space_order: Option<String>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1736,6 +1780,8 @@ pub enum PackUsage {
 pub struct MediaDescriptor {
     pub id: MediaId,
     pub kind: MediaKind,
+    /// only for unencrypted media, an encrypted file's mxc is ciphertext without the keys
+    pub mxc: Option<OwnedMxcUri>,
     pub filename: String,
     pub caption: Option<String>,
     pub mimetype: Option<String>,

Modified file: src/normalise/media.rs+58 additions−22 deletions@@ -2,12 +2,15 @@ use std::sync::atomic::{AtomicU64, Ordering};
 
 use matrix_sdk::{media::MediaEventContent, ruma::events::room::MediaSource};
 use matrix_sdk_ui::timeline::{MsgLikeKind, TimelineItem as SdkTimelineItem, TimelineItemContent};
-use ruma::events::{
-    room::{
-        ImageInfo, ThumbnailInfo,
-        message::{FileInfo, MessageType, VideoInfo},
+use ruma::{
+    OwnedMxcUri,
+    events::{
+        room::{
+            ImageInfo, ThumbnailInfo,
+            message::{FileInfo, MessageType, VideoInfo},
+        },
+        sticker::{StickerEventContent, StickerMediaSource},
     },
-    sticker::StickerEventContent,
 };
 
 use super::link_preview::sender_previews;
@@ -87,19 +90,21 @@ pub(super) fn media_identity(item: &SdkTimelineItem, scope: &MediaScope) -> Stri
 }
 
 pub(super) fn media_from_message(identity: &str, message: &MessageType) -> Option<MediaDescriptor> {
-    let descriptor = |kind, filename: &str, caption: Option<&str>| MediaDescriptor {
-        id: media_id(identity, "media"),
-        kind,
-        filename: filename.to_owned(),
-        caption: caption.map(str::to_owned),
-        mimetype: None,
-        size_bytes: None,
-        width: None,
-        height: None,
-        duration_ms: None,
-        blurhash: None,
-        has_thumbnail: false,
-    };
+    let descriptor =
+        |kind, source: &MediaSource, filename: &str, caption: Option<&str>| MediaDescriptor {
+            id: media_id(identity, "media"),
+            kind,
+            mxc: plain_mxc(source),
+            filename: filename.to_owned(),
+            caption: caption.map(str::to_owned),
+            mimetype: None,
+            size_bytes: None,
+            width: None,
+            height: None,
+            duration_ms: None,
+            blurhash: None,
+            has_thumbnail: false,
+        };
     let millis = |duration: std::time::Duration| u64::try_from(duration.as_millis()).ok();
     Some(match message {
         MessageType::Image(content) => {
@@ -111,7 +116,12 @@ pub(super) fn media_from_message(identity: &str, message: &MessageType) -> Optio
                 height: info.and_then(|info| info.height).map(u64::from),
                 blurhash: info.and_then(|info| info.blurhash.clone()),
                 has_thumbnail: info.is_some_and(|info| info.thumbnail_source.is_some()),
-                ..descriptor(MediaKind::Image, content.filename(), content.caption())
+                ..descriptor(
+                    MediaKind::Image,
+                    &content.source,
+                    content.filename(),
+                    content.caption(),
+                )
             }
         }
         MessageType::Video(content) => {
@@ -124,7 +134,12 @@ pub(super) fn media_from_message(identity: &str, message: &MessageType) -> Optio
                 duration_ms: info.and_then(|info| info.duration).and_then(millis),
                 blurhash: info.and_then(|info| info.blurhash.clone()),
                 has_thumbnail: info.is_some_and(|info| info.thumbnail_source.is_some()),
-                ..descriptor(MediaKind::Video, content.filename(), content.caption())
+                ..descriptor(
+                    MediaKind::Video,
+                    &content.source,
+                    content.filename(),
+                    content.caption(),
+                )
             }
         }
         MessageType::Audio(content) => {
@@ -133,7 +148,12 @@ pub(super) fn media_from_message(identity: &str, message: &MessageType) -> Optio
                 mimetype: info.and_then(|info| info.mimetype.clone()),
                 size_bytes: info.and_then(|info| info.size).map(u64::from),
                 duration_ms: info.and_then(|info| info.duration).and_then(millis),
-                ..descriptor(MediaKind::Audio, content.filename(), content.caption())
+                ..descriptor(
+                    MediaKind::Audio,
+                    &content.source,
+                    content.filename(),
+                    content.caption(),
+                )
             }
         }
         MessageType::File(content) => {
@@ -142,7 +162,12 @@ pub(super) fn media_from_message(identity: &str, message: &MessageType) -> Optio
                 mimetype: info.and_then(|info| info.mimetype.clone()),
                 size_bytes: info.and_then(|info| info.size).map(u64::from),
                 has_thumbnail: info.is_some_and(|info| info.thumbnail_source.is_some()),
-                ..descriptor(MediaKind::File, content.filename(), content.caption())
+                ..descriptor(
+                    MediaKind::File,
+                    &content.source,
+                    content.filename(),
+                    content.caption(),
+                )
             }
         }
         _ => return None,
@@ -156,6 +181,10 @@ pub(super) fn media_descriptor_for_sticker(
     MediaDescriptor {
         id: media_id(identity, "sticker"),
         kind: MediaKind::Sticker,
+        mxc: match &content.source {
+            StickerMediaSource::Plain(uri) => Some(uri.clone()),
+            _ => None,
+        },
         filename: content.body.clone(),
         caption: None,
         mimetype: content.info.mimetype.clone(),
@@ -168,6 +197,13 @@ pub(super) fn media_descriptor_for_sticker(
     }
 }
 
+fn plain_mxc(source: &MediaSource) -> Option<OwnedMxcUri> {
+    match source {
+        MediaSource::Plain(uri) => Some(uri.clone()),
+        MediaSource::Encrypted(_) => None,
+    }
+}
+
 pub(super) fn media_id(identity: &str, suffix: &str) -> MediaId {
     MediaId::new(format!("{identity}#{suffix}"))
 }

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

@@ -10,5 +10,5 @@ pub(crate) use link_preview::{ROOM_PREVIEW_URLS, server_preview, url_previews_al

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

1111 pub(crate) use member::member_summary;

1212 pub(crate) use room::notification_mode;

13-pub(crate) use room::{room_summaries, space_child};

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

1414 pub(crate) use timeline::{message_kind, normalise_timeline, normalise_timeline_diffs};

Modified file: src/normalise/room.rs+22 additions−2 deletions@@ -10,12 +10,15 @@ use matrix_sdk::{
     },
 };
 use matrix_sdk_ui::spaces::{SpaceRoom, SpaceService};
-use ruma::OwnedRoomId;
+use ruma::{
+    OwnedRoomId,
+    serde::{JsonObject, Raw},
+};
 
 use super::message_kind;
 use crate::{
     LatestEvent, MediaId, MessageKind, RoomHero, RoomMembership, RoomNotificationMode, RoomSummary,
-    SendState, SpaceChild,
+    SendState, SpaceChild, space_order,
 };
 
 pub(crate) async fn room_summaries(client: &Client, spaces: &SpaceService) -> Vec<RoomSummary> {
@@ -99,9 +102,26 @@ async fn room_summary(room: &Room, spaces: &SpaceService) -> RoomSummary {
             .map(|parent| parent.room_id)
             .collect(),
         children,
+        space_order: if room.is_space() {
+            stored_space_order(room).await
+        } else {
+            None
+        },
     }
 }
 
+/// None when unset or when another client wrote something msc3230 doesn't allow
+pub(crate) async fn stored_space_order(room: &Room) -> Option<String> {
+    room.account_data(space_order::EVENT_TYPE.into())
+        .await
+        .ok()??
+        .get_field::<Raw<JsonObject>>("content")
+        .ok()??
+        .get_field::<String>("order")
+        .ok()?
+        .filter(|order| space_order::valid(order))
+}
+
 const fn membership(state: RoomState) -> RoomMembership {
     match state {
         RoomState::Joined => RoomMembership::Joined,

Added file: src/space_order.rs+269 additions@@ -0,0 +1,269 @@
+use std::cmp::Ordering;
+
+use ruma::OwnedRoomId;
+
+const FIRST: u8 = 0x20;
+const LAST: u8 = 0x7e;
+const BASE: u64 = (LAST - FIRST + 1) as u64;
+const MAX_LEN: usize = 50;
+
+pub(crate) const EVENT_TYPE: &str = "org.matrix.msc3230.space_order";
+
+pub(crate) fn valid(order: &str) -> bool {
+    (1..=MAX_LEN).contains(&order.len()) && order.bytes().all(|b| (FIRST..=LAST).contains(&b))
+}
+
+/// how msc3230 clients sort spaces: ordered ones by (order, room id), then the rest by room id
+pub(crate) fn compare(
+    (a_id, a_order): (&OwnedRoomId, Option<&str>),
+    (b_id, b_order): (&OwnedRoomId, Option<&str>),
+) -> Ordering {
+    match (a_order, b_order) {
+        (Some(a), Some(b)) => a.cmp(b).then_with(|| a_id.cmp(b_id)),
+        (Some(_), None) => Ordering::Less,
+        (None, Some(_)) => Ordering::Greater,
+        (None, None) => a_id.cmp(b_id),
+    }
+}
+
+/// the orders to write so `spaces`, given with their current valid orders, sort in
+/// exactly this sequence. keeps the longest run of orders that already sorts right
+pub(crate) fn plan(spaces: &[(OwnedRoomId, Option<String>)]) -> Vec<(OwnedRoomId, String)> {
+    let key = |index: usize| (&spaces[index].0, spaces[index].1.as_deref());
+    let n = spaces.len();
+
+    let mut unordered_tail = n;
+    while unordered_tail > 0
+        && spaces[unordered_tail - 1].1.is_none()
+        && (unordered_tail == n
+            || compare(key(unordered_tail - 1), key(unordered_tail)) == Ordering::Less)
+    {
+        unordered_tail -= 1;
+    }
+
+    let mut chain = vec![0usize; n];
+    let mut previous = vec![None; n];
+    for i in (0..n).filter(|&i| spaces[i].1.is_some()) {
+        chain[i] = 1;
+        for j in 0..i {
+            if chain[j] > 0 && chain[j] + 1 > chain[i] && compare(key(j), key(i)) == Ordering::Less
+            {
+                chain[i] = chain[j] + 1;
+                previous[i] = Some(j);
+            }
+        }
+    }
+
+    let mut longest: Option<usize> = None;
+    let mut best: Option<(usize, usize, Option<usize>)> = None;
+    for split in 0..=n {
+        if split > 0 && chain[split - 1] > longest.map_or(0, |end| chain[end]) {
+            longest = Some(split - 1);
+        }
+        if split < unordered_tail {
+            continue;
+        }
+        let cost = split - longest.map_or(0, |end| chain[end]);
+        if best.is_none_or(|(best_cost, _, _)| cost < best_cost) {
+            best = Some((cost, split, longest));
+        }
+    }
+    let Some((_, split, end)) = best else {
+        return Vec::new();
+    };
+
+    let mut kept = vec![false; n];
+    let mut cursor = end;
+    while let Some(index) = cursor {
+        kept[index] = true;
+        cursor = previous[index];
+    }
+
+    let mut writes = Vec::new();
+    let mut run_start = 0;
+    for index in 0..=split {
+        if index < split && !kept[index] {
+            continue;
+        }
+        if index > run_start {
+            let lo = run_start
+                .checked_sub(1)
+                .and_then(|i| spaces[i].1.as_deref());
+            let hi = (index < split)
+                .then(|| spaces[index].1.as_deref())
+                .flatten();
+            let Some(orders) = between(lo, hi, index - run_start) else {
+                return rebalance(&spaces[..split]);
+            };
+            writes.extend(
+                spaces[run_start..index]
+                    .iter()
+                    .map(|(id, _)| id.clone())
+                    .zip(orders),
+            );
+        }
+        run_start = index + 1;
+    }
+    writes
+}
+
+fn rebalance(spaces: &[(OwnedRoomId, Option<String>)]) -> Vec<(OwnedRoomId, String)> {
+    let orders = between(None, None, spaces.len()).unwrap_or_default();
+    spaces
+        .iter()
+        .zip(orders)
+        .filter(|((_, current), order)| current.as_ref() != Some(order))
+        .map(|((id, _), order)| (id.clone(), order))
+        .collect()
+}
+
+/// `count` evenly spread orders strictly between `lo` and `hi`, as short as they can be
+fn between(lo: Option<&str>, hi: Option<&str>, count: usize) -> Option<Vec<String>> {
+    let lo = lo.unwrap_or("").as_bytes();
+    (lo.len().max(1)..=MAX_LEN).find_map(|len| {
+        let lo = digits(lo, len);
+        let hi = match hi {
+            Some(hi) => digits(&hi.as_bytes()[..hi.len().min(len)], len),
+            None => {
+                let mut one = vec![0; len + 1];
+                one[0] = 1;
+                one
+            }
+        };
+        if hi <= lo {
+            return None;
+        }
+        let step = divide(&subtract(&hi, &lo), count as u64 + 1);
+        if step.iter().all(|&digit| digit == 0) {
+            return None;
+        }
+        let mut point = lo;
+        Some(
+            (0..count)
+                .map(|_| {
+                    point = add(&point, &step);
+                    let mut order: Vec<u8> = point[1..].iter().map(|&d| FIRST + d as u8).collect();
+                    while order.last() == Some(&FIRST) {
+                        order.pop();
+                    }
+                    String::from_utf8(order).expect("orders are ascii")
+                })
+                .collect(),
+        )
+    })
+}
+
+/// big-endian base-95 digits with one leading digit of headroom, zero padded to `len`
+fn digits(order: &[u8], len: usize) -> Vec<u64> {
+    let mut out = vec![0; len + 1];
+    for (slot, byte) in out[1..].iter_mut().zip(order) {
+        *slot = u64::from(byte - FIRST);
+    }
+    out
+}
+
+fn subtract(a: &[u64], b: &[u64]) -> Vec<u64> {
+    let mut out = vec![0; a.len()];
+    let mut borrow = 0;
+    for i in (0..a.len()).rev() {
+        let (value, under) = (a[i] + BASE - b[i] - borrow, a[i] < b[i] + borrow);
+        out[i] = value % BASE;
+        borrow = u64::from(under);
+    }
+    out
+}
+
+fn add(a: &[u64], b: &[u64]) -> Vec<u64> {
+    let mut out = vec![0; a.len()];
+    let mut carry = 0;
+    for i in (0..a.len()).rev() {
+        let sum = a[i] + b[i] + carry;
+        out[i] = sum % BASE;
+        carry = sum / BASE;
+    }
+    out
+}
+
+fn divide(a: &[u64], divisor: u64) -> Vec<u64> {
+    let mut remainder = 0;
+    a.iter()
+        .map(|&digit| {
+            let current = remainder * BASE + digit;
+            remainder = current % divisor;
+            current / divisor
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use ruma::owned_room_id;
+
+    use super::*;
+
+    fn apply(spaces: &[(OwnedRoomId, Option<String>)]) -> (Vec<OwnedRoomId>, usize) {
+        let writes = plan(spaces);
+        let mut after: Vec<_> = spaces
+            .iter()
+            .map(|(id, order)| {
+                let written = writes.iter().find(|(w, _)| w == id).map(|(_, o)| o.clone());
+                (id.clone(), written.or_else(|| order.clone()))
+            })
+            .collect();
+        assert!(after.iter().all(|(_, o)| o.as_deref().is_none_or(valid)));
+        after.sort_by(|a, b| compare((&a.0, a.1.as_deref()), (&b.0, b.1.as_deref())));
+        (after.into_iter().map(|(id, _)| id).collect(), writes.len())
+    }
+
+    fn ids(spaces: &[(OwnedRoomId, Option<String>)]) -> Vec<OwnedRoomId> {
+        spaces.iter().map(|(id, _)| id.clone()).collect()
+    }
+
+    #[test]
+    fn already_sorted_spaces_need_no_writes() {
+        let spaces = vec![
+            (owned_room_id!("!z:x"), Some("a".to_owned())),
+            (owned_room_id!("!a:x"), None),
+            (owned_room_id!("!b:x"), None),
+        ];
+        assert_eq!(apply(&spaces), (ids(&spaces), 0));
+    }
+
+    #[test]
+    fn moving_one_space_writes_one_order() {
+        let spaces = vec![
+            (owned_room_id!("!c:x"), Some("c".to_owned())),
+            (owned_room_id!("!a:x"), Some("a".to_owned())),
+            (owned_room_id!("!b:x"), Some("b".to_owned())),
+            (owned_room_id!("!d:x"), Some("d".to_owned())),
+        ];
+        assert_eq!(apply(&spaces), (ids(&spaces), 1));
+    }
+
+    #[test]
+    fn unordered_spaces_out_of_id_order_get_orders() {
+        let spaces = vec![
+            (owned_room_id!("!c:x"), None),
+            (owned_room_id!("!a:x"), None),
+            (owned_room_id!("!b:x"), None),
+        ];
+        assert_eq!(apply(&spaces), (ids(&spaces), 1));
+    }
+
+    #[test]
+    fn orders_with_no_room_between_them_rebalance() {
+        let spaces = vec![
+            (owned_room_id!("!a:x"), Some("a".to_owned())),
+            (owned_room_id!("!c:x"), None),
+            (owned_room_id!("!b:x"), Some("a ".to_owned())),
+        ];
+        assert_eq!(apply(&spaces).0, ids(&spaces));
+        let prefix = "~".repeat(MAX_LEN - 1);
+        let spaces = vec![
+            (owned_room_id!("!b:x"), Some(format!("{prefix}!"))),
+            (owned_room_id!("!a:x"), None),
+            (owned_room_id!("!c:x"), Some(format!("{prefix}\""))),
+        ];
+        assert_eq!(apply(&spaces).0, ids(&spaces));
+    }
+}

Modified file: src/transport.rs+93 additions−2 deletions@@ -653,6 +653,89 @@ impl ClientHandle {
         .await
     }
 
+    /// unencrypted, for room avatars and anything else that only needs the uri
+    pub async fn upload_media(
+        &self,
+        mimetype: impl Into<String>,
+        bytes: Vec<u8>,
+    ) -> Result<OwnedMxcUri, Error> {
+        let command = Command::Account(AccountCommand::UploadMedia {
+            mimetype: mimetype.into(),
+            bytes,
+        });
+        match self.execute(command).await? {
+            CommandOutput::Mxc(uri) => Ok(uri),
+            output => Err(Error::new(
+                ErrorKind::Other,
+                format!("expected an mxc but got {output:?}"),
+            )),
+        }
+    }
+
+    pub async fn ignore_user(&self, user_id: OwnedUserId) -> Result<(), Error> {
+        self.run(Command::Account(AccountCommand::IgnoreUser(user_id)))
+            .await
+    }
+
+    pub async fn unignore_user(&self, user_id: OwnedUserId) -> Result<(), Error> {
+        self.run(Command::Account(AccountCommand::UnignoreUser(user_id)))
+            .await
+    }
+
+    /// writes msc3230 orders so these spaces sort in exactly this sequence, touching as few as it can
+    pub async fn reorder_spaces(&self, order: Vec<OwnedRoomId>) -> Result<(), Error> {
+        self.run(Command::Account(AccountCommand::ReorderSpaces(order)))
+            .await
+    }
+
+    /// adding m.favourite drops m.lowpriority, the way Element does
+    pub async fn set_favourite(&self, room_id: OwnedRoomId, favourite: bool) -> Result<(), Error> {
+        self.run(Command::Room(RoomCommand::SetFavourite {
+            room_id,
+            favourite,
+        }))
+        .await
+    }
+
+    /// None goes back to your global name
+    pub async fn set_room_display_name(
+        &self,
+        room_id: OwnedRoomId,
+        name: Option<String>,
+    ) -> Result<(), Error> {
+        self.run(Command::Room(RoomCommand::SetOwnDisplayName {
+            room_id,
+            name,
+        }))
+        .await
+    }
+
+    /// None goes back to your global avatar
+    pub async fn set_room_avatar(
+        &self,
+        room_id: OwnedRoomId,
+        avatar: Option<OwnedMxcUri>,
+    ) -> Result<(), Error> {
+        self.run(Command::Room(RoomCommand::SetOwnAvatar { room_id, avatar }))
+            .await
+    }
+
+    /// muting drops them below what sending a message takes, unmuting puts a muted user back
+    /// at users_default and leaves anyone else alone. `ErrorKind::Forbidden` if you can't
+    pub async fn mute_user(
+        &self,
+        room_id: OwnedRoomId,
+        user_id: OwnedUserId,
+        muted: bool,
+    ) -> Result<(), Error> {
+        self.run(Command::Room(RoomCommand::MuteUser {
+            room_id,
+            user_id,
+            muted,
+        }))
+        .await
+    }
+
     pub async fn rooms_filtered(&self, filter: &RoomListFilter) -> Vec<RoomSummary> {
         let matcher = filter.matcher();
         self.rooms()
@@ -756,7 +839,12 @@ impl ClientHandle {
         let room = self.room(room_id)?;
         // stores have been seen with members_synced persisted over a partial
         // roster, and the sdk never asks /members again once it's set
-        if self.members_checked.lock().unwrap().insert(room_id.to_owned()) {
+        if self
+            .members_checked
+            .lock()
+            .unwrap()
+            .insert(room_id.to_owned())
+        {
             room.mark_members_missing();
         }
         list_members(&room, filter).await
@@ -770,7 +858,10 @@ impl ClientHandle {
     ) -> Result<Vec<MemberSummary>, Error> {
         let room = self.room(room_id)?;
         room.mark_members_missing();
-        self.members_checked.lock().unwrap().insert(room_id.to_owned());
+        self.members_checked
+            .lock()
+            .unwrap()
+            .insert(room_id.to_owned());
         list_members(&room, filter).await
     }

macltok

Commit 9bd34e25bb86

Commit `9bd34e25bb86`