diff --git a/config/teapot.example.toml b/config/teapot.example.toml
index 3416321..25d8ca2 100644
--- a/config/teapot.example.toml
+++ b/config/teapot.example.toml
@@ -55,8 +55,8 @@ kagiTokenFile = ""
 
 [gifTranscoding]
 # Transcode Twitter GIF MP4s to actual GIF format for Discord inline playback
-# Modes: "off" (default), "local" (ffmpeg on server), "external" (URL rewrite)
-mode = "off"
+# Modes: "local" (default, ffmpeg on server), "off", "external" (URL rewrite)
+mode = "local"
 # Cache directory for transcoded GIFs (local mode only)
 cacheDir = "./cache/gif"
 # Maximum cache size in MB (local mode only)
diff --git a/flake.nix b/flake.nix
index 5db08e2..66f5b50 100644
--- a/flake.nix
+++ b/flake.nix
@@ -56,6 +56,7 @@
               pkgs.pkg-config
               pkgs.mold
               pkgs.clang
+              pkgs.ffmpeg-headless
             ];
           };
         }
@@ -245,7 +246,7 @@
                   "local"
                   "external"
                 ];
-                default = "off";
+                default = "local";
                 description = "GIF transcoding mode. 'local' requires ffmpeg, 'external' rewrites URLs to an external domain.";
               };
               cacheDir = lib.mkOption {
diff --git a/nix/package.nix b/nix/package.nix
index a366e3f..3efdaa1 100644
--- a/nix/package.nix
+++ b/nix/package.nix
@@ -2,6 +2,8 @@
   lib,
   rustPlatform,
   pkg-config,
+  makeWrapper,
+  ffmpeg-headless,
 }:
 rustPlatform.buildRustPackage {
   pname = "teapot";
@@ -20,7 +22,10 @@ rustPlatform.buildRustPackage {
 
   cargoLock.lockFile = ../Cargo.lock;
 
-  nativeBuildInputs = [ pkg-config ];
+  nativeBuildInputs = [
+    pkg-config
+    makeWrapper
+  ];
 
   doCheck = false;
   stripAllList = [ "bin" ];
@@ -29,6 +34,8 @@ rustPlatform.buildRustPackage {
     mkdir -p $out/share/teapot
     cp -r public $out/share/teapot/
     cp -r config $out/share/teapot/
+    wrapProgram $out/bin/teapot \
+      --prefix PATH : ${lib.makeBinPath [ ffmpeg-headless ]}
   '';
 
   meta = {
diff --git a/src/api/client.rs b/src/api/client.rs
index ab8d0fc..e804bc5 100644
--- a/src/api/client.rs
+++ b/src/api/client.rs
@@ -13,6 +13,10 @@ use super::{
 };
 use crate::{
    api::schema::{
+      AudioSpaceData,
+      AudioSpaceMetadata,
+      BroadcastMetadata,
+      BroadcastsData,
       ConversationData,
       EditHistoryData,
       GqlResponse,
@@ -22,6 +26,7 @@ use crate::{
       ListTimelineData,
       RetweetersData,
       SearchTimelineData,
+      TweetData,
       UserResultData,
       UserTimelineData,
    },
@@ -33,6 +38,7 @@ use crate::{
    },
    types::{
       Article,
+      CardKind,
       Conversation,
       EditHistory,
       GalleryPhoto,
@@ -45,8 +51,188 @@ use crate::{
       Tweet,
       User,
    },
+   utils::formatters,
 };
 
+fn space_id_from_url(url: &str) -> Option<&str> {
+   url.split("/spaces/")
+      .nth(1)?
+      .split(['/', '?', '#'])
+      .next()
+      .filter(|id| !id.is_empty())
+}
+
+fn millis_to_time(milliseconds: i64) -> Option<time::OffsetDateTime> {
+   time::OffsetDateTime::from_unix_timestamp(milliseconds.checked_div(1_000)?).ok()
+}
+
+fn audio_space_status(metadata: &AudioSpaceMetadata) -> String {
+   match metadata.state.as_deref() {
+      Some("NotStarted") => {
+         metadata
+            .scheduled_start
+            .and_then(millis_to_time)
+            .map_or_else(
+               || "Scheduled".to_owned(),
+               |time| format!("Scheduled · {}", formatters::format_tweet_time(time)),
+            )
+      },
+      Some("Running") => {
+         metadata
+            .total_live_listeners
+            .filter(|count| *count > 0)
+            .map_or_else(
+               || "Live now".to_owned(),
+               |count| {
+                  format!(
+                     "Live now · {} listening",
+                     formatters::abbreviate_number(count)
+                  )
+               },
+            )
+      },
+      Some("Ended" | "TimedOut") if metadata.is_space_available_for_replay.unwrap_or(false) => {
+         metadata
+            .total_replay_watched
+            .filter(|count| *count > 0)
+            .map_or_else(
+               || "Replay available".to_owned(),
+               |count| {
+                  format!(
+                     "Replay available · {} plays",
+                     formatters::abbreviate_number(count)
+                  )
+               },
+            )
+      },
+      Some("Ended" | "TimedOut") => "Space ended".to_owned(),
+      _ => String::new(),
+   }
+}
+
+fn audio_space_host(metadata: &AudioSpaceMetadata) -> String {
+   let Some(user) = metadata
+      .creator_results
+      .as_ref()
+      .and_then(|results| results.result.as_deref())
+   else {
+      return "X Space".to_owned();
+   };
+   let name = user
+      .core
+      .as_ref()
+      .and_then(|core| core.name.as_deref())
+      .or_else(|| {
+         user
+            .legacy
+            .as_ref()
+            .and_then(|legacy| legacy.name.as_deref())
+      })
+      .unwrap_or_default();
+   let username = user
+      .core
+      .as_ref()
+      .and_then(|core| core.screen_name.as_deref())
+      .or_else(|| {
+         user
+            .legacy
+            .as_ref()
+            .and_then(|legacy| legacy.screen_name.as_deref())
+      })
+      .unwrap_or_default();
+
+   hosted_by(name, username).unwrap_or_else(|| "X Space".to_owned())
+}
+
+fn hosted_by(name: &str, username: &str) -> Option<String> {
+   match (name.is_empty(), username.is_empty()) {
+      (false, false) => Some(format!("Hosted by {name} (@{username})")),
+      (false, true) => Some(format!("Hosted by {name}")),
+      (true, false) => Some(format!("Hosted by @{username}")),
+      (true, true) => None,
+   }
+}
+
+fn broadcast_id_from_url(url: &str) -> Option<&str> {
+   url.split("/broadcasts/")
+      .nth(1)?
+      .split(['/', '?', '#'])
+      .next()
+      .filter(|id| !id.is_empty())
+}
+
+fn broadcast_status(metadata: &BroadcastMetadata) -> String {
+   match metadata.state.as_str() {
+      "RUNNING" => {
+         metadata
+            .total_watching
+            .filter(|count| *count > 0)
+            .map_or_else(
+               || "Live now".to_owned(),
+               |count| {
+                  format!(
+                     "Live now · {} watching",
+                     formatters::abbreviate_number(count)
+                  )
+               },
+            )
+      },
+      "ENDED" if metadata.available_for_replay => {
+         metadata
+            .total_watched
+            .filter(|count| *count > 0)
+            .map_or_else(
+               || "Replay available".to_owned(),
+               |count| {
+                  format!(
+                     "Replay available · {} views",
+                     formatters::abbreviate_number(count)
+                  )
+               },
+            )
+      },
+      "ENDED" => {
+         metadata
+            .total_watched
+            .filter(|count| *count > 0)
+            .map_or_else(
+               || "Broadcast ended".to_owned(),
+               |count| {
+                  format!(
+                     "Broadcast ended · {} views",
+                     formatters::abbreviate_number(count)
+                  )
+               },
+            )
+      },
+      _ => String::new(),
+   }
+}
+
+fn article_tweet_data<'a>(data: &'a ConversationData, tweet_id: &str) -> Option<&'a TweetData> {
+   let raw = data
+      .tweet_result
+      .as_ref()
+      .and_then(|nested| nested.result.as_deref())
+      .or_else(|| {
+         data
+            .threaded_conversation_with_injections_v2
+            .as_ref()?
+            .instructions
+            .iter()
+            .filter_map(|instruction| instruction.entries.as_deref())
+            .flatten()
+            .find(|entry| {
+               entry
+                  .entry_id_str()
+                  .starts_with(&format!("tweet-{tweet_id}"))
+            })
+            .and_then(|entry| entry.tweet_result())
+      })?;
+
+   raw.tweet.as_deref().or(Some(raw))
+}
+
 /// Twitter/X API client.
 #[derive(Clone)]
 pub struct ApiClient {
@@ -347,6 +533,82 @@ impl ApiClient {
       Ok(resp.data)
    }
 
+   async fn cookie_json_request<T: DeserializeOwned>(
+      &self,
+      session_key: &str,
+      api_path: &str,
+      url: &str,
+   ) -> Result<T> {
+      let session = self.sessions.get_session(session_key).await?;
+      if !matches!(session.kind, SessionKind::Cookie) {
+         return Err(Error::Internal(
+            "This X endpoint requires a cookie session".into(),
+         ));
+      }
+
+      let (bearer, tid) = self
+         .tid
+         .generate(api_path)
+         .await
+         .map_or((endpoints::BEARER_TOKEN_NO_TID, None), |tid_val| {
+            (endpoints::BEARER_TOKEN, Some(tid_val))
+         });
+      let mut headers = header::HeaderMap::new();
+      headers.insert(
+         header::AUTHORIZATION,
+         header::HeaderValue::from_str(bearer)
+            .map_err(|_| Error::Internal("invalid bearer token value".into()))?,
+      );
+      headers.insert(
+         "x-twitter-auth-type",
+         header::HeaderValue::from_static("OAuth2Session"),
+      );
+      headers.insert(
+         "x-csrf-token",
+         session
+            .ct0
+            .parse()
+            .map_err(|_| Error::Internal("invalid ct0 header value".into()))?,
+      );
+      headers.insert(
+         header::COOKIE,
+         format!("auth_token={}; ct0={}", session.auth_token, session.ct0)
+            .parse()
+            .map_err(|_| Error::Internal("invalid cookie header value".into()))?,
+      );
+      headers.insert(
+         header::ORIGIN,
+         header::HeaderValue::from_static("https://x.com"),
+      );
+      headers.insert(header::ACCEPT, header::HeaderValue::from_static("*/*"));
+      headers.insert(
+         "x-twitter-active-user",
+         header::HeaderValue::from_static("yes"),
+      );
+      headers.insert(
+         "x-twitter-client-language",
+         header::HeaderValue::from_static("en"),
+      );
+      if let Some(tid) = tid
+         && let Ok(value) = tid.parse()
+      {
+         headers.insert("x-client-transaction-id", value);
+      }
+
+      let response = self.client.get_with_headers(url, &headers).await?;
+      if !response.status().is_success() {
+         let status = response.status();
+         let body = response.text().await.unwrap_or_default();
+         return Err(Error::TwitterApi(format!(
+            "X API request failed ({status}): {body}"
+         )));
+      }
+
+      let bytes = response.bytes().await?;
+      serde_json::from_slice(&bytes)
+         .map_err(|err| Error::Internal(format!("Response parse error: {err}")))
+   }
+
    /// Get user by screen name.
    pub async fn get_user(&self, screen_name: &str) -> Result<User> {
       let data = self
@@ -414,6 +676,94 @@ impl ApiClient {
       }
    }
 
+   async fn enrich_audio_space_card(&self, tweet: &mut Tweet) {
+      let Some(space_id) = tweet
+         .card
+         .as_ref()
+         .filter(|card| card.kind == CardKind::Audiospace)
+         .and_then(|card| space_id_from_url(&card.url))
+         .map(str::to_owned)
+      else {
+         return;
+      };
+
+      let Ok(data) = self
+         .graphql_request::<AudioSpaceData>(
+            endpoints::GRAPH_AUDIO_SPACE,
+            &endpoints::audio_space_vars(&space_id),
+            endpoints::GQL_FEATURES,
+            None,
+         )
+         .await
+      else {
+         return;
+      };
+      let Some(metadata) = data.audio_space.and_then(|space| space.metadata) else {
+         return;
+      };
+      let Some(card) = tweet
+         .card
+         .as_mut()
+         .filter(|card| card.kind == CardKind::Audiospace)
+      else {
+         return;
+      };
+
+      if let Some(title) = metadata.title.as_deref().filter(|title| !title.is_empty()) {
+         title.clone_into(&mut card.title);
+      }
+      card.text = audio_space_status(&metadata);
+      card.dest = audio_space_host(&metadata);
+   }
+
+   async fn enrich_broadcast_card(&self, tweet: &mut Tweet) {
+      let Some(broadcast_id) = tweet
+         .card
+         .as_ref()
+         .filter(|card| matches!(card.kind, CardKind::Broadcast | CardKind::Periscope))
+         .and_then(|card| broadcast_id_from_url(&card.url))
+         .map(str::to_owned)
+      else {
+         return;
+      };
+      let url = endpoints::broadcast_show_url(&broadcast_id);
+      let Ok(data) = self
+         .cookie_json_request::<BroadcastsData>(
+            endpoints::BROADCAST_SHOW_PATH,
+            endpoints::BROADCAST_SHOW_PATH,
+            &url,
+         )
+         .await
+      else {
+         return;
+      };
+      let Some(metadata) = data.broadcasts.get(&broadcast_id) else {
+         return;
+      };
+      let Some(card) = tweet
+         .card
+         .as_mut()
+         .filter(|card| matches!(card.kind, CardKind::Broadcast | CardKind::Periscope))
+      else {
+         return;
+      };
+
+      if !metadata.status.is_empty() {
+         metadata.status.clone_into(&mut card.title);
+      } else if !card.text.is_empty() {
+         card.text.clone_into(&mut card.title);
+      }
+      card.text = broadcast_status(metadata);
+      card.dest = hosted_by(&metadata.user_display_name, &metadata.twitter_username)
+         .unwrap_or_else(|| "Live broadcast".to_owned());
+      if !metadata.image_url.is_empty() {
+         metadata.image_url.clone_into(&mut card.image);
+         if let Some(video) = card.video.as_mut() {
+            metadata.image_url.clone_into(&mut video.thumb);
+         }
+      }
+   }
+
    /// Get conversation/thread for a tweet.
    pub async fn get_conversation(
       &self,
@@ -429,7 +779,28 @@ impl ApiClient {
             Some(endpoints::TWEET_DETAIL_FIELD_TOGGLES),
          )
          .await?;
-      super::parse_conversation(&data, tweet_id, cursor.is_some())
+      let mut conversation = super::parse_conversation(&data, tweet_id, cursor.is_some())?;
+      if cursor.is_none()
+         && let Some(tweet_data) = article_tweet_data(&data, tweet_id)
+         && let Ok(article) = parser::parse_article(tweet_data)
+      {
+         parser::attach_article_preview(&mut conversation.tweet, &article);
+      }
+      if cursor.is_none()
+         && conversation
+            .tweet
+            .entities
+            .iter()
+            .any(|entity| entity.url.contains("/article/"))
+         && let Ok((_tweet, article)) = self.get_article_tweet(tweet_id).await
+      {
+         parser::attach_article_preview(&mut conversation.tweet, &article);
+      }
+      if cursor.is_none() {
+         self.enrich_audio_space_card(&mut conversation.tweet).await;
+         self.enrich_broadcast_card(&mut conversation.tweet).await;
+      }
+      Ok(conversation)
    }
 
    /// Get user's tweets timeline.
@@ -703,34 +1074,12 @@ impl ApiClient {
       let conversation = super::parse_conversation(&data, tweet_id, false)?;
       let tweet = conversation.tweet;
 
-      // Extract raw TweetData for the article — try single-tweet path first,
-      // then scan timeline entries. Handle TweetWithVisibilityResults wrapper.
-      let raw = data
-         .tweet_result
-         .as_ref()
-         .and_then(|nested| nested.result.as_deref())
-         .or_else(|| {
-            data
-               .threaded_conversation_with_injections_v2
-               .as_ref()?
-               .instructions
-               .iter()
-               .filter_map(|instr| instr.entries.as_deref())
-               .flatten()
-               .find(|entry| {
-                  entry
-                     .entry_id_str()
-                     .starts_with(&format!("tweet-{tweet_id}"))
-               })
-               .and_then(|entry| entry.tweet_result())
-         });
-
-      // Unwrap TweetWithVisibilityResults if needed
-      let tweet_data = raw
-         .and_then(|td| td.tweet.as_deref().or(Some(td)))
+      let tweet_data = article_tweet_data(&data, tweet_id)
          .ok_or_else(|| Error::TweetNotFound("Tweet data not found in response".into()))?;
 
       let article = parser::parse_article(tweet_data)?;
+      let mut tweet = tweet;
+      parser::attach_article_preview(&mut tweet, &article);
       Ok((tweet, article))
    }
 
@@ -1000,3 +1349,88 @@ impl ApiClient {
       Ok(photos)
    }
 }
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+
+   #[test]
+   fn formats_scheduled_audio_space_status() {
+      let metadata = AudioSpaceMetadata {
+         state: Some("NotStarted".to_owned()),
+         scheduled_start: Some(1_784_203_200_000),
+         ..AudioSpaceMetadata::default()
+      };
+
+      assert_eq!(
+         audio_space_status(&metadata),
+         "Scheduled · Jul 16, 2026 · 12:00 PM UTC"
+      );
+   }
+
+   #[test]
+   fn parses_recorded_audio_space_metadata() {
+      let data: AudioSpaceData = serde_json::from_str(
+         r#"{
+            "audioSpace": {
+               "metadata": {
+                  "ended_at": "1784107519245",
+                  "is_space_available_for_replay": true,
+                  "state": "TimedOut",
+                  "title": "Interlink enters a new phase",
+                  "total_replay_watched": 4
+               }
+            }
+         }"#,
+      )
+      .unwrap();
+      let metadata = data.audio_space.unwrap().metadata.unwrap();
+
+      assert_eq!(metadata.ended_at, Some(1_784_107_519_245));
+      assert_eq!(audio_space_status(&metadata), "Replay available · 4 plays");
+   }
+
+   #[test]
+   fn parses_live_broadcast_metadata() {
+      let data: BroadcastsData = serde_json::from_str(
+         r#"{
+            "broadcasts": {
+               "1XxyggAaLzvGM": {
+                  "available_for_replay": true,
+                  "image_url": "https://video.pscp.tv/latest.jpg",
+                  "state": "RUNNING",
+                  "status": "Stripe x PayPal",
+                  "total_watched": "26",
+                  "total_watching": "26",
+                  "twitter_username": "tbpn",
+                  "user_display_name": "TBPN"
+               }
+            }
+         }"#,
+      )
+      .unwrap();
+      let metadata = &data.broadcasts["1XxyggAaLzvGM"];
+
+      assert_eq!(broadcast_status(metadata), "Live now · 26 watching");
+      assert_eq!(
+         hosted_by(&metadata.user_display_name, &metadata.twitter_username),
+         Some("Hosted by TBPN (@tbpn)".to_owned())
+      );
+   }
+
+   #[test]
+   fn extracts_audio_space_id_from_canonical_url() {
+      assert_eq!(
+         space_id_from_url("https://x.com/i/spaces/1AxRnnrNvyDxl/peek?foo=bar"),
+         Some("1AxRnnrNvyDxl")
+      );
+   }
+
+   #[test]
+   fn extracts_broadcast_id_from_canonical_url() {
+      assert_eq!(
+         broadcast_id_from_url("https://x.com/i/broadcasts/1XxyggAaLzvGM?foo=bar"),
+         Some("1XxyggAaLzvGM")
+      );
+   }
+}
diff --git a/src/api/endpoints.rs b/src/api/endpoints.rs
index 7706c13..c4a95e4 100644
--- a/src/api/endpoints.rs
+++ b/src/api/endpoints.rs
@@ -31,6 +31,8 @@ pub const GRAPH_USER_TWEETS_AND_REPLIES_V2: &str =
    "BDX77Xzqypdt11-mDfgdpQ/UserWithProfileTweetsAndRepliesQueryV2";
 pub const GRAPH_TWEET_EDIT_HISTORY: &str = "upS9teTSG45aljmP9oTuXA/TweetEditHistory";
 pub const GRAPH_RETWEETERS: &str = "tj-dlOvzRKjw69iy4z3LzQ/Retweeters";
+pub const GRAPH_AUDIO_SPACE: &str = "xpwpkJD3FetGBaSq7zH4Lw/AudioSpaceById";
+pub const BROADCAST_SHOW_PATH: &str = "/i/api/1.1/broadcasts/show.json";
 pub const USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 \
                               (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36";
 
@@ -127,6 +129,20 @@ pub fn retweeters_vars(tweet_id: &str, cursor: Option<&str>) -> String {
    }))
 }
 
+pub fn audio_space_vars(space_id: &str) -> String {
+   json!({
+      "id": space_id,
+      "isMetatagsQuery": false,
+      "withReplays": true,
+      "withListeners": true,
+   })
+   .to_string()
+}
+
+pub fn broadcast_show_url(broadcast_id: &str) -> String {
+   format!("https://x.com{BROADCAST_SHOW_PATH}?ids={broadcast_id}&include_events=false")
+}
+
 pub fn search_vars(raw_query: &str, cursor: Option<&str>, product: &str) -> String {
    vars(json!({
       "rawQuery": raw_query, "cursor": cursor, "count": 20,
diff --git a/src/api/parser/article.rs b/src/api/parser/article.rs
index 63d209f..707115d 100644
--- a/src/api/parser/article.rs
+++ b/src/api/parser/article.rs
@@ -22,6 +22,10 @@ use crate::{
       ArticleParagraph,
       ArticleStyle,
       ArticleStyleRange,
+      Card,
+      CardKind,
+      EntityKind,
+      Tweet,
       User,
    },
 };
@@ -47,6 +51,60 @@ pub fn parse_article(tweet_data: &TweetData) -> Result<Article> {
    Ok(parse_inline_article(inline, user))
 }
 
+pub fn attach_article_preview(tweet: &mut Tweet, article: &Article) {
+   let has_usable_card = tweet
+      .card
+      .as_ref()
+      .is_some_and(|card| !matches!(card.kind, CardKind::Hidden | CardKind::Unknown));
+   if article.title.is_empty() || has_usable_card {
+      return;
+   }
+
+   if let Some(start) = tweet
+      .entities
+      .iter()
+      .filter(|entity| entity.kind == EntityKind::Url && entity.url.contains("/article/"))
+      .map(|entity| entity.indices.0)
+      .min()
+   {
+      let byte_start = tweet
+         .text
+         .char_indices()
+         .nth(start)
+         .map_or(tweet.text.len(), |(index, _)| index);
+      tweet.text.truncate(byte_start);
+      tweet.text = tweet.text.trim_end().to_owned();
+      tweet
+         .entities
+         .retain(|entity| entity.kind != EntityKind::Url || !entity.url.contains("/article/"));
+   }
+
+   let description = article
+      .paragraphs
+      .iter()
+      .find(|paragraph| {
+         paragraph.base_type == ArticleBlockType::Unstyled && !paragraph.text.trim().is_empty()
+      })
+      .map(|paragraph| {
+         let mut excerpt: String = paragraph.text.chars().take(200).collect();
+         if paragraph.text.chars().count() > 200 {
+            excerpt.push('…');
+         }
+         excerpt
+      })
+      .unwrap_or_default();
+
+   tweet.card = Some(Card {
+      kind: CardKind::Article,
+      url: format!("/{}/article/{}", tweet.user.username, tweet.id),
+      title: article.title.clone(),
+      image: article.cover_image.clone(),
+      text: description,
+      dest: format!("Article · @{}", tweet.user.username),
+      ..Card::default()
+   });
+}
+
 fn parse_inline_article(raw: &InlineArticle, user: User) -> Article {
    let title = raw.title.clone().unwrap_or_default();
 
diff --git a/src/api/parser/card.rs b/src/api/parser/card.rs
index c38cfef..045e159 100644
--- a/src/api/parser/card.rs
+++ b/src/api/parser/card.rs
@@ -134,6 +134,12 @@ impl TryFrom<&CardData> for Card {
          CardKind::LiveEvent => {
             bv.string("event_title").clone_into(&mut card_text);
          },
+         CardKind::Audiospace => {
+            let space_id = bv.string("id");
+            if !space_id.is_empty() {
+               card_url = format!("https://x.com/i/spaces/{space_id}");
+            }
+         },
          CardKind::Player => {
             let player_url = bv.string("player_url");
             if !player_url.is_empty() {
diff --git a/src/api/parser/media.rs b/src/api/parser/media.rs
index 9d4538e..2804318 100644
--- a/src/api/parser/media.rs
+++ b/src/api/parser/media.rs
@@ -19,12 +19,13 @@ use crate::{
 
 /// Parsed media result (no side effects on tweet text).
 pub struct ParsedMedia {
-   pub photos:      Vec<Photo>,
-   pub video:       Option<Video>,
-   pub gif:         Option<Gif>,
-   pub attribution: Option<User>,
+   pub photos:            Vec<Photo>,
+   pub video:             Option<Video>,
+   pub additional_videos: Vec<Video>,
+   pub gif:               Option<Gif>,
+   pub attribution:       Option<User>,
    /// t.co and expanded URLs that should be stripped from tweet text.
-   pub strip_urls:  Vec<String>,
+   pub strip_urls:        Vec<String>,
 }
 
 /// Parse media from tweet legacy data.
@@ -34,6 +35,7 @@ pub struct ParsedMedia {
 pub fn parse_media(legacy: &TweetLegacy) -> ParsedMedia {
    let mut photos = Vec::new();
    let mut video = None;
+   let mut additional_videos = Vec::new();
    let mut gif = None;
    let mut attribution = None;
    let mut strip_urls = Vec::new();
@@ -47,11 +49,18 @@ pub fn parse_media(legacy: &TweetLegacy) -> ParsedMedia {
                photos.push(Photo {
                   url:      url.to_owned(),
                   alt_text: media.ext_alt_text.clone().unwrap_or_default(),
+                  width:    media.original_info.as_ref().map_or(0, |info| info.width),
+                  height:   media.original_info.as_ref().map_or(0, |info| info.height),
                });
             }
          },
          MediaType::Video => {
-            video = Some(parse_video(media));
+            let parsed = parse_video(media);
+            if video.is_none() {
+               video = Some(parsed);
+            } else {
+               additional_videos.push(parsed);
+            }
             // Parse media attribution from additional_media_info.source_user
             if let Some(ref info) = media.additional_media_info
                && let Some(ref source_user) = info.source_user
@@ -79,6 +88,7 @@ pub fn parse_media(legacy: &TweetLegacy) -> ParsedMedia {
    ParsedMedia {
       photos,
       video,
+      additional_videos,
       gif,
       attribution,
       strip_urls,
@@ -192,5 +202,68 @@ pub fn parse_gif(media: &MediaItem) -> Gif {
       .unwrap_or_default()
       .to_owned();
 
-   Gif { url, thumb }
+   let (width, height) = media
+      .original_info
+      .as_ref()
+      .map_or((0, 0), |info| (info.width, info.height));
+
+   Gif {
+      url,
+      thumb,
+      alt_text: media.ext_alt_text.clone().unwrap_or_default(),
+      width,
+      height,
+   }
+}
+
+#[cfg(test)]
+mod tests {
+   use serde_json::json;
+
+   use super::*;
+
+   #[test]
+   fn parse_media_preserves_multiple_videos() {
+      let legacy: TweetLegacy = serde_json::from_value(json!({
+         "extended_entities": {
+            "media": [
+               {
+                  "type": "video",
+                  "media_url_https": "https://pbs.twimg.com/first.jpg",
+                  "video_info": {
+                     "variants": [{
+                        "content_type": "video/mp4",
+                        "bitrate": 832000,
+                        "url": "https://video.twimg.com/vid/640x360/first.mp4"
+                     }]
+                  }
+               },
+               {
+                  "type": "video",
+                  "media_url_https": "https://pbs.twimg.com/second.jpg",
+                  "video_info": {
+                     "variants": [{
+                        "content_type": "video/mp4",
+                        "bitrate": 832000,
+                        "url": "https://video.twimg.com/vid/1280x720/second.mp4"
+                     }]
+                  }
+               }
+            ]
+         }
+      }))
+      .unwrap();
+
+      let parsed = parse_media(&legacy);
+
+      assert_eq!(
+         parsed.video.as_ref().map(|video| video.url.as_str()),
+         Some("https://video.twimg.com/vid/640x360/first.mp4")
+      );
+      assert_eq!(parsed.additional_videos.len(), 1);
+      assert_eq!(
+         parsed.additional_videos[0].url,
+         "https://video.twimg.com/vid/1280x720/second.mp4"
+      );
+   }
 }
diff --git a/src/api/parser/mod.rs b/src/api/parser/mod.rs
index 3a28f14..46bbaeb 100644
--- a/src/api/parser/mod.rs
+++ b/src/api/parser/mod.rs
@@ -9,7 +9,10 @@ mod timeline;
 mod tweet;
 mod user;
 
-pub use article::parse_article;
+pub use article::{
+   attach_article_preview,
+   parse_article,
+};
 pub use conversation::parse_conversation;
 pub use search::{
    parse_list,
diff --git a/src/api/parser/tweet.rs b/src/api/parser/tweet.rs
index f4fbe1b..74980e0 100644
--- a/src/api/parser/tweet.rs
+++ b/src/api/parser/tweet.rs
@@ -124,6 +124,7 @@ impl TryFrom<&TweetData> for Tweet {
       let media = parse_media(legacy);
       let mut photos = media.photos;
       let video = media.video;
+      let additional_videos = media.additional_videos;
       let gif = media.gif;
       let media_attribution = media.attribution;
 
@@ -171,6 +172,7 @@ impl TryFrom<&TweetData> for Tweet {
       {
          reply = vec![screen_name.clone()];
       }
+      let mut reply_mentions_stripped = false;
 
       // Parse thread info
       let has_thread = legacy.self_thread.is_some();
@@ -294,13 +296,14 @@ impl TryFrom<&TweetData> for Tweet {
          for mention in &ent.user_mentions {
             let screen_name = mention.screen_name.as_deref().unwrap_or_default();
             let (start, _) = indices(&mention.indices);
-            if start < display_start
-               && !screen_name.is_empty()
-               && !reply
+            if start < display_start && !screen_name.is_empty() {
+               reply_mentions_stripped = true;
+               if !reply
                   .iter()
                   .any(|existing| existing.eq_ignore_ascii_case(screen_name))
-            {
-               reply.push(screen_name.to_owned());
+               {
+                  reply.push(screen_name.to_owned());
+               }
             }
          }
       }
@@ -308,6 +311,7 @@ impl TryFrom<&TweetData> for Tweet {
       if display_start > 0 && note_tweet.is_none() {
          for entity in &entities {
             if entity.indices.0 < display_start && entity.kind == EntityKind::Mention {
+               reply_mentions_stripped = true;
                // url is "/{screen_name}", strip the leading "/"
                let screen_name = entity.url.trim_start_matches('/');
                if !screen_name.is_empty()
@@ -350,7 +354,7 @@ impl TryFrom<&TweetData> for Tweet {
          .and_then(super::super::schema::BirdwatchPivot::to_note);
 
       // Parse content disclosure labels
-      let (paid_promotion, ai_generated) =
+      let (paid_promotion, disclosed_ai) =
          raw.content_disclosure
             .as_ref()
             .map_or((false, false), |cd| {
@@ -364,6 +368,13 @@ impl TryFrom<&TweetData> for Tweet {
                   .is_some_and(|ag| ag.has_ai_generated_media);
                (paid, ai)
             });
+      let ai_generated = disclosed_ai
+         || legacy.media_items().iter().any(|media| {
+            media
+               .grok_post_id
+               .as_deref()
+               .is_some_and(|id| !id.is_empty())
+         });
 
       // Parse edit history IDs
       let history = raw
@@ -384,6 +395,8 @@ impl TryFrom<&TweetData> for Tweet {
          photos.push(Photo {
             url:      img_url.clone(),
             alt_text: String::new(),
+            width:    0,
+            height:   0,
          });
       }
 
@@ -414,7 +427,10 @@ impl TryFrom<&TweetData> for Tweet {
       // withArticleRichContentState is true. When we have a card, strip the
       // article URL from the text (the card is clickable). Otherwise, keep it
       // as a "View article" text link fallback.
-      let has_article_card = card.is_none() && {
+      let can_replace_card = card
+         .as_ref()
+         .is_none_or(|card| matches!(card.kind, CardKind::Hidden | CardKind::Unknown));
+      let has_article_card = can_replace_card && {
          if let Some(article) = raw
             .article
             .as_ref()
@@ -495,6 +511,7 @@ impl TryFrom<&TweetData> for Tweet {
       });
 
       let lang = legacy.lang.as_deref().unwrap_or_default().to_owned();
+      let sensitive = legacy.possibly_sensitive.unwrap_or(false);
 
       Ok(Self {
          id,
@@ -504,12 +521,13 @@ impl TryFrom<&TweetData> for Tweet {
          text: text.clone(),
          time,
          reply,
+         reply_mentions_stripped,
          pinned: false,
          has_thread,
          available: !is_withheld,
          tombstone: if is_withheld { text } else { String::new() },
          location,
-         source: String::new(),
+         source: raw.source.clone().unwrap_or_default(),
          stats,
          retweet,
          attribution: media_attribution,
@@ -519,8 +537,10 @@ impl TryFrom<&TweetData> for Tweet {
          poll,
          gif,
          video,
+         additional_videos,
          photos,
          note,
+         sensitive,
          paid_promotion,
          ai_generated,
          history,
diff --git a/src/api/schema.rs b/src/api/schema.rs
index 19e7159..c8ca5f1 100644
--- a/src/api/schema.rs
+++ b/src/api/schema.rs
@@ -7,7 +7,10 @@ use serde::{
    Deserialize,
    Deserializer,
    Serialize,
-   de::IgnoredAny,
+   de::{
+      Error as _,
+      IgnoredAny,
+   },
 };
 
 use crate::utils::formatters::parse_twitter_time;
@@ -327,12 +330,20 @@ pub struct MediaItem {
    #[serde(rename = "type")]
    pub media_type:             Option<MediaType>,
    pub media_url_https:        Option<String>,
+   pub original_info:          Option<MediaOriginalInfo>,
    pub url:                    Option<String>,
    pub expanded_url:           Option<String>,
    pub video_info:             Option<VideoInfo>,
    pub ext_media_availability: Option<MediaAvailability>,
    pub additional_media_info:  Option<AdditionalMediaInfo>,
    pub ext_alt_text:           Option<String>,
+   pub grok_post_id:           Option<String>,
+}
+
+#[derive(Deserialize, Default)]
+pub struct MediaOriginalInfo {
+   pub width:  i32,
+   pub height: i32,
 }
 
 #[derive(Deserialize, Default)]
@@ -489,6 +500,7 @@ pub struct TweetData {
    pub article:                 Option<ArticleWrapper>,
    pub content_disclosure:      Option<ContentDisclosure>,
    pub is_translatable:         Option<bool>,
+   pub source:                  Option<String>,
 }
 
 #[derive(Deserialize, Default)]
@@ -515,6 +527,7 @@ pub struct TweetLegacy {
    pub is_quote_status:           Option<bool>,
    pub created_at_ms:             Option<i64>,
    pub lang:                      Option<String>,
+   pub possibly_sensitive:        Option<bool>,
    pub entities:                  Option<Entities>,
    pub extended_entities:         Option<ExtendedEntities>,
 }
@@ -1000,6 +1013,82 @@ pub struct GqlResponse<T> {
    pub data: T,
 }
 
+// ── X Spaces ──
+
+#[derive(Deserialize, Default)]
+#[serde(default)]
+pub struct AudioSpaceData {
+   #[serde(rename = "audioSpace")]
+   pub audio_space: Option<AudioSpace>,
+}
+
+#[derive(Deserialize, Default)]
+#[serde(default)]
+pub struct AudioSpace {
+   pub metadata: Option<AudioSpaceMetadata>,
+}
+
+#[derive(Deserialize, Default)]
+#[serde(default)]
+pub struct AudioSpaceMetadata {
+   pub rest_id:                       Option<String>,
+   pub state:                         Option<String>,
+   pub title:                         Option<String>,
+   #[serde(default, deserialize_with = "deser_optional_i64")]
+   pub scheduled_start:               Option<i64>,
+   #[serde(default, deserialize_with = "deser_optional_i64")]
+   pub started_at:                    Option<i64>,
+   #[serde(default, deserialize_with = "deser_optional_i64")]
+   pub ended_at:                      Option<i64>,
+   pub is_space_available_for_replay: Option<bool>,
+   #[serde(default, deserialize_with = "deser_optional_i64")]
+   pub total_live_listeners:          Option<i64>,
+   #[serde(default, deserialize_with = "deser_optional_i64")]
+   pub total_replay_watched:          Option<i64>,
+   pub creator_results:               Option<NestedResult<UserData>>,
+}
+
+// ── Live broadcasts ──
+
+#[derive(Deserialize, Default)]
+#[serde(default)]
+pub struct BroadcastsData {
+   pub broadcasts: HashMap<String, BroadcastMetadata>,
+}
+
+#[derive(Deserialize, Default)]
+#[serde(default)]
+pub struct BroadcastMetadata {
+   pub status:               String,
+   pub image_url:            String,
+   pub state:                String,
+   pub user_display_name:    String,
+   pub twitter_username:     String,
+   pub available_for_replay: bool,
+   #[serde(default, deserialize_with = "deser_optional_i64")]
+   pub total_watching:       Option<i64>,
+   #[serde(default, deserialize_with = "deser_optional_i64")]
+   pub total_watched:        Option<i64>,
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum I64OrString {
+   I64(i64),
+   String(String),
+}
+
+fn deser_optional_i64<'de, D: Deserializer<'de>>(de: D) -> result::Result<Option<i64>, D::Error> {
+   Option::<I64OrString>::deserialize(de)?
+      .map(|value| {
+         match value {
+            I64OrString::I64(value) => Ok(value),
+            I64OrString::String(value) => value.parse().map_err(D::Error::custom),
+         }
+      })
+      .transpose()
+}
+
 /// `{timeline: {instructions: [...]}}` — shared by all timeline-shaped
 /// endpoints.
 #[derive(Deserialize, Default)]
diff --git a/src/config.rs b/src/config.rs
index 9289570..e4b6c75 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -14,8 +14,8 @@ use crate::error::{
 #[derive(Debug, Clone, Copy, Default, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 pub enum GifTranscodingMode {
-   #[default]
    Off,
+   #[default]
    Local,
    External,
 }
@@ -35,7 +35,7 @@ pub struct GifTranscodingConfig {
 impl Default for GifTranscodingConfig {
    fn default() -> Self {
       Self {
-         mode:            GifTranscodingMode::Off,
+         mode:            GifTranscodingMode::Local,
          cache_dir:       default_gif_cache_dir(),
          cache_max_mb:    default_gif_cache_max_mb(),
          external_domain: String::new(),
diff --git a/src/routes/embed.rs b/src/routes/embed.rs
index f03a331..b66625f 100644
--- a/src/routes/embed.rs
+++ b/src/routes/embed.rs
@@ -22,10 +22,15 @@ use serde::Deserialize;
 
 use crate::{
    AppState,
+   cache::{
+      keys as cache_keys,
+      ttl,
+   },
    error::{
       Error,
       Result,
    },
+   types::Conversation,
    utils::formatters::format_relative_time,
    views::{
       embed as embed_view,
@@ -35,9 +40,10 @@ use crate::{
 
 #[derive(Debug, Deserialize)]
 pub struct OEmbedQuery {
-   pub text:   Option<String>,
-   pub author: Option<String>,
-   pub status: Option<String>,
+   pub text:     Option<String>,
+   pub author:   Option<String>,
+   pub status:   Option<String>,
+   pub provider: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
@@ -60,6 +66,9 @@ pub fn router() -> Router<AppState> {
         .route("/embed/Tweet.html", get(legacy_embed_redirect))
         // ActivityPub endpoint for Discord multi-image support
         .route("/users/{username}/statuses/{id}", get(activity_pub_status))
+        // Discord turns the Mastodon-looking discovery URL above into this
+        // API request; the discovery URL itself is not the JSON endpoint.
+        .route("/api/v1/statuses/{id}", get(mastodon_status))
         // oEmbed endpoints
         .route("/owoembed", get(oembed))
         .route("/oembed", get(oembed_standard))
@@ -78,20 +87,21 @@ async fn legacy_embed_redirect(Query(query): Query<LegacyEmbedQuery>) -> Respons
 async fn tweet_embed(
    State(state): State<AppState>,
    Path((_username, id)): Path<(String, String)>,
+   headers: HeaderMap,
 ) -> Result<Response> {
-   // Fetch tweet from API
-   let mut tweet = state.api.get_tweet(&id).await?;
-   state.api.resolve_unavailable_quote(&mut tweet).await;
+   let tweet = cached_conversation(&state, &id).await?.tweet;
 
-   let markup = embed_view::render_tweet_embed(&tweet, &state.config);
+   let discord_activity = headers
+      .get(header::USER_AGENT)
+      .and_then(|value| value.to_str().ok())
+      .is_some_and(|user_agent| user_agent.contains("Discordbot"));
+   let markup = embed_view::render_tweet_embed(&tweet, &state.config, discord_activity);
    Ok(Html(markup.into_string()).into_response())
 }
 
 /// Video embed endpoint - returns HTML with video player.
 async fn video_embed(State(state): State<AppState>, Path(id): Path<String>) -> Result<Response> {
-   // Fetch tweet from API
-   let mut tweet = state.api.get_tweet(&id).await?;
-   state.api.resolve_unavailable_quote(&mut tweet).await;
+   let tweet = cached_conversation(&state, &id).await?.tweet;
 
    if !embed_view::has_playable_video(&tweet) {
       return Err(Error::NotFound("No video found".into()));
@@ -126,24 +136,79 @@ async fn activity_pub_status(
       || accept.contains("application/activity+json")
       || accept.contains("application/ld+json")
    {
-      // Fetch tweet from API
-      let mut tweet = state.api.get_tweet(&id).await?;
-      state.api.resolve_unavailable_quote(&mut tweet).await;
-
-      // Build ActivityPub JSON
-      let activity = embed_view::build_activity_pub(&tweet, &state.config);
-
-      return Ok((
-         [(header::CONTENT_TYPE, "application/json; charset=utf-8")],
-         Json(activity),
-      )
-         .into_response());
+      return activity_response(&state, &id).await;
    }
 
    // Otherwise redirect to normal status page
    Ok(Redirect::to(&format!("/{username}/status/{id}")).into_response())
 }
 
+/// Mastodon API v1 status endpoint used by Discord after discovery.
+async fn mastodon_status(
+   State(state): State<AppState>,
+   Path(id): Path<String>,
+) -> Result<Response> {
+   activity_response(&state, &id).await
+}
+
+async fn activity_response(state: &AppState, id: &str) -> Result<Response> {
+   let conversation = cached_conversation(state, id).await?;
+   let reply_id = conversation.tweet.reply_id;
+   let mut replied_to = if reply_id > 0 {
+      conversation
+         .before
+         .content
+         .iter()
+         .find(|candidate| candidate.id == reply_id)
+         .cloned()
+   } else {
+      None
+   };
+   let mut tweet = conversation.tweet;
+
+   if replied_to.is_none() && reply_id > 0 && reply_id != tweet.id {
+      replied_to = cached_conversation(state, &reply_id.to_string())
+         .await
+         .ok()
+         .map(|context| context.tweet);
+   }
+
+   if tweet.is_translatable {
+      let kagi = &state.config.config.kagi_token;
+      let token = (!kagi.is_empty()).then_some(kagi.as_str());
+      if let Ok(translation) = state.api.translate_auto(id, token).await
+         && !translation.text.is_empty()
+      {
+         tweet.translation = Some(translation);
+      }
+   }
+
+   let activity = replied_to.as_ref().map_or_else(
+      || embed_view::build_activity_pub(&tweet, &state.config),
+      |original| embed_view::build_activity_pub_with_reply(&tweet, Some(original), &state.config),
+   );
+   Ok((
+      [(header::CONTENT_TYPE, "application/json; charset=utf-8")],
+      Json(activity),
+   )
+      .into_response())
+}
+
+async fn cached_conversation(state: &AppState, id: &str) -> Result<Conversation> {
+   let cache_key = cache_keys::conversation(id);
+   if let Some(cached) = state.cache.get::<Conversation>(&cache_key) {
+      return Ok(cached);
+   }
+
+   let mut conversation = state.api.get_conversation(id, None, "Relevance").await?;
+   state
+      .api
+      .resolve_unavailable_quote(&mut conversation.tweet)
+      .await;
+   state.cache.set(&cache_key, &conversation, ttl::DEFAULT);
+   Ok(conversation)
+}
+
 /// oEmbed JSON endpoint for engagement metrics in Discord embed footers.
 async fn oembed(
    State(state): State<AppState>,
@@ -164,17 +229,20 @@ async fn oembed(
    let text = query.text.unwrap_or_default();
    let author = query.author.unwrap_or_default();
    let status = query.status.unwrap_or_default();
+   let provider = query.provider.filter(|value| !value.is_empty());
 
    let author_url = format!("https://x.com/{author}/status/{status}");
 
    let oembed = OEmbedData {
-      author_name: text,
-      author_url,
-      provider_name: state.config.server.title.clone(),
-      provider_url: state.config.url_prefix().to_owned(),
-      title: "Embed",
-      kind: "rich",
-      version: "1.0",
+      author_name:   text,
+      author_url:    author_url.clone(),
+      provider_name: provider
+         .clone()
+         .unwrap_or_else(|| state.config.server.title.clone()),
+      provider_url:  provider.map_or_else(|| state.config.url_prefix().to_owned(), |_| author_url),
+      title:         "Embed",
+      kind:          "rich",
+      version:       "1.0",
    };
 
    Ok((
diff --git a/src/routes/media.rs b/src/routes/media.rs
index 8fdfb29..3a1c906 100644
--- a/src/routes/media.rs
+++ b/src/routes/media.rs
@@ -316,9 +316,8 @@ fn validate_media_url(url: &str, kind: MediaKind) -> Result<()> {
       .host()
       .ok_or_else(|| Error::InvalidUrl("media URL is missing host".into()))?
       .to_ascii_lowercase();
-
    let allowed = match kind {
-      MediaKind::Image => is_twimg_host(&host),
+      MediaKind::Image => is_twimg_host(&host) || is_pscp_image_host(&host),
       MediaKind::Video => host == "video.twimg.com",
    };
    if allowed {
@@ -332,6 +331,10 @@ fn is_twimg_host(host: &str) -> bool {
    host == "twimg.com" || host.ends_with(".twimg.com")
 }
 
+fn is_pscp_image_host(host: &str) -> bool {
+   host == "video.pscp.tv" || host.ends_with(".video.pscp.tv")
+}
+
 fn ensure_content_length_under(headers: &HeaderMap, max_bytes: u64) -> Result<()> {
    let Some(value) = headers.get(header::CONTENT_LENGTH) else {
       return Ok(());
@@ -348,3 +351,26 @@ fn ensure_content_length_under(headers: &HeaderMap, max_bytes: u64) -> Result<()
    }
    Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+
+   #[test]
+   fn broadcast_thumbnail_hosts_are_allowed() {
+      assert!(
+         validate_media_url(
+            "https://prod-fastly-us-east-1.video.pscp.tv/Transcoding/v1/live_thumbnail/latest.jpg",
+            MediaKind::Image,
+         )
+         .is_ok()
+      );
+      assert!(
+         validate_media_url(
+            "https://prod-fastly-us-east-1.video.pscp.tv.evil.example/latest.jpg",
+            MediaKind::Image,
+         )
+         .is_err()
+      );
+   }
+}
diff --git a/src/routes/status.rs b/src/routes/status.rs
index a8dbdb0..246adb6 100644
--- a/src/routes/status.rs
+++ b/src/routes/status.rs
@@ -5,7 +5,11 @@ use axum::{
       Query,
       State,
    },
-   http::StatusCode,
+   http::{
+      HeaderMap,
+      StatusCode,
+      header,
+   },
    response::{
       Html,
       IntoResponse as _,
@@ -127,11 +131,16 @@ async fn status_media_redirect(Path((username, id)): Path<(String, String)>) ->
 async fn status(
    State(state): State<AppState>,
    jar: CookieJar,
+   headers: HeaderMap,
    Path((username, id)): Path<(String, String)>,
    Query(query): Query<StatusQuery>,
 ) -> Result<Response> {
    // Extract prefs from cookies
    let prefs = Prefs::from_cookies(&jar, &state.config);
+   let discord_activity = headers
+      .get(header::USER_AGENT)
+      .and_then(|value| value.to_str().ok())
+      .is_some_and(|user_agent| user_agent.contains("Discordbot"));
 
    let sort = ranking_mode(query.sort.as_deref());
    let is_sorted = sort != "Relevance";
@@ -171,7 +180,7 @@ async fn status(
          let has_cursor = query.cursor.is_some();
 
          // Auto-translate for embeds (OG tags / ActivityPub show translated text)
-         if !is_scroll && !has_cursor && conversation.tweet.is_translatable {
+         if !discord_activity && !is_scroll && !has_cursor && conversation.tweet.is_translatable {
             let tid = conversation.tweet.id.to_string();
             let kagi = &state.config.config.kagi_token;
             let token = (!kagi.is_empty()).then_some(kagi.as_str());
@@ -224,6 +233,7 @@ async fn status(
                &prefs,
                &state.config,
                query.sort.as_deref(),
+               discord_activity,
             ));
          }
 
@@ -249,6 +259,7 @@ async fn status(
             &prefs,
             &state.config,
             query.sort.as_deref(),
+            discord_activity,
          ))
       },
       Err(Error::TweetNotFound(msg)) => {
@@ -267,6 +278,10 @@ async fn status(
 }
 
 /// Render a conversation page (first page or paginated replies).
+#[expect(
+   clippy::too_many_arguments,
+   reason = "rendering needs route identity, preferences, sorting, and scraper mode"
+)]
 fn render_conversation(
    conversation: &Conversation,
    has_cursor: bool,
@@ -275,6 +290,7 @@ fn render_conversation(
    prefs: &Prefs,
    config: &Config,
    sort: Option<&str>,
+   discord_activity: bool,
 ) -> Response {
    let tweet = &conversation.tweet;
 
@@ -422,13 +438,22 @@ fn render_conversation(
        }
    };
 
-   let markup = embed::render_status_page(tweet, &content, prefs, config, username, id);
+   let markup = embed::render_status_page(
+      tweet,
+      &content,
+      prefs,
+      config,
+      username,
+      id,
+      discord_activity,
+   );
    Html(markup.into_string()).into_response()
 }
 
 async fn status_by_id(
    State(state): State<AppState>,
    jar: CookieJar,
+   headers: HeaderMap,
    Path(id): Path<String>,
    Query(query): Query<StatusQuery>,
 ) -> Result<Response> {
@@ -442,6 +467,10 @@ async fn status_by_id(
    }
 
    let prefs = Prefs::from_cookies(&jar, &state.config);
+   let discord_activity = headers
+      .get(header::USER_AGENT)
+      .and_then(|value| value.to_str().ok())
+      .is_some_and(|user_agent| user_agent.contains("Discordbot"));
    let sort = ranking_mode(query.sort.as_deref());
 
    // Fetch conversation directly — render the tweet page inline instead of
@@ -476,7 +505,7 @@ async fn status_by_id(
    match conv_result {
       Ok(mut conversation) => {
          // Auto-translate for embeds (OG tags / ActivityPub show translated text)
-         if conversation.tweet.is_translatable {
+         if !discord_activity && conversation.tweet.is_translatable {
             let tid = conversation.tweet.id.to_string();
             let kagi = &state.config.config.kagi_token;
             let token = (!kagi.is_empty()).then_some(kagi.as_str());
@@ -496,6 +525,7 @@ async fn status_by_id(
             &prefs,
             &state.config,
             query.sort.as_deref(),
+            discord_activity,
          ))
       },
       Err(Error::TweetNotFound(msg)) => {
diff --git a/src/types/tweet.rs b/src/types/tweet.rs
index 421b0cf..c19c657 100644
--- a/src/types/tweet.rs
+++ b/src/types/tweet.rs
@@ -124,8 +124,11 @@ impl Video {
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 #[serde(default)]
 pub struct Gif {
-   pub url:   String,
-   pub thumb: String,
+   pub url:      String,
+   pub thumb:    String,
+   pub alt_text: String,
+   pub width:    i32,
+   pub height:   i32,
 }
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
@@ -133,6 +136,8 @@ pub struct Gif {
 pub struct Photo {
    pub url:      String,
    pub alt_text: String,
+   pub width:    i32,
+   pub height:   i32,
 }
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
@@ -291,45 +296,48 @@ pub struct TweetStats {
    reason = "mirrors Twitter API tweet fields"
 )]
 pub struct Tweet {
-   pub id:              i64,
-   pub thread_id:       i64,
-   pub reply_id:        i64,
-   pub user:            User,
-   pub text:            String,
+   pub id:                      i64,
+   pub thread_id:               i64,
+   pub reply_id:                i64,
+   pub user:                    User,
+   pub text:                    String,
    #[serde(with = "time::serde::timestamp::option")]
-   pub time:            Option<time::OffsetDateTime>,
-   pub reply:           Vec<String>,
-   pub pinned:          bool,
-   pub has_thread:      bool,
-   pub available:       bool,
-   pub tombstone:       String,
-   pub location:        String,
-   pub source:          String,
-   pub stats:           TweetStats,
-   pub retweet:         Option<Box<Self>>,
-   pub attribution:     Option<User>,
-   pub media_tags:      Vec<User>,
-   pub quote:           Option<Box<Self>>,
-   pub card:            Option<Card>,
-   pub poll:            Option<Poll>,
-   pub gif:             Option<Gif>,
-   pub video:           Option<Video>,
-   pub photos:          Vec<Photo>,
+   pub time:                    Option<time::OffsetDateTime>,
+   pub reply:                   Vec<String>,
+   pub reply_mentions_stripped: bool,
+   pub pinned:                  bool,
+   pub has_thread:              bool,
+   pub available:               bool,
+   pub tombstone:               String,
+   pub location:                String,
+   pub source:                  String,
+   pub stats:                   TweetStats,
+   pub retweet:                 Option<Box<Self>>,
+   pub attribution:             Option<User>,
+   pub media_tags:              Vec<User>,
+   pub quote:                   Option<Box<Self>>,
+   pub card:                    Option<Card>,
+   pub poll:                    Option<Poll>,
+   pub gif:                     Option<Gif>,
+   pub video:                   Option<Video>,
+   pub additional_videos:       Vec<Video>,
+   pub photos:                  Vec<Photo>,
    /// Community note (Birdwatch) -- structured data, rendered in views.
-   pub note:            Option<CommunityNote>,
+   pub note:                    Option<CommunityNote>,
    /// Content disclosure labels (paid promotion, AI-generated media).
-   pub paid_promotion:  bool,
-   pub ai_generated:    bool,
+   pub sensitive:               bool,
+   pub paid_promotion:          bool,
+   pub ai_generated:            bool,
    /// Edit history tweet IDs.
-   pub history:         Vec<i64>,
+   pub history:                 Vec<i64>,
    /// Text entities for expansion (mentions, hashtags, URLs).
-   pub entities:        Vec<Entity>,
+   pub entities:                Vec<Entity>,
    /// BCP-47 language code from Twitter's language detection.
-   pub lang:            String,
+   pub lang:                    String,
    /// Whether Twitter considers this tweet translatable.
-   pub is_translatable: bool,
+   pub is_translatable:         bool,
    /// Pre-fetched translation for embeds (OG tags, `ActivityPub`).
-   pub translation:     Option<Translation>,
+   pub translation:             Option<Translation>,
 }
 
 /// Translation of a tweet's text via Twitter's Strato translation API.
@@ -345,6 +353,9 @@ pub struct Translation {
 impl Tweet {
    /// Check if this tweet has any media.
    pub const fn has_media(&self) -> bool {
-      !self.photos.is_empty() || self.video.is_some() || self.gif.is_some()
+      !self.photos.is_empty()
+         || self.video.is_some()
+         || !self.additional_videos.is_empty()
+         || self.gif.is_some()
    }
 }
diff --git a/src/utils/entity_expander.rs b/src/utils/entity_expander.rs
index 238afd0..195ae41 100644
--- a/src/utils/entity_expander.rs
+++ b/src/utils/entity_expander.rs
@@ -44,6 +44,15 @@ fn char_to_byte_index(text: &str, char_idx: usize) -> Option<usize> {
 /// then reconstructs the text with HTML anchor tags. Text between entities
 /// is passed through verbatim (Twitter already HTML-escapes it).
 pub fn expand_entities(text: &str, entities: &[Entity]) -> String {
+   expand_entities_with_target(text, entities, false)
+}
+
+/// Expand entities with links pointing back to X.
+pub fn expand_entities_for_x(text: &str, entities: &[Entity]) -> String {
+   expand_entities_with_target(text, entities, true)
+}
+
+fn expand_entities_with_target(text: &str, entities: &[Entity], link_to_x: bool) -> String {
    if entities.is_empty() {
       return text.to_owned();
    }
@@ -88,34 +97,47 @@ pub fn expand_entities(text: &str, entities: &[Entity]) -> String {
       let entity_text = &text[start_byte..end_byte];
       match entity.kind {
          EntityKind::Mention => {
-            let _ = write!(
-               result,
-               r#"<a href="{}" title="{}">{}</a>"#,
-               html_escape(&entity.url),
-               html_escape(&entity.display),
-               entity_text
-            );
+            if link_to_x {
+               let username = entity_text.trim_start_matches('@');
+               let _ = write!(
+                  result,
+                  r#"<a href="https://x.com/{}">{}</a>"#,
+                  url_encode(username),
+                  entity_text,
+               );
+            } else {
+               let _ = write!(
+                  result,
+                  r#"<a href="{}" title="{}">{}</a>"#,
+                  html_escape(&entity.url),
+                  html_escape(&entity.display),
+                  entity_text
+               );
+            }
          },
          EntityKind::Hashtag => {
             let tag_name = entity_text.trim_start_matches('#').trim_start_matches('$');
-            let _ = write!(
-               result,
-               r#"<a href="/search?q=%23{}">{}</a>"#,
-               url_encode(tag_name),
-               entity_text
-            );
+            let href = if link_to_x {
+               format!("https://x.com/hashtag/{}", url_encode(tag_name))
+            } else {
+               format!("/search?q=%23{}", url_encode(tag_name))
+            };
+            let _ = write!(result, r#"<a href="{href}">{entity_text}</a>"#);
          },
          EntityKind::Symbol => {
             let symbol_name = entity_text.trim_start_matches('$');
+            let root = if link_to_x { "https://x.com" } else { "" };
             let _ = write!(
                result,
-               r#"<a href="/search?q=%24{}">{}</a>"#,
+               r#"<a href="{root}/search?q=%24{}">{}</a>"#,
                url_encode(symbol_name),
-               entity_text
+               entity_text,
             );
          },
          EntityKind::Url => {
-            let display = if entity.display.is_empty() {
+            let display = if link_to_x {
+               short_url(&entity.url, 0)
+            } else if entity.display.is_empty() {
                short_url(&entity.url, 28)
             } else {
                entity.display.clone()
@@ -233,6 +255,41 @@ mod tests {
       assert!(result.contains(r#"href="/search?q=%23rust""#));
    }
 
+   #[test]
+   fn activity_entities_link_to_x() {
+      let entities = vec![
+         Entity {
+            indices: (0, 5),
+            kind: EntityKind::Mention,
+            url: "/test".to_owned(),
+            ..Default::default()
+         },
+         Entity {
+            indices: (6, 11),
+            kind: EntityKind::Hashtag,
+            ..Default::default()
+         },
+      ];
+      let result = expand_entities_for_x("@test #rust", &entities);
+
+      assert!(result.contains(r#"href="https://x.com/test""#));
+      assert!(result.contains(r#"href="https://x.com/hashtag/rust""#));
+   }
+
+   #[test]
+   fn activity_urls_use_full_expanded_url() {
+      let entities = vec![Entity {
+         indices: (0, 16),
+         kind: EntityKind::Url,
+         url: "https://example.com/a/long/path?with=query&and=more".to_owned(),
+         ..Default::default()
+      }];
+      let result = expand_entities_for_x("https://t.co/xyz", &entities);
+
+      assert!(result.contains("example.com/a/long/path?with=query&amp;and=more"));
+      assert!(!result.contains('…'));
+   }
+
    #[test]
    fn test_expand_url() {
       let entities = vec![Entity {
diff --git a/src/utils/formatters.rs b/src/utils/formatters.rs
index 8ac2cdc..027612f 100644
--- a/src/utils/formatters.rs
+++ b/src/utils/formatters.rs
@@ -247,7 +247,7 @@ pub fn format_with_commas(num: i64) -> String {
    result
 }
 
-/// Abbreviate a number: 1234 → "1.2K", 1234567 → "1.23M".
+/// Abbreviate a number using `FxTwitter`'s fixed precision.
 #[expect(
    clippy::cast_precision_loss,
    reason = "display-only, precision loss is fine"
@@ -256,14 +256,8 @@ pub fn abbreviate_number(num: i64) -> String {
    let abs = num.unsigned_abs() as f64;
    if abs >= 1_000_000.0 {
       format!("{:.2}M", abs / 1_000_000.0)
-         .trim_end_matches('0')
-         .trim_end_matches('.')
-         .to_owned()
    } else if abs >= 1_000.0 {
       format!("{:.1}K", abs / 1_000.0)
-         .trim_end_matches('0')
-         .trim_end_matches('.')
-         .to_owned()
    } else {
       num.to_string()
    }
@@ -377,7 +371,7 @@ pub fn format_join_date(time: time::OffsetDateTime) -> String {
 pub const fn scale_dimensions_for_embed(width: i32, height: i32) -> (i32, i32) {
    if width > 1920 || height > 1920 {
       (width / 2, height / 2)
-   } else if width < 400 && height < 400 {
+   } else if width < 400 || height < 400 {
       (width * 2, height * 2)
    } else {
       (width, height)
@@ -479,4 +473,16 @@ mod tests {
       let dt = parse_twitter_time("Tue Jun 02 20:12:29 +0000 2009").unwrap();
       assert_eq!(format_join_date(dt), "Joined June 2009");
    }
+
+   #[test]
+   fn abbreviate_number_keeps_fxtwitter_precision() {
+      assert_eq!(abbreviate_number(496_000), "496.0K");
+      assert_eq!(abbreviate_number(1_000_000), "1.00M");
+   }
+
+   #[test]
+   fn narrow_video_dimensions_match_fxtwitter_scaling() {
+      assert_eq!(scale_dimensions_for_embed(320, 480), (640, 960));
+      assert_eq!(scale_dimensions_for_embed(3840, 2160), (1920, 1080));
+   }
 }
diff --git a/src/views/embed.rs b/src/views/embed.rs
index ba9d7b0..e206263 100644
--- a/src/views/embed.rs
+++ b/src/views/embed.rs
@@ -10,6 +10,7 @@ use time::format_description::well_known::Rfc3339;
 
 use super::{
    layout::strip_html,
+   renderutils::community_note_to_html,
    tweet::TweetRenderer,
 };
 use crate::{
@@ -18,23 +19,27 @@ use crate::{
       GifTranscodingMode,
    },
    types::{
+      CardKind,
       Gif,
+      Photo,
       Prefs,
       Tweet,
       Video,
    },
-   utils::formatters,
+   utils::{
+      entity_expander::{
+         expand_entities_for_x,
+         html_escape,
+      },
+      formatters,
+   },
 };
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
 /// Compute aspect ratio from integer dimensions.
-#[expect(
-   clippy::cast_precision_loss,
-   reason = "video dimensions are small enough for f32"
-)]
-fn aspect_ratio(width: i32, height: i32) -> f32 {
-   width as f32 / height as f32
+fn aspect_ratio(width: i32, height: i32) -> f64 {
+   f64::from(width) / f64::from(height)
 }
 
 // ── OG/embed media helpers (extracted from Tweet methods) ──────────────
@@ -86,6 +91,18 @@ pub fn og_images_with_quote(tweet: &Tweet) -> Vec<&str> {
       .map_or_else(Vec::new, og_images)
 }
 
+fn photos_with_quote(tweet: &Tweet) -> &[Photo] {
+   if !tweet.photos.is_empty() {
+      &tweet.photos
+   } else if !tweet.has_media()
+      && let Some(quote) = tweet.quote.as_deref()
+   {
+      &quote.photos
+   } else {
+      &[]
+   }
+}
+
 /// Get the video source tweet and media, falling back to quote tweet.
 fn video_source_with_quote(tweet: &Tweet) -> Option<(&Tweet, &Video)> {
    with_quote_media_source(tweet, |tw| tw.video.as_ref())
@@ -197,10 +214,47 @@ pub fn build_embed_description(tweet: &Tweet) -> String {
    desc
 }
 
+fn text_without_urls(text: &str) -> String {
+   strip_html(text)
+      .replace("&amp;", "&")
+      .replace("&quot;", "\"")
+      .replace("&#39;", "'")
+      .replace("&apos;", "'")
+      .replace("&lt;", "<")
+      .replace("&gt;", ">")
+      .split_whitespace()
+      .filter(|part| !part.starts_with("http://") && !part.starts_with("https://"))
+      .collect::<Vec<_>>()
+      .join(" ")
+}
+
+fn broadcast_title_repeats_tweet(tweet: &Tweet, title: &str) -> bool {
+   let tweet_text = text_without_urls(&tweet.text);
+   !tweet_text.is_empty() && tweet_text.eq_ignore_ascii_case(title.trim())
+}
+
+fn build_discord_embed_description(tweet: &Tweet) -> String {
+   let mut description = build_embed_description(tweet);
+   let Some(card) = tweet.card.as_ref().filter(|card| {
+      matches!(card.kind, CardKind::Broadcast | CardKind::Periscope) && !card.title.is_empty()
+   }) else {
+      return description;
+   };
+
+   if !broadcast_title_repeats_tweet(tweet, &card.title)
+      && !description.trim().ends_with(card.title.trim())
+   {
+      let _ = write!(description, "\n\n📺 {}", card.title);
+   }
+
+   description
+}
+
 /// Render OG image, twitter:image, and video/gif meta tags for a tweet.
 /// Shared between `render_tweet_embed` and `render_status_page`.
 fn render_media_meta_tags(tweet: &Tweet, config: &Config, url_prefix: &str) -> Markup {
    let images = og_images_with_quote(tweet);
+   let photos = photos_with_quote(tweet);
    let video_source = video_source_with_quote(tweet);
    let has_video = video_source.is_some();
    // GIF tweets provide their own og:image (the transcoded .gif URL)
@@ -223,6 +277,12 @@ fn render_media_meta_tags(tweet: &Tweet, config: &Config, url_prefix: &str) -> M
                @let pic_url = formatters::get_pic_url(image, config.config.base64_media);
                @let full_pic_url = format!("{url_prefix}{pic_url}");
                meta property="og:image" content=(full_pic_url);
+               @if let Some(photo) = photos.iter().find(|photo| photo.url == *image) {
+                   @if photo.width > 0 && photo.height > 0 {
+                       meta property="og:image:width" content=(photo.width);
+                       meta property="og:image:height" content=(photo.height);
+                   }
+               }
            }
        }
 
@@ -232,7 +292,13 @@ fn render_media_meta_tags(tweet: &Tweet, config: &Config, url_prefix: &str) -> M
            @for image in &images {
                @let pic_url = formatters::get_pic_url(image, config.config.base64_media);
                @let full_pic_url = format!("{url_prefix}{pic_url}");
-               meta property="twitter:image:src" content=(full_pic_url);
+               meta property="twitter:image" content=(full_pic_url);
+               @if let Some(photo) = photos.iter().find(|photo| photo.url == *image) {
+                   @if photo.width > 0 && photo.height > 0 {
+                       meta property="twitter:image:width" content=(photo.width);
+                       meta property="twitter:image:height" content=(photo.height);
+                   }
+               }
            }
        }
 
@@ -291,20 +357,96 @@ fn render_media_meta_tags(tweet: &Tweet, config: &Config, url_prefix: &str) -> M
    }
 }
 
+/// Discord normally gets tweet media from `/api/v1/statuses/{id}`. Broadcasts
+/// keep an OG fallback because Discord sometimes skips that second request.
+fn render_discord_activity_meta_tags(tweet: &Tweet, config: &Config, url_prefix: &str) -> Markup {
+   let has_video = video_source_with_quote(tweet).is_some();
+   let has_gif = gif_source_with_quote(tweet).is_some();
+   let has_photo = !tweet.photos.is_empty()
+      || (!tweet.has_media()
+         && tweet
+            .quote
+            .as_deref()
+            .is_some_and(|quote| !quote.photos.is_empty()));
+   let broadcast_image = tweet.card.as_ref().and_then(|card| {
+      (matches!(card.kind, CardKind::Broadcast | CardKind::Periscope) && !card.image.is_empty())
+         .then_some(card.image.as_str())
+   });
+   let has_activity_media = has_video || has_gif || has_photo || broadcast_image.is_some();
+
+   html! {
+       @if let Some(image) = broadcast_image {
+           @let image_path = formatters::get_pic_url(image, config.config.base64_media);
+           @let image_url = format!("{url_prefix}{image_path}");
+           meta property="og:image" content=(image_url);
+           meta property="og:image:width" content="1920";
+           meta property="og:image:height" content="1080";
+           meta property="twitter:image" content=(image_url);
+           meta property="twitter:image:width" content="1920";
+           meta property="twitter:image:height" content="1080";
+       } @else if !has_activity_media {
+           @let avatar_path = formatters::get_pic_url(
+               &tweet.user.user_pic,
+               config.config.base64_media,
+           );
+           @let avatar_url = format!("{url_prefix}{avatar_path}");
+           meta property="og:image" content=(avatar_url);
+           meta property="twitter:image" content="0";
+       }
+
+       @if has_video {
+           meta property="twitter:card" content="player";
+       } @else if has_gif || has_photo || broadcast_image.is_some() {
+           meta property="twitter:card" content="summary_large_image";
+       } @else {
+           meta property="twitter:card" content="summary";
+       }
+   }
+}
+
+fn content_disclosure_label(tweet: &Tweet, config: &Config) -> Option<String> {
+   let mut labels = Vec::new();
+   if tweet.paid_promotion {
+      labels.push(format!("{} Paid partnership", config.config.paid_emoji));
+   }
+   if tweet.ai_generated {
+      labels.push(format!("{} Made with AI", config.config.ai_emoji));
+   }
+   (!labels.is_empty()).then(|| labels.join(" · "))
+}
+
+fn embed_provider_name(tweet: &Tweet, config: &Config) -> String {
+   content_disclosure_label(tweet, config).map_or_else(
+      || config.server.title.clone(),
+      |label| format!("{} · {label}", config.server.title),
+   )
+}
+
 /// Build the oEmbed URL for a tweet's engagement metrics.
-fn build_oembed_url(tweet: &Tweet, url_prefix: &str) -> String {
+fn build_oembed_url(tweet: &Tweet, config: &Config) -> String {
    let engagement_text = formatters::format_engagement_text(
       tweet.stats.likes,
       tweet.stats.retweets,
       tweet.stats.replies,
       tweet.stats.views,
    );
-   format!(
-      "{url_prefix}/owoembed?text={}&author={}&status={}",
+   let mut url = format!(
+      "{}/owoembed?text={}&author={}&status={}",
+      config.url_prefix(),
       formatters::url_encode(&engagement_text),
       formatters::url_encode(&tweet.user.username),
       tweet.id,
-   )
+   );
+   let provider = content_disclosure_label(tweet, config)
+      .map(|_| embed_provider_name(tweet, config))
+      .or_else(|| {
+         (video_source_with_quote(tweet).is_some() && !engagement_text.is_empty())
+            .then(|| engagement_text.clone())
+      });
+   if let Some(provider) = provider {
+      let _ = write!(url, "&provider={}", formatters::url_encode(&provider));
+   }
+   url
 }
 
 /// Render a tweet embed with proper OG meta tags for Discord.
@@ -312,9 +454,14 @@ fn build_oembed_url(tweet: &Tweet, url_prefix: &str) -> String {
    clippy::module_name_repetitions,
    reason = "public API name is clear and conventional"
 )]
-pub fn render_tweet_embed(tweet: &Tweet, config: &Config) -> Markup {
+pub fn render_tweet_embed(tweet: &Tweet, config: &Config, discord_activity: bool) -> Markup {
    let url_prefix = config.url_prefix();
-   let oembed_url = build_oembed_url(tweet, url_prefix);
+   let oembed_url = build_oembed_url(tweet, config);
+   let description = if discord_activity {
+      build_discord_embed_description(tweet)
+   } else {
+      build_embed_description(tweet)
+   };
 
    html! {
        (DOCTYPE)
@@ -323,16 +470,22 @@ pub fn render_tweet_embed(tweet: &Tweet, config: &Config) -> Markup {
                meta charset="utf-8";
                meta name="viewport" content="width=device-width, initial-scale=1.0";
 
-               meta property="og:site_name" content="teapot";
+               meta property="og:site_name" content=(embed_provider_name(tweet, config));
                meta property="og:title" content=(format!("@{}", tweet.user.username));
-               meta property="og:description" content=(build_embed_description(tweet));
+               meta property="og:description" content=(description);
 
-               (render_media_meta_tags(tweet, config, url_prefix))
+               @if discord_activity {
+                   meta property="theme-color" content="#005ace";
+                   (render_discord_activity_meta_tags(tweet, config, url_prefix))
+               } @else {
+                   (render_media_meta_tags(tweet, config, url_prefix))
+               }
 
-               // ActivityPub discovery link for Discord multi-image
-               link rel="alternate"
-                   href=(format!("{url_prefix}/users/{}/statuses/{}", tweet.user.username, tweet.id))
-                   type="application/activity+json";
+               @if discord_activity {
+                   link rel="alternate"
+                       href=(format!("{url_prefix}/users/{}/statuses/{}", tweet.user.username, tweet.id))
+                       type="application/activity+json";
+               }
 
                // oEmbed link for engagement metrics in embed footer
                link rel="alternate"
@@ -429,37 +582,101 @@ pub fn render_video_embed(tweet: &Tweet, config: &Config) -> Markup {
 /// for rich text rendering (blockquotes for quoted tweets).
 #[derive(Debug, Serialize)]
 pub struct ActivityPubNote {
-   pub id:                String,
-   pub url:               String,
-   pub uri:               String,
-   pub created_at:        String,
-   pub content:           String,
-   pub visibility:        String,
-   pub media_attachments: Vec<MediaAttachment>,
-   pub account:           MastodonAccount,
-   pub emojis:            Vec<()>,
+   pub id:                     String,
+   pub url:                    String,
+   pub uri:                    String,
+   pub created_at:             String,
+   pub edited_at:              Option<String>,
+   pub reblog:                 Option<()>,
+   pub in_reply_to_id:         Option<String>,
+   pub in_reply_to_account_id: Option<String>,
+   pub language:               String,
+   pub content:                String,
+   pub spoiler_text:           String,
+   pub sensitive:              bool,
+   pub visibility:             String,
+   pub application:            MastodonApplication,
+   pub media_attachments:      Vec<MediaAttachment>,
+   pub account:                MastodonAccount,
+   pub mentions:               Vec<()>,
+   pub tags:                   Vec<()>,
+   pub emojis:                 Vec<()>,
+   pub card:                   Option<MastodonPreviewCard>,
+   pub poll:                   Option<()>,
 }
 
 #[derive(Debug, Serialize)]
+pub struct MastodonPreviewCard {
+   pub url:           String,
+   pub title:         String,
+   pub description:   String,
+   #[serde(rename = "type")]
+   pub type_:         String,
+   pub authors:       Vec<()>,
+   pub author_name:   String,
+   pub author_url:    String,
+   pub provider_name: String,
+   pub provider_url:  String,
+   pub html:          String,
+   pub width:         i32,
+   pub height:        i32,
+   pub image:         Option<String>,
+   pub embed_url:     String,
+   pub blurhash:      Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct MastodonApplication {
+   pub name:    String,
+   pub website: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[expect(
+   clippy::struct_excessive_bools,
+   reason = "mirrors the Mastodon API account schema Discord expects"
+)]
 pub struct MastodonAccount {
-   pub id:           String,
-   pub display_name: String,
-   pub username:     String,
-   pub acct:         String,
-   pub url:          String,
-   pub avatar:       String,
+   pub id:               String,
+   pub display_name:     String,
+   pub username:         String,
+   pub acct:             String,
+   pub url:              String,
+   pub uri:              String,
+   pub created_at:       String,
+   pub locked:           bool,
+   pub bot:              bool,
+   pub discoverable:     bool,
+   pub indexable:        bool,
+   pub group:            bool,
+   pub avatar:           String,
+   pub avatar_static:    String,
+   #[serde(skip_serializing_if = "Option::is_none")]
+   pub header:           Option<String>,
+   #[serde(skip_serializing_if = "Option::is_none")]
+   pub header_static:    Option<String>,
+   pub followers_count:  i64,
+   pub following_count:  i64,
+   pub statuses_count:   i64,
+   pub hide_collections: bool,
+   pub noindex:          bool,
+   pub emojis:           Vec<()>,
+   pub roles:            Vec<()>,
+   pub fields:           Vec<()>,
 }
 
 #[derive(Debug, Serialize)]
 pub struct MediaAttachment {
-   pub id:          String,
+   pub id:                 String,
    #[serde(rename = "type")]
-   pub type_:       String,
-   pub url:         String,
-   pub preview_url: Option<String>,
-   pub remote_url:  Option<String>,
-   pub description: Option<String>,
-   pub meta:        Option<MediaMeta>,
+   pub type_:              String,
+   pub url:                String,
+   pub preview_url:        Option<String>,
+   pub remote_url:         Option<String>,
+   pub preview_remote_url: Option<String>,
+   pub text_url:           Option<String>,
+   pub description:        Option<String>,
+   pub meta:               Option<MediaMeta>,
 }
 
 #[derive(Debug, Serialize)]
@@ -471,8 +688,8 @@ pub struct MediaMeta {
 pub struct MediaDimensions {
    pub width:  i32,
    pub height: i32,
-   #[serde(skip_serializing_if = "Option::is_none")]
-   pub aspect: Option<f32>,
+   pub size:   String,
+   pub aspect: f64,
 }
 
 /// Create a Mastodon-compatible media attachment.
@@ -480,30 +697,111 @@ fn make_attachment(
    type_: &str,
    url: String,
    preview: Option<String>,
+   description: Option<String>,
    width: i32,
    height: i32,
 ) -> MediaAttachment {
    MediaAttachment {
-      id: "0".to_owned(),
+      id: "114163769487684704".to_owned(),
       type_: type_.to_owned(),
       url,
       preview_url: preview,
       remote_url: None,
-      description: None,
+      preview_remote_url: None,
+      text_url: None,
+      description,
       meta: Some(MediaMeta {
          original: MediaDimensions {
             width,
             height,
-            aspect: Some(aspect_ratio(width, height)),
+            size: format!("{width}x{height}"),
+            aspect: aspect_ratio(width, height),
          },
       }),
    }
 }
 
+const fn dimensions_or(width: i32, height: i32, fallback: (i32, i32)) -> (i32, i32) {
+   if width > 0 && height > 0 {
+      (width, height)
+   } else {
+      fallback
+   }
+}
+
 fn full_media_url(url_prefix: &str, path: &str) -> String {
    format!("{url_prefix}{path}")
 }
 
+fn application_name(source: &str) -> String {
+   let mut name = String::with_capacity(source.len());
+   let mut in_tag = false;
+   for character in source.chars() {
+      match character {
+         '<' => in_tag = true,
+         '>' => in_tag = false,
+         _ if !in_tag => name.push(character),
+         _ => {},
+      }
+   }
+   name
+}
+
+fn card_image_dimensions(url: &str) -> (i32, i32) {
+   url.split(['?', '&'])
+      .find_map(|part| {
+         let dimensions = part.strip_prefix("name=")?;
+         let (width, height) = dimensions.split_once('x')?;
+         Some((width.parse().ok()?, height.parse().ok()?))
+      })
+      .unwrap_or_default()
+}
+
+fn build_preview_card(
+   tweet: &Tweet,
+   config: &Config,
+   url_prefix: &str,
+) -> Option<MastodonPreviewCard> {
+   let card = tweet.card.as_ref().filter(|card| {
+      !card.url.is_empty()
+         && !matches!(card.kind, CardKind::Hidden | CardKind::Unknown)
+         && tweet.poll.is_none()
+   })?;
+   let url = if card.url.starts_with("http://") || card.url.starts_with("https://") {
+      card.url.clone()
+   } else {
+      format!("{url_prefix}{}", card.url)
+   };
+   let (width, height) = match card_image_dimensions(&card.image) {
+      (0, 0) if matches!(card.kind, CardKind::Broadcast | CardKind::Periscope) => (1920, 1080),
+      dimensions => dimensions,
+   };
+   let image = (!card.image.is_empty()).then(|| {
+      full_media_url(
+         url_prefix,
+         &formatters::get_pic_url(&card.image, config.config.base64_media),
+      )
+   });
+
+   Some(MastodonPreviewCard {
+      url: url.clone(),
+      title: card.title.clone(),
+      description: card.text.clone(),
+      type_: "link".to_owned(),
+      authors: vec![],
+      author_name: String::new(),
+      author_url: String::new(),
+      provider_name: card.dest.clone(),
+      provider_url: url,
+      html: String::new(),
+      width,
+      height,
+      image,
+      embed_url: String::new(),
+      blurhash: None,
+   })
+}
+
 /// Build media attachments for a single tweet's photos/video/gif.
 fn build_media_attachments(
    tweet: &Tweet,
@@ -512,30 +810,14 @@ fn build_media_attachments(
 ) -> Vec<MediaAttachment> {
    let mut attachments = Vec::new();
 
-   for photo in &tweet.photos {
-      attachments.push(make_attachment(
-         "image",
-         full_media_url(
-            url_prefix,
-            &formatters::get_orig_pic_url(&photo.url, config.config.base64_media),
-         ),
-         Some(full_media_url(
-            url_prefix,
-            &formatters::get_pic_url(&photo.url, config.config.base64_media),
-         )),
-         1200,
-         675,
-      ));
-      if let Some(last) = attachments.last_mut()
-         && !photo.alt_text.is_empty()
-      {
-         last.description = Some(photo.alt_text.clone());
-      }
-   }
-
-   if let Some(ref video) = tweet.video {
-      let (width, height) = video.best_dimensions();
+   if let Some(video) = tweet.video.as_ref() {
+      let (raw_width, raw_height) = video.best_dimensions();
+      let (width, height) = formatters::scale_dimensions_for_embed(raw_width, raw_height);
       if let Some(mp4_url) = video.best_mp4_url() {
+         let poster = tweet
+            .photos
+            .first()
+            .map_or(video.thumb.as_str(), |photo| photo.url.as_str());
          attachments.push(make_attachment(
             "video",
             full_media_url(
@@ -548,71 +830,486 @@ fn build_media_attachments(
             ),
             Some(full_media_url(
                url_prefix,
-               &formatters::get_pic_url(&video.thumb, config.config.base64_media),
+               &formatters::get_pic_url(poster, config.config.base64_media),
             )),
+            None,
             width,
             height,
          ));
       }
    }
 
+   for photo in &tweet.photos {
+      let (width, height) = dimensions_or(photo.width, photo.height, (1200, 675));
+      attachments.push(make_attachment(
+         "image",
+         full_media_url(
+            url_prefix,
+            &formatters::get_orig_pic_url(&photo.url, config.config.base64_media),
+         ),
+         None,
+         (!photo.alt_text.is_empty()).then(|| photo.alt_text.clone()),
+         width,
+         height,
+      ));
+   }
+
    if let Some(ref gif) = tweet.gif
       && !gif.url.is_empty()
    {
-      attachments.push(make_attachment(
-         "video",
-         full_media_url(
-            url_prefix,
-            &formatters::get_vid_url(
-               &gif.url,
-               &config.config.hmac_key,
-               config.config.base64_media,
-            ),
-         ),
-         Some(full_media_url(
-            url_prefix,
-            &formatters::get_pic_url(&gif.thumb, config.config.base64_media),
-         )),
-         480,
-         480,
-      ));
+      let (width, height) = dimensions_or(gif.width, gif.height, (480, 480));
+      let description = (!gif.alt_text.is_empty()).then(|| gif.alt_text.clone());
+      match config.gif_transcoding.mode {
+         GifTranscodingMode::Local => {
+            attachments.push(make_attachment(
+               "image",
+               full_media_url(
+                  url_prefix,
+                  &formatters::get_gif_url(
+                     &gif.url,
+                     &config.config.hmac_key,
+                     config.config.base64_media,
+                  ),
+               ),
+               None,
+               description,
+               width,
+               height,
+            ));
+         },
+         GifTranscodingMode::External => {
+            attachments.push(make_attachment(
+               "image",
+               formatters::get_external_gif_url(&gif.url, &config.gif_transcoding.external_domain),
+               None,
+               description,
+               width,
+               height,
+            ));
+         },
+         GifTranscodingMode::Off => {
+            attachments.push(make_attachment(
+               "video",
+               full_media_url(
+                  url_prefix,
+                  &formatters::get_vid_url(
+                     &gif.url,
+                     &config.config.hmac_key,
+                     config.config.base64_media,
+                  ),
+               ),
+               Some(full_media_url(
+                  url_prefix,
+                  &formatters::get_pic_url(&gif.thumb, config.config.base64_media),
+               )),
+               description,
+               width,
+               height,
+            ));
+         },
+      }
    }
 
    attachments
 }
 
-/// Build rich HTML content with quote tweet formatting.
-fn build_mastodon_content(tweet: &Tweet) -> String {
+fn append_media_overflow(content: &mut String, tweet: &Tweet, config: &Config) {
+   if tweet.additional_videos.is_empty() {
+      return;
+   }
+
+   let count = usize::from(tweet.video.is_some())
+      + tweet.additional_videos.len()
+      + tweet.photos.len()
+      + usize::from(tweet.gif.is_some());
+   let url = format!(
+      "{}/{}/status/{}",
+      config.url_prefix(),
+      tweet.user.username,
+      tweet.id
+   );
+   let _ = write!(
+      content,
+      r#"<sub>🗂️ <a href="{}">View all {count} media</a></sub><br>"#,
+      html_escape(&url)
+   );
+}
+
+fn preserve_activity_spacing(html: &str) -> String {
+   const MAX_RUN: usize = 64;
+
+   let mut output = String::with_capacity(html.len());
+   let mut spaces = 0_usize;
+   let flush_spaces = |target: &mut String, run_length: usize| {
+      if run_length == 1 {
+         target.push(' ');
+      } else if run_length > 1 {
+         for index in 0..run_length.min(MAX_RUN) {
+            if index.is_multiple_of(2) {
+               target.push_str("&nbsp;");
+            } else {
+               target.push(' ');
+            }
+         }
+         if run_length > MAX_RUN {
+            target.push(' ');
+         }
+      }
+   };
+
+   for character in html.chars() {
+      if character == ' ' {
+         spaces += 1;
+         continue;
+      }
+      flush_spaces(&mut output, spaces);
+      spaces = 0;
+      output.push(character);
+   }
+   flush_spaces(&mut output, spaces);
+   output
+}
+
+fn activity_text(tweet: &Tweet) -> String {
+   let expanded = expand_entities_for_x(tweet.text.trim(), &tweet.entities).replace('\n', "<br>︀︀");
+   preserve_activity_spacing(&expanded)
+}
+
+fn activity_text_limited(tweet: &Tweet, max_chars: usize) -> String {
+   let text = tweet.text.trim();
+   if text.chars().count() <= max_chars {
+      return activity_text(tweet);
+   }
+
+   let prefix = text.chars().take(max_chars).collect::<String>();
+   let mut cutoff = prefix
+      .rfind(char::is_whitespace)
+      .map(|byte_index| prefix[..byte_index].chars().count())
+      .filter(|&char_index| char_index >= max_chars * 3 / 4)
+      .unwrap_or(max_chars);
+
+   if let Some(entity) = tweet
+      .entities
+      .iter()
+      .find(|entity| entity.indices.0 < cutoff && entity.indices.1 > cutoff)
+   {
+      cutoff = entity.indices.0;
+   }
+
+   let truncated = text.chars().take(cutoff).collect::<String>();
+   let entities = tweet
+      .entities
+      .iter()
+      .filter(|entity| entity.indices.1 <= cutoff)
+      .cloned()
+      .collect::<Vec<_>>();
+   let expanded = expand_entities_for_x(truncated.trim_end(), &entities).replace('\n', "<br>︀︀");
+   let expanded = preserve_activity_spacing(&expanded);
+   format!("{expanded}…")
+}
+
+fn activity_text_with_reply_mentions(tweet: &Tweet) -> String {
+   let text = activity_text(tweet);
+   if !tweet.reply_mentions_stripped {
+      return text;
+   }
+   let Some(first_reply) = tweet.reply.first() else {
+      return text;
+   };
+   if tweet
+      .text
+      .trim_start()
+      .get(..=first_reply.len())
+      .is_some_and(|prefix| prefix.eq_ignore_ascii_case(&format!("@{first_reply}")))
+   {
+      return text;
+   }
+
+   let mentions = tweet
+      .reply
+      .iter()
+      .map(|username| {
+         let username = html_escape(username);
+         format!(r#"<a href="https://x.com/{username}">@{username}</a>"#)
+      })
+      .collect::<Vec<_>>()
+      .join(" ");
+   format!("{mentions} {text}")
+}
+
+fn engagement_html(tweet: &Tweet) -> String {
+   let status_id = tweet.id;
+   let mut parts = Vec::new();
+
+   if tweet.stats.replies > 0 {
+      parts.push(format!(
+         r#"<a href="https://x.com/intent/tweet?in_reply_to={status_id}">💬</a> {}"#,
+         formatters::abbreviate_number(tweet.stats.replies)
+      ));
+   }
+   if tweet.stats.retweets > 0 {
+      parts.push(format!(
+         r#"<a href="https://x.com/intent/retweet?tweet_id={status_id}">🔁</a> {}"#,
+         formatters::abbreviate_number(tweet.stats.retweets)
+      ));
+   }
+   if tweet.stats.likes > 0 {
+      parts.push(format!(
+         r#"<a href="https://x.com/intent/like?tweet_id={status_id}">❤️</a> {}"#,
+         formatters::abbreviate_number(tweet.stats.likes)
+      ));
+   }
+   if tweet.stats.views > 0 {
+      parts.push(format!(
+         "👁️ {}",
+         formatters::abbreviate_number(tweet.stats.views)
+      ));
+   }
+
+   if parts.is_empty() {
+      String::new()
+   } else {
+      format!("<b>{}&ensp;</b>", parts.join("&ensp;"))
+   }
+}
+
+fn append_poll(content: &mut String, tweet: &Tweet) {
+   let Some(poll) = tweet.poll.as_ref() else {
+      return;
+   };
+
+   let total_votes = if poll.votes > 0 {
+      poll.votes
+   } else {
+      poll.values.iter().sum()
+   };
+   content.push_str("<blockquote>");
+
+   for (option, votes) in poll.options.iter().zip(&poll.values) {
+      let percentage = if total_votes > 0 {
+         (votes.saturating_mul(100) + total_votes / 2) / total_votes
+      } else {
+         0
+      }
+      .clamp(0, 100);
+      let bar_len = usize::try_from(percentage * 32 / 100).unwrap_or_default();
+      let _ = write!(
+         content,
+         "{}<br><b>{}</b>&emsp;{percentage}%<br>︀︀︀<br>︀",
+         "█".repeat(bar_len),
+         html_escape(option),
+      );
+   }
+
+   let _ = write!(
+      content,
+      "{} votes · {}</blockquote>",
+      formatters::abbreviate_number(total_votes),
+      html_escape(&poll.status_text()),
+   );
+}
+
+fn append_quote(content: &mut String, tweet: &Tweet) {
+   let Some(quote) = tweet.quote.as_ref() else {
+      return;
+   };
+
+   let quote_url = format!("https://x.com/{}/status/{}", quote.user.username, quote.id);
+   let profile_url = format!("https://x.com/{}", quote.user.username);
+   let _ = write!(
+      content,
+      r#"<blockquote><b><a href="{quote_url}">Quoting</a> {} (<a href="{profile_url}">@{}</a>)</b><br>︀<br>{}</blockquote>"#,
+      html_escape(&quote.user.fullname),
+      html_escape(&quote.user.username),
+      activity_text(quote),
+   );
+}
+
+fn reply_context<'a>(tweet: &Tweet, replied_to: Option<&'a Tweet>) -> Option<&'a Tweet> {
+   replied_to.filter(|original| {
+      tweet.reply_id > 0 && original.id == tweet.reply_id && !original.text.trim().is_empty()
+   })
+}
+
+fn append_reply_context(content: &mut String, original: &Tweet) {
+   const MAX_CHARS: usize = 220;
+
+   let status_url = format!(
+      "https://x.com/{}/status/{}",
+      original.user.username, original.id
+   );
+   let profile_url = format!("https://x.com/{}", original.user.username);
+   let username = html_escape(&original.user.username);
+   let _ = write!(
+      content,
+      r#"<blockquote><b>↩ <a href="{status_url}">Original post</a> · <a href="{profile_url}">@{username}</a></b><br>{}</blockquote>"#,
+      activity_text_limited(original, MAX_CHARS),
+   );
+}
+
+fn append_community_note(content: &mut String, tweet: &Tweet) {
+   let Some(note) = tweet.note.as_ref() else {
+      return;
+   };
+
+   let note_html = community_note_to_html(note).replace('\n', "<br>︀︀");
+   let _ = write!(
+      content,
+      "<blockquote><b>📝 Community Note</b><br>{note_html}</blockquote>",
+   );
+}
+
+fn append_article_preview(content: &mut String, tweet: &Tweet, config: &Config) {
+   let Some(card) = tweet
+      .card
+      .as_ref()
+      .filter(|card| card.kind == CardKind::Article && !card.title.is_empty())
+   else {
+      return;
+   };
+
+   if content == "<br><br>" {
+      content.clear();
+   }
+
+   let url = if card.url.starts_with("http://") || card.url.starts_with("https://") {
+      card.url.clone()
+   } else {
+      format!("{}{}", config.url_prefix(), card.url)
+   };
+   let description = preserve_activity_spacing(&html_escape(&card.text).replace('\n', "<br>"));
+   let _ = write!(
+      content,
+      r#"<blockquote><b>📄 <a href="{}">{}</a></b>"#,
+      html_escape(&url),
+      html_escape(&card.title),
+   );
+   if !description.is_empty() {
+      let _ = write!(content, "<br>{description}");
+   }
+   content.push_str("</blockquote>");
+}
+
+fn append_audio_space_preview(content: &mut String, tweet: &Tweet) {
+   let Some(card) = tweet
+      .card
+      .as_ref()
+      .filter(|card| card.kind == CardKind::Audiospace && !card.url.is_empty())
+   else {
+      return;
+   };
+
+   if content == "<br><br>" {
+      content.clear();
+   }
+
+   let title = if card.title.is_empty() {
+      "X Space"
+   } else {
+      &card.title
+   };
+   let _ = write!(
+      content,
+      r#"<blockquote><b>🎙️ <a href="{}">{}</a></b>"#,
+      html_escape(&card.url),
+      html_escape(title),
+   );
+   if !card.text.is_empty() {
+      let _ = write!(content, "<br>{}", html_escape(&card.text));
+   }
+   if !card.dest.is_empty() {
+      let _ = write!(content, "<br>{}", html_escape(&card.dest));
+   }
+   content.push_str("</blockquote>");
+}
+
+fn append_broadcast_preview(content: &mut String, tweet: &Tweet) {
+   let Some(card) = tweet.card.as_ref().filter(|card| {
+      matches!(card.kind, CardKind::Broadcast | CardKind::Periscope) && !card.url.is_empty()
+   }) else {
+      return;
+   };
+
+   if content == "<br><br>" {
+      content.clear();
+   }
+
+   let title = if card.title.is_empty() {
+      "Live broadcast"
+   } else {
+      &card.title
+   };
+   if broadcast_title_repeats_tweet(tweet, title) {
+      content.push_str("<blockquote>📺");
+      if !card.text.is_empty() {
+         let _ = write!(content, " {}", html_escape(&card.text));
+      }
+      if !card.dest.is_empty() {
+         let _ = write!(content, "<br>{}", html_escape(&card.dest));
+      }
+      content.push_str("</blockquote>");
+      return;
+   }
+   let _ = write!(
+      content,
+      r#"<blockquote><b>📺 <a href="{}">{}</a></b>"#,
+      html_escape(&card.url),
+      html_escape(title),
+   );
+   if !card.text.is_empty() {
+      let _ = write!(content, "<br>{}", html_escape(&card.text));
+   }
+   if !card.dest.is_empty() {
+      let _ = write!(content, "<br>{}", html_escape(&card.dest));
+   }
+   content.push_str("</blockquote>");
+}
+
+/// Build rich Mastodon-status HTML for Discord's activity embed path.
+fn build_mastodon_content(tweet: &Tweet, replied_to: Option<&Tweet>, config: &Config) -> String {
+   let reply_context = reply_context(tweet, replied_to);
+   let tweet_text = if reply_context.is_some() {
+      activity_text(tweet)
+   } else {
+      activity_text_with_reply_mentions(tweet)
+   };
    let mut content = tweet.translation.as_ref().map_or_else(
-      || tweet.text.replace('\n', "<br>"),
+      || format!("{tweet_text}<br><br>"),
       |tl| {
+         let translated = html_escape(&tl.text).replace('\n', "<br>");
+         let translated = preserve_activity_spacing(&translated);
          format!(
-            "{}<br><br><i>[{}]</i><br>{}",
-            tl.text.replace('\n', "<br>"),
-            tl.source_lang_display,
-            tweet.text.replace('\n', "<br>")
+            "<b>📑 Translated from {}</b><br><br>{}<br><br><blockquote><b>Original \
+             text</b><br>{}</blockquote>",
+            html_escape(&tl.source_lang_display),
+            translated,
+            tweet_text,
          )
       },
    );
 
-   if let Some(ref quote) = tweet.quote {
-      let _ = write!(
-         content,
-         "<br><br><blockquote><b>Quoting {} (@{})</b><br>{}</blockquote>",
-         quote.user.fullname,
-         quote.user.username,
-         quote.text.replace('\n', "<br>")
+   append_article_preview(&mut content, tweet, config);
+   append_audio_space_preview(&mut content, tweet);
+   append_broadcast_preview(&mut content, tweet);
+   append_quote(&mut content, tweet);
+   if let Some(original) = reply_context {
+      append_reply_context(&mut content, original);
+   }
+   append_community_note(&mut content, tweet);
+
+   if reply_context.is_none() && !tweet.reply.is_empty() {
+      let username = html_escape(&tweet.reply[0]);
+      content = format!(
+         r#"<sub>↩ <a href="https://x.com/{username}" class="u-url mention"> (@{username})</a></sub><br>{content}"#
       );
    }
 
-   if !tweet.reply.is_empty() {
-      let replies = tweet
-         .reply
-         .iter()
-         .map(|username| format!("@{username}"))
-         .collect::<Vec<_>>()
-         .join(" ");
-      content = format!("<sub>↩ Replying to {replies}</sub><br>{content}");
+   append_poll(&mut content, tweet);
+   append_media_overflow(&mut content, tweet, config);
+
+   let engagement = engagement_html(tweet);
+   if !engagement.is_empty() {
+      content.push_str(&engagement);
    }
 
    content
@@ -620,6 +1317,15 @@ fn build_mastodon_content(tweet: &Tweet) -> String {
 
 /// Build Mastodon API v1-compatible status JSON for Discord.
 pub fn build_activity_pub(tweet: &Tweet, config: &Config) -> ActivityPubNote {
+   build_activity_pub_with_reply(tweet, None, config)
+}
+
+/// Build a Mastodon status with optional replied-to context for Discord.
+pub fn build_activity_pub_with_reply(
+   tweet: &Tweet,
+   replied_to: Option<&Tweet>,
+   config: &Config,
+) -> ActivityPubNote {
    let url_prefix = config.url_prefix();
 
    let mut attachments = build_media_attachments(tweet, config, url_prefix);
@@ -630,31 +1336,98 @@ pub fn build_activity_pub(tweet: &Tweet, config: &Config) -> ActivityPubNote {
       attachments.extend(build_media_attachments(quote, config, url_prefix));
    }
 
+   let card = build_preview_card(tweet, config, url_prefix);
+
+   // Discord ignores Mastodon's PreviewCard object, but does render media
+   // attachments.
+   if attachments.is_empty()
+      && let Some(preview_card) = card.as_ref()
+      && let Some(image) = preview_card.image.as_ref()
+   {
+      let (width, height) = dimensions_or(preview_card.width, preview_card.height, (800, 419));
+      attachments.push(make_attachment(
+         "image",
+         image.clone(),
+         None,
+         Some(preview_card.title.clone()),
+         width,
+         height,
+      ));
+   }
+
    let created_at = tweet.time.map_or_else(
       || time::OffsetDateTime::now_utc().format(&Rfc3339).unwrap(),
       |ts| ts.format(&Rfc3339).unwrap(),
    );
+   let account_created_at = tweet.user.join_date.map_or_else(
+      || time::OffsetDateTime::now_utc().format(&Rfc3339).unwrap(),
+      |ts| ts.format(&Rfc3339).unwrap(),
+   );
 
-   let status_url = format!("{url_prefix}/{}/status/{}", tweet.user.username, tweet.id);
+   let status_url = format!("https://x.com/{}/status/{}", tweet.user.username, tweet.id);
    let avatar_url = formatters::get_pic_url(&tweet.user.user_pic, config.config.base64_media);
+   let avatar_url = format!("{url_prefix}{avatar_url}");
+   let header_url = (!tweet.user.banner.is_empty()).then(|| {
+      format!(
+         "{url_prefix}{}",
+         formatters::get_pic_url(&tweet.user.banner, config.config.base64_media)
+      )
+   });
 
    ActivityPubNote {
-      id: status_url.clone(),
+      id: tweet.id.to_string(),
       url: status_url.clone(),
-      uri: status_url,
+      uri: status_url.clone(),
       created_at,
-      content: build_mastodon_content(tweet),
+      edited_at: None,
+      reblog: None,
+      in_reply_to_id: None,
+      in_reply_to_account_id: None,
+      language: if tweet.lang.is_empty() {
+         "en".to_owned()
+      } else {
+         tweet.lang.clone()
+      },
+      content: build_mastodon_content(tweet, replied_to, config),
+      spoiler_text: String::new(),
+      sensitive: tweet.sensitive,
       visibility: "public".to_owned(),
+      application: MastodonApplication {
+         name:    application_name(&tweet.source),
+         website: None,
+      },
       media_attachments: attachments,
       account: MastodonAccount {
-         id:           tweet.user.id.clone(),
-         display_name: tweet.user.fullname.clone(),
-         username:     tweet.user.username.clone(),
-         acct:         tweet.user.username.clone(),
-         url:          format!("{url_prefix}/{}", tweet.user.username),
-         avatar:       format!("{url_prefix}{avatar_url}"),
+         id:               tweet.user.id.clone(),
+         display_name:     tweet.user.fullname.clone(),
+         username:         tweet.user.username.clone(),
+         acct:             tweet.user.username.clone(),
+         url:              status_url.clone(),
+         uri:              status_url,
+         created_at:       account_created_at,
+         locked:           false,
+         bot:              false,
+         discoverable:     true,
+         indexable:        false,
+         group:            false,
+         avatar:           avatar_url.clone(),
+         avatar_static:    avatar_url,
+         header:           header_url.clone(),
+         header_static:    header_url,
+         followers_count:  tweet.user.followers,
+         following_count:  tweet.user.following,
+         statuses_count:   tweet.user.tweets,
+         hide_collections: false,
+         noindex:          false,
+         emojis:           vec![],
+         roles:            vec![],
+         fields:           vec![],
       },
+      mentions: vec![],
+      tags: vec![],
       emojis: vec![],
+      card,
+      poll: None,
    }
 }
 
@@ -668,16 +1441,21 @@ pub fn render_status_page(
    config: &Config,
    username: &str,
    id: &str,
+   discord_activity: bool,
 ) -> Markup {
    let url_prefix = config.url_prefix();
-   let oembed_url = build_oembed_url(tweet, url_prefix);
+   let oembed_url = build_oembed_url(tweet, config);
 
    let title = format!(
       "{} (@{}): \"{}\"",
       tweet.user.fullname, tweet.user.username, tweet.text
    );
    let og_title = format!("{} (@{})", tweet.user.fullname, tweet.user.username);
-   let description = build_embed_description(tweet);
+   let description = if discord_activity {
+      build_discord_embed_description(tweet)
+   } else {
+      build_embed_description(tweet)
+   };
    let canonical = format!("https://x.com/{username}/status/{id}");
    let referer = format!("/{username}/status/{id}");
 
@@ -688,28 +1466,31 @@ pub fn render_status_page(
        meta property="og:url" content=(canonical);
        meta property="twitter:site" content=(format!("@{}", tweet.user.username));
        meta property="twitter:creator" content=(format!("@{}", tweet.user.username));
-       meta property="theme-color" content="#1F1F1F";
        meta property="twitter:title" content=(og_title);
        link rel="apple-touch-icon" href=(format!("{url_prefix}{avatar_url}"));
 
        // Publish time for Discord footer timestamp
-       @if let Some(ts) = tweet.time {
+       @if !discord_activity && let Some(ts) = tweet.time {
            @let iso = ts.format(&Rfc3339).unwrap_or_default();
            meta property="article:published_time" content=(iso);
        }
 
-       // Media-specific OG/twitter tags
-       (render_media_meta_tags(tweet, config, url_prefix))
+       @if discord_activity {
+           (render_discord_activity_meta_tags(tweet, config, url_prefix))
+       } @else {
+           (render_media_meta_tags(tweet, config, url_prefix))
+       }
 
        meta property="og:title" content=(og_title);
        meta property="og:description" content=(description);
-       meta property="og:site_name" content=(config.server.title);
-       meta property="og:locale" content="en_US";
-
-       // ActivityPub discovery link
-       link rel="alternate"
-           href=(format!("{url_prefix}/users/{username}/statuses/{id}"))
-           type="application/activity+json";
+       meta property="og:site_name" content=(embed_provider_name(tweet, config));
+       @if discord_activity {
+           // Discord recognizes this as a Mastodon status, then requests
+           // `/api/v1/statuses/{id}` from the same host.
+            link rel="alternate"
+                href=(format!("{url_prefix}/users/{username}/statuses/{id}"))
+                type="application/activity+json";
+       }
 
        // oEmbed link for engagement metrics
        link rel="alternate"
@@ -726,6 +1507,7 @@ pub fn render_status_page(
       .rss(&rss_url)
       .canonical(&canonical)
       .referer(&referer)
+      .theme_color("#005ace")
       .head_extra(&head_extra)
       .custom_open_graph()
       .render()
@@ -735,6 +1517,7 @@ pub fn render_status_page(
 mod tests {
    use super::*;
    use crate::{
+      api::schema::CommunityNote,
       config::{
          AppConfig,
          CacheConfig,
@@ -743,7 +1526,9 @@ mod tests {
          ServerConfig,
       },
       types::{
+         Card,
          Photo,
+         Poll,
          User,
          VideoType,
          VideoVariant,
@@ -833,7 +1618,7 @@ mod tests {
 
    #[test]
    fn quoted_video_player_uses_quote_tweet_id() {
-      let html = render_tweet_embed(&quoted_video_tweet(), &test_config()).into_string();
+      let html = render_tweet_embed(&quoted_video_tweet(), &test_config(), false).into_string();
 
       assert!(
          html.contains(r#"name="twitter:player" content="https://teapot.test/i/videos/tweet/200""#)
@@ -863,6 +1648,7 @@ mod tests {
    fn activity_pub_quote_fallback_uses_signed_media_urls() {
       let mut tweet = quoted_video_tweet();
       tweet.reply = vec!["parent".to_owned()];
+      tweet.reply_mentions_stripped = true;
 
       let activity = build_activity_pub(&tweet, &test_config());
       let attachment = activity.media_attachments.first().unwrap();
@@ -878,7 +1664,345 @@ mod tests {
             .as_ref()
             .is_some_and(|url| url.starts_with("https://teapot.test/pic/enc/"))
       );
-      assert!(activity.content.contains("Replying to @parent"));
+      let dimensions = &attachment.meta.as_ref().unwrap().original;
+      assert_eq!((dimensions.width, dimensions.height), (720, 1280));
+      assert_eq!(dimensions.size, "720x1280");
+      assert!(activity.content.contains(
+         r#"<sub>↩ <a href="https://x.com/parent" class="u-url mention"> (@parent)</a>"#
+      ));
+      assert!(
+         activity
+            .content
+            .contains(r#"</sub><br><a href="https://x.com/parent">@parent</a> outer text"#)
+      );
+   }
+
+   #[test]
+   fn activity_reply_context_links_and_truncates_original_post() {
+      let mut reply = tweet(402, "replier", "reply text");
+      reply.reply_id = 401;
+      reply.reply = vec!["parent".to_owned()];
+      reply.reply_mentions_stripped = true;
+      let original_text = format!("{} final marker", "original context ".repeat(20));
+      let original = tweet(401, "parent", &original_text);
+
+      let activity = build_activity_pub_with_reply(&reply, Some(&original), &test_config());
+
+      let context_start = activity
+         .content
+         .find(r#"<blockquote><b>↩ <a href="https://x.com/parent/status/401">Original post</a> · <a href="https://x.com/parent">@parent</a></b><br>"#)
+         .unwrap();
+      assert!(activity.content.find("reply text").unwrap() < context_start);
+      assert!(!activity.content.contains("<sub>↩"));
+      assert!(!activity.content.contains(r#">@parent</a> reply text"#));
+      assert!(activity.content.contains("original context"));
+      assert!(activity.content.contains('…'));
+      assert!(!activity.content.contains("final marker"));
+   }
+
+   #[test]
+   fn activity_payload_preserves_intentional_space_runs() {
+      let status = tweet(403, "spaced", "How it started     How it's going");
+
+      let activity = build_activity_pub(&status, &test_config());
+
+      assert!(
+         activity
+            .content
+            .contains("How it started&nbsp; &nbsp; &nbsp;How it's going")
+      );
+   }
+
+   #[test]
+   fn activity_payload_includes_community_note_with_sources() {
+      let mut status = tweet(403, "noted", "A claim");
+      let note_text = "Germany did so in 2002. Source";
+      let source_start = note_text.find("Source").unwrap();
+      status.note = Some(CommunityNote {
+         text:  note_text.to_owned(),
+         links: vec![(
+            source_start,
+            source_start + "Source".chars().count(),
+            "https://example.com/source".to_owned(),
+         )],
+      });
+
+      let activity = build_activity_pub(&status, &test_config());
+
+      assert!(activity.content.contains(
+         r#"<blockquote><b>📝 Community Note</b><br>Germany did so in 2002. <a href="https://example.com/source">Source</a></blockquote>"#,
+      ));
+   }
+
+   #[test]
+   fn activity_payload_marks_sensitive_media() {
+      let mut status = tweet(403, "sensitive", "content warning");
+      status.sensitive = true;
+      status.photos.push(Photo {
+         url: "https://pbs.twimg.com/media/sensitive.jpg".to_owned(),
+         width: 1200,
+         height: 800,
+         ..Photo::default()
+      });
+
+      let activity = build_activity_pub(&status, &test_config());
+
+      assert!(activity.sensitive);
+      assert!(activity.spoiler_text.is_empty());
+      assert_eq!(activity.media_attachments.len(), 1);
+   }
+
+   #[test]
+   fn activity_payload_renders_article_title_and_excerpt() {
+      let mut status = tweet(404, "writer", "");
+      status.card = Some(Card {
+         kind: CardKind::Article,
+         url: "/writer/article/404".to_owned(),
+         title: "Defining Taste".to_owned(),
+         text: "Taste is the ability to make qualitative judgments.".to_owned(),
+         dest: "Article · @writer".to_owned(),
+         ..Card::default()
+      });
+
+      let activity = build_activity_pub(&status, &test_config());
+
+      assert!(activity.content.contains(
+         r#"<blockquote><b>📄 <a href="https://teapot.test/writer/article/404">Defining Taste</a></b><br>Taste is the ability to make qualitative judgments.</blockquote>"#,
+      ));
+      assert!(!activity.content.starts_with("<br>"));
+   }
+
+   #[test]
+   fn activity_payload_renders_audio_space_preview() {
+      let mut status = tweet(405, "host", "Join our Space");
+      status.card = Some(Card {
+         kind: CardKind::Audiospace,
+         url: "https://x.com/i/spaces/1AxRnnrNvyDxl".to_owned(),
+         title: "Building in public".to_owned(),
+         text: "Scheduled · Jul 16, 2026 · 8:00 AM UTC".to_owned(),
+         dest: "Hosted by Example (@host)".to_owned(),
+         ..Card::default()
+      });
+
+      let activity = build_activity_pub(&status, &test_config());
+
+      assert!(activity.content.contains(
+         r#"<blockquote><b>🎙️ <a href="https://x.com/i/spaces/1AxRnnrNvyDxl">Building in public</a></b><br>Scheduled · Jul 16, 2026 · 8:00 AM UTC<br>Hosted by Example (@host)</blockquote>"#,
+      ));
+   }
+
+   #[test]
+   fn activity_payload_renders_live_broadcast_preview() {
+      let mut status = tweet(406, "tbpn", "Going live");
+      status.card = Some(Card {
+         kind: CardKind::Broadcast,
+         url: "https://x.com/i/broadcasts/1XxyggAaLzvGM".to_owned(),
+         title: "Stripe x PayPal".to_owned(),
+         text: "Live now · 26 watching".to_owned(),
+         dest: "Hosted by TBPN (@tbpn)".to_owned(),
+         image: "https://video.pscp.tv/latest.jpg".to_owned(),
+         ..Card::default()
+      });
+
+      let activity = build_activity_pub(&status, &test_config());
+      let html = render_status_page(
+         &status,
+         &html! {},
+         &Prefs::default(),
+         &test_config(),
+         "tbpn",
+         "406",
+         true,
+      )
+      .into_string();
+      let image_url = format!(
+         "https://teapot.test{}",
+         formatters::get_pic_url("https://video.pscp.tv/latest.jpg", true)
+      );
+
+      assert!(activity.content.contains("📺"));
+      assert!(activity.content.contains("Stripe x PayPal"));
+      assert!(activity.content.contains("Live now · 26 watching"));
+      assert!(activity.content.contains("Hosted by TBPN (@tbpn)"));
+      assert_eq!(activity.media_attachments.len(), 1);
+      assert_eq!(
+         activity.media_attachments[0]
+            .meta
+            .as_ref()
+            .unwrap()
+            .original
+            .size,
+         "1920x1080"
+      );
+      assert!(html.contains(r#"property="og:site_name" content="teapot""#));
+      assert!(html.contains(&format!(r#"property="og:image" content="{image_url}""#)));
+      assert!(html.contains(r#"property="og:image:width" content="1920""#));
+      assert!(html.contains(r#"property="twitter:card" content="summary_large_image""#));
+      assert!(!build_oembed_url(&status, &test_config()).contains("&provider="));
+
+      status.text = "Stripe x PayPal https://t.co/broadcast".to_owned();
+      assert_eq!(
+         build_discord_embed_description(&status),
+         "Stripe x PayPal https://t.co/broadcast"
+      );
+      let duplicate_activity = build_activity_pub(&status, &test_config());
+      assert_eq!(
+         duplicate_activity
+            .content
+            .matches("Stripe x PayPal")
+            .count(),
+         1
+      );
+      assert!(
+         duplicate_activity.content.contains(
+            "<blockquote>📺 Live now · 26 watching<br>Hosted by TBPN (@tbpn)</blockquote>"
+         )
+      );
+
+      status.text = "Stripe &amp; PayPal https://t.co/broadcast".to_owned();
+      status.card.as_mut().unwrap().title = "Stripe & PayPal".to_owned();
+      let entity_activity = build_activity_pub(&status, &test_config());
+      assert_eq!(
+         entity_activity
+            .content
+            .matches("Stripe &amp; PayPal")
+            .count(),
+         1
+      );
+   }
+
+   #[test]
+   fn oembed_footer_renders_content_disclosures() {
+      let mut status = tweet(405, "creator", "Generated campaign artwork");
+      status.paid_promotion = true;
+      status.ai_generated = true;
+
+      let oembed_url = build_oembed_url(&status, &test_config());
+      let html = render_tweet_embed(&status, &test_config(), true).into_string();
+      let activity = build_activity_pub(&status, &test_config());
+
+      assert!(oembed_url.contains(&format!(
+         "&provider={}",
+         formatters::url_encode("teapot · :paid: Paid partnership · :ai: Made with AI")
+      )));
+      assert!(html.contains(
+         r#"property="og:site_name" content="teapot · :paid: Paid partnership · :ai: Made with AI""#
+      ));
+      assert!(!activity.content.contains("Paid partnership"));
+      assert!(!activity.content.contains("Made with AI"));
+   }
+
+   #[test]
+   fn activity_payload_includes_external_link_preview_card() {
+      let mut status = tweet(403, "github", "Download the app");
+      status.card = Some(Card {
+         kind: CardKind::SummaryLarge,
+         url: "https://github.com/mobile?utm_source=x".to_owned(),
+         title: "GitHub Mobile".to_owned(),
+         dest: "github.com".to_owned(),
+         text: "The world's development platform, in your pocket".to_owned(),
+         image:
+            "https://pbs.twimg.com/card_img/2075083153316749312/qlKLI1ak?format=jpg&name=800x419"
+               .to_owned(),
+         ..Card::default()
+      });
+
+      let activity = build_activity_pub(&status, &test_config());
+      let card = activity.card.unwrap();
+
+      assert_eq!(card.url, "https://github.com/mobile?utm_source=x");
+      assert_eq!(card.title, "GitHub Mobile");
+      assert_eq!(
+         card.description,
+         "The world's development platform, in your pocket"
+      );
+      assert_eq!(card.type_, "link");
+      assert_eq!((card.width, card.height), (800, 419));
+      assert_eq!(card.provider_name, "github.com");
+      assert!(
+         card
+            .image
+            .is_some_and(|image| image.starts_with("https://teapot.test/pic/enc/"))
+      );
+      assert_eq!(activity.media_attachments.len(), 1);
+      let attachment = &activity.media_attachments[0];
+      assert_eq!(attachment.type_, "image");
+      assert_eq!(attachment.description.as_deref(), Some("GitHub Mobile"));
+      assert_eq!(
+         attachment
+            .meta
+            .as_ref()
+            .map(|meta| (meta.original.width, meta.original.height,)),
+         Some((800, 419))
+      );
+   }
+
+   #[test]
+   fn activity_payload_renders_poll_and_quote_blocks() {
+      let mut status = tweet(405, "poller", "pick one");
+      status.poll = Some(Poll {
+         options: vec!["first".to_owned(), "second".to_owned()],
+         values: vec![3, 1],
+         votes: 4,
+         ..Poll::default()
+      });
+      let quote = tweet(406, "quoted", "quoted text");
+      status.quote = Some(Box::new(quote));
+
+      let activity = build_activity_pub(&status, &test_config());
+
+      assert!(
+         activity
+            .content
+            .contains("<blockquote>████████████████████████")
+      );
+      assert!(activity.content.contains("<b>first</b>&emsp;75%"));
+      assert!(
+         activity
+            .content
+            .contains("4 votes · Final results</blockquote>")
+      );
+      assert!(
+         activity
+            .content
+            .contains(r#"<a href="https://x.com/quoted/status/406">Quoting</a> quoted"#)
+      );
+   }
+
+   #[test]
+   fn activity_payload_uses_image_attachment_for_transcoded_gif() {
+      let mut tweet = tweet(407, "gif", "animated");
+      tweet.gif = Some(Gif {
+         url:      "https://video.twimg.com/tweet_video/animation.mp4".to_owned(),
+         thumb:    "https://pbs.twimg.com/tweet_video_thumb/animation.jpg".to_owned(),
+         alt_text: "animation alt text".to_owned(),
+         width:    400,
+         height:   400,
+      });
+      let mut config = test_config();
+      config.gif_transcoding.mode = GifTranscodingMode::Local;
+
+      let activity = build_activity_pub(&tweet, &config);
+      let attachment = activity.media_attachments.first().unwrap();
+
+      assert_eq!(attachment.type_, "image");
+      assert!(attachment.url.starts_with("https://teapot.test/gif/"));
+      assert_eq!(attachment.preview_url, None);
+      assert_eq!(
+         attachment.description.as_deref(),
+         Some("animation alt text")
+      );
+   }
+
+   #[test]
+   fn player_oembed_duplicates_engagement_in_provider() {
+      let mut tweet = quoted_video_tweet();
+      tweet.stats.views = 1_200;
+      let html = render_tweet_embed(&tweet, &test_config(), true).into_string();
+
+      assert!(html.contains("&amp;provider="));
+      assert!(html.contains(r#"property="twitter:card" content="player""#));
+      assert!(!html.contains(r#"property="og:video""#));
    }
 
    #[test]
@@ -887,6 +2011,8 @@ mod tests {
       tweet.photos.push(Photo {
          url:      "https://pbs.twimg.com/media/photo.jpg?format=jpg&name=large".to_owned(),
          alt_text: "alt text".to_owned(),
+         width:    2048,
+         height:   1536,
       });
 
       let activity = build_activity_pub(&tweet, &test_config());
@@ -898,13 +2024,59 @@ mod tests {
             .url
             .starts_with("https://teapot.test/pic/orig/enc/")
       );
-      assert!(
-         attachment
-            .preview_url
-            .as_ref()
-            .is_some_and(|url| url.starts_with("https://teapot.test/pic/enc/"))
-      );
+      assert_eq!(attachment.preview_url, None);
       assert_eq!(attachment.description.as_deref(), Some("alt text"));
+      let dimensions = &attachment.meta.as_ref().unwrap().original;
+      assert_eq!((dimensions.width, dimensions.height), (2048, 1536));
+      assert_eq!(dimensions.size, "2048x1536");
+      assert!((dimensions.aspect - 4.0 / 3.0).abs() < f64::EPSILON);
+   }
+
+   #[test]
+   fn activity_mixed_media_prioritizes_video_with_photo_poster() {
+      let mut status = tweet(301, "mixed", "mixed media");
+      let photo_url = "https://pbs.twimg.com/media/photo.jpg";
+      status.photos.push(Photo {
+         url: photo_url.to_owned(),
+         width: 1200,
+         height: 1600,
+         ..Photo::default()
+      });
+      status.video = Some(video());
+      let config = test_config();
+
+      let activity = build_activity_pub(&status, &config);
+      let expected_poster = format!(
+         "https://teapot.test{}",
+         formatters::get_pic_url(photo_url, config.config.base64_media),
+      );
+
+      assert_eq!(activity.media_attachments.len(), 2);
+      assert_eq!(activity.media_attachments[0].type_, "video");
+      assert_eq!(activity.media_attachments[1].type_, "image");
+      assert_eq!(
+         activity.media_attachments[0].preview_url.as_deref(),
+         Some(expected_poster.as_str()),
+      );
+   }
+
+   #[test]
+   fn activity_pub_links_to_additional_videos() {
+      let mut status = tweet(302, "videos", "two videos");
+      status.video = Some(video());
+      let mut second = video();
+      second.thumb = "https://pbs.twimg.com/ext_tw_video_thumb/second.jpg".to_owned();
+      second.variants[0].url =
+         "https://video.twimg.com/ext_tw_video/2/pu/vid/1280x720/video.mp4".to_owned();
+      status.additional_videos.push(second);
+
+      let activity = build_activity_pub(&status, &test_config());
+
+      assert_eq!(activity.media_attachments.len(), 1);
+      assert_eq!(activity.media_attachments[0].type_, "video");
+      assert!(activity.content.contains(
+         r#"<sub>🗂️ <a href="https://teapot.test/videos/status/302">View all 2 media</a></sub><br>"#
+      ));
    }
 
    #[test]
@@ -917,6 +2089,7 @@ mod tests {
          &test_config(),
          "G2CSGO",
          "400",
+         false,
       )
       .into_string();
 
@@ -938,8 +2111,142 @@ mod tests {
       );
    }
 
+   #[test]
+   fn discord_activity_page_defers_photo_media_to_mastodon_api() {
+      let mut tweet = tweet(401, "photos", "photo text");
+      tweet.time = time::OffsetDateTime::from_unix_timestamp(1).ok();
+      tweet.photos.push(Photo {
+         url: "https://pbs.twimg.com/media/photo.jpg".to_owned(),
+         width: 2048,
+         height: 1536,
+         ..Photo::default()
+      });
+
+      let html = render_status_page(
+         &tweet,
+         &html! {},
+         &Prefs::default(),
+         &test_config(),
+         "photos",
+         "401",
+         true,
+      )
+      .into_string();
+
+      assert!(html.contains(r##"property="theme-color" content="#005ace""##));
+      assert!(html.contains(r##"rel="mask-icon" href="/safari-pinned-tab.svg" color="#005ace""##));
+      assert!(html.contains(
+         r#"href="https://teapot.test/users/photos/statuses/401" type="application/activity+json""#
+      ));
+      assert!(html.contains(r#"property="twitter:card" content="summary_large_image""#));
+      assert!(!html.contains(r#"property="og:image" content="https://teapot.test/pic/"#));
+      assert!(!html.contains("article:published_time"));
+   }
+
+   #[test]
+   fn discord_activity_page_uses_avatar_for_text_only_status() {
+      let tweet = tweet(402, "plain", "plain text");
+      let html = render_status_page(
+         &tweet,
+         &html! {},
+         &Prefs::default(),
+         &test_config(),
+         "plain",
+         "402",
+         true,
+      )
+      .into_string();
+
+      assert!(html.contains(r#"property="og:image" content="https://teapot.test/pic/enc/"#));
+      assert!(html.contains(r#"property="twitter:image" content="0""#));
+      assert!(html.contains(r#"property="twitter:card" content="summary""#));
+   }
+
+   #[test]
+   fn generic_photo_metadata_includes_real_dimensions() {
+      let mut tweet = tweet(403, "photos", "photo text");
+      tweet.photos.push(Photo {
+         url: "https://pbs.twimg.com/media/photo.jpg".to_owned(),
+         width: 2048,
+         height: 1536,
+         ..Photo::default()
+      });
+
+      let html = render_status_page(
+         &tweet,
+         &html! {},
+         &Prefs::default(),
+         &test_config(),
+         "photos",
+         "403",
+         false,
+      )
+      .into_string();
+
+      assert!(html.contains(r#"property="og:image:width" content="2048""#));
+      assert!(html.contains(r#"property="og:image:height" content="1536""#));
+      assert!(html.contains(r#"property="twitter:image" content="https://teapot.test/pic/enc/"#));
+      assert!(!html.contains("twitter:image:src"));
+      assert!(!html.contains("application/activity+json"));
+   }
+
+   #[test]
+   fn activity_payload_matches_discord_mastodon_shape() {
+      let mut tweet = tweet(404, "photos", "hello\nworld");
+      tweet.stats.replies = 2;
+      tweet.stats.retweets = 3;
+      tweet.stats.likes = 4;
+      tweet.stats.views = 5;
+      tweet.lang = "en".to_owned();
+      tweet.photos.extend([
+         Photo {
+            url: "https://pbs.twimg.com/media/one.jpg".to_owned(),
+            width: 2048,
+            height: 1536,
+            ..Photo::default()
+         },
+         Photo {
+            url: "https://pbs.twimg.com/media/two.jpg".to_owned(),
+            width: 1024,
+            height: 2048,
+            ..Photo::default()
+         },
+      ]);
+
+      let activity = build_activity_pub(&tweet, &test_config());
+
+      assert_eq!(activity.id, "404");
+      assert_eq!(activity.url, "https://x.com/photos/status/404");
+      assert_eq!(activity.language, "en");
+      assert_eq!(activity.media_attachments.len(), 2);
+      assert_eq!(activity.media_attachments[0].preview_url, None);
+      assert_eq!(
+         activity.media_attachments[1]
+            .meta
+            .as_ref()
+            .map(|meta| (meta.original.width, meta.original.height)),
+         Some((1024, 2048))
+      );
+      assert!(activity.content.contains("hello<br>︀︀world<br><br><b>"));
+      assert!(activity.content.contains("in_reply_to=404"));
+      assert!(activity.content.contains("tweet_id=404"));
+      assert_eq!(activity.account.avatar, activity.account.avatar_static);
+      assert!(activity.card.is_none());
+      assert!(activity.poll.is_none());
+   }
+
    #[test]
    fn best_dimensions_parse_non_widescreen_video_url() {
       assert_eq!(video().best_dimensions(), (720, 1280));
    }
+
+   #[test]
+   fn activity_application_uses_source_label() {
+      assert_eq!(
+         application_name(
+            r#"<a href="https://mobile.twitter.com" rel="nofollow">Twitter for iPhone</a>"#
+         ),
+         "Twitter for iPhone"
+      );
+   }
 }
diff --git a/src/views/layout.rs b/src/views/layout.rs
index 864cf7e..a648568 100644
--- a/src/views/layout.rs
+++ b/src/views/layout.rs
@@ -32,6 +32,7 @@ pub struct PageLayout<'a> {
    referer:     &'a str,
    og_image:    &'a str,
    og_type:     &'a str,
+   theme_color: &'a str,
    head_extra:  Option<&'a Markup>,
    custom_og:   bool,
 }
@@ -49,6 +50,7 @@ impl<'a> PageLayout<'a> {
          referer: "",
          og_image: "",
          og_type: "article",
+         theme_color: "#1F1F1F",
          head_extra: None,
          custom_og: false,
       }
@@ -89,6 +91,11 @@ impl<'a> PageLayout<'a> {
       self
    }
 
+   pub const fn theme_color(mut self, theme_color: &'a str) -> Self {
+      self.theme_color = theme_color;
+      self
+   }
+
    /// Extra markup injected into `<head>` after the standard OG tags.
    /// Use for custom meta tags (media OG, oEmbed, `ActivityPub` links).
    pub const fn head_extra(mut self, head_extra: &'a Markup) -> Self {
@@ -131,6 +138,11 @@ impl<'a> PageLayout<'a> {
          },
          _ => None,
       };
+      let mask_icon_color = if self.custom_og {
+         self.theme_color
+      } else {
+         "#ff6c60"
+      };
 
       html! {
           (DOCTYPE)
@@ -138,7 +150,11 @@ impl<'a> PageLayout<'a> {
               head {
                   meta charset="utf-8";
                   meta name="viewport" content="width=device-width, initial-scale=1.0";
-                  meta name="theme-color" content="#1F1F1F";
+                  @if self.custom_og {
+                      meta property="theme-color" content=(self.theme_color);
+                  } @else {
+                      meta name="theme-color" content=(self.theme_color);
+                  }
 
                   // Favicon and manifest links
                   @if !self.custom_og {
@@ -147,7 +163,7 @@ impl<'a> PageLayout<'a> {
                   link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png";
                   link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png";
                   link rel="manifest" href="/site.webmanifest";
-                  link rel="mask-icon" href="/safari-pinned-tab.svg" color="#ff6c60";
+                  link rel="mask-icon" href="/safari-pinned-tab.svg" color=(mask_icon_color);
 
                   // OpenSearch description (full absolute URL to /opensearch)
                   link rel="search" type="application/opensearchdescription+xml"
diff --git a/src/views/rss.rs b/src/views/rss.rs
index ea28566..aac9442 100644
--- a/src/views/rss.rs
+++ b/src/views/rss.rs
@@ -295,6 +295,19 @@ fn render_rss_tweet(tweet: &Tweet, config: &Config) -> String {
             r#"<a href="{tweet_link}">
 <br>Video<br>
   <img src="{url_prefix}{thumb_url}" style="max-width:250px;" />
+</a>"#
+         );
+      }
+   }
+   for video in &tweet.additional_videos {
+      if !video.thumb.is_empty() {
+         let thumb_url = get_pic_url(&video.thumb, config);
+         let tweet_link = format!("{}{}", url_prefix, tweet_link(tweet));
+         let _ = write!(
+            body,
+            r#"<a href="{tweet_link}">
+<br>Video<br>
+  <img src="{url_prefix}{thumb_url}" style="max-width:250px;" />
 </a>"#
          );
       }
diff --git a/src/views/tweet.rs b/src/views/tweet.rs
index 121c383..aae4101 100644
--- a/src/views/tweet.rs
+++ b/src/views/tweet.rs
@@ -329,6 +329,9 @@ impl<'a> TweetRenderer<'a> {
                   @if let Some(ref video) = display_tweet.video {
                       (render_video(video, config, prefs))
                   }
+                  @for video in &display_tweet.additional_videos {
+                      (render_video(video, config, prefs))
+                  }
 
                   // GIF
                   @if let Some(ref gif) = display_tweet.gif {
@@ -568,6 +571,9 @@ fn render_quote(quote: &Tweet, config: &Config, prefs: Option<&Prefs>) -> Markup
            @if let Some(ref video) = quote.video {
                (render_video(video, config, prefs))
            }
+           @for video in &quote.additional_videos {
+               (render_video(video, config, prefs))
+           }
            @if let Some(ref gif) = quote.gif {
                @let gif_url = formatters::get_vid_url(&gif.url, &config.config.hmac_key, config.config.base64_media);
                div class="attachments media-gif" {