malice

public

Star0

Fork 0

Watch0

5 commits 2 branches 0 tags 0 releases4.4 MiB

Commit `ecb8598b38af`

tarball

atagen <boss@atagen.co>2026-10-22 13:19 UTC

46 files changed+1918-403

vendor: update macltok and wire image packs, emote reactions and link previews

macltok now calls fork-only matrix-sdk APIs, and cargo patches do not reach dependents, so both workspaces carry the [patch.crates-io] block pointing at the sibling ~/code/matrix-rust-sdk checkout. A sender's bundled MSC4095 previews always show, while homeserver previews are fetched only outside encrypted rooms unless dev.malice.url_previews opts in, since the homeserver sees every url asked about. A stored OAuthPending record restores as no session because malice only does password login.

Modified file: Cargo.lock+1 additions−20 deletions@@ -1945,6 +1945,7 @@ dependencies = [
  "imbl",
  "js-sys",
  "matrix-sdk",
+ "matrix-sdk-base",
  "matrix-sdk-crypto",
  "matrix-sdk-store-encryption",
  "matrix-sdk-test",
@@ -2171,8 +2172,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7083d580527511ac5d9369e03b9f2b20902e76949f1b3964051f978e4d3756ae"
 dependencies = [
  "anymap2",
  "aquamarine",
@@ -2235,8 +2234,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-base"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e09a917eb1f7643d9d9a06b2f131e2ceb39df6910a7b830dac18bfd6db37a1f5"
 dependencies = [
  "as_variant",
  "assert_matches",
@@ -2266,8 +2263,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-common"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b9d1e0fee0f090180ef9457034adc547e80de9e6e3eb2e63aaac68a8476f836"
 dependencies = [
  "eyeball-im",
  "futures-core",
@@ -2290,8 +2285,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-crypto"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c54afd2a326f51c13a6ad44ec86315a688fffeb3f1e287fb343e0e1836a3bdaf"
 dependencies = [
  "aes",
  "aquamarine",
@@ -2332,8 +2325,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-indexeddb"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fef37395fffb7c916f7109ab0d16d8ca599403dd8164d08c0d966176b66ede47"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -2365,8 +2356,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-sqlite"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a49133429271005745f8d5a05362d2ba6567274777250236799927ca30dc0670"
 dependencies = [
  "as_variant",
  "async-trait",
@@ -2393,8 +2382,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-store-encryption"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f48f304e553fb6200b1d7d1f77a88fd182076d4b25624e9dbfa42d6a37de35e"
 dependencies = [
  "base64 0.22.1",
  "blake3",
@@ -2415,8 +2402,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-test"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8023d4315fff35598c2d4a955920c1273c6aaab4dcd9ed405238a882581649bf"
 dependencies = [
  "as_variant",
  "ctor",
@@ -2439,8 +2424,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-test-macros"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d97d6a0e5b1401c530b3c5d18cb98257d255d396bacf3903beda6718a2f4c4c5"
 dependencies = [
  "quote",
  "syn 2.0.119",
@@ -2449,8 +2432,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-ui"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d1f2b8a8cf57164d7cee4eb61c0b9f074b2e11d766a9391b7db0b9f2cbd83d8"
 dependencies = [
  "as_variant",
  "async-rx",

Modified file: Cargo.toml+12 additions@@ -13,3 +13,15 @@ http = "1"
 
 [workspace.lints.rust]
 unsafe_code = "forbid"
+
+[patch.crates-io]
+matrix-sdk = { path = "../matrix-rust-sdk/crates/matrix-sdk" }
+matrix-sdk-base = { path = "../matrix-rust-sdk/crates/matrix-sdk-base" }
+matrix-sdk-common = { path = "../matrix-rust-sdk/crates/matrix-sdk-common" }
+matrix-sdk-crypto = { path = "../matrix-rust-sdk/crates/matrix-sdk-crypto" }
+matrix-sdk-indexeddb = { path = "../matrix-rust-sdk/crates/matrix-sdk-indexeddb" }
+matrix-sdk-sqlite = { path = "../matrix-rust-sdk/crates/matrix-sdk-sqlite" }
+matrix-sdk-store-encryption = { path = "../matrix-rust-sdk/crates/matrix-sdk-store-encryption" }
+matrix-sdk-test = { path = "../matrix-rust-sdk/testing/matrix-sdk-test" }
+matrix-sdk-test-macros = { path = "../matrix-rust-sdk/testing/matrix-sdk-test-macros" }
+matrix-sdk-ui = { path = "../matrix-rust-sdk/crates/matrix-sdk-ui" }

Modified file: README.md+4 additions−2 deletions@@ -61,8 +61,10 @@ network address used at sign-in, not a space. Sending a message returns a queued
 command, then the timeline shows whether delivery is queued, sending, confirmed
 by the server, or failed. Opening a room loads its timeline; scrolling up loads
 older history. Images and avatars are served through authenticated, bounded
-media endpoints; SVG content is not rendered. Link previews use URL text only
-and do not fetch third-party pages.
+media endpoints; SVG content is not rendered. Link previews embedded by the
+sender always show. Otherwise the homeserver fetches previews in unencrypted
+rooms, and in encrypted rooms only when the user enables it in the Security
+panel. Room admins can disable previews per room.
 
 The Security panel accepts incoming device-verification requests and supports
 emoji/number comparison, confirmation, rejection, and recovery-key entry.

Modified file: crates/malice-core/src/error.rs+1−1

@@ -50,7 +50,7 @@ impl From<macltok::Error> for CoreError {

5050 "the sync engine stopped; sign in again",

5151 );

5252 }

53- ErrorKind::QueueFull | ErrorKind::RoomBusy => Failure::Busy,

53+ ErrorKind::QueueFull | ErrorKind::RoomBusy | ErrorKind::RateLimited => Failure::Busy,

5454 ErrorKind::RoomUnknown | ErrorKind::MediaUnknown | ErrorKind::MediaUnavailable => {

5555 Failure::NotFound

5656 }

Modified file: crates/malice-core/src/feed.rs+11 additions−2 deletions@@ -2,8 +2,9 @@ use std::collections::HashMap;
 
 use futures_util::{Stream, StreamExt, stream};
 use macltok::{
-    ConnectionState, EncryptionState, MirrorHandle, RoomSummary, SessionStatus, State, StateChange,
-    TimelineChange, TimelineId, TimelineItem, UploadOutcome, VerificationState, imbl::Vector,
+    ConnectionState, EncryptionState, ImagePacks, MirrorHandle, RoomSummary, SessionStatus, State,
+    StateChange, TimelineChange, TimelineId, TimelineItem, UploadOutcome, VerificationState,
+    imbl::Vector,
 };
 use serde::Serialize;
 
@@ -16,6 +17,10 @@ pub enum WireEvent {
         connection: String,
         encryption: Option<EncryptionState>,
         verification: Option<VerificationState>,
+        image_packs: ImagePacks,
+    },
+    ImagePacks {
+        packs: ImagePacks,
     },
     Rooms {
         rooms: Vec<RoomSummary>,
@@ -85,6 +90,7 @@ pub fn snapshot_event(state: &State) -> WireEvent {
         connection: connection_label(&state.connection),
         encryption: state.encryption.clone(),
         verification: state.verification.clone(),
+        image_packs: state.image_packs.clone(),
     }
 }
 
@@ -133,6 +139,9 @@ pub fn wire_events(change: &StateChange) -> Vec<WireEvent> {
         StateChange::Verification(state) => vec![WireEvent::Verification {
             state: state.clone(),
         }],
+        StateChange::ImagePacks(packs) => vec![WireEvent::ImagePacks {
+            packs: packs.clone(),
+        }],
         StateChange::Failed(failure) => vec![error(&failure.message)],
         StateChange::SessionSaveFailed(_) => {
             vec![error(

Modified file: crates/malice-core/src/request.rs+54 additions−1 deletions@@ -66,6 +66,8 @@ pub enum Request {
         event_id: String,
         #[serde(default)]
         key: String,
+        #[serde(default)]
+        shortcode: Option<String>,
     },
     Read {
         #[serde(default)]
@@ -106,6 +108,12 @@ pub enum Request {
         event_type: String,
         content: serde_json::Value,
     },
+    UrlPreview {
+        #[serde(default)]
+        room_id: String,
+        #[serde(default)]
+        url: String,
+    },
 }
 
 impl Request {
@@ -227,6 +235,7 @@ pub async fn dispatch(
             room_id,
             event_id,
             key,
+            shortcode,
         } => {
             let room_id = parse_room_id(&room_id)?;
             let event_id = parse_event_id(&event_id)?;
@@ -236,8 +245,13 @@ pub async fn dispatch(
                     "key must be 1..32 characters, or an mxc uri up to 255",
                 ));
             }
+            let shortcode = match shortcode.as_deref().map(str::trim) {
+                Some("") | None => None,
+                Some(code) if code.chars().count() <= 100 => Some(code.to_owned()),
+                Some(_) => return Err(CoreError::bad_request("shortcode must be up to 100 characters")),
+            };
             handle
-                .toggle_reaction(TimelineId::Room(room_id), event_id, key)
+                .toggle_reaction(TimelineId::Room(room_id), event_id, key, shortcode)
                 .await?;
             Ok(Reply::Done)
         }
@@ -362,6 +376,17 @@ pub async fn dispatch(
                 .await?;
             Ok(Reply::Done)
         }
+        Request::UrlPreview { room_id, url } => {
+            let room_id = parse_room_id(&room_id)?;
+            let url = preview_url(&url)?;
+            if !handle.url_previews_allowed(&room_id).await? {
+                return Ok(Reply::Json(serde_json::Value::Null));
+            }
+            let preview = handle.url_preview(url).await?;
+            let value = serde_json::to_value(preview)
+                .map_err(|_| CoreError::bad_request("preview is not valid json"))?;
+            Ok(Reply::Json(value))
+        }
     }
 }
 
@@ -386,11 +411,39 @@ fn account_data_type(event_type: &str) -> Result<GlobalAccountDataEventType, Cor
     Ok(GlobalAccountDataEventType::from(event_type))
 }
 
+const MAX_PREVIEW_URL_BYTES: usize = 2048;
+
+fn preview_url(url: &str) -> Result<&str, CoreError> {
+    let host = url
+        .strip_prefix("https://")
+        .or_else(|| url.strip_prefix("http://"))
+        .and_then(|rest| rest.split(['/', '?', '#']).next())
+        .filter(|host| !host.is_empty());
+    if url.len() > MAX_PREVIEW_URL_BYTES
+        || host.is_none()
+        || url.chars().any(|c| c.is_whitespace() || c.is_control())
+    {
+        return Err(CoreError::bad_request("url must be a short http(s) url"));
+    }
+    Ok(url)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
+    fn preview_urls() {
+        assert!(preview_url("https://example.org/a?b=c").is_ok());
+        assert!(preview_url("http://example.org").is_ok());
+        assert!(preview_url("ftp://example.org").is_err());
+        assert!(preview_url("https://").is_err());
+        assert!(preview_url("https:///path").is_err());
+        assert!(preview_url("https://exa mple.org").is_err());
+        assert!(preview_url(&format!("https://e.org/{}", "a".repeat(2048))).is_err());
+    }
+
+    #[test]
     fn reaction_keys() {
         assert!(valid_reaction_key("👍"));
         assert!(!valid_reaction_key(""));

Modified file: crates/malice-server/src/routes.rs+34 additions@@ -69,6 +69,8 @@ struct ReactBody {
     event_id: String,
     #[serde(default)]
     key: String,
+    #[serde(default)]
+    shortcode: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -118,6 +120,14 @@ struct AccountDataQuery {
 }
 
 #[derive(Debug, Deserialize)]
+struct UrlPreviewQuery {
+    #[serde(default)]
+    room_id: String,
+    #[serde(default)]
+    url: String,
+}
+
+#[derive(Debug, Deserialize)]
 struct AccountDataBody {
     event_type: String,
     content: serde_json::Value,
@@ -538,6 +548,7 @@ async fn rooms_react(
                 room_id: body.0.room_id,
                 event_id: body.0.event_id,
                 key: body.0.key,
+                shortcode: body.0.shortcode,
             },
         )
         .await,
@@ -738,6 +749,28 @@ async fn get_account_data(
     )
 }
 
+async fn get_url_preview(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Query(query): Query<UrlPreviewQuery>,
+) -> Response {
+    let (user, _) = match auth(&state, &headers).await {
+        Ok(pair) => pair,
+        Err(error) => return error.into_response(),
+    };
+    respond(
+        dispatch(
+            &user.handle,
+            &user.mirror,
+            Request::UrlPreview {
+                room_id: query.room_id,
+                url: query.url,
+            },
+        )
+        .await,
+    )
+}
+
 async fn set_account_data(
     State(state): State<AppState>,
     headers: HeaderMap,
@@ -811,6 +844,7 @@ pub fn router(state: AppState, web_dir: Option<String>) -> Router {
             "/account-data",
             get(get_account_data).post(set_account_data),
         )
+        .route("/url-preview", get(get_url_preview))
         .route("/profile", get(get_profile))
         .route("/media", get(get_media))
         .route("/message-media", get(get_message_media))

Modified file: crates/malice-server/src/state.rs+1−1

@@ -154,7 +154,7 @@ impl AppState {

154154 restore_error(error)

155155 })?;

156156 match restore {

157- None => Err(RestoreError::NotFound),

157+ None | Some(Restore::OAuthPending) => Err(RestoreError::NotFound),

158158 Some(Restore::SoftLoggedOut(soft)) => Err(RestoreError::SoftLoggedOut {

159159 user_id: soft.user_id.to_string(),

160160 homeserver: soft.homeserver,

Modified file: crates/malice-worker/Cargo.lock+9 additions−16 deletions@@ -1731,6 +1731,7 @@ dependencies = [
  "imbl",
  "js-sys",
  "matrix-sdk",
+ "matrix-sdk-base",
  "matrix-sdk-crypto",
  "matrix-sdk-store-encryption",
  "matrix-sdk-ui",
@@ -1925,8 +1926,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7083d580527511ac5d9369e03b9f2b20902e76949f1b3964051f978e4d3756ae"
 dependencies = [
  "anymap2",
  "aquamarine",
@@ -1986,8 +1985,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-base"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e09a917eb1f7643d9d9a06b2f131e2ceb39df6910a7b830dac18bfd6db37a1f5"
 dependencies = [
  "as_variant",
  "async-trait",
@@ -2013,8 +2010,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-common"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b9d1e0fee0f090180ef9457034adc547e80de9e6e3eb2e63aaac68a8476f836"
 dependencies = [
  "eyeball-im",
  "futures-core",
@@ -2037,8 +2032,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-crypto"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c54afd2a326f51c13a6ad44ec86315a688fffeb3f1e287fb343e0e1836a3bdaf"
 dependencies = [
  "aes",
  "aquamarine",
@@ -2078,8 +2071,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-indexeddb"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fef37395fffb7c916f7109ab0d16d8ca599403dd8164d08c0d966176b66ede47"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -2111,8 +2102,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-sqlite"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a49133429271005745f8d5a05362d2ba6567274777250236799927ca30dc0670"
 dependencies = [
  "as_variant",
  "async-trait",
@@ -2139,8 +2128,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-store-encryption"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f48f304e553fb6200b1d7d1f77a88fd182076d4b25624e9dbfa42d6a37de35e"
 dependencies = [
  "base64 0.22.1",
  "blake3",
@@ -2161,8 +2148,6 @@ dependencies = [
 [[package]]
 name = "matrix-sdk-ui"
 version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d1f2b8a8cf57164d7cee4eb61c0b9f074b2e11d766a9391b7db0b9f2cbd83d8"
 dependencies = [
  "as_variant",
  "async-rx",
@@ -4528,3 +4513,11 @@ name = "zmij"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
+
+[[patch.unused]]
+name = "matrix-sdk-test"
+version = "0.18.0"
+
+[[patch.unused]]
+name = "matrix-sdk-test-macros"
+version = "0.18.0"

Modified file: crates/malice-worker/Cargo.toml+12 additions@@ -45,3 +45,15 @@ lto = true
 codegen-units = 1
 panic = "abort"
 strip = true
+
+[patch.crates-io]
+matrix-sdk = { path = "../../../matrix-rust-sdk/crates/matrix-sdk" }
+matrix-sdk-base = { path = "../../../matrix-rust-sdk/crates/matrix-sdk-base" }
+matrix-sdk-common = { path = "../../../matrix-rust-sdk/crates/matrix-sdk-common" }
+matrix-sdk-crypto = { path = "../../../matrix-rust-sdk/crates/matrix-sdk-crypto" }
+matrix-sdk-indexeddb = { path = "../../../matrix-rust-sdk/crates/matrix-sdk-indexeddb" }
+matrix-sdk-sqlite = { path = "../../../matrix-rust-sdk/crates/matrix-sdk-sqlite" }
+matrix-sdk-store-encryption = { path = "../../../matrix-rust-sdk/crates/matrix-sdk-store-encryption" }
+matrix-sdk-test = { path = "../../../matrix-rust-sdk/testing/matrix-sdk-test" }
+matrix-sdk-test-macros = { path = "../../../matrix-rust-sdk/testing/matrix-sdk-test-macros" }
+matrix-sdk-ui = { path = "../../../matrix-rust-sdk/crates/matrix-sdk-ui" }

Modified file: crates/malice-worker/src/lib.rs+1−1

@@ -79,7 +79,7 @@ impl Host {

7979 StoreConfig::indexeddb(store_name(&account), passphrase),

8080 ));

8181 match Session::restore(sessions.clone()).await {

82- Ok(None) => Ok(to_js_value(&serde_json::json!({ "status": "none" }))),

82+ Ok(None | Some(Restore::OAuthPending)) => Ok(to_js_value(&serde_json::json!({ "status": "none" }))),

8383 Ok(Some(Restore::SoftLoggedOut(soft))) => Ok(to_js_value(&serde_json::json!({

8484 "status": "soft_logged_out",

8585 "user_id": soft.user_id.to_string(),

Modified file: vendor/macltok/Cargo.toml+2 additions−1 deletions@@ -27,10 +27,11 @@ futures-util = { version = "0.3.31", default-features = false, features = ["std"
 http = "1"
 imbl = { version = "6.1.0", default-features = false }
 matrix-sdk = { version = "0.18.0", default-features = false, features = ["e2e-encryption"] }
+matrix-sdk-base = { version = "0.18.0", default-features = false }
 matrix-sdk-crypto = { version = "0.18.0", default-features = false }
 matrix-sdk-store-encryption = { version = "0.18.0", optional = true }
 matrix-sdk-ui = { version = "0.18.0", default-features = false }
-ruma = { version = "0.16.0", 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 }
 thiserror = "2.0.16"
 mime = "0.3.17"

Modified file: vendor/macltok/examples/headless.rs+1−1

@@ -23,7 +23,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {

2323 )

2424 .await?

2525 }

26- None => {

26+ None | Some(Restore::OAuthPending) => {

2727 Session::login_password(

2828 PasswordLogin::new(

2929 required("MATRIX_HOMESERVER")?,

Modified file: vendor/macltok/src/account.rs+198 additions−11 deletions@@ -11,13 +11,14 @@ use matrix_sdk::{
         AuthSession,
         matrix::MatrixSession,
         oauth::{
-            ClientId, ClientRegistrationData, CsrfToken, OAuthSession, UserSession,
+            ClientId, ClientRegistrationData, CsrfToken, OAuthSession, PendingAuthorization,
+            UserSession,
             registration::{ApplicationType, ClientMetadata, Localized, OAuthGrantType},
         },
     },
     cross_process_lock::CrossProcessLockConfig,
     encryption::{BackupDownloadStrategy, EncryptionSettings},
-    ruma::{OwnedDeviceId, OwnedUserId, serde::Raw},
+    ruma::{MilliSecondsSinceUnixEpoch, OwnedDeviceId, OwnedUserId, serde::Raw},
 };
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
@@ -167,6 +168,7 @@ pub struct PendingOAuthLogin {
     tracking: Option<(Tracking, StoreLock)>,
     authorization_url: String,
     state: Option<CsrfToken>,
+    previous: Option<SessionRecord>,
 }
 
 impl PendingOAuthLogin {
@@ -200,6 +202,9 @@ impl PendingOAuthLogin {
         let oauth = self.client.oauth();
         if let Err(error) = oauth.finish_login(callback_url.into()).await {
             oauth.abort_login(&state).await;
+            if let Some(previous) = self.previous.take() {
+                put_back(self.sessions.as_ref(), previous).await;
+            }
             return Err(account_error("OAuth login", error));
         }
         let (tracking, store_lock) = self
@@ -215,10 +220,36 @@ impl PendingOAuthLogin {
         .await
     }
 
-    pub async fn abort(mut self) {
-        if let Some(state) = self.state.take() {
-            self.client.oauth().abort_login(&state).await;
+    /// puts back what the store held before, or deletes the store if it held nothing
+    pub async fn abort(self) {
+        let Self {
+            client,
+            sessions,
+            tracking,
+            state,
+            previous,
+            ..
+        } = self;
+        let Some(state) = state else {
+            return;
+        };
+        client.oauth().abort_login(&state).await;
+        drop(client);
+        match previous {
+            Some(previous) => put_back(sessions.as_ref(), previous).await,
+            None => {
+                if let Err(error) = sessions.discard().await {
+                    tracing::warn!(%error, "deleting an abandoned OAuth login's store failed");
+                }
+            }
         }
+        drop(tracking);
+    }
+}
+
+async fn put_back(sessions: &dyn SessionStore, previous: SessionRecord) {
+    if let Err(error) = sessions.save(&previous).await {
+        tracing::warn!(%error, "putting back the record an OAuth login replaced failed");
     }
 }
 
@@ -308,6 +339,32 @@ enum AuthenticationRecord {
         meta: SessionMeta,
         client_id: Option<ClientId>,
     },
+    /// an oauth login waiting on its redirect. `authorization` holds the pkce verifier
+    PendingOAuth {
+        client_id: ClientId,
+        state: CsrfToken,
+        authorization: Box<PendingAuthorization>,
+        started_ms: u64,
+        /// what the store held before, put back if the login never finishes
+        previous: Option<Box<SessionRecord>>,
+    },
+}
+
+/// authorization codes live for minutes, so a login this old was abandoned
+const OAUTH_PENDING_FOR_MS: u64 = 60 * 60 * 1000;
+
+/// the authorization server answers in the query, or the fragment when asked to
+pub(crate) fn callback_state(callback: &Url) -> Option<String> {
+    let query = callback.query_pairs();
+    let fragment = url::form_urlencoded::parse(callback.fragment().unwrap_or_default().as_bytes());
+    query
+        .chain(fragment)
+        .find(|(key, _)| key == "state")
+        .map(|(_, state)| state.into_owned())
+}
+
+fn now_ms() -> u64 {
+    MilliSecondsSinceUnixEpoch::now().get().into()
 }
 
 impl SessionRecord {
@@ -316,17 +373,47 @@ impl SessionRecord {
         &self.homeserver
     }
 
-    pub(crate) fn user_id(&self) -> &OwnedUserId {
+    /// a pending oauth login is nobody yet, unless it resumes someone
+    pub(crate) fn user_id(&self) -> Option<&OwnedUserId> {
         match &self.authentication {
-            AuthenticationRecord::Matrix(session) => &session.meta.user_id,
-            AuthenticationRecord::OAuth { user, .. } => &user.meta.user_id,
-            AuthenticationRecord::SoftLoggedOut { meta, .. } => &meta.user_id,
+            AuthenticationRecord::Matrix(session) => Some(&session.meta.user_id),
+            AuthenticationRecord::OAuth { user, .. } => Some(&user.meta.user_id),
+            AuthenticationRecord::SoftLoggedOut { meta, .. } => Some(&meta.user_id),
+            AuthenticationRecord::PendingOAuth { previous, .. } => previous.as_ref()?.user_id(),
+        }
+    }
+
+    /// what a login should resume. a pending oauth login stands in for the record before it
+    pub(crate) fn resumable(self) -> Option<Self> {
+        match self.authentication {
+            AuthenticationRecord::PendingOAuth { previous, .. } => {
+                previous.and_then(|previous| previous.resumable())
+            }
+            _ => Some(self),
         }
     }
 
+    pub(crate) fn pending_oauth_state(&self) -> Option<&str> {
+        match &self.authentication {
+            AuthenticationRecord::PendingOAuth { state, .. } => Some(state.secret()),
+            _ => None,
+        }
+    }
+
+    pub(crate) fn oauth_expired(&self) -> bool {
+        let AuthenticationRecord::PendingOAuth { started_ms, .. } = &self.authentication else {
+            return false;
+        };
+        now_ms().saturating_sub(*started_ms) > OAUTH_PENDING_FOR_MS
+    }
+
     pub(crate) fn soft_logout(&self) -> Option<SoftLogout> {
-        let AuthenticationRecord::SoftLoggedOut { meta, client_id } = &self.authentication else {
-            return None;
+        let (meta, client_id) = match &self.authentication {
+            AuthenticationRecord::SoftLoggedOut { meta, client_id } => (meta, client_id),
+            AuthenticationRecord::PendingOAuth { previous, .. } => {
+                return previous.as_ref()?.soft_logout();
+            }
+            _ => return None,
         };
         Some(SoftLogout {
             homeserver: self.homeserver.clone(),
@@ -351,6 +438,7 @@ impl SessionRecord {
                 }
             }
             soft @ AuthenticationRecord::SoftLoggedOut { .. } => soft,
+            pending @ AuthenticationRecord::PendingOAuth { .. } => pending,
         };
         Self {
             homeserver: self.homeserver,
@@ -362,6 +450,8 @@ impl SessionRecord {
 pub enum Restore {
     Resumed(Session),
     SoftLoggedOut(SoftLogout),
+    /// an oauth login is waiting on its redirect. `Session::finish_oauth` takes the callback
+    OAuthPending,
 }
 
 /// who to log in again as. the store keeps this device's e2ee keys, so a login
@@ -422,6 +512,10 @@ pub enum AccountError {
     UnsupportedAuthentication,
     #[error("the OAuth callback was already submitted")]
     OAuthCallbackAlreadySubmitted,
+    /// nothing is waiting for this callback. it was finished, abandoned, expired, or begun
+    /// somewhere else
+    #[error("no OAuth login is waiting for this callback")]
+    NoPendingOAuth,
     /// what was typed can't name a homeserver, so nothing was sent anywhere
     #[error("that isn't a usable homeserver, {0}")]
     InvalidHomeserver(&'static str),
@@ -586,15 +680,99 @@ impl Session {
             .build()
             .await
             .map_err(|error| account_error("starting OAuth login", error))?;
+        let previous = sessions.load().await?.and_then(SessionRecord::resumable);
+        let pending = SessionRecord {
+            homeserver: client.homeserver().to_string(),
+            authentication: AuthenticationRecord::PendingOAuth {
+                client_id: client
+                    .oauth()
+                    .client_id()
+                    .ok_or(AccountError::MissingSession)?
+                    .clone(),
+                state: authorization.state.clone(),
+                authorization: Box::new(
+                    client
+                        .oauth()
+                        .pending_authorization(&authorization.state)
+                        .await
+                        .ok_or(AccountError::MissingSession)?,
+                ),
+                started_ms: now_ms(),
+                previous: previous.clone().map(Box::new),
+            },
+        };
+        sessions.save(&pending).await?;
         Ok(PendingOAuthLogin {
             client,
             sessions,
             tracking: Some((tracking, store_lock)),
             authorization_url: authorization.url.to_string(),
             state: Some(authorization.state),
+            previous,
         })
     }
 
+    /// finishes a login `begin_oauth` started in another process, from the callback the
+    /// redirect brought back. the pending login is in `sessions`, so nothing else is needed
+    pub async fn finish_oauth(
+        sessions: Arc<dyn SessionStore>,
+        callback_url: &str,
+    ) -> Result<Self, AccountError> {
+        let store_lock = sessions.store().lock().await?;
+        Self::finish_oauth_locked(sessions, store_lock, callback_url).await
+    }
+
+    pub(crate) async fn finish_oauth_locked(
+        sessions: Arc<dyn SessionStore>,
+        store_lock: StoreLock,
+        callback_url: &str,
+    ) -> Result<Self, AccountError> {
+        let callback = Url::parse(callback_url)
+            .map_err(|error| account_error("parsing the OAuth callback URL", error))?;
+        let record = sessions.load().await?.ok_or(AccountError::NoPendingOAuth)?;
+        if record.pending_oauth_state() != callback_state(&callback).as_deref() {
+            return Err(AccountError::NoPendingOAuth);
+        }
+        let AuthenticationRecord::PendingOAuth {
+            client_id,
+            state,
+            authorization,
+            previous,
+            ..
+        } = record.authentication
+        else {
+            return Err(AccountError::NoPendingOAuth);
+        };
+        let client = matrix_client_builder(sessions.store())
+            .homeserver_url(&record.homeserver)
+            .build()
+            .await
+            .map_err(|error| account_error("reopening the Matrix store", error))?;
+        let tracking = Tracking::start(&client, sessions.clone())?;
+        let oauth = client.oauth();
+        oauth.restore_registered_client(client_id);
+        let finished = match oauth
+            .restore_pending_authorization(state, *authorization)
+            .await
+        {
+            Ok(()) => oauth.finish_login(callback.into()).await,
+            Err(error) => Err(error.into()),
+        };
+        if let Err(error) = finished {
+            match previous {
+                Some(previous) => put_back(sessions.as_ref(), *previous).await,
+                None => {
+                    drop((tracking, client));
+                    if let Err(error) = sessions.discard().await {
+                        tracing::warn!(%error, "deleting a failed OAuth login's store failed");
+                    }
+                }
+            }
+            return Err(account_error("OAuth login", error));
+        }
+        Self::saved(client, sessions, tracking, store_lock).await
+    }
+
     /// Restore the record `sessions` holds, or `None` when it holds none.
     /// The caller must also handle rejection and explicit logout.
     pub async fn restore(sessions: Arc<dyn SessionStore>) -> Result<Option<Restore>, AccountError> {
@@ -606,6 +784,15 @@ impl Session {
             AuthenticationRecord::OAuth { client_id, user } => {
                 OAuthSession { client_id, user }.into()
             }
+            AuthenticationRecord::PendingOAuth { .. } if record.oauth_expired() => {
+                let previous = record.resumable();
+                match previous {
+                    Some(previous) => put_back(sessions.as_ref(), previous).await,
+                    None => sessions.discard().await?,
+                }
+                return Box::pin(Self::restore(sessions)).await;
+            }
+            AuthenticationRecord::PendingOAuth { .. } => return Ok(Some(Restore::OAuthPending)),
             AuthenticationRecord::SoftLoggedOut { meta, client_id } => {
                 return Ok(Some(Restore::SoftLoggedOut(SoftLogout {
                     homeserver: record.homeserver,

Modified file: vendor/macltok/src/accounts.rs+71 additions−8 deletions@@ -6,7 +6,8 @@ use ruma::TransactionId;
 
 use crate::{
     AccountError, EncryptedSessionStore, OAuthLogin, PasswordLogin, PendingOAuthLogin, Restore,
-    Session, SessionRecord, SessionStore, SoftLogout, StoreConfig, account::homeserver_input,
+    Session, SessionRecord, SessionStore, SoftLogout, StoreConfig,
+    account::{callback_state, homeserver_input},
     engine::StoreLock,
 };
 
@@ -94,18 +95,50 @@ impl Accounts {
     }
 
     /// every account with a record. a store left without one, by a login that died halfway or a
-    /// discard that couldn't finish, is deleted on the way past
+    /// discard that couldn't finish, is deleted on the way past, and so is an oauth login whose
+    /// redirect never came back. one that resumed an account puts that account back
     pub async fn list(&self) -> Result<Vec<Account>, AccountError> {
         let mut accounts = Vec::new();
         for account in self.slots().await? {
             match account.sessions.load().await {
                 Ok(None) => self.sweep(&account).await,
+                Ok(Some(record)) if record.oauth_expired() => {
+                    if self.expire(&account).await {
+                        accounts.push(account);
+                    }
+                }
                 Ok(Some(_)) | Err(_) => accounts.push(account),
             }
         }
         Ok(accounts)
     }
 
+    /// finishes an oauth login begun before a redirect, finding its account by the callback's
+    /// state, so the host needs to have kept nothing across the redirect
+    pub async fn finish_oauth(
+        &self,
+        callback_url: &str,
+    ) -> Result<(Account, Session), AccountError> {
+        let state = url::Url::parse(callback_url)
+            .ok()
+            .as_ref()
+            .and_then(callback_state)
+            .ok_or(AccountError::NoPendingOAuth)?;
+        for account in self.slots().await? {
+            let Ok(Some(record)) = account.sessions.load().await else {
+                continue;
+            };
+            if record.pending_oauth_state() != Some(state.as_str()) {
+                continue;
+            }
+            let store_lock = account.sessions.store().lock().await?;
+            let session =
+                Session::finish_oauth_locked(account.sessions(), store_lock, callback_url).await?;
+            return Ok((account, session));
+        }
+        Err(AccountError::NoPendingOAuth)
+    }
+
     /// a soft-logged-out account the login names is resumed as its own device, keeping its keys.
     /// anyone else gets a new account
     pub async fn login_password(
@@ -193,9 +226,10 @@ impl Accounts {
             if !resumes(&record) {
                 continue;
             }
-            return match record.soft_logout() {
-                Some(soft) => Ok(Found::SoftLoggedOut(account, soft)),
-                None => Err(AccountError::AlreadyLoggedIn(record.user_id().clone())),
+            return match (record.soft_logout(), record.user_id()) {
+                (Some(soft), _) => Ok(Found::SoftLoggedOut(account, soft)),
+                (None, Some(user_id)) => Err(AccountError::AlreadyLoggedIn(user_id.clone())),
+                (None, None) => continue,
             };
         }
         Ok(Found::Nobody)
@@ -227,9 +261,36 @@ impl Accounts {
         let Ok(_store_lock) = account.sessions.store().lock().await else {
             return;
         };
-        if !matches!(account.sessions.load().await, Ok(None)) {
-            return;
+        if matches!(account.sessions.load().await, Ok(None)) {
+            self.remove(account).await;
         }
+    }
+
+    /// whether the account is still there. a login running in another tab holds the lock and
+    /// is left alone
+    async fn expire(&self, account: &Account) -> bool {
+        let Ok(_store_lock) = account.sessions.store().lock().await else {
+            return true;
+        };
+        let Ok(Some(record)) = account.sessions.load().await else {
+            return true;
+        };
+        if !record.oauth_expired() {
+            return true;
+        }
+        match record.resumable() {
+            Some(previous) => {
+                let _ = account.sessions.save(&previous).await;
+                true
+            }
+            None => {
+                self.remove(account).await;
+                false
+            }
+        }
+    }
+
+    async fn remove(&self, account: &Account) {
         if account.sessions.discard().await.is_err() {
             return;
         }
@@ -274,7 +335,9 @@ impl Accounts {
 /// is compared by name as well as by url, so a delegated `example.org` still finds the account
 /// discovery took to `matrix.example.org`
 fn record_names(record: &SessionRecord, homeserver: &str, username: &str) -> bool {
-    let user_id = record.user_id();
+    let Some(user_id) = record.user_id() else {
+        return false;
+    };
     let username = username.trim();
     let user = if username.starts_with('@') {
         username.eq_ignore_ascii_case(user_id.as_str())

Modified file: vendor/macltok/src/engine/media.rs+9 additions−3 deletions@@ -31,10 +31,10 @@ use matrix_sdk_crypto::{AttachmentDecryptor, MediaEncryptionInfo};
 use ruma::MxcUri;
 use tokio::sync::Mutex;
 
-use super::executor::EngineBoxFuture;
+use super::{executor::EngineBoxFuture, url_preview::UrlPreviews};
 use crate::{
-    AttachmentEncryption, AttachmentUpload, Error, ErrorKind, Media, MediaFile, MediaId, MediaKind,
-    MediaLocation, MediaSize, TimelineId,
+    AttachmentEncryption, AttachmentUpload, Error, ErrorKind, LinkPreview, Media, MediaFile,
+    MediaId, MediaKind, MediaLocation, MediaSize, TimelineId,
     normalise::{MediaRegistration, MediaScope, MediaSourceInfo},
     upload::prepare_upload,
 };
@@ -54,11 +54,13 @@ pub(crate) struct MediaService {
     registry: Mutex<MediaRegistry>,
     flights: Mutex<HashMap<String, WeakShared<FlightFuture>>>,
     max_bytes: usize,
+    url_previews: UrlPreviews,
 }
 
 impl MediaService {
     pub(crate) fn new(client: Client, max_bytes: usize, max_sources: usize) -> Self {
         Self {
+            url_previews: UrlPreviews::new(client.clone()),
             client,
             registry: Mutex::new(MediaRegistry::new(max_sources)),
             flights: Mutex::new(HashMap::new()),
@@ -66,6 +68,10 @@ impl MediaService {
         }
     }
 
+    pub(crate) async fn url_preview(&self, url: &str) -> Result<Option<LinkPreview>, Error> {
+        self.url_previews.preview(url).await
+    }
+
     pub(crate) async fn register(&self, media: Vec<MediaRegistration>) {
         if !media.is_empty() {
             self.registry.lock().await.insert_all(media);

Modified file: vendor/macltok/src/engine/mod.rs+12 additions−45 deletions@@ -6,6 +6,7 @@ mod prepare;
 mod room;
 mod session;
 mod timeline;
+mod url_preview;
 mod watchers;
 
 use std::{
@@ -41,6 +42,7 @@ use crate::{
     AccountCommand, ClientHandle, Command, 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},
 };
 
@@ -245,7 +247,6 @@ struct Queues {
     encryption: mpsc::Receiver<Job<EncryptionCommand>>,
     session_changes: broadcast::Receiver<SessionChange>,
     persistence: Option<Persistence>,
-    upload_reports: mpsc::Receiver<watchers::RoomUpload>,
 }
 
 /// requests other devices send us, handed from the sdk's event handler to the encryption worker
@@ -269,9 +270,6 @@ pub struct Engine {
     notifications: mpsc::Sender<Job<NotificationCommand>>,
     encryption: mpsc::Sender<Job<EncryptionCommand>>,
     queues: Option<Queues>,
-    /// one progress forwarder per room that has uploaded, and whether it's subscribed yet
-    uploads: HashMap<OwnedRoomId, watch::Receiver<bool>>,
-    upload_reports: mpsc::Sender<watchers::RoomUpload>,
     /// the client can outlive us, so the handler has to come off it when we stop
     verification_handler: Option<matrix_sdk::event_handler::EventHandlerHandle>,
     stop: mpsc::UnboundedSender<Termination>,
@@ -313,6 +311,10 @@ impl Engine {
         let sync = Arc::new(
             SyncService::builder(client.clone())
                 .with_offline_mode()
+                .with_room_list_extra_required_state(vec![
+                    (ROOM_PACKS.into(), "*".to_owned()),
+                    (ROOM_PREVIEW_URLS.into(), String::new()),
+                ])
                 .build()
                 .await
                 .map_err(EngineError::SyncService)?,
@@ -332,9 +334,9 @@ impl Engine {
             config.event_capacity,
         );
         client.send_queue().enable_upload_progress(true);
+        client.send_queue().enable_global_upload_progress(true);
         let (note_sender, notes) = mpsc::unbounded_channel();
         let (stop, stops) = mpsc::unbounded_channel();
-        let (upload_reports, upload_report_queue) = mpsc::channel(config.event_capacity);
         let (mutations, mutation_queue) = mpsc::channel(config.command_capacity);
         let (notifications, notification_queue) = mpsc::channel(config.command_capacity);
         let (encryption, encryption_queue) = mpsc::channel(config.command_capacity);
@@ -361,10 +363,7 @@ impl Engine {
                 encryption: encryption_queue,
                 session_changes,
                 persistence,
-                upload_reports: upload_report_queue,
             }),
-            upload_reports,
-            uploads: HashMap::new(),
             verification_handler: None,
             preparations: prepare::Preparations::default(),
             stop,
@@ -401,7 +400,6 @@ impl Engine {
             }
         }
         self.start_tasks();
-        self.resume_upload_forwarders().await;
         self.sync.start().await;
 
         let mut shutdown_reply = None;
@@ -462,13 +460,12 @@ impl Engine {
         let client = &self.client;
         let events = || self.port.event_sender();
         let (notices, notice_queue) = mpsc::unbounded_channel();
-        let watchers: [(&'static str, EngineBoxFuture<'static, ()>); 12] = [
+        let watchers: [(&'static str, EngineBoxFuture<'static, ()>); 13] = [
             (
                 "upload tracker",
                 Box::pin(watchers::uploads(
                     client.clone(),
                     client.send_queue().subscribe(),
-                    queues.upload_reports,
                     events(),
                 )),
             ),
@@ -528,6 +525,10 @@ impl Engine {
                 Box::pin(watchers::rooms(client.clone(), events())),
             ),
             (
+                "image pack watcher",
+                Box::pin(watchers::image_packs(client.clone(), events())),
+            ),
+            (
                 "notification settings watcher",
                 Box::pin(watchers::notification_settings(client.clone(), events())),
             ),
@@ -734,45 +735,12 @@ impl Engine {
         let Some(room) = self.client.get_room(upload.timeline_id.room_id()) else {
             return reply.done(Err(Error::room_unknown()));
         };
-        let mut ready = self.upload_forwarder(&room);
         let max_bytes = self.config.max_media_bytes;
-        // queueing before the forwarder listens would lose the first progress ticks
         self.spawn_command("upload", reply, async move {
-            ready
-                .wait_for(|subscribed| *subscribed)
-                .await
-                .map_err(|_| Error::new(ErrorKind::Store, "reading the media send queue failed"))?;
             media::queue_upload(room, upload, max_bytes).await
         });
     }
 
-    fn upload_forwarder(&mut self, room: &matrix_sdk::Room) -> watch::Receiver<bool> {
-        self.uploads.retain(|_, ready| ready.has_changed().is_ok());
-        if let Some(ready) = self.uploads.get(room.room_id()) {
-            return ready.clone();
-        }
-        let (subscribed, ready) = watch::channel(false);
-        self.tasks.spawn(
-            TaskContext::Command("upload watcher"),
-            watchers::room_uploads(room.clone(), self.upload_reports.clone(), subscribed),
-        );
-        self.uploads
-            .insert(room.room_id().to_owned(), ready.clone());
-        ready
-    }
-
-    /// the sdk resumes uploads left over from last time, and they deserve progress too
-    async fn resume_upload_forwarders(&mut self) {
-        let Ok(echoes) = self.client.send_queue().local_echoes().await else {
-            return;
-        };
-        for room_id in echoes.keys() {
-            if let Some(room) = self.client.get_room(room_id) {
-                self.upload_forwarder(&room);
-            }
-        }
-    }
-
     fn route_timeline(&mut self, command: TimelineCommand, reply: Responder) {
         let sender = match self.rooms.get(command.room_id()) {
             Some(RoomSlot::Active { sender, .. }) => Some(sender.clone()),
@@ -942,7 +910,6 @@ impl Engine {
         self.port.close();
         self.tasks.shutdown().await;
         self.rooms.clear();
-        self.uploads.clear();
         self.media.clear().await;
         self.sync.stop().await;
         self.port

Modified file: vendor/macltok/src/engine/prepare.rs+5 additions−9 deletions@@ -33,15 +33,11 @@ impl Preparations {
     }
 }
 
-/// the part of the sdk's pre-send encryption work it lets us reach. syncing the members
-/// has the sdk track them all, and its own background `/keys/query` then catches up
-/// their devices. the one time key claim and the room key share stay on the send path
+/// the sdk's own pre-send work, run early. a send landing mid-share waits on the
+/// sdk's per-room share lock instead of starting another (forked sdk, see design-decisions)
 async fn prepare(client: Client, room_id: OwnedRoomId) -> Result<(), Error> {
     let room = client.get_room(&room_id).ok_or_else(Error::room_unknown)?;
-    if room.encryption_state().is_encrypted() && !room.are_members_synced() {
-        room.sync_members()
-            .await
-            .map_err(|source| Error::from_sdk("syncing room members failed", source))?;
-    }
-    Ok(())
+    room.prepare_encryption()
+        .await
+        .map_err(|source| Error::from_sdk("preparing room encryption failed", source))
 }

Modified file: vendor/macltok/src/engine/timeline.rs+7 additions−2 deletions@@ -185,9 +185,14 @@ impl TimelineSession {
                     .await
                     .map_err(timeline_error)
             }),
-            TimelineCommand::ToggleReaction { target, key, .. } => Box::pin(async move {
+            TimelineCommand::ToggleReaction {
+                target,
+                key,
+                shortcode,
+                ..
+            } => Box::pin(async move {
                 timeline
-                    .toggle_reaction(&item_id(target), &key)
+                    .toggle_reaction_with_shortcode(&item_id(target), &key, shortcode.as_deref())
                     .await
                     .map(drop)
                     .map_err(timeline_error)

Added file: vendor/macltok/src/engine/url_preview.rs+166 additions@@ -0,0 +1,166 @@
+use std::{
+    collections::{HashMap, VecDeque},
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
+    time::Duration,
+};
+
+use futures_util::{FutureExt, future::WeakShared};
+use matrix_sdk::{
+    Client, HttpError,
+    ruma::api::{
+        Metadata,
+        client::{authenticated_media, media},
+    },
+};
+use ruma::{
+    api::error::ErrorKind as ApiErrorKind,
+    serde::{JsonObject, Raw},
+    time::Instant,
+};
+use tokio::sync::Mutex;
+
+use super::executor::EngineBoxFuture;
+use crate::{Error, LinkPreview, normalise::server_preview};
+
+const HIT_FOR: Duration = Duration::from_secs(60 * 60);
+const MISS_FOR: Duration = Duration::from_secs(10 * 60);
+const REMEMBERED: usize = 512;
+
+type Lookup = EngineBoxFuture<'static, Result<Option<LinkPreview>, Error>>;
+
+/// the homeserver rate limits `preview_url` and a busy timeline repeats links, so answers are
+/// kept a while, misses too, and asks for one url at once share one request
+pub(crate) struct UrlPreviews(Arc<Inner>);
+
+struct Inner {
+    client: Client,
+    /// a server that doesn't preview at all says so once and isn't asked again
+    unsupported: AtomicBool,
+    cache: Mutex<Cache>,
+    lookups: Mutex<HashMap<String, WeakShared<Lookup>>>,
+}
+
+#[derive(Default)]
+struct Cache {
+    entries: HashMap<String, (Instant, Option<LinkPreview>)>,
+    order: VecDeque<String>,
+}
+
+impl UrlPreviews {
+    pub(crate) fn new(client: Client) -> Self {
+        Self(Arc::new(Inner {
+            client,
+            unsupported: AtomicBool::new(false),
+            cache: Mutex::new(Cache::default()),
+            lookups: Mutex::new(HashMap::new()),
+        }))
+    }
+
+    pub(crate) async fn preview(&self, url: &str) -> Result<Option<LinkPreview>, Error> {
+        if self.0.unsupported.load(Ordering::Relaxed) {
+            return Ok(None);
+        }
+        if let Some(preview) = self.0.cache.lock().await.get(url) {
+            return Ok(preview);
+        }
+        let lookup = {
+            let mut lookups = self.0.lookups.lock().await;
+            lookups.retain(|_, lookup| lookup.upgrade().is_some());
+            match lookups.get(url).and_then(WeakShared::upgrade) {
+                Some(lookup) => lookup,
+                None => {
+                    let inner = self.0.clone();
+                    let owned = url.to_owned();
+                    let lookup: Lookup = Box::pin(async move { inner.look_up(owned).await });
+                    let lookup = lookup.shared();
+                    if let Some(weak) = lookup.downgrade() {
+                        lookups.insert(url.to_owned(), weak);
+                    }
+                    lookup
+                }
+            }
+        };
+        lookup.await
+    }
+}
+
+impl Inner {
+    async fn look_up(&self, url: String) -> Result<Option<LinkPreview>, Error> {
+        let data = match self.fetch(&url).await {
+            Ok(data) => data,
+            Err(error) => {
+                let Some(api) = error.as_client_api_error() else {
+                    return Err(Error::from_sdk(
+                        "asking for a url preview failed",
+                        error.into(),
+                    ));
+                };
+                let unrecognised = matches!(api.error_kind(), Some(ApiErrorKind::Unrecognized))
+                    || api.status_code.as_u16() == 405;
+                if unrecognised {
+                    self.unsupported.store(true, Ordering::Relaxed);
+                    return Ok(None);
+                }
+                // synapse answers 500 for a page it can't download, 502 when dns fails and 403 for
+                // its blocklist (synapse/media/url_previewer.py). a real fault hides in the 500s too,
+                // but a missing card is cheap and only cached ten minutes
+                if !matches!(api.status_code.as_u16(), 400 | 403 | 404 | 500 | 502) {
+                    return Err(Error::from_sdk(
+                        "asking for a url preview failed",
+                        error.into(),
+                    ));
+                }
+                None
+            }
+        };
+        let preview = data.and_then(|data| server_preview(&url, &data));
+        self.cache.lock().await.insert(url, preview.clone());
+        Ok(preview)
+    }
+
+    async fn fetch(&self, url: &str) -> Result<Option<Raw<JsonObject>>, HttpError> {
+        let versions = self.client.supported_versions().await?;
+        let data = if authenticated_media::get_media_preview::v1::Request::PATH_BUILDER
+            .is_supported(&versions)
+        {
+            self.client
+                .send(authenticated_media::get_media_preview::v1::Request::new(
+                    url.to_owned(),
+                ))
+                .await?
+                .data
+        } else {
+            #[allow(deprecated)]
+            let request = media::get_media_preview::v3::Request::new(url.to_owned());
+            self.client.send(request).await?.data
+        };
+        Ok(data.map(Raw::from_json))
+    }
+}
+
+impl Cache {
+    fn get(&mut self, url: &str) -> Option<Option<LinkPreview>> {
+        let (at, preview) = self.entries.get(url)?;
+        let lasts = if preview.is_some() { HIT_FOR } else { MISS_FOR };
+        (at.elapsed() < lasts).then(|| preview.clone())
+    }
+
+    fn insert(&mut self, url: String, preview: Option<LinkPreview>) {
+        if self
+            .entries
+            .insert(url.clone(), (Instant::now(), preview))
+            .is_none()
+        {
+            self.order.push_back(url);
+        }
+        while self.entries.len() > REMEMBERED {
+            let Some(oldest) = self.order.pop_front() else {
+                break;
+            };
+            self.entries.remove(&oldest);
+        }
+    }
+}

Modified file: vendor/macltok/src/engine/watchers.rs+206 additions−172 deletions@@ -1,18 +1,31 @@
-use std::{collections::HashSet, sync::Arc, time::Duration};
+use std::{
+    collections::{HashSet, VecDeque},
+    sync::Arc,
+    time::Duration,
+};
 
 use futures_util::StreamExt;
 use matrix_sdk::{
-    Client, Room,
+    Client,
     ruma::events::{AnyMessageLikeEventContent, room::message::MessageType},
     send_queue::{LocalEchoContent, RoomSendQueueUpdate, SendQueueUpdate},
 };
+use matrix_sdk_base::RoomInfoNotableUpdateReasons;
 use matrix_sdk_ui::sync_service::{State as SyncState, SyncService};
-use ruma::{OwnedRoomId, OwnedTransactionId, time::Instant};
-use tokio::sync::{broadcast::error::RecvError, mpsc, watch};
+use ruma::{
+    OwnedRoomId, OwnedTransactionId,
+    events::{AnyGlobalAccountDataEvent, AnySyncStateEvent},
+    serde::Raw,
+    time::Instant,
+};
+use tokio::sync::{Notify, broadcast::error::RecvError, watch};
 
 use super::executor::TaskSet;
 use crate::{
-    ConnectionState, Event, UploadOutcome, encryption::encryption_state, error::classify_sdk_error,
+    ConnectionState, Event, UploadOutcome,
+    encryption::encryption_state,
+    error::classify_sdk_error,
+    normalise::{ENABLED_ROOMS, ROOM_PACKS, USER_PACK},
     transport::EventSender,
 };
 
@@ -113,84 +126,20 @@ pub(super) async fn send_queue_errors(
     }
 }
 
-/// upload progress only goes out on the room's own channel, never the client-wide one.
-/// the room's sends and cancels come along behind it, so an upload's end can't
-/// overtake its own progress
-pub(super) async fn room_uploads(
-    room: Room,
-    tracker: mpsc::Sender<RoomUpload>,
-    ready: watch::Sender<bool>,
-) {
-    let room_id = room.room_id().to_owned();
-    let mut updates = match room.send_queue().subscribe().await {
-        Ok((_, updates)) => updates,
-        Err(error) => {
-            tracing::warn!(%room_id, %error, "reading the media send queue failed");
-            return;
-        }
-    };
-    ready.send_replace(true);
-    loop {
-        let report = match updates.recv().await {
-            Ok(RoomSendQueueUpdate::MediaUpload {
-                related_to,
-                file,
-                progress,
-                ..
-            }) => RoomUpload::Progress {
-                upload: (room_id.clone(), related_to),
-                uploaded_bytes: progress.current as u64,
-                total_bytes: progress.total as u64,
-                complete: file.is_some() && progress.current == progress.total,
-            },
-            Ok(RoomSendQueueUpdate::SentEvent {
-                transaction_id,
-                event_id,
-            }) => RoomUpload::Ended(
-                (room_id.clone(), transaction_id),
-                UploadOutcome::Sent { event_id },
-            ),
-            Ok(RoomSendQueueUpdate::CancelledLocalEvent { transaction_id }) => {
-                RoomUpload::Ended((room_id.clone(), transaction_id), UploadOutcome::Cancelled)
-            }
-            Ok(_) => continue,
-            Err(RecvError::Lagged(_)) => RoomUpload::Lagged,
-            Err(RecvError::Closed) => return,
-        };
-        if tracker.send(report).await.is_err() {
-            return;
-        }
-    }
-}
-
-pub(super) enum RoomUpload {
-    Progress {
-        upload: Upload,
-        uploaded_bytes: u64,
-        total_bytes: u64,
-        complete: bool,
-    },
-    Ended(Upload, UploadOutcome),
-    /// an end may have been lost with the ticks
-    Lagged,
-}
-
 /// the one place upload events leave from, so an upload is never reported after it
-/// ended. progress comes in from the room forwarders, the rest from the client-wide
-/// channel, which exists before any upload does
+/// ended. the client-wide channel exists before any upload does. it holds 32 updates and
+/// progress ticks share it, so this keeps draining while the event stream is full
 pub(super) async fn uploads(
     client: Client,
     mut updates: tokio::sync::broadcast::Receiver<SendQueueUpdate>,
-    mut rooms_reports: mpsc::Receiver<RoomUpload>,
     events: EventSender,
 ) {
     let (_, mut rooms) = client.rooms_stream();
-    let mut tracker = UploadTracker {
-        live: attachment_echoes(&client).await,
-        ended: HashSet::new(),
-    };
+    let mut tracker = UploadTracker::new(attachment_echoes(&client).await);
+    let mut pending = VecDeque::new();
     loop {
-        let reports = tokio::select! {
+        let reports: Vec<Event> = tokio::select! {
+            biased;
             update = updates.recv() => match update {
                 Ok(update) => tracker.update(update).into_iter().collect(),
                 Err(RecvError::Lagged(skipped)) => {
@@ -199,10 +148,6 @@ pub(super) async fn uploads(
                 }
                 Err(RecvError::Closed) => return,
             },
-            Some(report) = rooms_reports.recv() => match report {
-                RoomUpload::Lagged => tracker.resnapshot(attachment_echoes(&client).await),
-                report => tracker.room(report).into_iter().collect(),
-            },
             update = rooms.next() => {
                 if update.is_none() {
                     return;
@@ -212,26 +157,77 @@ pub(super) async fn uploads(
                     &UploadOutcome::RoomForgotten,
                 )
             }
+            permit = events.reserve(), if !pending.is_empty() => {
+                let Ok(permit) = permit else { return };
+                permit.send(pending.pop_front().expect("pending was checked"));
+                continue;
+            }
         };
         for event in reports {
-            if events.send(event).await.is_err() {
-                return;
-            }
+            queue_upload_event(&mut pending, event);
         }
     }
 }
 
+/// a progress tick replaces a waiting one for the same upload, unless something else about
+/// that upload is queued after it
+fn queue_upload_event(pending: &mut VecDeque<Event>, event: Event) {
+    if matches!(event, Event::MediaUploadProgress { .. })
+        && let Some(waiting) = pending
+            .iter_mut()
+            .rev()
+            .find(|waiting| upload_of(waiting) == upload_of(&event))
+        && matches!(waiting, Event::MediaUploadProgress { .. })
+    {
+        *waiting = event;
+        return;
+    }
+    pending.push_back(event);
+}
+
+fn upload_of(event: &Event) -> Option<(&OwnedRoomId, &OwnedTransactionId)> {
+    match event {
+        Event::MediaUploadProgress {
+            room_id,
+            transaction_id,
+            ..
+        }
+        | Event::MediaUploadFailed {
+            room_id,
+            transaction_id,
+            ..
+        }
+        | Event::MediaUploadFinished {
+            room_id,
+            transaction_id,
+            ..
+        } => Some((room_id, transaction_id)),
+        _ => None,
+    }
+}
+
 type Upload = (OwnedRoomId, OwnedTransactionId);
 
-/// everything reported gets exactly one `MediaUploadFinished`. an upload ended from
-/// anywhere but its room's forwarder goes in `ended` until the forwarder's own end for
-/// it arrives, since until then the forwarder can still be holding progress for it
+/// the sdk sends progress ticks from a detached task, so a tick can land after its
+/// upload's end. it trails by one task hop, so a short memory of ends covers it
+const REMEMBERED_ENDS: usize = 256;
+
+/// everything reported gets exactly one `MediaUploadFinished` and nothing after it
 struct UploadTracker {
     live: HashSet<Upload>,
     ended: HashSet<Upload>,
+    ended_order: VecDeque<Upload>,
 }
 
 impl UploadTracker {
+    fn new(live: HashSet<Upload>) -> Self {
+        Self {
+            live,
+            ended: HashSet::new(),
+            ended_order: VecDeque::new(),
+        }
+    }
+
     fn update(&mut self, update: SendQueueUpdate) -> Option<Event> {
         let room_id = update.room_id;
         let (transaction_id, outcome) = match update.update {
@@ -242,6 +238,26 @@ impl UploadTracker {
                 }
                 return None;
             }
+            RoomSendQueueUpdate::MediaUpload {
+                related_to,
+                file,
+                progress,
+                ..
+            } => {
+                let upload = (room_id, related_to);
+                if self.ended.contains(&upload) {
+                    return None;
+                }
+                self.live.insert(upload.clone());
+                let (room_id, transaction_id) = upload;
+                return Some(Event::MediaUploadProgress {
+                    room_id,
+                    transaction_id,
+                    uploaded_bytes: progress.current as u64,
+                    total_bytes: progress.total as u64,
+                    complete: file.is_some() && progress.current == progress.total,
+                });
+            }
             RoomSendQueueUpdate::SendError {
                 transaction_id,
                 error,
@@ -268,36 +284,7 @@ impl UploadTracker {
             }
             _ => return None,
         };
-        self.finish((room_id, transaction_id), outcome, true)
-    }
-
-    fn room(&mut self, report: RoomUpload) -> Option<Event> {
-        match report {
-            RoomUpload::Progress {
-                upload,
-                uploaded_bytes,
-                total_bytes,
-                complete,
-            } => {
-                if self.ended.contains(&upload) {
-                    return None;
-                }
-                self.live.insert(upload.clone());
-                let (room_id, transaction_id) = upload;
-                Some(Event::MediaUploadProgress {
-                    room_id,
-                    transaction_id,
-                    uploaded_bytes,
-                    total_bytes,
-                    complete,
-                })
-            }
-            RoomUpload::Ended(upload, outcome) => {
-                self.ended.remove(&upload);
-                self.finish(upload, outcome, false)
-            }
-            RoomUpload::Lagged => None,
-        }
+        self.finish((room_id, transaction_id), outcome)
     }
 
     fn resnapshot(&mut self, current: HashSet<Upload>) -> Vec<Event> {
@@ -321,17 +308,23 @@ impl UploadTracker {
             .collect::<Vec<_>>();
         ending
             .into_iter()
-            .filter_map(|upload| self.finish(upload, outcome.clone(), true))
+            .filter_map(|upload| self.finish(upload, outcome.clone()))
             .collect()
     }
 
-    fn finish(&mut self, upload: Upload, outcome: UploadOutcome, remember: bool) -> Option<Event> {
+    /// an end for an upload we never saw is remembered too, its ticks may still be coming
+    fn finish(&mut self, upload: Upload, outcome: UploadOutcome) -> Option<Event> {
+        if self.ended.insert(upload.clone()) {
+            self.ended_order.push_back(upload.clone());
+            if self.ended_order.len() > REMEMBERED_ENDS
+                && let Some(oldest) = self.ended_order.pop_front()
+            {
+                self.ended.remove(&oldest);
+            }
+        }
         if !self.live.remove(&upload) {
             return None;
         }
-        if remember {
-            self.ended.insert(upload.clone());
-        }
         let (room_id, transaction_id) = upload;
         Some(Event::MediaUploadFinished {
             room_id,
@@ -425,6 +418,61 @@ pub(super) async fn rooms(client: Client, events: EventSender) {
     }
 }
 
+/// packs live in room state and account data, and leaving a room takes its packs with it
+pub(super) async fn image_packs(client: Client, events: EventSender) {
+    let changed = Arc::new(Notify::new());
+    let handlers = [
+        client.add_event_handler({
+            let changed = changed.clone();
+            move |event: Raw<AnySyncStateEvent>| {
+                let changed = changed.clone();
+                async move {
+                    if event_type(&event).as_deref() == Some(ROOM_PACKS) {
+                        changed.notify_one();
+                    }
+                }
+            }
+        }),
+        client.add_event_handler({
+            let changed = changed.clone();
+            move |event: Raw<AnyGlobalAccountDataEvent>| {
+                let changed = changed.clone();
+                async move {
+                    if matches!(
+                        event_type(&event).as_deref(),
+                        Some(USER_PACK | ENABLED_ROOMS)
+                    ) {
+                        changed.notify_one();
+                    }
+                }
+            }
+        }),
+    ];
+    let mut info = client.room_info_notable_update_receiver();
+    loop {
+        tokio::select! {
+            () = changed.notified() => {}
+            update = info.recv() => match update {
+                Ok(update) if !update.reasons.contains(RoomInfoNotableUpdateReasons::MEMBERSHIP) => {
+                    continue;
+                }
+                Ok(_) | Err(RecvError::Lagged(_)) => {}
+                Err(RecvError::Closed) => break,
+            },
+        }
+        if events.send(Event::ImagePacksChanged).await.is_err() {
+            break;
+        }
+    }
+    for handler in handlers {
+        client.remove_event_handler(handler);
+    }
+}
+
+fn event_type<T>(event: &Raw<T>) -> Option<String> {
+    event.get_field("type").ok().flatten()
+}
+
 pub(super) async fn notification_settings(client: Client, events: EventSender) {
     let settings = client.notification_settings().await;
     let mut changes = settings.subscribe_to_changes();
@@ -440,10 +488,10 @@ pub(super) async fn notification_settings(client: Client, events: EventSender) {
 
 #[cfg(test)]
 mod tests {
-    use matrix_sdk::send_queue::{RoomSendQueueUpdate, SendQueueUpdate};
+    use matrix_sdk::send_queue::{AbstractProgress, RoomSendQueueUpdate, SendQueueUpdate};
     use ruma::{OwnedTransactionId, event_id, owned_room_id};
 
-    use super::{HashSet, RoomUpload, Upload, UploadTracker};
+    use super::{HashSet, Upload, UploadTracker};
     use crate::{Event, UploadOutcome};
 
     fn upload() -> Upload {
@@ -453,26 +501,30 @@ mod tests {
         )
     }
 
-    fn tick() -> RoomUpload {
-        RoomUpload::Progress {
-            upload: upload(),
-            uploaded_bytes: 1,
-            total_bytes: 2,
-            complete: false,
+    fn update(update: RoomSendQueueUpdate) -> SendQueueUpdate {
+        SendQueueUpdate {
+            room_id: upload().0,
+            update,
         }
     }
 
-    fn sent() -> UploadOutcome {
-        UploadOutcome::Sent {
-            event_id: event_id!("$sent:localhost").to_owned(),
-        }
+    fn tick() -> SendQueueUpdate {
+        update(RoomSendQueueUpdate::MediaUpload {
+            related_to: upload().1,
+            file: None,
+            index: 0,
+            progress: AbstractProgress {
+                current: 1,
+                total: 2,
+            },
+        })
     }
 
-    fn tracker() -> UploadTracker {
-        UploadTracker {
-            live: HashSet::new(),
-            ended: HashSet::new(),
-        }
+    fn sent() -> SendQueueUpdate {
+        update(RoomSendQueueUpdate::SentEvent {
+            transaction_id: upload().1,
+            event_id: event_id!("$sent:localhost").to_owned(),
+        })
     }
 
     fn finished(event: Option<Event>) -> Option<UploadOutcome> {
@@ -483,9 +535,21 @@ mod tests {
     }
 
     #[test]
+    fn a_tick_trailing_its_end_says_nothing() {
+        let mut tracker = UploadTracker::new(HashSet::new());
+        assert!(tracker.update(tick()).is_some());
+        assert!(matches!(
+            finished(tracker.update(sent())),
+            Some(UploadOutcome::Sent { .. })
+        ));
+        assert!(tracker.update(tick()).is_none());
+        assert!(tracker.live.is_empty());
+    }
+
+    #[test]
     fn a_stale_tick_after_a_missed_end_changes_nothing() {
-        let mut tracker = tracker();
-        assert!(tracker.room(tick()).is_some());
+        let mut tracker = UploadTracker::new(HashSet::new());
+        assert!(tracker.update(tick()).is_some());
         let missed = tracker.resnapshot(HashSet::new());
         assert!(matches!(
             missed.as_slice(),
@@ -494,38 +558,8 @@ mod tests {
                 ..
             }]
         ));
-
-        assert!(tracker.room(tick()).is_none());
-        let (room_id, transaction_id) = upload();
-        let global = SendQueueUpdate {
-            room_id,
-            update: RoomSendQueueUpdate::SentEvent {
-                transaction_id,
-                event_id: event_id!("$sent:localhost").to_owned(),
-            },
-        };
-        assert!(tracker.update(global).is_none());
-        assert!(tracker.room(RoomUpload::Ended(upload(), sent())).is_none());
-        assert!(tracker.live.is_empty() && tracker.ended.is_empty());
-    }
-
-    #[test]
-    fn an_end_the_tracker_never_knew_about_still_follows_its_progress() {
-        let mut tracker = tracker();
-        let (room_id, transaction_id) = upload();
-        let global = SendQueueUpdate {
-            room_id,
-            update: RoomSendQueueUpdate::SentEvent {
-                transaction_id,
-                event_id: event_id!("$sent:localhost").to_owned(),
-            },
-        };
-        assert!(tracker.update(global).is_none());
-        assert!(tracker.room(tick()).is_some());
-        assert_eq!(
-            finished(tracker.room(RoomUpload::Ended(upload(), sent()))),
-            Some(sent())
-        );
-        assert!(tracker.live.is_empty() && tracker.ended.is_empty());
+        assert!(tracker.update(tick()).is_none());
+        assert!(tracker.update(sent()).is_none());
+        assert!(tracker.live.is_empty());
     }
 }

Modified file: vendor/macltok/src/error.rs+9 additions@@ -63,6 +63,8 @@ pub enum ErrorKind {
     NoCrossSigningIdentity,
     RecoveryRejected,
     Network,
+    /// the homeserver wants us to slow down. try again later
+    RateLimited,
     Server,
     Store,
     Timeline,
@@ -269,6 +271,13 @@ pub(crate) fn classify_sdk_error(source: &matrix_sdk::Error) -> ErrorKind {
 fn classify_http_error(source: &HttpError) -> ErrorKind {
     match source {
         HttpError::Reqwest(_) => ErrorKind::Network,
+        HttpError::Api(_)
+            if source
+                .as_client_api_error()
+                .is_some_and(|api| api.status_code.as_u16() == 429) =>
+        {
+            ErrorKind::RateLimited
+        }
         HttpError::Api(_) => ErrorKind::Server,
         HttpError::RefreshToken(source) => classify_refresh_token_error(source),
         HttpError::Cached(source) => classify_http_error(source),

Modified file: vendor/macltok/src/lib.rs+10 additions−9 deletions@@ -48,16 +48,17 @@ pub use mirror::{
 pub use model::{
     AccountCommand, AttachmentEncryption, AttachmentUpload, Change, Command, CommandOutput,
     ConnectionState, CreateRoomOptions, EncryptionCommand, EncryptionState, EngineErrorKind,
-    EngineFailure, Event, EventRef, HistoryState, KeyBackupState, LatestEvent, LifecycleCommand,
-    Media, MediaCommand, MediaDescriptor, MediaFile, MediaId, MediaKind, MediaLocation, MediaSize,
+    EngineFailure, Event, EventRef, HistoryState, ImagePack, ImagePackSource, ImagePacks,
+    KeyBackupState, LatestEvent, LifecycleCommand, LinkPreview, LinkPreviewImage, Media,
+    MediaCommand, MediaDescriptor, MediaFile, MediaId, MediaKind, MediaLocation, MediaSize,
     MemberFilter, MemberMembership, MemberSummary, MembershipChange, Message, MessageContent,
-    MessageEditContent, MessageKind, MessageMentions, NotificationCommand, OwnDevice,
-    PowerLevelChanges, Profile, PushNotification, PushNotificationEvent, PushNotificationRoom,
-    PushNotificationSender, PushNotificationStatus, Reaction, RecoveryState, ReplyDetails,
-    ReplyReference, Retain, RichText, RoomCategory, RoomCommand, RoomHero, RoomListFilter,
-    RoomMatcher, RoomMembership, RoomNotificationMode, RoomNotificationSettings, RoomPowerLevels,
-    RoomPreset, RoomSummary, RoomVisibility, SendState, Sender, SpaceChild, Termination,
-    ThreadSummary, TimelineCommand, TimelineContent, TimelineDiff, TimelineDiffError,
+    MessageEditContent, MessageKind, MessageMentions, NotificationCommand, OwnDevice, PackImage,
+    PackUsage, PowerLevelChanges, Profile, PushNotification, PushNotificationEvent,
+    PushNotificationRoom, PushNotificationSender, PushNotificationStatus, Reaction, RecoveryState,
+    ReplyDetails, ReplyReference, Retain, RichText, RoomCategory, RoomCommand, RoomHero,
+    RoomListFilter, RoomMatcher, RoomMembership, RoomNotificationMode, RoomNotificationSettings,
+    RoomPowerLevels, RoomPreset, RoomSummary, RoomVisibility, SendState, Sender, SpaceChild,
+    Termination, ThreadSummary, TimelineCommand, TimelineContent, TimelineDiff, TimelineDiffError,
     TimelineEvent, TimelineId, TimelineItem, TimelineItemId, TypingState, UploadDetails,
     UploadOutcome, UploadThumbnail, UtdCause, VerificationAction, VerificationFailure,
     VerificationState, VerificationTarget,

Modified file: vendor/macltok/src/mirror.rs+87 additions−19 deletions@@ -20,7 +20,7 @@ use tokio::sync::broadcast;
 
 use crate::{
     ClientHandle, Command, ConnectionState, EncryptionState, EngineFailure, ErrorKind, Event,
-    HistoryState, RoomSummary, TimelineCommand, TimelineDiff, TimelineId, TimelineItem,
+    HistoryState, ImagePacks, RoomSummary, TimelineCommand, TimelineDiff, TimelineId, TimelineItem,
     TypingState, UploadOutcome, VerificationState, VerificationTarget,
     engine::executor::EngineBoxFuture,
 };
@@ -46,6 +46,7 @@ pub struct State {
     pub verification: Option<VerificationState>,
     pub verification_target: Option<VerificationTarget>,
     pub rooms: Vector<RoomSummary>,
+    pub image_packs: ImagePacks,
     pub timelines: imbl::HashMap<TimelineId, TimelineState>,
     pub typing: imbl::HashMap<OwnedRoomId, Vec<OwnedUserId>>,
     pub uploads: imbl::HashMap<OwnedTransactionId, UploadState>,
@@ -125,6 +126,7 @@ pub enum StateChange {
     /// room modes arrive with the `Rooms` that follows
     NotificationSettings,
     Rooms(Vector<RoomSummary>),
+    ImagePacks(ImagePacks),
     Timeline {
         timeline_id: TimelineId,
         change: TimelineChange,
@@ -169,6 +171,7 @@ pub struct Mirror {
     shared: Arc<Shared>,
     resyncs: HashMap<TimelineId, AbortHandle>,
     rooms_fetch: Option<AbortHandle>,
+    packs_fetch: Option<AbortHandle>,
 }
 
 impl fmt::Debug for Mirror {
@@ -201,6 +204,7 @@ impl Mirror {
             verification: None,
             verification_target: None,
             rooms: Vector::new(),
+            image_packs: ImagePacks::default(),
             timelines: imbl::HashMap::new(),
             typing: imbl::HashMap::new(),
             uploads: imbl::HashMap::new(),
@@ -212,7 +216,8 @@ impl Mirror {
                 state: Arc::new(state),
                 sequence: 0,
                 updates: Some(broadcast::channel(capacity.max(1)).0),
-                rooms_fetch: RoomsFetch::Idle,
+                rooms_fetch: Fetch::Idle,
+                packs_fetch: Fetch::Idle,
             }),
         });
         #[cfg(not(target_family = "wasm"))]
@@ -225,6 +230,7 @@ impl Mirror {
             shared: shared.clone(),
             resyncs: HashMap::new(),
             rooms_fetch: None,
+            packs_fetch: None,
         };
         (mirror, MirrorHandle { shared })
     }
@@ -233,6 +239,7 @@ impl Mirror {
     pub fn run(mut self) -> EngineBoxFuture<'static, ()> {
         Box::pin(async move {
             self.refetch_rooms();
+            self.refetch_image_packs();
             while let Some(event) = self.events.next().await {
                 self.apply(event);
             }
@@ -286,6 +293,7 @@ impl Mirror {
                 self.publish(|_| Some(StateChange::NotificationSettings));
             }
             Event::RoomsChanged => self.refetch_rooms(),
+            Event::ImagePacksChanged => self.refetch_image_packs(),
             Event::EncryptionChanged(encryption) => self.publish(|state| {
                 state.encryption = Some(encryption.clone());
                 Some(StateChange::Encryption(encryption))
@@ -451,16 +459,22 @@ impl Mirror {
     }
 
     fn refetch_rooms(&mut self) {
-        let mut published = self.shared.lock();
-        match published.rooms_fetch {
-            RoomsFetch::Idle => {
-                published.rooms_fetch = RoomsFetch::Running;
-                drop(published);
-                let task = spawn(fetch_rooms(self.handle.clone(), self.shared.clone()));
-                self.rooms_fetch = Some(task.abort_handle());
-            }
-            RoomsFetch::Running => published.rooms_fetch = RoomsFetch::Again,
-            RoomsFetch::Again => {}
+        let fetch = fetch_rooms(self.handle.clone(), self.shared.clone());
+        if let Some(task) = self
+            .shared
+            .start(|published| &mut published.rooms_fetch, fetch)
+        {
+            self.rooms_fetch = Some(task);
+        }
+    }
+
+    fn refetch_image_packs(&mut self) {
+        let fetch = fetch_image_packs(self.handle.clone(), self.shared.clone());
+        if let Some(task) = self
+            .shared
+            .start(|published| &mut published.packs_fetch, fetch)
+        {
+            self.packs_fetch = Some(task);
         }
     }
 
@@ -484,7 +498,10 @@ impl Mirror {
 impl Drop for Mirror {
     fn drop(&mut self) {
         self.cancel_resyncs();
-        if let Some(task) = self.rooms_fetch.take() {
+        for task in [self.rooms_fetch.take(), self.packs_fetch.take()]
+            .into_iter()
+            .flatten()
+        {
             task.abort();
         }
         self.shared.lock().updates = None;
@@ -518,12 +535,28 @@ async fn fetch_rooms(handle: ClientHandle, shared: Arc<Shared>) {
             state.rooms = rooms.clone();
             Some(StateChange::Rooms(rooms))
         });
-        let mut published = shared.lock();
-        if published.rooms_fetch != RoomsFetch::Again {
-            published.rooms_fetch = RoomsFetch::Idle;
+        if !shared.fetched(|published| &mut published.rooms_fetch) {
+            return;
+        }
+    }
+}
+
+/// a failed read keeps the packs from before, the next change asks again
+async fn fetch_image_packs(handle: ClientHandle, shared: Arc<Shared>) {
+    loop {
+        match handle.image_packs().await {
+            Ok(packs) => shared.publish(|state| {
+                if state.image_packs == packs {
+                    return None;
+                }
+                state.image_packs = packs.clone();
+                Some(StateChange::ImagePacks(packs))
+            }),
+            Err(error) => tracing::warn!(%error, "reading image packs failed"),
+        }
+        if !shared.fetched(|published| &mut published.packs_fetch) {
             return;
         }
-        published.rooms_fetch = RoomsFetch::Running;
     }
 }
 
@@ -592,11 +625,12 @@ struct Published {
     sequence: u64,
     /// gone once the mirror stops, which ends every subscription
     updates: Option<broadcast::Sender<Update>>,
-    rooms_fetch: RoomsFetch,
+    rooms_fetch: Fetch,
+    packs_fetch: Fetch,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum RoomsFetch {
+enum Fetch {
     Idle,
     Running,
     Again,
@@ -609,6 +643,40 @@ impl Shared {
             .unwrap_or_else(PoisonError::into_inner)
     }
 
+    /// one fetch at a time, with at most one more owed
+    fn start(
+        &self,
+        fetch: impl FnOnce(&mut Published) -> &mut Fetch,
+        task: impl Future<Output = ()> + SendOutsideWasm + 'static,
+    ) -> Option<AbortHandle> {
+        let mut published = self.lock();
+        let fetch = fetch(&mut published);
+        match *fetch {
+            Fetch::Idle => {
+                *fetch = Fetch::Running;
+                drop(published);
+                Some(spawn(task).abort_handle())
+            }
+            Fetch::Running => {
+                *fetch = Fetch::Again;
+                None
+            }
+            Fetch::Again => None,
+        }
+    }
+
+    /// whether another fetch was asked for while this one ran
+    fn fetched(&self, fetch: impl FnOnce(&mut Published) -> &mut Fetch) -> bool {
+        let mut published = self.lock();
+        let fetch = fetch(&mut published);
+        if *fetch == Fetch::Again {
+            *fetch = Fetch::Running;
+            return true;
+        }
+        *fetch = Fetch::Idle;
+        false
+    }
+
     /// state, sequence and send move together under the one lock, which is what lets
     /// `subscribe` take a snapshot and a receiver with nothing between them
     fn publish(&self, change: impl FnOnce(&mut State) -> Option<StateChange>) {

Modified file: vendor/macltok/src/model.rs+117 additions−1 deletions@@ -3,7 +3,7 @@ use std::{fmt, sync::Arc};
 use imbl::Vector;
 use ruma::{
     MxcUri, OwnedDeviceId, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId,
-    OwnedRoomOrAliasId, OwnedServerName, OwnedTransactionId, OwnedUserId,
+    OwnedRoomOrAliasId, OwnedServerName, OwnedTransactionId, OwnedUserId, RoomId,
     events::{
         AnyGlobalAccountDataEventContent, AnyRoomAccountDataEventContent, AnySyncTimelineEvent,
         GlobalAccountDataEventType, RoomAccountDataEventType,
@@ -236,6 +236,8 @@ pub enum TimelineCommand {
         timeline_id: TimelineId,
         target: EventRef,
         key: String,
+        /// a custom emote's shortcode, sent along so clients without the pack can label it
+        shortcode: Option<String>,
     },
     /// works on a closed room too, it just can't refuse to move the marker backwards
     MarkRead {
@@ -654,6 +656,8 @@ pub enum Event {
     NotificationSettingsChanged,
     VerificationTargetChanged(VerificationTarget),
     RoomsChanged,
+    /// an image pack came, went or changed somewhere. ask `image_packs` again
+    ImagePacksChanged,
     /// replaces whatever you had for this timeline. every diff after it applies to it
     TimelineReset {
         timeline_id: TimelineId,
@@ -1490,6 +1494,36 @@ pub struct Message {
     pub mentions: Option<MessageMentions>,
     pub edited: bool,
     pub media: Option<MediaDescriptor>,
+    /// previews the sender attached (msc4095), so showing them asks no one about the url.
+    /// one for a url the body doesn't contain is dropped
+    pub link_previews: Vec<LinkPreview>,
+}
+
+/// a link card, from the sender's own message or from `ClientHandle::url_preview`. page
+/// text passes through whoever made it unfiltered, so it arrives trimmed to a sane length
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct LinkPreview {
+    /// the url as it appears in the message, or as it was asked about
+    pub url: String,
+    /// where the page says it lives, when that's somewhere else
+    pub canonical_url: Option<String>,
+    pub title: Option<String>,
+    pub description: Option<String>,
+    pub site_name: Option<String>,
+    pub image: Option<LinkPreviewImage>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct LinkPreviewImage {
+    pub media_id: MediaId,
+    pub mimetype: Option<String>,
+    pub size_bytes: Option<u64>,
+    pub width: Option<u64>,
+    pub height: Option<u64>,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1603,11 +1637,93 @@ pub enum ReplyDetails {
 #[non_exhaustive]
 pub struct Reaction {
     pub key: String,
+    /// a custom emote's shortcode, from whichever sender gave one
+    pub shortcode: Option<String>,
+    /// the custom emote itself, when the key is an image
+    pub image: Option<MediaId>,
     pub count: usize,
     pub own: bool,
     pub senders: Vec<OwnedUserId>,
 }
 
+/// every custom emote and sticker pack the account can reach, from the user's own
+/// pack, each joined room's packs, and the rooms the user enabled everywhere
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct ImagePacks {
+    /// the user's own pack, then the packs of rooms enabled everywhere
+    pub global: Vec<ImagePack>,
+    /// each joined room's own packs, rooms without any left out
+    pub rooms: imbl::HashMap<OwnedRoomId, Vec<ImagePack>>,
+}
+
+impl ImagePacks {
+    /// what a picker in this room offers. the user's pack, the room's own, then the
+    /// rest of the enabled ones, each pack once
+    #[must_use]
+    pub fn for_room(&self, room_id: Option<&RoomId>) -> Vec<&ImagePack> {
+        let is_user = |pack: &&ImagePack| pack.source == ImagePackSource::User;
+        let own = room_id.and_then(|room_id| self.rooms.get(room_id));
+        let mut packs: Vec<&ImagePack> = self.global.iter().filter(is_user).collect();
+        packs.extend(own.into_iter().flatten());
+        for pack in self.global.iter().filter(|pack| !is_user(pack)) {
+            if !packs.iter().any(|seen| seen.id == pack.id) {
+                packs.push(pack);
+            }
+        }
+        packs
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct ImagePack {
+    /// `user`, or `room:<room id>:<state key>`, the same across calls
+    pub id: String,
+    pub display_name: Option<String>,
+    pub avatar: Option<MediaId>,
+    pub attribution: Option<String>,
+    pub source: ImagePackSource,
+    pub images: Vec<PackImage>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum ImagePackSource {
+    User,
+    Room {
+        room_id: OwnedRoomId,
+        state_key: String,
+    },
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub struct PackImage {
+    pub shortcode: String,
+    pub media_id: MediaId,
+    /// what `toggle_reaction` takes to react with this image
+    pub reaction_key: String,
+    pub body: Option<String>,
+    pub mimetype: Option<String>,
+    pub width: Option<u64>,
+    pub height: Option<u64>,
+    /// the image's own, else its pack's, else both
+    pub usage: Vec<PackUsage>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[non_exhaustive]
+pub enum PackUsage {
+    Emoticon,
+    Sticker,
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[non_exhaustive]

Added file: vendor/macltok/src/normalise/image_pack.rs+152 additions@@ -0,0 +1,152 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use matrix_sdk::{Client, Room, deserialized_responses::RawAnySyncOrStrippedState};
+use ruma::{
+    OwnedRoomId,
+    events::{
+        GlobalAccountDataEventType, StateEventType,
+        image_pack::{PackImage as SourceImage, PackInfo, PackUsage as SourceUsage},
+    },
+    serde::{JsonObject, Raw},
+};
+
+use crate::{Error, ImagePack, ImagePackSource, ImagePacks, MediaId, PackImage, PackUsage};
+
+pub(crate) const ROOM_PACKS: &str = "im.ponies.room_emotes";
+pub(crate) const USER_PACK: &str = "im.ponies.user_emotes";
+pub(crate) const ENABLED_ROOMS: &str = "im.ponies.emote_rooms";
+
+/// rooms enabled everywhere that the user hasn't joined are skipped, we hold no state for them
+pub(crate) async fn image_packs(client: &Client) -> Result<ImagePacks, Error> {
+    let mut rooms = imbl::HashMap::new();
+    for room in client.joined_rooms() {
+        let packs = room_packs(&room).await?;
+        if !packs.is_empty() {
+            rooms.insert(room.room_id().to_owned(), packs);
+        }
+    }
+    let mut global = Vec::new();
+    if let Some(content) = account_data(client, USER_PACK).await? {
+        global.extend(pack("user".to_owned(), ImagePackSource::User, &content));
+    }
+    if let Some(content) = account_data(client, ENABLED_ROOMS).await? {
+        let enabled = content
+            .get_field::<BTreeMap<OwnedRoomId, BTreeMap<String, Raw<JsonObject>>>>("rooms")
+            .ok()
+            .flatten()
+            .unwrap_or_default();
+        for (room_id, state_keys) in enabled {
+            let packs = rooms.get(&room_id).into_iter().flatten();
+            global.extend(
+                packs
+                    .filter(|pack| match &pack.source {
+                        ImagePackSource::Room { state_key, .. } => {
+                            state_keys.contains_key(state_key)
+                        }
+                        ImagePackSource::User => false,
+                    })
+                    .cloned(),
+            );
+        }
+    }
+    Ok(ImagePacks { global, rooms })
+}
+
+async fn room_packs(room: &Room) -> Result<Vec<ImagePack>, Error> {
+    let events = room
+        .get_state_events(StateEventType::from(ROOM_PACKS))
+        .await
+        .map_err(|source| Error::from_sdk("reading image packs failed", source))?;
+    let by_state_key: BTreeMap<String, Raw<JsonObject>> = events
+        .into_iter()
+        .filter_map(|event| match event {
+            RawAnySyncOrStrippedState::Sync(event) => Some((
+                event.get_field::<String>("state_key").ok()??,
+                event.get_field::<Raw<JsonObject>>("content").ok()??,
+            )),
+            RawAnySyncOrStrippedState::Stripped(_) => None,
+        })
+        .collect();
+    Ok(by_state_key
+        .into_iter()
+        .filter_map(|(state_key, content)| {
+            let source = ImagePackSource::Room {
+                room_id: room.room_id().to_owned(),
+                state_key: state_key.clone(),
+            };
+            pack(
+                format!("room:{}:{state_key}", room.room_id()),
+                source,
+                &content,
+            )
+        })
+        .collect())
+}
+
+async fn account_data(client: &Client, event_type: &str) -> Result<Option<Raw<JsonObject>>, Error> {
+    Ok(client
+        .account()
+        .account_data_raw(GlobalAccountDataEventType::from(event_type))
+        .await
+        .map_err(|source| Error::from_sdk("reading image packs failed", source))?
+        .map(|content| content.cast_unchecked()))
+}
+
+/// one bad image costs that image, not its pack. a pack with nothing usable left is dropped
+fn pack(id: String, source: ImagePackSource, content: &Raw<JsonObject>) -> Option<ImagePack> {
+    let info = content
+        .get_field::<PackInfo>("pack")
+        .ok()
+        .flatten()
+        .unwrap_or_default();
+    let pack_usage = usage(&info.usage);
+    let images: Vec<PackImage> = content
+        .get_field::<BTreeMap<String, Raw<SourceImage>>>("images")
+        .ok()
+        .flatten()
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(|(shortcode, image)| {
+            let image = image.deserialize().ok()?;
+            if !image.url.is_valid() {
+                return None;
+            }
+            let info = image.info.as_ref();
+            Some(PackImage {
+                shortcode,
+                media_id: MediaId::plain(&image.url),
+                reaction_key: image.url.to_string(),
+                body: image.body,
+                mimetype: info.and_then(|info| info.mimetype.clone()),
+                width: info.and_then(|info| info.width).map(u64::from),
+                height: info.and_then(|info| info.height).map(u64::from),
+                usage: usage(&image.usage)
+                    .or_else(|| pack_usage.clone())
+                    .unwrap_or_else(|| vec![PackUsage::Emoticon, PackUsage::Sticker]),
+            })
+        })
+        .collect();
+    (!images.is_empty()).then(|| ImagePack {
+        id,
+        display_name: info.display_name,
+        avatar: info
+            .avatar_url
+            .filter(|uri| uri.is_valid())
+            .map(|uri| MediaId::plain(&uri)),
+        attribution: info.attribution,
+        source,
+        images,
+    })
+}
+
+fn usage(usage: &BTreeSet<SourceUsage>) -> Option<Vec<PackUsage>> {
+    let usage: Vec<PackUsage> = usage
+        .iter()
+        .filter_map(|usage| match usage {
+            SourceUsage::Emoticon => Some(PackUsage::Emoticon),
+            SourceUsage::Sticker => Some(PackUsage::Sticker),
+            _ => None,
+        })
+        .collect();
+    (!usage.is_empty()).then_some(usage)
+}

Added file: vendor/macltok/src/normalise/link_preview.rs+217 additions@@ -0,0 +1,217 @@
+use matrix_sdk::{Room, deserialized_responses::RawAnySyncOrStrippedState};
+use ruma::{
+    MxcUri,
+    events::{
+        GlobalAccountDataEventType, RoomAccountDataEventType, StateEventType,
+        room::{
+            MediaSource,
+            message::{MessageType, PreviewImageSource, UrlPreview},
+        },
+    },
+    serde::{JsonObject, Raw},
+};
+
+use super::media::{MediaRegistration, MediaSourceInfo, media_id};
+use crate::{Error, LinkPreview, LinkPreviewImage, MediaId, MediaKind};
+
+/// room state an admin sets, and room account data a user sets, under the same name
+pub(crate) const ROOM_PREVIEW_URLS: &str = "org.matrix.room.preview_urls";
+const USER_PREVIEW_URLS: &str = "org.matrix.preview_urls";
+
+const SHORT_TEXT: usize = 256;
+const LONG_TEXT: usize = 1024;
+
+/// the previews a text message's sender attached, each with the registration its image needs
+/// when it's encrypted. embedded reply content has no media identity, so its encrypted images
+/// go without
+pub(crate) fn sender_previews(
+    identity: Option<&str>,
+    message: &MessageType,
+) -> Vec<(LinkPreview, Option<MediaRegistration>)> {
+    let MessageType::Text(text) = message else {
+        return Vec::new();
+    };
+    text.url_previews
+        .iter()
+        .flatten()
+        .enumerate()
+        .filter_map(|(index, preview)| sender_preview(identity, &text.body, index, preview))
+        .collect()
+}
+
+/// the matched url has to be in the body, or a sender could caption any link with any card
+fn sender_preview(
+    identity: Option<&str>,
+    body: &str,
+    index: usize,
+    preview: &UrlPreview,
+) -> Option<(LinkPreview, Option<MediaRegistration>)> {
+    let url = preview.matched_url.as_deref()?;
+    if url.is_empty() || !body.contains(url) || !preview.contains_preview() {
+        return None;
+    }
+    let (image, registration) = match &preview.image {
+        None => (None, None),
+        Some(image) => {
+            let (media_id, registration) = match &image.source {
+                PreviewImageSource::Url(uri) => (plain(uri)?, None),
+                PreviewImageSource::EncryptedImage(file) => {
+                    let id = media_id(identity?, &format!("preview{index}"));
+                    let registration = MediaRegistration {
+                        id: id.clone(),
+                        kind: MediaKind::Image,
+                        full: MediaSourceInfo {
+                            source: MediaSource::Encrypted(Box::new(file.clone())),
+                            mimetype: image.mimetype.clone(),
+                            declared_size: image.size.map(u64::from),
+                        },
+                        thumbnail: None,
+                    };
+                    (id, Some(registration))
+                }
+            };
+            let image = LinkPreviewImage {
+                media_id,
+                mimetype: image.mimetype.clone(),
+                size_bytes: image.size.map(u64::from),
+                width: image.width.map(u64::from),
+                height: image.height.map(u64::from),
+            };
+            (Some(image), registration)
+        }
+    };
+    let preview = LinkPreview {
+        url: url.to_owned(),
+        canonical_url: preview.url.clone().filter(|canonical| canonical != url),
+        title: clamp(preview.title.as_deref(), SHORT_TEXT),
+        description: clamp(preview.description.as_deref(), LONG_TEXT),
+        site_name: None,
+        image,
+    };
+    Some((preview, registration))
+}
+
+/// what the homeserver's `preview_url` answered, a loose map of `og:` keys. `None` when
+/// nothing in it is worth a card
+pub(crate) fn server_preview(url: &str, data: &Raw<JsonObject>) -> Option<LinkPreview> {
+    let text = |key: &str| data.get_field::<String>(key).ok().flatten();
+    let image = text("og:image")
+        .as_deref()
+        .and_then(|uri| plain(<&MxcUri>::from(uri)))
+        .map(|media_id| LinkPreviewImage {
+            media_id,
+            mimetype: text("og:image:type"),
+            size_bytes: number(data, "matrix:image:size"),
+            width: number(data, "og:image:width"),
+            height: number(data, "og:image:height"),
+        });
+    let preview = LinkPreview {
+        url: url.to_owned(),
+        canonical_url: text("og:url").filter(|canonical| canonical != url),
+        title: clamp(text("og:title").as_deref(), SHORT_TEXT),
+        description: clamp(text("og:description").as_deref(), LONG_TEXT),
+        site_name: clamp(text("og:site_name").as_deref(), SHORT_TEXT),
+        image,
+    };
+    (preview.title.is_some() || preview.description.is_some() || preview.image.is_some())
+        .then_some(preview)
+}
+
+/// element's order, so both clients agree. the user's choice for this room, then their own
+/// default, then the room admins'. encrypted rooms are the host's call
+pub(crate) async fn url_previews_allowed(room: &Room) -> Result<bool, Error> {
+    let room_choice = room
+        .account_data(RoomAccountDataEventType::from(ROOM_PREVIEW_URLS))
+        .await
+        .map_err(|source| Error::from_sdk("reading url preview settings failed", source))?
+        .and_then(|event| disabled(&event.get_field::<Raw<JsonObject>>("content").ok()??));
+    let own_default = || async {
+        room.client()
+            .account()
+            .account_data_raw(GlobalAccountDataEventType::from(USER_PREVIEW_URLS))
+            .await
+            .map(|content| content.and_then(|content| disabled(&content.cast_unchecked())))
+            .map_err(|source| Error::from_sdk("reading url preview settings failed", source))
+    };
+    let admins = || async {
+        room.get_state_event(StateEventType::from(ROOM_PREVIEW_URLS), "")
+            .await
+            .map(|event| match event {
+                Some(RawAnySyncOrStrippedState::Sync(event)) => {
+                    disabled(&event.get_field::<Raw<JsonObject>>("content").ok()??)
+                }
+                _ => None,
+            })
+            .map_err(|source| Error::from_sdk("reading url preview settings failed", source))
+    };
+    let disabled = match room_choice {
+        Some(disabled) => disabled,
+        None => match own_default().await? {
+            Some(disabled) => disabled,
+            None => admins().await?.unwrap_or(false),
+        },
+    };
+    Ok(!disabled)
+}
+
+fn disabled(content: &Raw<JsonObject>) -> Option<bool> {
+    content.get_field::<bool>("disable").ok().flatten()
+}
+
+fn plain(uri: &MxcUri) -> Option<MediaId> {
+    uri.is_valid().then(|| MediaId::plain(uri))
+}
+
+/// servers send dimensions as numbers or as the page's own strings
+fn number(data: &Raw<JsonObject>, key: &str) -> Option<u64> {
+    data.get_field::<u64>(key).ok().flatten().or_else(|| {
+        data.get_field::<String>(key)
+            .ok()
+            .flatten()?
+            .trim()
+            .parse()
+            .ok()
+    })
+}
+
+fn clamp(text: Option<&str>, chars: usize) -> Option<String> {
+    let text = text?.trim();
+    (!text.is_empty()).then(|| match text.char_indices().nth(chars) {
+        Some((end, _)) => text[..end].trim_end().to_owned(),
+        None => text.to_owned(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use ruma::{events::room::message::MessageType, serde::Raw};
+    use serde_json::json;
+
+    use super::sender_previews;
+
+    #[test]
+    fn a_sender_cannot_caption_a_link_the_message_does_not_contain() {
+        let message: MessageType = Raw::new(&json!({
+            "msgtype": "m.text",
+            "body": "look at https://example.org/real",
+            "com.beeper.linkpreviews": [
+                {
+                    "matched_url": "https://example.org/real",
+                    "og:title": "real",
+                    "og:image": "mxc://example.org/image",
+                },
+                { "matched_url": "https://bank.example/login", "og:title": "your bank" },
+            ],
+        }))
+        .unwrap()
+        .cast_unchecked()
+        .deserialize()
+        .unwrap();
+        let previews = sender_previews(Some("1#item"), &message);
+        assert_eq!(previews.len(), 1);
+        let (preview, registration) = &previews[0];
+        assert_eq!(preview.url, "https://example.org/real");
+        assert_eq!(preview.title.as_deref(), Some("real"));
+        assert!(preview.image.is_some() && registration.is_none());
+    }
+}

Modified file: vendor/macltok/src/normalise/media.rs+20 additions−9 deletions@@ -10,6 +10,7 @@ use ruma::events::{
     sticker::StickerEventContent,
 };
 
+use super::link_preview::sender_previews;
 use crate::{MediaDescriptor, MediaId, MediaKind};
 
 static NEXT_MEDIA_SCOPE: AtomicU64 = AtomicU64::new(1);
@@ -54,20 +55,30 @@ pub(crate) struct MediaSourceInfo {
     pub(crate) declared_size: Option<u64>,
 }
 
-pub(super) fn media_registration_for_item(
+pub(super) fn media_registrations_for_item(
     item: &SdkTimelineItem,
     scope: &MediaScope,
-) -> Option<MediaRegistration> {
-    let event = item.as_event()?;
+) -> Vec<MediaRegistration> {
+    let Some(event) = item.as_event() else {
+        return Vec::new();
+    };
     let identity = media_identity(item, scope);
-    let content = match event.content() {
-        TimelineItemContent::MsgLike(content) => content,
-        _ => return None,
+    let TimelineItemContent::MsgLike(content) = event.content() else {
+        return Vec::new();
     };
     match &content.kind {
-        MsgLikeKind::Message(message) => media_registration(&identity, message.msgtype()),
-        MsgLikeKind::Sticker(sticker) => media_sticker_registration(&identity, sticker.content()),
-        _ => None,
+        MsgLikeKind::Message(message) => media_registration(&identity, message.msgtype())
+            .into_iter()
+            .chain(
+                sender_previews(Some(&identity), message.msgtype())
+                    .into_iter()
+                    .filter_map(|(_, registration)| registration),
+            )
+            .collect(),
+        MsgLikeKind::Sticker(sticker) => media_sticker_registration(&identity, sticker.content())
+            .into_iter()
+            .collect(),
+        _ => Vec::new(),
     }
 }
 

Modified file: vendor/macltok/src/normalise/mod.rs+4 additions@@ -1,8 +1,12 @@
+mod image_pack;
+mod link_preview;
 mod media;
 mod member;
 mod room;
 mod timeline;
 
+pub(crate) use image_pack::{ENABLED_ROOMS, ROOM_PACKS, USER_PACK, image_packs};
+pub(crate) use link_preview::{ROOM_PREVIEW_URLS, server_preview, url_previews_allowed};
 pub(crate) use media::{MediaRegistration, MediaScope, MediaSourceInfo};
 pub(crate) use member::member_summary;
 pub(crate) use room::notification_mode;

Modified file: vendor/macltok/src/normalise/timeline.rs+13 additions−5 deletions@@ -11,7 +11,7 @@ use matrix_sdk_ui::{
     },
 };
 use ruma::{
-    OwnedEventId, UserId,
+    MxcUri, OwnedEventId, UserId,
     events::{
         StateEventContentChange,
         room::message::{MessageFormat, MessageType},
@@ -24,9 +24,10 @@ use crate::{
     TimelineEvent, TimelineItem, TimelineItemId, UtdCause,
 };
 
+use super::link_preview::sender_previews;
 use super::media::{
     MediaRegistration, MediaScope, media_descriptor_for_sticker, media_from_message,
-    media_identity, media_registration_for_item,
+    media_identity, media_registrations_for_item,
 };
 
 #[derive(Default)]
@@ -52,9 +53,8 @@ struct Normaliser<'a> {
 
 impl Normaliser<'_> {
     fn item(&mut self, item: &SdkTimelineItem) -> TimelineItem {
-        if let Some(media) = media_registration_for_item(item, self.scope) {
-            self.media.push(media);
-        }
+        self.media
+            .extend(media_registrations_for_item(item, self.scope));
         match item.kind() {
             TimelineItemKind::Event(event) => {
                 TimelineItem::Event(Box::new(self.event(item, event)))
@@ -282,6 +282,10 @@ fn msg_like(content: &MsgLikeContent, media_identity: Option<&str>) -> TimelineC
             edited: message.is_edited(),
             media: media_identity
                 .and_then(|identity| media_from_message(identity, message.msgtype())),
+            link_previews: sender_previews(media_identity, message.msgtype())
+                .into_iter()
+                .map(|(preview, _)| preview)
+                .collect(),
         }),
         MsgLikeKind::Sticker(sticker) => {
             let sticker = sticker.content();
@@ -421,6 +425,10 @@ fn reactions(event: &EventTimelineItem, current_user_id: Option<&UserId>) -> Vec
         .flat_map(|reactions| reactions.iter())
         .map(|(key, senders)| Reaction {
             key: key.clone(),
+            shortcode: senders.values().find_map(|info| info.shortcode.clone()),
+            image: <&MxcUri>::from(key.as_str())
+                .is_valid()
+                .then(|| MediaId::plain(key)),
             count: senders.len(),
             own: current_user_id.is_some_and(|user_id| senders.contains_key(user_id)),
             senders: senders.keys().cloned().collect(),

Modified file: vendor/macltok/src/transport.rs+27 additions−6 deletions@@ -27,17 +27,17 @@ use tokio::sync::{OnceCell, mpsc, oneshot, watch};
 
 use crate::{
     AccountCommand, AttachmentUpload, Command, CommandOutput, ConnectionState, CreateRoomOptions,
-    EncryptionCommand, EncryptionState, Error, ErrorKind, Event, EventRef, InteractiveAuth,
-    InteractiveAuthOutcome, LifecycleCommand, Media, MediaCommand, MediaId, MediaLocation,
-    MediaSize, MemberFilter, MemberSummary, MessageContent, MessageEditContent,
-    NotificationCommand, OwnDevice, PowerLevelChanges, Profile, PushNotification,
-    PushNotificationEvent, PushNotificationStatus, RoomCommand, RoomListFilter,
+    EncryptionCommand, EncryptionState, Error, ErrorKind, Event, EventRef, ImagePacks,
+    InteractiveAuth, InteractiveAuthOutcome, LifecycleCommand, LinkPreview, Media, MediaCommand,
+    MediaId, MediaLocation, MediaSize, MemberFilter, MemberSummary, MessageContent,
+    MessageEditContent, NotificationCommand, OwnDevice, PowerLevelChanges, Profile,
+    PushNotification, PushNotificationEvent, PushNotificationStatus, RoomCommand, RoomListFilter,
     RoomNotificationMode, RoomNotificationSettings, RoomPowerLevels, RoomSummary, SpaceChild,
     TimelineCommand, TimelineId, VerificationAction, VerificationTarget,
     encryption::encryption_state,
     engine::{MediaService, StoreLock},
     model::{PushNotificationRoom, PushNotificationSender},
-    normalise::{member_summary, room_summaries, space_child},
+    normalise::{image_packs, member_summary, room_summaries, space_child, url_previews_allowed},
 };
 
 #[derive(Clone)]
@@ -341,11 +341,13 @@ impl ClientHandle {
         timeline_id: TimelineId,
         target: impl Into<EventRef>,
         key: impl Into<String>,
+        shortcode: Option<String>,
     ) -> Result<(), Error> {
         self.run(Command::Timeline(TimelineCommand::ToggleReaction {
             timeline_id,
             target: target.into(),
             key: key.into(),
+            shortcode,
         }))
         .await
     }
@@ -582,6 +584,21 @@ impl ClientHandle {
         room_summaries(&self.client, self.spaces().await).await
     }
 
+    pub async fn image_packs(&self) -> Result<ImagePacks, Error> {
+        image_packs(&self.client).await
+    }
+
+    /// the homeserver's preview of a page, `None` when it has none. the homeserver sees every
+    /// url asked about, so a host decides whether encrypted rooms ask at all
+    pub async fn url_preview(&self, url: &str) -> Result<Option<LinkPreview>, Error> {
+        self.media.url_preview(url).await
+    }
+
+    /// whether the room and the user's settings let link previews show here
+    pub async fn url_previews_allowed(&self, room_id: &RoomId) -> Result<bool, Error> {
+        url_previews_allowed(&self.room(room_id)?).await
+    }
+
     /// browse a space the way the server sees it, rooms you haven't joined included
     pub async fn space_hierarchy(&self, space_id: OwnedRoomId) -> SpaceHierarchy {
         SpaceHierarchy(SpaceRoomList::new(self.client.clone(), space_id).await)
@@ -986,6 +1003,10 @@ impl EventSender {
         self.0.send(event).await.map_err(|_| SendEventError)
     }
 
+    pub(crate) async fn reserve(&self) -> Result<mpsc::Permit<'_, Event>, SendEventError> {
+        self.0.reserve().await.map_err(|_| SendEventError)
+    }
+
     /// resolves once every `EventStream` is gone
     pub(crate) async fn closed(&self) {
         self.0.closed().await;

Modified file: web/src/App.svelte+42 additions−8 deletions@@ -33,6 +33,7 @@
     membersByRoom,
     membersLoading,
     pushBanner,
+    imagePacks,
     resetClientState,
     rooms,
     selectedRoomId,
@@ -44,9 +45,16 @@
   import { discardPending, pendingByRoom, queueSend, resetPending, retryPending } from './lib/pending';
   import type { PendingMessage } from './lib/pending';
   import { loadQuickReactions, quickReactions, saveQuickReactions } from './lib/quick-reactions';
+  import {
+    linkPreviews,
+    loadUrlPreviewSettings,
+    requestLinkPreview,
+    saveUrlPreviewSettings,
+    urlPreviewSettings
+  } from './lib/link-previews';
   import { notifyTyping, stopTyping } from './lib/typing';
   import { formatDay } from './lib/format';
-  import { parseEncryptionState, parseOwnProfile, parseVerificationState } from './lib/types';
+  import { packsForRoom, parseEncryptionState, parseOwnProfile, parseVerificationState } from './lib/types';
   import type { MemberSummary, OwnProfile, QuickReaction, RoomSummary, SendState, TimelineEvent, TimelineItem } from './lib/types';
 
   let roomsLoading = false;
@@ -89,10 +97,16 @@
   // account data is read from the local cache, which is empty on a fresh device until the first sync lands
   $: {
     const online = $connection === 'online';
-    if (online && !wasOnline) void loadQuickReactions();
+    if (online && !wasOnline) {
+      void loadQuickReactions();
+      void loadUrlPreviewSettings();
+    }
     wasOnline = online;
   }
   $: selectedRoom = $rooms.find((r) => r.room_id === $selectedRoomId) ?? null;
+  $: roomPacks = packsForRoom($imagePacks, $selectedRoomId);
+  $: previewsAllowed = selectedRoom !== null && (!selectedRoom.encrypted || $urlPreviewSettings.encrypted_rooms);
+  $: loadPreview = previewsAllowed && $selectedRoomId ? previewLoader($selectedRoomId) : null;
   $: spaceRooms = $rooms.filter((r) => r.space);
   $: invites = $rooms.filter((r) => r.membership === 'Invited');
   $: query = search.trim().toLowerCase();
@@ -213,6 +227,7 @@
         void loadProfile();
         void loadEncryption();
         void loadQuickReactions();
+        void loadUrlPreviewSettings();
       } else {
         softLogout.set(session.soft_logout ?? null);
       }
@@ -268,6 +283,7 @@
     void loadProfile();
     void loadEncryption();
     void loadQuickReactions();
+    void loadUrlPreviewSettings();
   }
 
   async function doLogout(): Promise<void> {
@@ -498,12 +514,12 @@
       if (fileInput) fileInput.value = '';
     }
   }
-  async function react(eventId: string, key: string): Promise<void> {
+  async function react(eventId: string, key: string, shortcode?: string): Promise<void> {
     const roomId = $selectedRoomId;
     if (!roomId || !eventId || reacting) return;
     reacting = true;
     try {
-      await reactToMessage(roomId, eventId, key);
+      await reactToMessage(roomId, eventId, key, shortcode);
     } catch (e) {
       pushBanner(e instanceof Error ? e.message : 'Reaction failed');
     } finally {
@@ -511,6 +527,18 @@
     }
   }
 
+  function previewLoader(roomId: string): (url: string) => void {
+    return (url) => requestLinkPreview(roomId, url);
+  }
+
+  async function changeEncryptedPreviews(enabled: boolean): Promise<void> {
+    try {
+      await saveUrlPreviewSettings({ encrypted_rooms: enabled });
+    } catch (e) {
+      pushBanner(e instanceof Error ? e.message : 'Could not save link preview setting');
+    }
+  }
+
   async function changeQuickReactions(list: QuickReaction[]): Promise<void> {
     try {
       await saveQuickReactions(list);
@@ -1083,9 +1111,11 @@
                   showSender={g.showSender}
                   senderAvatar={senderAvatarFor(g.item.event.sender.user_id)}
                   {reacting}
-                  onReact={(eventId, key) => void react(eventId, key)}
+                  onReact={(eventId, key, shortcode) => void react(eventId, key, shortcode)}
                   quickReactions={$quickReactions}
-                  packs={[]}
+                  packs={roomPacks}
+                  linkPreviews={$linkPreviews}
+                  {loadPreview}
                   onQuickChange={(list) => void changeQuickReactions(list)}
                 />
               {/if}
@@ -1098,9 +1128,11 @@
               showSender={pendingShowSender(i)}
               senderAvatar={senderAvatarFor($sessionUser ?? '')}
               {reacting}
-              onReact={(eventId, key) => void react(eventId, key)}
+              onReact={(eventId, key, shortcode) => void react(eventId, key, shortcode)}
               quickReactions={$quickReactions}
-              packs={[]}
+              packs={roomPacks}
+              linkPreviews={$linkPreviews}
+              {loadPreview}
               onQuickChange={(list) => void changeQuickReactions(list)}
             />
             {#if p.status === 'failed'}
@@ -1204,6 +1236,8 @@
             encryptionState={$encryption}
             verificationState={$verification}
             onAction={() => void loadEncryption()}
+            encryptedPreviews={$urlPreviewSettings.encrypted_rooms}
+            onEncryptedPreviews={(enabled) => void changeEncryptedPreviews(enabled)}
             on:close={() => (dialog = null)}
           />
         {:else}

Modified file: web/src/lib/LinkCard.stories.ts+5 additions−4 deletions@@ -21,6 +21,7 @@ const [link] = findUrls('https://example.org/rabbit-hole/chapter-1?ref=matrix');
 function preview(overrides: Partial<LinkPreview> = {}): LinkPreview {
   return {
     url: link.href,
+    canonical_url: null,
     title: 'Down the Rabbit-Hole',
     description:
       'Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do.',
@@ -47,13 +48,13 @@ export const UrlOnly: Story = {
 };
 export const TextOnly: Story = { args: { preview: preview() } };
 export const Thumbnail: Story = {
-  args: { preview: preview({ image: { media_id: 'mxc://example.org/icon', width: 200, height: 200 } }) }
+  args: { preview: preview({ image: { media_id: 'mxc://example.org/icon', mimetype: null, size_bytes: null, width: 200, height: 200 } }) }
 };
 export const Banner: Story = {
-  args: { preview: preview({ image: { media_id: 'mxc://example.org/banner', width: 1200, height: 630 } }) }
+  args: { preview: preview({ image: { media_id: 'mxc://example.org/banner', mimetype: null, size_bytes: null, width: 1200, height: 630 } }) }
 };
 export const UnknownImageSize: Story = {
-  args: { preview: preview({ image: { media_id: 'mxc://example.org/banner', width: null, height: null } }) }
+  args: { preview: preview({ image: { media_id: 'mxc://example.org/banner', mimetype: null, size_bytes: null, width: null, height: null } }) }
 };
 export const NoSiteName: Story = {
   args: { preview: preview({ site_name: null, description: null }) },
@@ -63,7 +64,7 @@ export const NoSiteName: Story = {
   }
 };
 export const ImageFails: Story = {
-  args: { preview: preview({ image: { media_id: 'mxc://example.org/gone', width: 1200, height: 630 } }) },
+  args: { preview: preview({ image: { media_id: 'mxc://example.org/gone', mimetype: null, size_bytes: null, width: 1200, height: 630 } }) },
   play: async ({ canvasElement }) => {
     await waitFor(() => expect(canvasElement.querySelector('img')).toBeNull());
   }

Modified file: web/src/lib/MessageRow.stories.ts+84 additions−4 deletions@@ -28,7 +28,7 @@ function event(content: TimelineContent, overrides: Partial<TimelineEvent> = {})
 function text(body: string): TimelineContent {
   return {
     kind: 'Message',
-    message: { kind: 'Text', body, geo_uri: null, formatted_body: null, edited: false, media: null }
+    message: { kind: 'Text', body, geo_uri: null, formatted_body: null, edited: false, media: null, link_previews: [] }
   };
 }
 
@@ -90,6 +90,7 @@ export const WithRichLink: Story = {
         url: 'https://example.org/rabbit-hole',
         title: 'Down the Rabbit-Hole',
         description: 'Alice was beginning to get very tired of sitting by her sister on the bank.',
+        canonical_url: null,
         site_name: 'Wonderland Press',
         image: null
       }
@@ -100,13 +101,61 @@ export const WithRichLink: Story = {
     await expect(canvas.getByText('example.net')).toBeVisible();
   }
 };
+export const BundledPreview: Story = {
+  args: {
+    event: event({
+      kind: 'Message',
+      message: {
+        kind: 'Text',
+        body: 'Notes are at https://example.org/rabbit-hole',
+        geo_uri: null,
+        formatted_body: null,
+        edited: false,
+        media: null,
+        link_previews: [
+          {
+            url: 'https://example.org/rabbit-hole',
+            canonical_url: null,
+            title: 'Down the Rabbit-Hole',
+            description: 'Embedded by the sender.',
+            site_name: 'Wonderland Press',
+            image: null
+          }
+        ]
+      }
+    }),
+    loadPreview: fn()
+  },
+  play: async ({ args, canvas }) => {
+    await expect(canvas.getByText('Down the Rabbit-Hole')).toBeVisible();
+    await expect(args.loadPreview).not.toHaveBeenCalled();
+  }
+};
+export const LoadsMissingPreview: Story = {
+  args: { event: event(text('Notes are at https://example.org/rabbit-hole')), loadPreview: fn() },
+  play: async ({ args }) => {
+    await expect(args.loadPreview).toHaveBeenCalledWith('https://example.org/rabbit-hole');
+  }
+};
+export const ImageReaction: Story = {
+  args: {
+    event: event(text('Tea party at six'), {
+      reactions: [
+        { key: 'mxc://example.org/rabbit', count: 2, own: false, senders: [], shortcode: 'rabbit', image: 'mxc://example.org/rabbit' }
+      ]
+    })
+  },
+  play: async ({ canvas }) => {
+    await expect(canvas.getByAltText('rabbit')).toBeVisible();
+  }
+};
 export const Reactions: Story = {
   args: {
     event: event(text('Tea party at six'), {
       reactions: [
-        { key: '🎉', count: 3, own: true, senders: [] },
-        { key: '😮', count: 1, own: false, senders: [] },
-        { key: 'mxc://example.org/rabbit', count: 2, own: false, senders: [] }
+        { key: '🎉', count: 3, own: true, senders: [], shortcode: null, image: null },
+        { key: '😮', count: 1, own: false, senders: [], shortcode: null, image: null },
+        { key: 'mxc://example.org/rabbit', count: 2, own: false, senders: [], shortcode: null, image: null }
       ]
     })
   }
@@ -143,3 +192,34 @@ export const JumboEmoji: Story = {
     await expect(imgs[0]).toHaveAttribute('draggable', 'false');
   }
 };
+export const PackEmotePick: Story = {
+  args: {
+    packs: [
+      {
+        id: 'user',
+        display_name: 'My emotes',
+        avatar: null,
+        attribution: null,
+        source: 'User',
+        images: [
+          {
+            shortcode: 'rabbit',
+            media_id: 'mxc://example.org/rabbit',
+            reaction_key: 'mxc://example.org/rabbit',
+            body: null,
+            mimetype: null,
+            width: null,
+            height: null,
+            usage: ['Emoticon']
+          }
+        ]
+      }
+    ]
+  },
+  play: async ({ args, canvas }) => {
+    await userEvent.click(canvas.getByText('Curiouser and curiouser!'));
+    await userEvent.click(canvas.getByRole('button', { name: 'Add reaction to message from Alice' }));
+    await userEvent.click(await canvas.findByRole('button', { name: ':rabbit:' }));
+    await expect(args.onReact).toHaveBeenCalledWith('$event1', 'mxc://example.org/rabbit', 'rabbit');
+  }
+};

Modified file: web/src/lib/MessageRow.svelte+27 additions−9 deletions@@ -5,7 +5,7 @@
   import EmojiText from './EmojiText.svelte';
   import ReactionPicker from './ReactionPicker.svelte';
   import LinkCard from './LinkCard.svelte';
-  import { mediaUrl } from './api';
+  import { mediaUrl, messageMediaUrl } from './api';
   import type { ImagePack, LinkPreview, QuickReaction, SendState, TimelineContent, TimelineEvent } from './types';
   import { senderLabel } from './types';
   import { formatClock, formatDay, initialsOf, senderHue } from './format';
@@ -15,12 +15,13 @@
   export let event: TimelineEvent;
   export let showSender: boolean;
   export let reacting: boolean;
-  export let onReact: (eventId: string, key: string) => void;
+  export let onReact: (eventId: string, key: string, shortcode?: string) => void;
   export let senderAvatar: string | null = null;
   export let quickReactions: QuickReaction[] = [];
   export let packs: ImagePack[] = [];
   export let onQuickChange: (list: QuickReaction[]) => void = () => {};
-  export let linkPreviews: Record<string, LinkPreview> = {};
+  export let linkPreviews: Record<string, LinkPreview | null> = {};
+  export let loadPreview: ((url: string) => void) | null = null;
 
   const PICKER_WIDTH = 320;
   const PICKER_HEIGHT = 380;
@@ -53,6 +54,12 @@
   $: displayName = event.sender.name_ambiguous ? `${name} (${event.sender.user_id})` : name;
   $: interactive = event.content.kind === 'Message' || event.content.kind === 'Sticker' || event.content.kind === 'Poll';
   $: previews = event.content.kind === 'Message' ? findUrls(event.content.message.body) : [];
+  $: bundled = event.content.kind === 'Message' ? event.content.message.link_previews : [];
+  $: if (loadPreview) {
+    for (const link of previews) {
+      if (!bundled.some((b) => b.url === link.href) && !(link.href in linkPreviews)) loadPreview(link.href);
+    }
+  }
 
   function sendLabel(state: SendState): string {
     if (state.kind === 'Failed') return state.will_retry ? 'failed — will retry' : 'failed — not delivered';
@@ -90,9 +97,18 @@
     pickerOpen = false;
   }
 
-  function pick(key: string) {
+  function isImageKey(key: string): boolean {
+    return key.startsWith('mxc://') || packs.some((p) => p.images.some((i) => i.reaction_key === key));
+  }
+
+  function react(key: string, shortcode: string | null) {
+    if (shortcode && isImageKey(key)) onReact(event.event_id ?? '', key, shortcode);
+    else onReact(event.event_id ?? '', key);
+  }
+
+  function pick(key: string, shortcode: string | null) {
     pickerOpen = false;
-    onReact(event.event_id ?? '', key);
+    react(key, shortcode);
   }
 
   function closeOnScroll(e: Event) {
@@ -187,7 +203,7 @@
           title={`React ${label}`}
           aria-label={`React ${label} to message from ${displayName}`}
           disabled={reacting}
-          on:click={() => onReact(event.event_id ?? '', r.key)}
+          on:click={() => react(r.key, r.shortcode)}
         >
           {#if r.key.startsWith('mxc://')}
             <img class="emote" src={mediaUrl(r.key) ?? ''} alt="" />
@@ -210,7 +226,7 @@
     </div>
     {#if pickerOpen}
       <div class="picker-pop" style={pickerStyle} bind:this={pickerPop}>
-        <ReactionPicker {packs} quick={quickReactions} onPick={(key) => pick(key)} {onQuickChange} onClose={closePicker} />
+        <ReactionPicker {packs} quick={quickReactions} onPick={pick} {onQuickChange} onClose={closePicker} />
       </div>
     {/if}
   {/if}
@@ -268,7 +284,7 @@
       {#if previews.length > 0}
         <div class="link-previews">
           {#each previews as preview (preview.href)}
-            <LinkCard link={preview} preview={linkPreviews[preview.href] ?? null} />
+            <LinkCard link={preview} preview={bundled.find((b) => b.url === preview.href) ?? linkPreviews[preview.href] ?? null} />
           {/each}
         </div>
       {/if}
@@ -294,7 +310,9 @@
             disabled={!event.event_id || reacting}
             on:click={() => event.event_id && onReact(event.event_id, r.key)}
           >
-            {#if r.key.startsWith('mxc://')}
+            {#if r.image}
+              <img class="emote" src={messageMediaUrl(r.image, 'Thumbnail')} alt={r.shortcode ?? ''} title={r.shortcode ?? ''} />
+            {:else if r.key.startsWith('mxc://')}
               <img class="emote" src={mediaUrl(r.key) ?? ''} alt="" />
             {:else}
               <Emoji emoji={r.key} size={16} />

Modified file: web/src/lib/ReactionPicker.stories.ts+15 additions−8 deletions@@ -1,25 +1,32 @@
 import type { Meta, StoryObj } from '@storybook/svelte-vite';
 import { expect, fn, userEvent, waitFor } from 'storybook/test';
 import ReactionPicker from './ReactionPicker.svelte';
-import type { ImagePack, QuickReaction } from './types';
+import type { ImagePack, PackImage, PackUsage, QuickReaction } from './types';
+
+function image(shortcode: string, body: string | null, usage: PackUsage[]): PackImage {
+  const mxc = `mxc://example.org/${shortcode}`;
+  return { shortcode, media_id: mxc, reaction_key: mxc, body, mimetype: null, width: null, height: null, usage };
+}
 
 const packs: ImagePack[] = [
   {
     id: 'user',
     display_name: 'My emotes',
-    avatar_url: null,
-    source: { kind: 'User' },
+    avatar: null,
+    attribution: null,
+    source: 'User',
     images: [
-      { shortcode: 'rabbit', url: 'mxc://example.org/rabbit', body: 'White rabbit', usage: ['emoticon'] },
-      { shortcode: 'teapot', url: 'mxc://example.org/teapot', body: null, usage: ['emoticon', 'sticker'] }
+      image('rabbit', 'White rabbit', ['Emoticon']),
+      image('teapot', null, ['Emoticon', 'Sticker'])
     ]
   },
   {
     id: 'room',
     display_name: 'Tea party stickers',
-    avatar_url: null,
-    source: { kind: 'Room', room_id: '!tea:example.org', state_key: 'tea' },
-    images: [{ shortcode: 'dormouse', url: 'mxc://example.org/dormouse', body: null, usage: ['sticker'] }]
+    avatar: null,
+    attribution: null,
+    source: { Room: { room_id: '!tea:example.org', state_key: 'tea' } },
+    images: [image('dormouse', null, ['Sticker'])]
   }
 ];
 

Modified file: web/src/lib/ReactionPicker.svelte+13 additions−9 deletions@@ -1,6 +1,6 @@
 <script lang="ts">
   import { onMount } from 'svelte';
-  import { mediaUrl } from './api';
+  import { mediaUrl, messageMediaUrl } from './api';
   import Emoji from './Emoji.svelte';
   import { loadEmoji, searchEmoji } from './emoji';
   import type { EmojiGroup } from './emoji';
@@ -41,6 +41,10 @@
     return image.shortcode.toLowerCase().includes(needle) || (image.body ?? '').toLowerCase().includes(needle);
   }
 
+  function packName(pack: ImagePack): string {
+    return pack.display_name ?? 'Emoji pack';
+  }
+
   function isQuick(key: string): boolean {
     return quick.some((r) => r.key === key);
   }
@@ -121,21 +125,21 @@
 
   <div class="scroll" aria-busy={groups === null && !loadFailed}>
     {#each filteredPacks as { pack, images } (pack.id)}
-      <section class="group" aria-label={pack.display_name}>
-        <h3>{pack.display_name}</h3>
+      <section class="group" aria-label={packName(pack)}>
+        <h3>{packName(pack)}</h3>
         <div class="grid">
-          {#each images as image (image.url + image.shortcode)}
+          {#each images as image (image.reaction_key + image.shortcode)}
             <button
               type="button"
               class="cell"
-              class:chosen={customising && isQuick(image.url)}
+              class:chosen={customising && isQuick(image.reaction_key)}
               title={`:${image.shortcode}:`}
               aria-label={`:${image.shortcode}:`}
-              aria-pressed={customising ? isQuick(image.url) : undefined}
-              disabled={customising && full && !isQuick(image.url)}
-              on:click={() => choose(image.url, image.shortcode)}
+              aria-pressed={customising ? isQuick(image.reaction_key) : undefined}
+              disabled={customising && full && !isQuick(image.reaction_key)}
+              on:click={() => choose(image.reaction_key, image.shortcode)}
             >
-              <img src={mediaUrl(image.url) ?? ''} alt="" loading="lazy" />
+              <img src={messageMediaUrl(image.media_id, 'Thumbnail')} alt="" loading="lazy" />
             </button>
           {/each}
         </div>

Modified file: web/src/lib/SecurityPanel.stories.ts+11 additions−2 deletions@@ -1,5 +1,5 @@
 import type { Meta, StoryObj } from '@storybook/svelte-vite';
-import { fn } from 'storybook/test';
+import { expect, fn, userEvent } from 'storybook/test';
 import SecurityPanel from './SecurityPanel.svelte';
 
 const unverified = { device_id: 'ABCDEFGHIJ', device_verified: false, recovery: 'Disabled', key_backup: 'Disabled' } as const;
@@ -7,7 +7,7 @@ const unverified = { device_id: 'ABCDEFGHIJ', device_verified: false, recovery: 
 const meta = {
   title: 'Panels/SecurityPanel',
   component: SecurityPanel,
-  args: { encryptionState: unverified, verificationState: null, onAction: fn() }
+  args: { encryptionState: unverified, verificationState: null, onAction: fn(), onEncryptedPreviews: fn() }
 } satisfies Meta<typeof SecurityPanel>;
 
 export default meta;
@@ -37,3 +37,12 @@ export const Comparison: Story = {
   }
 };
 export const Cancelled: Story = { args: { verificationState: { kind: 'Cancelled', reason: 'User cancelled' } } };
+
+export const EncryptedPreviews: Story = {
+  play: async ({ args, canvas }) => {
+    const box = canvas.getByRole('checkbox', { name: 'Fetch link previews in encrypted rooms' });
+    await expect(box).not.toBeChecked();
+    await userEvent.click(box);
+    await expect(args.onEncryptedPreviews).toHaveBeenCalledWith(true);
+  }
+};

Modified file: web/src/lib/SecurityPanel.svelte+15 additions@@ -14,6 +14,8 @@
   export let encryptionState: EncryptionState | null;
   export let verificationState: VerificationState | null;
   export let onAction: () => void = () => undefined;
+  export let encryptedPreviews = false;
+  export let onEncryptedPreviews: (enabled: boolean) => void = () => undefined;
 
   let recoveryKey = '';
   let busy: VerifyAction | 'recover' | 'start' | null = null;
@@ -197,6 +199,18 @@
       </div>
     {/if}
   </section>
+  <section aria-label="Link previews">
+    <h3 class="sec-h">Link previews</h3>
+    <label class="check">
+      <input
+        type="checkbox"
+        checked={encryptedPreviews}
+        on:change={(e) => onEncryptedPreviews(e.currentTarget.checked)}
+      />
+      <span>Fetch link previews in encrypted rooms</span>
+    </label>
+    <p class="sec-note">Your homeserver sees every link it fetches a preview for.</p>
+  </section>
 </div>
 
 <style>
@@ -208,6 +222,7 @@
   .pill.ok { background: rgba(63, 185, 127, 0.18); border-color: #3fb97f; color: #9fe3c3; }
   .pill.warn { background: rgba(232, 178, 90, 0.15); border-color: var(--warn); color: var(--warn); }
   code { font-size: 12px; background: var(--bg-soft); padding: 1px 6px; border-radius: 6px; }
+  .check { display: flex; align-items: center; gap: 8px; font-size: 13px; }
   .row { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 8px; }
   .emoji-grid {
     list-style: none; margin: 8px 0; padding: 0;

Modified file: web/src/lib/api.ts+3 additions−2 deletions@@ -37,6 +37,7 @@ export const sendMessage = (room_id: string, body: string) => transport.sendMess
 export const paginateRoom = (room_id: string) => transport.paginateRoom(room_id);
 export const setTyping = (room_id: string, typing: boolean) => transport.setTyping(room_id, typing);
 export const getAccountData = (eventType: string) => transport.getAccountData(eventType);
+export const getUrlPreview = (room_id: string, url: string) => transport.getUrlPreview(room_id, url);
 export const setAccountData = (eventType: string, content: Record<string, unknown>) =>
   transport.setAccountData(eventType, content);
 
@@ -49,8 +50,8 @@ export function createRoom(name: string, topic?: string): Promise<{ room_id: str
 }
 
 export const leaveRoom = (room_id: string) => transport.leaveRoom(room_id);
-export const reactToMessage = (room_id: string, event_id: string, key: string) =>
-  transport.reactToMessage(room_id, event_id, key);
+export const reactToMessage = (room_id: string, event_id: string, key: string, shortcode?: string) =>
+  transport.reactToMessage(room_id, event_id, key, shortcode);
 export const markRead = (room_id: string, event_id: string) => transport.markRead(room_id, event_id);
 
 export function getMembers(room_id: string): Promise<{ members: MemberSummary[] }> {

Added file: web/src/lib/link-previews.ts+55 additions@@ -0,0 +1,55 @@
+import { get, writable } from 'svelte/store';
+import { ApiError, getAccountData, getUrlPreview, setAccountData } from './api';
+import { parseLinkPreview } from './types';
+import type { LinkPreview } from './types';
+
+const EVENT_TYPE = 'dev.malice.url_previews';
+const BACKOFF_MS = 30_000;
+
+export interface UrlPreviewSettings {
+  encrypted_rooms: boolean;
+}
+
+const DEFAULT_SETTINGS: UrlPreviewSettings = { encrypted_rooms: false };
+
+export const linkPreviews = writable<Record<string, LinkPreview | null>>({});
+export const urlPreviewSettings = writable<UrlPreviewSettings>(DEFAULT_SETTINGS);
+
+const inFlight = new Set<string>();
+let backoffUntil = 0;
+
+export function requestLinkPreview(roomId: string, url: string): void {
+  if (inFlight.has(url) || url in get(linkPreviews) || Date.now() < backoffUntil) return;
+  inFlight.add(url);
+  getUrlPreview(roomId, url)
+    .then((raw) => linkPreviews.update((all) => ({ ...all, [url]: parseLinkPreview(raw) })))
+    .catch((e) => {
+      if (e instanceof ApiError && e.status === 429) backoffUntil = Date.now() + BACKOFF_MS;
+    })
+    .finally(() => inFlight.delete(url));
+}
+
+function parseSettings(raw: unknown): UrlPreviewSettings {
+  if (typeof raw !== 'object' || raw === null) return DEFAULT_SETTINGS;
+  return { encrypted_rooms: (raw as Record<string, unknown>)['encrypted_rooms'] === true };
+}
+
+export async function loadUrlPreviewSettings(): Promise<void> {
+  try {
+    urlPreviewSettings.set(parseSettings(await getAccountData(EVENT_TYPE)));
+  } catch {
+    urlPreviewSettings.set(DEFAULT_SETTINGS);
+  }
+}
+
+export async function saveUrlPreviewSettings(settings: UrlPreviewSettings): Promise<void> {
+  await setAccountData(EVENT_TYPE, { encrypted_rooms: settings.encrypted_rooms });
+  urlPreviewSettings.set(settings);
+}
+
+export function resetLinkPreviews(): void {
+  linkPreviews.set({});
+  urlPreviewSettings.set(DEFAULT_SETTINGS);
+  inFlight.clear();
+  backoffUntil = 0;
+}

Modified file: web/src/lib/store.ts+12 additions@@ -2,15 +2,19 @@ import { writable } from 'svelte/store';
 import { getSession, subscribeEvents } from './api';
 import type { SoftLogout } from './api';
 import { isRecord } from './guards';
+import { resetLinkPreviews } from './link-previews';
 import { resetQuickReactions } from './quick-reactions';
 import {
+  EMPTY_IMAGE_PACKS,
   parseEncryptionState,
+  parseImagePacks,
   parseRoomList,
   parseTimelineList,
   parseVerificationState
 } from './types';
 import type {
   EncryptionState,
+  ImagePacks,
   MemberSummary,
   RoomSummary,
   TimelineItem,
@@ -29,6 +33,7 @@ export const membersByRoom = writable<Record<string, MemberSummary[]>>({});
 export const membersLoading = writable<boolean>(false);
 export const encryption = writable<EncryptionState | null>(null);
 export const verification = writable<VerificationState | null>(null);
+export const imagePacks = writable<ImagePacks>(EMPTY_IMAGE_PACKS);
 
 export interface Banner {
   id: number;
@@ -57,7 +62,9 @@ export function resetClientState(): void {
   encryption.set(null);
   verification.set(null);
   banners.set([]);
+  imagePacks.set(EMPTY_IMAGE_PACKS);
   resetQuickReactions();
+  resetLinkPreviews();
 }
 
 function applyTimelinePayload(roomId: string, payload: Record<string, unknown>): void {
@@ -94,6 +101,11 @@ function handlePayload(text: string): void {
     if (snapshotEncryption) encryption.set(snapshotEncryption);
     const snapshotVerification = parseVerificationState(data['verification']);
     if (snapshotVerification) verification.set(snapshotVerification);
+    imagePacks.set(parseImagePacks(data['image_packs']));
+    return;
+  }
+  if (kind === 'image_packs') {
+    imagePacks.set(parseImagePacks(data['packs']));
     return;
   }
   if (kind === 'rooms') {

Modified file: web/src/lib/transport-http.ts+10 additions−2 deletions@@ -101,8 +101,8 @@ export class HttpTransport implements Transport {
   leaveRoom(room_id: string): Promise<void> {
     return this.roomCommand(ROOM_COMMAND_PATHS.leave, { room_id });
   }
-  reactToMessage(room_id: string, event_id: string, key: string): Promise<void> {
-    return this.roomCommand(ROOM_COMMAND_PATHS.react, { room_id, event_id, key });
+  reactToMessage(room_id: string, event_id: string, key: string, shortcode?: string): Promise<void> {
+    return this.roomCommand(ROOM_COMMAND_PATHS.react, shortcode ? { room_id, event_id, key, shortcode } : { room_id, event_id, key });
   }
   markRead(room_id: string, event_id: string): Promise<void> {
     return this.roomCommand(ROOM_COMMAND_PATHS.read, { room_id, event_id });
@@ -147,6 +147,14 @@ export class HttpTransport implements Transport {
     return json(res, 'Could not load account data');
   }
 
+  async getUrlPreview(room_id: string, url: string): Promise<unknown | null> {
+    const res = await fetch(
+      `/api/url-preview?room_id=${encodeURIComponent(room_id)}&url=${encodeURIComponent(url)}`,
+      { credentials: 'same-origin' }
+    );
+    return json(res, 'Could not load link preview');
+  }
+
   async setAccountData(eventType: string, content: Record<string, unknown>): Promise<void> {
     const res = await fetch('/api/account-data', {
       method: 'POST',

Modified file: web/src/lib/transport-worker.ts+5 additions−2 deletions@@ -233,8 +233,8 @@ export class WorkerTransport implements Transport {
   leaveRoom(room_id: string): Promise<void> {
     return this.client.call('leave', { room_id });
   }
-  reactToMessage(room_id: string, event_id: string, key: string): Promise<void> {
-    return this.client.call('react', { room_id, event_id, key });
+  reactToMessage(room_id: string, event_id: string, key: string, shortcode?: string): Promise<void> {
+    return this.client.call('react', shortcode ? { room_id, event_id, key, shortcode } : { room_id, event_id, key });
   }
   markRead(room_id: string, event_id: string): Promise<void> {
     return this.client.call('read', { room_id, event_id });
@@ -248,6 +248,9 @@ export class WorkerTransport implements Transport {
   getAccountData(eventType: string): Promise<unknown | null> {
     return this.client.call('get_account_data', { event_type: eventType });
   }
+  getUrlPreview(room_id: string, url: string): Promise<unknown | null> {
+    return this.client.call('url_preview', { room_id, url });
+  }
   setAccountData(eventType: string, content: Record<string, unknown>): Promise<void> {
     return this.client.call('set_account_data', { event_type: eventType, content });
   }

Modified file: web/src/lib/transport.ts+2 additions−1 deletions@@ -39,11 +39,12 @@ export interface Transport {
   paginateRoom(room_id: string): Promise<void>;
   setTyping(room_id: string, typing: boolean): Promise<void>;
   getAccountData(eventType: string): Promise<unknown | null>;
+  getUrlPreview(room_id: string, url: string): Promise<unknown | null>;
   setAccountData(eventType: string, content: Record<string, unknown>): Promise<void>;
   joinRoom(room: string): Promise<{ room_id: string }>;
   createRoom(name: string, topic?: string): Promise<{ room_id: string }>;
   leaveRoom(room_id: string): Promise<void>;
-  reactToMessage(room_id: string, event_id: string, key: string): Promise<void>;
+  reactToMessage(room_id: string, event_id: string, key: string, shortcode?: string): Promise<void>;
   markRead(room_id: string, event_id: string): Promise<void>;
   getMembers(room_id: string): Promise<{ members: MemberSummary[] }>;
   getProfile(): Promise<{ display_name: string | null; avatar_url: string | null }>;

Modified file: web/src/lib/types.ts+146 additions−7 deletions@@ -379,6 +379,8 @@ export interface Reaction {
   count: number;
   own: boolean;
   senders: string[];
+  shortcode: string | null;
+  image: string | null;
 }
 
 export interface Sender {
@@ -425,6 +427,7 @@ export interface MessageBody {
   formatted_body: string | null;
   edited: boolean;
   media: MediaAttachment | null;
+  link_previews: LinkPreview[];
 }
 
 function parseMessageBody(raw: unknown): MessageBody {
@@ -435,7 +438,8 @@ function parseMessageBody(raw: unknown): MessageBody {
     geo_uri: optionalString(o, 'geo_uri'),
     formatted_body: optionalString(o, 'formatted_body'),
     edited: o['edited'] === true,
-    media: parseMediaAttachment(o['media'])
+    media: parseMediaAttachment(o['media']),
+    link_previews: parseLinkPreviews(o['link_previews'])
   };
 }
 
@@ -590,7 +594,9 @@ function parseReactions(raw: unknown): Reaction[] {
       key: stringField(entry, 'key'),
       count: numberField(entry, 'count'),
       own: entry['own'] === true,
-      senders: stringList(entry['senders'])
+      senders: stringList(entry['senders']),
+      shortcode: optionalString(entry, 'shortcode'),
+      image: optionalString(entry, 'image')
     });
   }
   return out;
@@ -648,20 +654,113 @@ export function parseTimelineList(raw: unknown): TimelineItem[] {
   return out;
 }
 
-export type PackUsage = 'emoticon' | 'sticker';
+export type PackUsage = 'Emoticon' | 'Sticker';
 export interface PackImage {
   shortcode: string;
-  url: string;
+  media_id: string;
+  reaction_key: string;
   body: string | null;
+  mimetype: string | null;
+  width: number | null;
+  height: number | null;
   usage: PackUsage[];
 }
+export type PackSource = 'User' | { Room: { room_id: string; state_key: string } };
 export interface ImagePack {
   id: string;
-  display_name: string;
-  avatar_url: string | null;
-  source: { kind: 'User' } | { kind: 'Room'; room_id: string; state_key: string };
+  display_name: string | null;
+  avatar: string | null;
+  attribution: string | null;
+  source: PackSource;
   images: PackImage[];
 }
+export interface ImagePacks {
+  global: ImagePack[];
+  rooms: Record<string, ImagePack[]>;
+}
+
+function parsePackImage(raw: unknown): PackImage | null {
+  if (!isRecord(raw)) return null;
+  const shortcode = stringField(raw, 'shortcode');
+  const mediaId = stringField(raw, 'media_id');
+  if (!shortcode || !mediaId) return null;
+  return {
+    shortcode,
+    media_id: mediaId,
+    reaction_key: stringField(raw, 'reaction_key', mediaId),
+    body: optionalString(raw, 'body'),
+    mimetype: optionalString(raw, 'mimetype'),
+    width: optionalNumber(raw, 'width'),
+    height: optionalNumber(raw, 'height'),
+    usage: stringList(raw['usage']).filter((u): u is PackUsage => u === 'Emoticon' || u === 'Sticker')
+  };
+}
+
+function parsePackSource(raw: unknown): PackSource {
+  if (isRecord(raw) && isRecord(raw['Room'])) {
+    return {
+      Room: { room_id: stringField(raw['Room'], 'room_id'), state_key: stringField(raw['Room'], 'state_key') }
+    };
+  }
+  return 'User';
+}
+
+function parseImagePack(raw: unknown): ImagePack | null {
+  if (!isRecord(raw)) return null;
+  const id = stringField(raw, 'id');
+  if (!id) return null;
+  const images: PackImage[] = [];
+  if (Array.isArray(raw['images'])) {
+    for (const entry of raw['images']) {
+      const image = parsePackImage(entry);
+      if (image) images.push(image);
+    }
+  }
+  return {
+    id,
+    display_name: optionalString(raw, 'display_name'),
+    avatar: optionalString(raw, 'avatar'),
+    attribution: optionalString(raw, 'attribution'),
+    source: parsePackSource(raw['source']),
+    images
+  };
+}
+
+function parsePackList(raw: unknown): ImagePack[] {
+  if (!Array.isArray(raw)) return [];
+  const out: ImagePack[] = [];
+  for (const entry of raw) {
+    const pack = parseImagePack(entry);
+    if (pack) out.push(pack);
+  }
+  return out;
+}
+
+export const EMPTY_IMAGE_PACKS: ImagePacks = { global: [], rooms: {} };
+
+export function parseImagePacks(raw: unknown): ImagePacks {
+  if (!isRecord(raw)) return EMPTY_IMAGE_PACKS;
+  const rooms: Record<string, ImagePack[]> = {};
+  if (isRecord(raw['rooms'])) {
+    for (const [roomId, list] of Object.entries(raw['rooms'])) rooms[roomId] = parsePackList(list);
+  }
+  return { global: parsePackList(raw['global']), rooms };
+}
+
+export function packsForRoom(packs: ImagePacks, roomId: string | null): ImagePack[] {
+  const seen = new Set<string>();
+  const out: ImagePack[] = [];
+  const add = (pack: ImagePack) => {
+    if (seen.has(pack.id)) return;
+    seen.add(pack.id);
+    out.push(pack);
+  };
+  for (const pack of packs.global) if (pack.source === 'User') add(pack);
+  if (roomId) for (const pack of packs.rooms[roomId] ?? []) add(pack);
+  for (const pack of packs.global) add(pack);
+  return out;
+}
+
 export const MAX_QUICK_REACTIONS = 8;
 export interface QuickReaction {
   key: string;
@@ -670,13 +769,53 @@ export interface QuickReaction {
 
 export interface LinkPreviewImage {
   media_id: string;
+  mimetype: string | null;
+  size_bytes: number | null;
   width: number | null;
   height: number | null;
 }
 export interface LinkPreview {
   url: string;
+  canonical_url: string | null;
   title: string | null;
   description: string | null;
   site_name: string | null;
   image: LinkPreviewImage | null;
 }
+
+function parseLinkPreviewImage(raw: unknown): LinkPreviewImage | null {
+  if (!isRecord(raw)) return null;
+  const mediaId = stringField(raw, 'media_id');
+  if (!mediaId) return null;
+  return {
+    media_id: mediaId,
+    mimetype: optionalString(raw, 'mimetype'),
+    size_bytes: optionalNumber(raw, 'size_bytes'),
+    width: optionalNumber(raw, 'width'),
+    height: optionalNumber(raw, 'height')
+  };
+}
+
+export function parseLinkPreview(raw: unknown): LinkPreview | null {
+  if (!isRecord(raw)) return null;
+  const url = stringField(raw, 'url');
+  if (!url) return null;
+  return {
+    url,
+    canonical_url: optionalString(raw, 'canonical_url'),
+    title: optionalString(raw, 'title'),
+    description: optionalString(raw, 'description'),
+    site_name: optionalString(raw, 'site_name'),
+    image: parseLinkPreviewImage(raw['image'])
+  };
+}
+
+export function parseLinkPreviews(raw: unknown): LinkPreview[] {
+  if (!Array.isArray(raw)) return [];
+  const out: LinkPreview[] = [];
+  for (const entry of raw) {
+    const preview = parseLinkPreview(entry);
+    if (preview) out.push(preview);
+  }
+  return out;
+}

malice

Commit ecb8598b38af

Commit `ecb8598b38af`