diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99ca029..d78a36f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,39 @@
 # Changelog
 
+## v0.1.6 - Pinned Profiles
+
+### Profiles and Timelines
+- Added profile timeline tabs for posts, replies, media, and liked posts.
+- Added pinned profile posts with owner-only pin/unpin controls and automatic cleanup when a pinned post is deleted.
+- Added a liked-posts visibility setting so users can make their likes private while still seeing their own likes.
+- Preserved relationship and moderation visibility rules across profile tabs, pinned posts, private likes, blocked users, muted users, suspended accounts, and anonymous viewers.
+
+### Posting and Composer
+- Added server-enforced post editing during a configurable short edit window, with no-JS edit forms and edited markers on changed posts.
+- Added live mention autocomplete to composer text areas backed by bounded `/mentions` suggestions.
+- Greyed out composer submit buttons when text exceeds the configured character limit.
+
+### Onboarding and Notifications
+- Added first-run account onboarding for new users with profile setup, optional avatar upload, and follow suggestions.
+- Grouped notifications by activity target, added grouped read/open handling, and improved empty-state rendering across feeds, lists, search, bookmarks, and notifications.
+
+### Admin, Settings, and Operations
+- Added `posts.post_edit_window_seconds` to settings and deep server settings, including validation from `0` to `300` seconds.
+- Added an admin backups page for creating backup archives from the web UI.
+- Refactored the backup restore workflow around staged extraction and clearer restore handling.
+
+### Privacy, Security, and UI Fixes
+- Hardened mention suggestions so wildcard characters cannot broaden searches and unavailable or hidden users stay excluded.
+- Hid private likes from profile likes tabs, notifications, and visible like counts except for the liker.
+- Rejected non-image onboarding/profile-picture uploads before creating profile avatar state.
+- Fixed the no-JS banner so it appears only when JavaScript is disabled.
+- Restored the compact Tor onion address pill with a disclosure and copy control.
+
+### Migrations and Compatibility
+- Added migrations for onboarding completion state and liked-post visibility.
+- Existing active users are marked as already onboarded, deleted users remain incomplete, and existing users keep public likes by default.
+- Bumped the crate version to `0.1.6` and refreshed `Cargo.lock`.
+
 ## v0.1.5 - Safety, Media, and Link Previews
 
 ### Posts and Composer
diff --git a/Cargo.lock b/Cargo.lock
index 7f7d5df..1ebfeea 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3223,7 +3223,7 @@ dependencies = [
 
 [[package]]
 name = "rustpost"
-version = "0.1.5"
+version = "0.1.6"
 dependencies = [
  "anyhow",
  "argon2",
diff --git a/Cargo.toml b/Cargo.toml
index b519a6f..e05a5bd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rustpost"
-version = "0.1.5"
+version = "0.1.6"
 edition = "2024"
 license = "MIT"
 description = "A single-binary self-hosted microblogging app"
diff --git a/README.md b/README.md
index 962c142..65bed88 100644
--- a/README.md
+++ b/README.md
@@ -229,6 +229,15 @@ registration_captcha_enabled = false
 
 `registration_captcha_enabled` adds a single-use CAPTCHA challenge to registration only. Login is unchanged.
 
+### Post editing
+
+```toml
+[posts]
+post_edit_window_seconds = 15
+```
+
+Users can edit their own post text only during this short server-enforced window. The default is 15 seconds; set it to `0` to disable post editing.
+
 ### Clearnet only (default)
 
 ```toml
diff --git a/src/admin.rs b/src/admin.rs
index 0a1e239..14e4649 100644
--- a/src/admin.rs
+++ b/src/admin.rs
@@ -7,7 +7,7 @@ use rusqlite::{Row, params, params_from_iter};
 use serde::Deserialize;
 
 use crate::auth;
-use crate::config::Settings;
+use crate::config::{MAX_POST_EDIT_WINDOW_SECONDS, Settings};
 use crate::db::SqlitePool;
 
 const MIB: u64 = 1024 * 1024;
@@ -18,6 +18,7 @@ pub struct DeepSettingsForm {
     pub intent: Option<String>,
     pub site_name: String,
     pub max_text_chars: String,
+    pub post_edit_window_seconds: String,
     pub max_images_per_post: String,
     pub max_videos_per_post: String,
     pub max_media_per_post: String,
@@ -45,6 +46,7 @@ pub struct DeepSettingsForm {
 pub enum DeepSettingsField {
     SiteName,
     MaxTextChars,
+    PostEditWindowSeconds,
     MaxImagesPerPost,
     MaxVideosPerPost,
     MaxMediaPerPost,
@@ -79,6 +81,7 @@ pub enum DeepSettingsInputKind {
 pub struct DeepSettingsValues {
     pub site_name: String,
     pub max_text_chars: usize,
+    pub post_edit_window_seconds: u64,
     pub max_images_per_post: usize,
     pub max_videos_per_post: usize,
     pub max_media_per_post: usize,
@@ -110,9 +113,10 @@ pub struct DeepSettingsChange {
 }
 
 impl DeepSettingsField {
-    pub const ALL: [Self; 23] = [
+    pub const ALL: [Self; 24] = [
         Self::SiteName,
         Self::MaxTextChars,
+        Self::PostEditWindowSeconds,
         Self::MaxImagesPerPost,
         Self::MaxVideosPerPost,
         Self::MaxMediaPerPost,
@@ -141,6 +145,7 @@ impl DeepSettingsField {
         match self {
             Self::SiteName => "Site",
             Self::MaxTextChars
+            | Self::PostEditWindowSeconds
             | Self::MaxImagesPerPost
             | Self::MaxVideosPerPost
             | Self::MaxMediaPerPost
@@ -168,6 +173,7 @@ impl DeepSettingsField {
         match self {
             Self::SiteName => "site",
             Self::MaxTextChars
+            | Self::PostEditWindowSeconds
             | Self::MaxImagesPerPost
             | Self::MaxVideosPerPost
             | Self::MaxMediaPerPost
@@ -195,6 +201,7 @@ impl DeepSettingsField {
         match self {
             Self::SiteName => "name",
             Self::MaxTextChars => "max_text_chars",
+            Self::PostEditWindowSeconds => "post_edit_window_seconds",
             Self::MaxImagesPerPost => "max_images_per_post",
             Self::MaxVideosPerPost => "max_videos_per_post",
             Self::MaxMediaPerPost => "max_media_per_post",
@@ -224,6 +231,7 @@ impl DeepSettingsField {
         match self {
             Self::SiteName => "site_name",
             Self::MaxTextChars => "max_text_chars",
+            Self::PostEditWindowSeconds => "post_edit_window_seconds",
             Self::MaxImagesPerPost => "max_images_per_post",
             Self::MaxVideosPerPost => "max_videos_per_post",
             Self::MaxMediaPerPost => "max_media_per_post",
@@ -253,6 +261,7 @@ impl DeepSettingsField {
         match self {
             Self::SiteName => "Site name",
             Self::MaxTextChars => "Maximum post text length",
+            Self::PostEditWindowSeconds => "Post edit window",
             Self::MaxImagesPerPost => "Maximum images per post",
             Self::MaxVideosPerPost => "Maximum videos per post",
             Self::MaxMediaPerPost => "Maximum total media per post",
@@ -285,6 +294,9 @@ impl DeepSettingsField {
             | Self::MaxUsernameLen
             | Self::MaxDisplayNameLen
             | Self::MaxBioLen => Some("Characters."),
+            Self::PostEditWindowSeconds => {
+                Some("Seconds. Default is 15; valid range is 0 to 300. Set 0 to disable.")
+            }
             Self::MaxImagesPerPost | Self::MaxVideosPerPost | Self::MaxMediaPerPost => {
                 Some("Attachments per post.")
             }
@@ -325,6 +337,7 @@ impl DeepSettingsValues {
         Self {
             site_name: settings.site.name.clone(),
             max_text_chars: settings.posts.max_text_chars,
+            post_edit_window_seconds: settings.posts.post_edit_window_seconds,
             max_images_per_post: settings.posts.max_images_per_post,
             max_videos_per_post: settings.posts.max_videos_per_post,
             max_media_per_post: settings.posts.max_media_per_post,
@@ -354,6 +367,7 @@ impl DeepSettingsValues {
         match field {
             DeepSettingsField::SiteName => self.site_name.clone(),
             DeepSettingsField::MaxTextChars => self.max_text_chars.to_string(),
+            DeepSettingsField::PostEditWindowSeconds => self.post_edit_window_seconds.to_string(),
             DeepSettingsField::MaxImagesPerPost => self.max_images_per_post.to_string(),
             DeepSettingsField::MaxVideosPerPost => self.max_videos_per_post.to_string(),
             DeepSettingsField::MaxMediaPerPost => self.max_media_per_post.to_string(),
@@ -389,6 +403,7 @@ impl DeepSettingsValues {
             | DeepSettingsField::MaxUsernameLen
             | DeepSettingsField::MaxDisplayNameLen
             | DeepSettingsField::MaxBioLen => format!("{value} characters"),
+            DeepSettingsField::PostEditWindowSeconds => format!("{value} seconds"),
             DeepSettingsField::MaxImageSizeMb | DeepSettingsField::MaxVideoSizeMb => {
                 format!("{value} MB")
             }
@@ -401,6 +416,7 @@ impl DeepSettingsValues {
         let mut updated = current.clone();
         updated.site.name.clone_from(&self.site_name);
         updated.posts.max_text_chars = self.max_text_chars;
+        updated.posts.post_edit_window_seconds = self.post_edit_window_seconds;
         updated.posts.max_images_per_post = self.max_images_per_post;
         updated.posts.max_videos_per_post = self.max_videos_per_post;
         updated.posts.max_media_per_post = self.max_media_per_post;
@@ -433,6 +449,7 @@ pub fn parse_deep_settings_form(
     let values = DeepSettingsValues {
         site_name: form.site_name.clone(),
         max_text_chars: parse_usize(&form.max_text_chars, DeepSettingsField::MaxTextChars)?,
+        post_edit_window_seconds: parse_post_edit_window_seconds(&form.post_edit_window_seconds)?,
         max_images_per_post: parse_usize(
             &form.max_images_per_post,
             DeepSettingsField::MaxImagesPerPost,
@@ -539,6 +556,23 @@ fn parse_usize(value: &str, field: DeepSettingsField) -> anyhow::Result<usize> {
         .with_context(|| format!("{} must be a whole number", field.label()))
 }
 
+fn parse_post_edit_window_seconds(value: &str) -> anyhow::Result<u64> {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        anyhow::bail!("Post edit window is required");
+    }
+    if trimmed.starts_with('-') {
+        anyhow::bail!("Post edit window must not be negative");
+    }
+    let seconds = trimmed
+        .parse::<u64>()
+        .with_context(|| "Post edit window must be a whole number of seconds")?;
+    if seconds > MAX_POST_EDIT_WINDOW_SECONDS {
+        anyhow::bail!("Post edit window must be {MAX_POST_EDIT_WINDOW_SECONDS} seconds or less");
+    }
+    Ok(seconds)
+}
+
 fn parse_mb(value: &str, field: DeepSettingsField) -> anyhow::Result<u64> {
     let trimmed = value.trim();
     if trimmed.is_empty() {
@@ -667,6 +701,9 @@ fn toml_value(field: DeepSettingsField, settings: &Settings) -> String {
     match field {
         DeepSettingsField::SiteName => toml::Value::String(settings.site.name.clone()).to_string(),
         DeepSettingsField::MaxTextChars => settings.posts.max_text_chars.to_string(),
+        DeepSettingsField::PostEditWindowSeconds => {
+            settings.posts.post_edit_window_seconds.to_string()
+        }
         DeepSettingsField::MaxImagesPerPost => settings.posts.max_images_per_post.to_string(),
         DeepSettingsField::MaxVideosPerPost => settings.posts.max_videos_per_post.to_string(),
         DeepSettingsField::MaxMediaPerPost => settings.posts.max_media_per_post.to_string(),
@@ -1301,6 +1338,7 @@ mod tests {
             intent: Some("preview".to_owned()),
             site_name: values.site_name,
             max_text_chars: values.max_text_chars.to_string(),
+            post_edit_window_seconds: values.post_edit_window_seconds.to_string(),
             max_images_per_post: values.max_images_per_post.to_string(),
             max_videos_per_post: values.max_videos_per_post.to_string(),
             max_media_per_post: values.max_media_per_post.to_string(),
@@ -1547,6 +1585,18 @@ mod tests {
         assert_eq!(updated.accounts.min_password_length, 5);
     }
 
+    #[test]
+    fn deep_settings_accepts_zero_post_edit_window_as_disabled() {
+        let settings = Settings::default();
+        let mut form = form_from_settings(&settings);
+        form.post_edit_window_seconds = "0".to_owned();
+
+        let parsed = parse_deep_settings_form(&form, &settings).expect("valid form");
+        let updated = parsed.apply_to(&settings);
+
+        assert_eq!(updated.posts.post_edit_window_seconds, 0);
+    }
+
     #[test]
     fn deep_settings_writeback_preserves_unrelated_values_and_comments() {
         let temp = tempdir().expect("temp dir");
diff --git a/src/config.rs b/src/config.rs
index 3c870ae..3bdebaa 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -3,6 +3,9 @@ use std::path::Path;
 
 use serde::{Deserialize, Serialize};
 
+pub const DEFAULT_POST_EDIT_WINDOW_SECONDS: u64 = 15;
+pub const MAX_POST_EDIT_WINDOW_SECONDS: u64 = 300;
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Settings {
     #[serde(default)]
@@ -56,6 +59,8 @@ pub struct AccountSettings {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PostSettings {
     pub max_text_chars: usize,
+    #[serde(default = "default_post_edit_window_seconds")]
+    pub post_edit_window_seconds: u64,
     pub max_images_per_post: usize,
     pub max_videos_per_post: usize,
     pub max_media_per_post: usize,
@@ -143,6 +148,7 @@ impl Default for Settings {
             },
             posts: PostSettings {
                 max_text_chars: 280,
+                post_edit_window_seconds: DEFAULT_POST_EDIT_WINDOW_SECONDS,
                 max_images_per_post: 4,
                 max_videos_per_post: 1,
                 max_media_per_post: 4,
@@ -227,10 +233,24 @@ impl Settings {
         }
         validate_onion_service_name(&self.tor.onion_service_name)?;
         validate_display_onion_address(&self.tor.display_onion_address)?;
+        validate_post_edit_window(self.posts.post_edit_window_seconds)?;
         Ok(())
     }
 }
 
+const fn default_post_edit_window_seconds() -> u64 {
+    DEFAULT_POST_EDIT_WINDOW_SECONDS
+}
+
+fn validate_post_edit_window(seconds: u64) -> anyhow::Result<()> {
+    if seconds > MAX_POST_EDIT_WINDOW_SECONDS {
+        anyhow::bail!(
+            "posts.post_edit_window_seconds must be {MAX_POST_EDIT_WINDOW_SECONDS} seconds or less"
+        );
+    }
+    Ok(())
+}
+
 pub fn write_default_if_missing(path: &Path) -> anyhow::Result<()> {
     if path.exists() {
         return Ok(());
@@ -320,6 +340,9 @@ allow_profile_pictures = {allow_profile_pictures}
 # Maximum post text length in characters.
 max_text_chars = {max_text_chars}
 
+# Seconds after creation that a user may edit their own post. Set to 0 to disable editing.
+post_edit_window_seconds = {post_edit_window_seconds}
+
 # Maximum image attachments allowed on one post.
 max_images_per_post = {max_images_per_post}
 
@@ -478,6 +501,7 @@ backup_dir = {backup_dir}
         allow_profile_banners = settings.accounts.allow_profile_banners,
         allow_profile_pictures = settings.accounts.allow_profile_pictures,
         max_text_chars = settings.posts.max_text_chars,
+        post_edit_window_seconds = settings.posts.post_edit_window_seconds,
         max_images_per_post = settings.posts.max_images_per_post,
         max_videos_per_post = settings.posts.max_videos_per_post,
         max_media_per_post = settings.posts.max_media_per_post,
@@ -643,6 +667,39 @@ mod tests {
         assert!(parsed.tor.display_onion_address.is_empty());
     }
 
+    #[test]
+    fn missing_post_edit_window_defaults_to_fifteen_seconds() {
+        let raw = toml::to_string(&Settings::default())
+            .expect("settings toml")
+            .lines()
+            .filter(|line| !line.trim_start().starts_with("post_edit_window_seconds"))
+            .collect::<Vec<_>>()
+            .join("\n");
+        let parsed: Settings = toml::from_str(&raw).expect("legacy settings parse");
+
+        assert_eq!(
+            parsed.posts.post_edit_window_seconds,
+            DEFAULT_POST_EDIT_WINDOW_SECONDS
+        );
+        parsed.validate().expect("defaulted setting validates");
+    }
+
+    #[test]
+    fn accepts_zero_post_edit_window_as_disabled() {
+        let mut settings = Settings::default();
+        settings.posts.post_edit_window_seconds = 0;
+
+        settings.validate().expect("zero disables post editing");
+    }
+
+    #[test]
+    fn rejects_unsafe_post_edit_windows() {
+        let mut settings = Settings::default();
+
+        settings.posts.post_edit_window_seconds = MAX_POST_EDIT_WINDOW_SECONDS + 1;
+        assert!(settings.validate().is_err());
+    }
+
     #[test]
     fn tor_only_requires_tor_enabled() {
         let mut settings = Settings::default();
diff --git a/src/db.rs b/src/db.rs
index bceec93..c14e25d 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -128,6 +128,14 @@ pub async fn migrate(pool: &Db) -> anyhow::Result<()> {
             tx.execute_batch(MIGRATION_11)?;
             tx.execute("INSERT INTO schema_migrations (version) VALUES (11)", [])?;
         }
+        if applied.unwrap_or(0) < 12 {
+            tx.execute_batch(MIGRATION_12)?;
+            tx.execute("INSERT INTO schema_migrations (version) VALUES (12)", [])?;
+        }
+        if applied.unwrap_or(0) < 13 {
+            tx.execute_batch(MIGRATION_13)?;
+            tx.execute("INSERT INTO schema_migrations (version) VALUES (13)", [])?;
+        }
         tx.commit()?;
         Ok(())
     })
@@ -430,6 +438,17 @@ BEGIN
 END;
 "#;
 
+const MIGRATION_12: &str = r#"
+ALTER TABLE users ADD COLUMN onboarding_completed_at TEXT;
+UPDATE users
+SET onboarding_completed_at = CURRENT_TIMESTAMP
+WHERE onboarding_completed_at IS NULL AND is_deleted = 0;
+"#;
+
+const MIGRATION_13: &str = r#"
+ALTER TABLE users ADD COLUMN liked_posts_public INTEGER NOT NULL DEFAULT 1 CHECK (liked_posts_public IN (0, 1));
+"#;
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -471,7 +490,7 @@ mod tests {
             .await
             .expect("settings");
 
-        assert_eq!(versions, 11);
+        assert_eq!(versions, 13);
         assert_eq!(foreign_keys, 1);
         assert_eq!(journal_mode, "wal");
         assert!(busy_timeout >= 5_000);
@@ -611,6 +630,176 @@ mod tests {
         assert_eq!(is_nsfw, 0);
     }
 
+    #[tokio::test]
+    async fn onboarding_completion_defaults_to_incomplete() {
+        let temp = tempfile::tempdir().expect("temp dir");
+        let pool = connect(&temp.path().join("test.sqlite3"))
+            .await
+            .expect("connect");
+        migrate(&pool).await.expect("migrate");
+
+        let completed_at: Option<String> = pool
+            .call(|conn| {
+                conn.execute(
+                    "INSERT INTO users (username, normalized_username, password_hash, display_name) VALUES ('Alice', 'alice', 'hash', 'Alice')",
+                    [],
+                )?;
+                Ok(conn.query_row(
+                    "SELECT onboarding_completed_at FROM users WHERE normalized_username = 'alice'",
+                    [],
+                    |row| row.get(0),
+                )?)
+            })
+            .await
+            .expect("onboarding state");
+
+        assert!(completed_at.is_none());
+    }
+
+    #[tokio::test]
+    async fn liked_posts_are_public_by_default() {
+        let temp = tempfile::tempdir().expect("temp dir");
+        let pool = connect(&temp.path().join("test.sqlite3"))
+            .await
+            .expect("connect");
+        migrate(&pool).await.expect("migrate");
+
+        let liked_posts_public: i64 = pool
+            .call(|conn| {
+                conn.execute(
+                    "INSERT INTO users (username, normalized_username, password_hash, display_name) VALUES ('Alice', 'alice', 'hash', 'Alice')",
+                    [],
+                )?;
+                Ok(conn.query_row(
+                    "SELECT liked_posts_public FROM users WHERE normalized_username = 'alice'",
+                    [],
+                    |row| row.get(0),
+                )?)
+            })
+            .await
+            .expect("liked posts visibility");
+
+        assert_eq!(liked_posts_public, 1);
+    }
+
+    #[tokio::test]
+    async fn liked_posts_public_migration_defaults_existing_users_public() {
+        let temp = tempfile::tempdir().expect("temp dir");
+        let pool = connect(&temp.path().join("test.sqlite3"))
+            .await
+            .expect("connect");
+        pool.call(|conn| {
+            conn.execute_batch(
+                r#"
+                CREATE TABLE schema_migrations (version INTEGER PRIMARY KEY);
+                INSERT INTO schema_migrations (version) VALUES (12);
+                CREATE TABLE users (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    username TEXT NOT NULL,
+                    normalized_username TEXT NOT NULL UNIQUE,
+                    password_hash TEXT NOT NULL,
+                    display_name TEXT NOT NULL DEFAULT '',
+                    is_deleted INTEGER NOT NULL DEFAULT 0
+                );
+                INSERT INTO users (username, normalized_username, password_hash, display_name)
+                    VALUES ('Alice', 'alice', 'hash', 'Alice');
+                INSERT INTO users (username, normalized_username, password_hash, display_name, is_deleted)
+                    VALUES ('Deleted', 'deleted', 'hash', 'Deleted', 1);
+                "#,
+            )?;
+            Ok(())
+        })
+        .await
+        .expect("legacy schema");
+
+        migrate(&pool).await.expect("migrate to liked_posts_public");
+        migrate(&pool).await.expect("second migrate");
+
+        let (alice_public, deleted_public, column_count, version): (i64, i64, i64, i64) = pool
+            .call(|conn| {
+                let alice = conn.query_row(
+                    "SELECT liked_posts_public FROM users WHERE normalized_username = 'alice'",
+                    [],
+                    |row| row.get(0),
+                )?;
+                let deleted = conn.query_row(
+                    "SELECT liked_posts_public FROM users WHERE normalized_username = 'deleted'",
+                    [],
+                    |row| row.get(0),
+                )?;
+                let column_count = conn.query_row(
+                    "SELECT COUNT(*) FROM pragma_table_info('users') WHERE name = 'liked_posts_public'",
+                    [],
+                    |row| row.get(0),
+                )?;
+                let version =
+                    conn.query_row("SELECT MAX(version) FROM schema_migrations", [], |row| {
+                        row.get(0)
+                    })?;
+                Ok((alice, deleted, column_count, version))
+            })
+            .await
+            .expect("liked posts migration state");
+
+        assert_eq!(alice_public, 1);
+        assert_eq!(deleted_public, 1);
+        assert_eq!(column_count, 1);
+        assert_eq!(version, 13);
+    }
+
+    #[tokio::test]
+    async fn onboarding_migration_marks_existing_active_users_complete() {
+        let temp = tempfile::tempdir().expect("temp dir");
+        let pool = connect(&temp.path().join("test.sqlite3"))
+            .await
+            .expect("connect");
+        pool.call(|conn| {
+            conn.execute_batch(
+                r#"
+                CREATE TABLE schema_migrations (version INTEGER PRIMARY KEY);
+                INSERT INTO schema_migrations (version) VALUES (11);
+                CREATE TABLE users (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    username TEXT NOT NULL,
+                    normalized_username TEXT NOT NULL UNIQUE,
+                    password_hash TEXT NOT NULL,
+                    display_name TEXT NOT NULL DEFAULT '',
+                    is_deleted INTEGER NOT NULL DEFAULT 0
+                );
+                INSERT INTO users (username, normalized_username, password_hash, display_name)
+                    VALUES ('Alice', 'alice', 'hash', 'Alice');
+                INSERT INTO users (username, normalized_username, password_hash, display_name, is_deleted)
+                    VALUES ('Deleted', 'deleted', 'hash', 'Deleted', 1);
+                "#,
+            )?;
+            Ok(())
+        })
+        .await
+        .expect("legacy schema");
+
+        migrate(&pool).await.expect("migrate");
+
+        let (active_completed_at, deleted_completed_at): (Option<String>, Option<String>) = pool
+            .call(|conn| {
+                let active = conn.query_row(
+                    "SELECT onboarding_completed_at FROM users WHERE normalized_username = 'alice'",
+                    [],
+                    |row| row.get(0),
+                )?;
+                let deleted = conn.query_row(
+                    "SELECT onboarding_completed_at FROM users WHERE normalized_username = 'deleted'",
+                    [],
+                    |row| row.get(0),
+                )?;
+                Ok((active, deleted))
+            })
+            .await
+            .expect("onboarding state");
+
+        assert!(active_completed_at.is_some());
+        assert!(deleted_completed_at.is_none());
+    }
+
     #[tokio::test]
     async fn posts_support_quote_repost_references() {
         let temp = tempfile::tempdir().expect("temp dir");
diff --git a/src/media.rs b/src/media.rs
index a7e108d..91c53ca 100644
--- a/src/media.rs
+++ b/src/media.rs
@@ -118,12 +118,24 @@ impl MediaKind {
 }
 
 pub async fn save_upload(
+    pool: &SqlitePool,
+    settings: &Settings,
+    paths: &RuntimePaths,
+    ffmpeg: &FfmpegStatus,
+    owner_user_id: Option<i64>,
+    field: Field<'_>,
+) -> anyhow::Result<i64> {
+    save_upload_inner(pool, settings, paths, ffmpeg, owner_user_id, field, None).await
+}
+
+async fn save_upload_inner(
     pool: &SqlitePool,
     settings: &Settings,
     paths: &RuntimePaths,
     ffmpeg: &FfmpegStatus,
     owner_user_id: Option<i64>,
     mut field: Field<'_>,
+    required_image_label: Option<&'static str>,
 ) -> anyhow::Result<i64> {
     let original_filename = field.file_name().unwrap_or("upload").to_owned();
     reject_path_tricks(&original_filename)?;
@@ -144,6 +156,7 @@ pub async fn save_upload(
             staging,
             bytes,
         },
+        required_image_label,
     )
     .await
 }
@@ -151,8 +164,15 @@ pub async fn save_upload(
 async fn save_staged_upload(
     context: &UploadContext<'_>,
     upload: StagedUpload,
+    required_image_label: Option<&'static str>,
 ) -> anyhow::Result<i64> {
     let prepared = prepare_staged_upload(context.settings, upload).await?;
+    if let Some(label) = required_image_label
+        && prepared.media_kind != MediaKind::Image
+    {
+        remove_staged_upload(&prepared.staging).await;
+        anyhow::bail!("{label} must be an image");
+    }
     if let Some(media_id) = try_insert_duplicate(
         context,
         &prepared,
@@ -450,7 +470,16 @@ pub async fn save_profile_picture_upload(
     owner_user_id: i64,
     field: Field<'_>,
 ) -> anyhow::Result<i64> {
-    let media_id = save_upload(pool, settings, paths, ffmpeg, Some(owner_user_id), field).await?;
+    let media_id = save_upload_inner(
+        pool,
+        settings,
+        paths,
+        ffmpeg,
+        Some(owner_user_id),
+        field,
+        Some("profile picture"),
+    )
+    .await?;
     generate_profile_picture_thumbnail(pool, settings, paths, ffmpeg, media_id).await?;
     Ok(media_id)
 }
@@ -1777,6 +1806,7 @@ mod tests {
                 staging,
                 bytes: u64::try_from(bytes.len()).expect("byte len"),
             },
+            None,
         )
         .await
         .expect("save upload")
diff --git a/src/render.rs b/src/render.rs
index 5ecd962..6a526d3 100644
--- a/src/render.rs
+++ b/src/render.rs
@@ -1,6 +1,7 @@
 use crate::auth::{CurrentUser, Theme};
 use crate::social::{
-    AccountView, MediaView, NotificationView, PostView, QuotePreview, TimelineEventKind,
+    AccountView, MediaView, NotificationGroupView, PostView, ProfileTimelineTab, QuotePreview,
+    TimelineEventKind,
 };
 use axum::http::{StatusCode, Uri};
 use chrono::{DateTime, NaiveDateTime, Utc};
@@ -38,6 +39,53 @@ pub struct PostRenderOptions {
     pub show_timestamp: bool,
     pub clickable_card: bool,
     pub blur_nsfw_media: bool,
+    pub post_edit_window_seconds: u64,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct SearchRenderOptions {
+    pub blur_nsfw_media: bool,
+    pub post_edit_window_seconds: u64,
+}
+
+impl Default for SearchRenderOptions {
+    fn default() -> Self {
+        Self {
+            blur_nsfw_media: true,
+            post_edit_window_seconds: crate::config::DEFAULT_POST_EDIT_WINDOW_SECONDS,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct OnboardingPage<'a> {
+    pub csrf: &'a str,
+    pub display_name: &'a str,
+    pub bio: &'a str,
+    pub picture_path: Option<&'a str>,
+    pub suggestions: &'a [AccountView],
+    pub allow_profile_pictures: bool,
+    pub max_display_name_len: usize,
+    pub max_bio_len: usize,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct EmptyState<'a> {
+    pub title: &'a str,
+    pub message: &'a str,
+}
+
+impl<'a> EmptyState<'a> {
+    pub const fn new(title: &'a str, message: &'a str) -> Self {
+        Self { title, message }
+    }
+
+    const fn default_posts() -> Self {
+        Self {
+            title: "No posts yet.",
+            message: "The timeline will fill in once people start posting.",
+        }
+    }
 }
 
 impl PostRenderOptions {
@@ -46,6 +94,7 @@ impl PostRenderOptions {
             show_timestamp: false,
             clickable_card: true,
             blur_nsfw_media: true,
+            post_edit_window_seconds: crate::config::DEFAULT_POST_EDIT_WINDOW_SECONDS,
         }
     }
 
@@ -54,8 +103,14 @@ impl PostRenderOptions {
             show_timestamp: true,
             clickable_card: true,
             blur_nsfw_media: true,
+            post_edit_window_seconds: crate::config::DEFAULT_POST_EDIT_WINDOW_SECONDS,
         }
     }
+
+    const fn with_edit_window(mut self, seconds: u64) -> Self {
+        self.post_edit_window_seconds = seconds;
+        self
+    }
 }
 
 pub fn layout(user: Option<&CurrentUser>, title: &str, body: &str, site_name: &str) -> String {
@@ -135,12 +190,13 @@ pub fn layout_with_context(
 <meta name="referrer" content="same-origin">
 <link rel="icon" href="/favicon.ico" type="{}">
 <title>{} - {}</title>
+<script src="/assets/rustpost-boot.js"></script>
 <style>{}</style>
 <script src="/assets/rustpost.js" defer></script>
 </head>
 <body>
 <header class="site-header"><div class="header-inner"><div class="header-brand-row"><a class="brand" href="/home"><span class="brand-mark">{}</span><span>{}</span></a>{}</div><nav class="mobile-nav" aria-label="Primary">{}</nav></div></header>
-<section class="noscript-banner" role="status"><strong>JavaScript is disabled.</strong> RustPost will use standard links and forms.</section>
+<noscript><section class="noscript-banner" role="status"><strong>JavaScript is disabled.</strong> RustPost will use standard links and forms.</section></noscript>
 <main><div class="app-shell" data-testid="app-shell">{}<section class="primary-column" data-testid="primary-column">{} </section>{}</div></main>
 <footer class="site-footer">{} alpha</footer>
 </body>
@@ -165,14 +221,16 @@ fn tor_header_indicator(onion: Option<&str>) -> String {
     onion.map_or_else(String::new, |onion| {
         let attr_onion = html_escape::encode_double_quoted_attribute(onion);
         let onion_url = format!("http://{onion}");
+        let escaped_onion_url = html_escape::encode_text(&onion_url);
         let attr_onion_url = html_escape::encode_double_quoted_attribute(&onion_url);
         let short = short_onion_address(onion);
         format!(
-            r#"<div class="tor-indicator" role="status" data-testid="tor-header-indicator"><span class="tor-label">Tor:</span><a class="tor-address-link" href="{}" title="Open Tor mirror: {}" aria-label="Open Tor mirror at {}" data-testid="tor-address-link"><span class="tor-summary-text">{}</span></a><button class="tor-copy-button" type="button" data-copy-text="{}" data-copy-label="Copy" data-copied-label="Copied" aria-label="Copy Tor onion address" title="Copy Tor onion address" data-testid="tor-copy-button">Copy</button></div>"#,
+            r#"<div class="tor-indicator" aria-label="Tor onion service" data-testid="tor-header-indicator"><details class="tor-disclosure"><summary class="tor-pill" aria-label="Show Tor onion address" title="Show Tor onion address" data-testid="tor-pill"><span class="tor-pill-label">Tor</span><span class="tor-summary-text">{}</span></summary><div class="tor-details" data-testid="tor-popover"><a class="tor-full-link" href="{}" title="Open Tor mirror: {}" aria-label="Open Tor mirror at {}" data-testid="tor-full-address">{}</a></div></details><button class="tor-copy-button" type="button" data-copy-text="{}" data-copy-label="Copy" data-copied-label="Copied" data-copy-failed-label="Failed" aria-label="Copy Tor onion address" title="Copy Tor onion address" data-testid="tor-copy-button"><span data-copy-feedback aria-live="polite">Copy</span></button></div>"#,
+            html_escape::encode_text(&short),
             attr_onion_url,
             attr_onion,
             attr_onion,
-            html_escape::encode_text(&short),
+            escaped_onion_url,
             attr_onion,
         )
     })
@@ -320,6 +378,8 @@ fn password_requirement_hint(min_password_length: usize) -> String {
     }
 }
 
+const CLIENT_BOOT_SCRIPT: &str = r#"document.documentElement.classList.add("js-enabled");"#;
+
 const CLIENT_SCRIPT: &str = r#"document.documentElement.classList.add("js-enabled");
 
 function cardInteractiveTarget(target) {
@@ -333,6 +393,19 @@ document.addEventListener("click", (event) => {
   if (!(event.target instanceof Element)) {
     return;
   }
+  const formCard = event.target.closest("[data-card-form]");
+  if (formCard && !cardInteractiveTarget(event.target)) {
+    const form = document.getElementById(formCard.getAttribute("data-card-form"));
+    if (form instanceof HTMLFormElement) {
+      event.preventDefault();
+      if (form.requestSubmit) {
+        form.requestSubmit();
+      } else {
+        form.submit();
+      }
+      return;
+    }
+  }
   const card = event.target.closest("[data-card-href]");
   if (!card || cardInteractiveTarget(event.target)) {
     return;
@@ -344,6 +417,18 @@ document.addEventListener("keydown", (event) => {
   if (!(event.target instanceof Element)) {
     return;
   }
+  if (event.key === "Enter" && event.target === event.target.closest("[data-card-form]")) {
+    const form = document.getElementById(event.target.getAttribute("data-card-form"));
+    if (form instanceof HTMLFormElement) {
+      event.preventDefault();
+      if (form.requestSubmit) {
+        form.requestSubmit();
+      } else {
+        form.submit();
+      }
+      return;
+    }
+  }
   if (event.key !== "Enter" || event.target !== event.target.closest("[data-card-href]")) {
     return;
   }
@@ -450,21 +535,325 @@ document.addEventListener("keydown", (event) => {
   }
 });
 
-function updateComposerCount(textarea) {
+const CHARACTER_COUNTER_CLASSES = [
+  "character-counter-normal",
+  "character-counter-warning",
+  "character-counter-danger"
+];
+
+function characterCounterFor(textarea) {
   const counter = document.querySelector(`[data-character-counter="${textarea.id}"]`);
+  return counter;
+}
+
+function characterCounterClass(remaining) {
+  if (remaining <= 10) {
+    return "character-counter-danger";
+  }
+  if (remaining <= 50) {
+    return "character-counter-warning";
+  }
+  return "character-counter-normal";
+}
+
+function updateComposerSubmit(textarea, remaining) {
+  const form = textarea.closest("form");
+  const submit = form ? form.querySelector('button[type="submit"]') : null;
+  if (!submit) {
+    return;
+  }
+  submit.disabled = remaining < 0 || form.dataset.submitting === "true";
+}
+
+function updateComposerCount(textarea) {
+  const counter = characterCounterFor(textarea);
   if (!counter) {
     return;
   }
   const max = Number.parseInt(textarea.getAttribute("data-character-limit") || "0", 10);
+  if (!Number.isFinite(max)) {
+    return;
+  }
   const length = Array.from(textarea.value).length;
-  counter.textContent = `${Math.max(0, max - length)} remaining`;
+  const remaining = max - length;
+  counter.textContent = `${remaining} remaining`;
+  counter.classList.remove(...CHARACTER_COUNTER_CLASSES);
+  counter.classList.add(characterCounterClass(remaining));
+  updateComposerSubmit(textarea, remaining);
+}
+
+function initializeComposerCounters(root) {
+  if (root.matches && root.matches("textarea[data-character-limit]")) {
+    updateComposerCount(root);
+  }
+  if (root.querySelectorAll) {
+    root.querySelectorAll("textarea[data-character-limit]").forEach(updateComposerCount);
+  }
+}
+
+const mentionStates = new WeakMap();
+const MENTION_DEBOUNCE_MS = 120;
+
+function mentionStateFor(textarea) {
+  let state = mentionStates.get(textarea);
+  if (state) {
+    return state;
+  }
+  const menu = document.getElementById(textarea.getAttribute("aria-controls"));
+  if (!menu) {
+    return null;
+  }
+  state = {
+    textarea,
+    menu,
+    items: [],
+    activeIndex: -1,
+    atIndex: -1,
+    fragment: "",
+    requestId: 0,
+    timer: 0,
+    controller: null
+  };
+  mentionStates.set(textarea, state);
+  return state;
+}
+
+function mentionContext(textarea) {
+  if (textarea.selectionStart !== textarea.selectionEnd) {
+    return null;
+  }
+  const cursor = textarea.selectionStart;
+  const before = textarea.value.slice(0, cursor);
+  const atIndex = before.lastIndexOf("@");
+  if (atIndex < 0) {
+    return null;
+  }
+  const preceding = atIndex > 0 ? before.charAt(atIndex - 1) : "";
+  if (preceding && /[A-Za-z0-9_@.-]/.test(preceding)) {
+    return null;
+  }
+  const fragment = before.slice(atIndex + 1);
+  if (!/^[A-Za-z0-9_-]*$/.test(fragment)) {
+    return null;
+  }
+  return { atIndex, fragment };
+}
+
+function closeMentionMenu(textarea) {
+  const state = mentionStateFor(textarea);
+  if (!state) {
+    return;
+  }
+  if (state.timer) {
+    window.clearTimeout(state.timer);
+    state.timer = 0;
+  }
+  if (state.controller) {
+    state.controller.abort();
+    state.controller = null;
+  }
+  state.items = [];
+  state.activeIndex = -1;
+  state.atIndex = -1;
+  state.fragment = "";
+  state.menu.hidden = true;
+  state.menu.textContent = "";
+  textarea.setAttribute("aria-expanded", "false");
+  textarea.removeAttribute("aria-activedescendant");
+}
+
+function setActiveMention(state, index) {
+  if (state.items.length === 0) {
+    state.activeIndex = -1;
+    state.textarea.removeAttribute("aria-activedescendant");
+    return;
+  }
+  state.activeIndex = (index + state.items.length) % state.items.length;
+  state.menu.querySelectorAll("[role='option']").forEach((option, optionIndex) => {
+    const selected = optionIndex === state.activeIndex;
+    option.setAttribute("aria-selected", selected ? "true" : "false");
+    if (selected) {
+      state.textarea.setAttribute("aria-activedescendant", option.id);
+      option.scrollIntoView({ block: "nearest" });
+    }
+  });
+}
+
+function selectMention(textarea, index) {
+  const state = mentionStateFor(textarea);
+  if (!state || index < 0 || index >= state.items.length) {
+    return;
+  }
+  const context = mentionContext(textarea);
+  if (!context || context.atIndex !== state.atIndex) {
+    closeMentionMenu(textarea);
+    return;
+  }
+  const username = state.items[index].username;
+  const start = state.atIndex;
+  const end = textarea.selectionStart;
+  const suffix = textarea.value.slice(end);
+  const needsSpace = suffix.length === 0 || /^[A-Za-z0-9_@#-]/.test(suffix);
+  const replacement = `@${username}${needsSpace ? " " : ""}`;
+  textarea.value = `${textarea.value.slice(0, start)}${replacement}${suffix}`;
+  const cursor = start + replacement.length;
+  textarea.setSelectionRange(cursor, cursor);
+  closeMentionMenu(textarea);
+  textarea.dispatchEvent(new Event("input", { bubbles: true }));
+  textarea.focus();
+}
+
+function renderMentionSuggestions(state, suggestions) {
+  state.items = suggestions;
+  state.menu.textContent = "";
+  if (suggestions.length === 0) {
+    closeMentionMenu(state.textarea);
+    return;
+  }
+  suggestions.forEach((suggestion, index) => {
+    const option = document.createElement("button");
+    option.type = "button";
+    option.className = "mention-option";
+    option.id = `${state.menu.id}-option-${index}`;
+    option.setAttribute("role", "option");
+    option.setAttribute("aria-selected", "false");
+    option.dataset.username = suggestion.username;
+    const name = document.createElement("span");
+    name.className = "mention-name";
+    name.textContent = suggestion.display_name || suggestion.username;
+    const handle = document.createElement("span");
+    handle.className = "mention-handle";
+    handle.textContent = `@${suggestion.username}`;
+    option.append(name, handle);
+    option.addEventListener("pointerdown", (event) => {
+      event.preventDefault();
+      selectMention(state.textarea, index);
+    });
+    option.addEventListener("mouseenter", () => setActiveMention(state, index));
+    state.menu.append(option);
+  });
+  state.menu.hidden = false;
+  state.textarea.setAttribute("aria-expanded", "true");
+  setActiveMention(state, 0);
 }
 
-document.querySelectorAll("textarea[data-character-limit]").forEach((textarea) => {
-  updateComposerCount(textarea);
-  textarea.addEventListener("input", () => updateComposerCount(textarea));
+function requestMentionSuggestions(textarea) {
+  const state = mentionStateFor(textarea);
+  const context = mentionContext(textarea);
+  if (!state || !context || !window.fetch) {
+    closeMentionMenu(textarea);
+    return;
+  }
+  state.atIndex = context.atIndex;
+  state.fragment = context.fragment;
+  if (state.timer) {
+    window.clearTimeout(state.timer);
+  }
+  state.timer = window.setTimeout(async () => {
+    state.timer = 0;
+    if (state.controller) {
+      state.controller.abort();
+    }
+    const requestId = state.requestId + 1;
+    state.requestId = requestId;
+    state.controller = window.AbortController ? new AbortController() : null;
+    try {
+      const response = await fetch(`/mentions?q=${encodeURIComponent(context.fragment)}`, {
+        headers: { "Accept": "application/json" },
+        credentials: "same-origin",
+        signal: state.controller ? state.controller.signal : undefined
+      });
+      if (!response.ok || requestId !== state.requestId) {
+        return;
+      }
+      const suggestions = await response.json();
+      const current = mentionContext(textarea);
+      if (!current || current.atIndex !== context.atIndex || current.fragment !== context.fragment) {
+        return;
+      }
+      renderMentionSuggestions(state, Array.isArray(suggestions) ? suggestions : []);
+    } catch (error) {
+      if (!state.controller || error.name !== "AbortError") {
+        closeMentionMenu(textarea);
+      }
+    }
+  }, MENTION_DEBOUNCE_MS);
+}
+
+function initializeMentionAutocomplete(root) {
+  if (root.matches && root.matches("textarea[data-mention-autocomplete]")) {
+    mentionStateFor(root);
+  }
+  if (root.querySelectorAll) {
+    root.querySelectorAll("textarea[data-mention-autocomplete]").forEach(mentionStateFor);
+  }
+}
+
+document.addEventListener("input", (event) => {
+  const textarea = event.target.closest("textarea[data-character-limit]");
+  if (textarea) {
+    updateComposerCount(textarea);
+  }
+  const mentionTextarea = event.target.closest("textarea[data-mention-autocomplete]");
+  if (mentionTextarea) {
+    requestMentionSuggestions(mentionTextarea);
+  }
 });
 
+document.addEventListener("keydown", (event) => {
+  if (!(event.target instanceof Element)) {
+    return;
+  }
+  const textarea = event.target.closest("textarea[data-mention-autocomplete]");
+  if (!textarea) {
+    return;
+  }
+  const state = mentionStateFor(textarea);
+  if (!state || state.menu.hidden) {
+    return;
+  }
+  if (event.key === "ArrowDown") {
+    event.preventDefault();
+    setActiveMention(state, state.activeIndex + 1);
+  } else if (event.key === "ArrowUp") {
+    event.preventDefault();
+    setActiveMention(state, state.activeIndex - 1);
+  } else if (event.key === "Enter" || event.key === "Tab") {
+    event.preventDefault();
+    selectMention(textarea, state.activeIndex);
+  } else if (event.key === "Escape") {
+    event.preventDefault();
+    closeMentionMenu(textarea);
+  }
+});
+
+document.addEventListener("click", (event) => {
+  if (!(event.target instanceof Element)) {
+    return;
+  }
+  document.querySelectorAll("textarea[data-mention-autocomplete]").forEach((textarea) => {
+    const state = mentionStateFor(textarea);
+    if (state && event.target !== textarea && !state.menu.contains(event.target)) {
+      closeMentionMenu(textarea);
+    }
+  });
+});
+
+initializeComposerCounters(document);
+initializeMentionAutocomplete(document);
+window.addEventListener("pageshow", () => initializeComposerCounters(document));
+window.requestAnimationFrame(() => initializeComposerCounters(document));
+if (window.MutationObserver) {
+  new MutationObserver((mutations) => {
+    mutations.forEach((mutation) => {
+      mutation.addedNodes.forEach((node) => {
+        initializeComposerCounters(node);
+        initializeMentionAutocomplete(node);
+      });
+    });
+  }).observe(document.documentElement, { childList: true, subtree: true });
+}
+
 function mediaSummary(input) {
   if (!input.files || input.files.length === 0) {
     return "";
@@ -515,6 +904,72 @@ document.addEventListener("click", (event) => {
   input.focus();
 });
 
+function mediaFileName(input) {
+  if (!input.files || input.files.length === 0) {
+    return "";
+  }
+  return input.files[0].name || "media file";
+}
+
+function setProfileMediaStatus(frame, message) {
+  const status = frame.querySelector("[data-profile-media-status]");
+  if (status) {
+    status.textContent = message;
+  }
+}
+
+function updateProfileMediaFile(input) {
+  const frame = input.closest("[data-profile-media-frame]");
+  if (!frame) {
+    return;
+  }
+  const fileName = mediaFileName(input);
+  frame.classList.toggle("settings-media-has-file", fileName !== "");
+  if (fileName !== "") {
+    const remove = frame.querySelector("[data-profile-media-delete]");
+    if (remove) {
+      remove.checked = false;
+      frame.classList.remove("settings-media-removing");
+    }
+    setProfileMediaStatus(frame, `${fileName} selected`);
+  } else {
+    setProfileMediaStatus(frame, "");
+  }
+}
+
+function updateProfileMediaDelete(input) {
+  const frame = input.closest("[data-profile-media-frame]");
+  if (!frame) {
+    return;
+  }
+  frame.classList.toggle("settings-media-removing", input.checked);
+  const file = frame.querySelector("[data-profile-media-file]");
+  if (input.checked && file) {
+    file.value = "";
+    updateProfileMediaFile(file);
+    frame.classList.add("settings-media-removing");
+  }
+  const label = input.getAttribute("aria-label") || "Media";
+  setProfileMediaStatus(frame, input.checked ? `${label} selected` : `${label} cancelled`);
+}
+
+document.querySelectorAll("[data-profile-media-file]").forEach(updateProfileMediaFile);
+
+document.addEventListener("change", (event) => {
+  if (!(event.target instanceof Element)) {
+    return;
+  }
+  const file = event.target.closest("[data-profile-media-file]");
+  if (file) {
+    updateProfileMediaFile(file);
+    return;
+  }
+  const remove = event.target.closest("[data-profile-media-delete]");
+  if (remove) {
+    updateProfileMediaDelete(remove);
+  }
+});
+
 function resetSubmittingForms() {
   document.querySelectorAll('form[data-submitting="true"]').forEach((form) => {
     delete form.dataset.submitting;
@@ -678,8 +1133,13 @@ document.addEventListener("submit", (event) => {
 
 async function copyTextToClipboard(text) {
   if (navigator.clipboard && navigator.clipboard.writeText) {
-    await navigator.clipboard.writeText(text);
-    return;
+    try {
+      await navigator.clipboard.writeText(text);
+      return;
+    } catch (_err) {
+      // Fall back to the selection-based path below for browsers that expose
+      // the Clipboard API but deny writes in this context.
+    }
   }
   const textarea = document.createElement("textarea");
   textarea.value = text;
@@ -688,8 +1148,20 @@ async function copyTextToClipboard(text) {
   textarea.style.top = "-1000px";
   document.body.append(textarea);
   textarea.select();
-  document.execCommand("copy");
+  const copied = document.execCommand("copy");
   textarea.remove();
+  if (!copied) {
+    throw new Error("copy command failed");
+  }
+}
+
+function setCopyButtonLabel(button, label) {
+  const feedback = button.querySelector("[data-copy-feedback]");
+  if (feedback) {
+    feedback.textContent = label;
+    return;
+  }
+  button.textContent = label;
 }
 
 document.addEventListener("click", async (event) => {
@@ -697,28 +1169,40 @@ document.addEventListener("click", async (event) => {
   if (!button) {
     return;
   }
+  event.preventDefault();
+  event.stopPropagation();
+  const original = button.getAttribute("data-copy-label") || button.textContent || "Copy";
+  if (button.dataset.copyTimer) {
+    window.clearTimeout(Number.parseInt(button.dataset.copyTimer, 10));
+    delete button.dataset.copyTimer;
+  }
   try {
     await copyTextToClipboard(button.getAttribute("data-copy-text") || "");
-    const original = button.getAttribute("data-copy-label") || button.textContent;
-    button.textContent = button.getAttribute("data-copied-label") || "Copied";
-    window.setTimeout(() => {
-      button.textContent = original;
-    }, 1600);
+    setCopyButtonLabel(button, button.getAttribute("data-copied-label") || "Copied");
   } catch (_err) {
-    button.textContent = "Copy failed";
+    setCopyButtonLabel(button, button.getAttribute("data-copy-failed-label") || "Failed");
   }
+  button.dataset.copyTimer = String(window.setTimeout(() => {
+    setCopyButtonLabel(button, original);
+    delete button.dataset.copyTimer;
+  }, 1600));
 });"#;
 
 pub fn client_script() -> &'static str {
     CLIENT_SCRIPT
 }
 
+pub fn client_boot_script() -> &'static str {
+    CLIENT_BOOT_SCRIPT
+}
+
 pub fn composer(csrf: Option<&str>, parent: Option<i64>, max_text_chars: usize) -> String {
     let parent_input = parent.map_or_else(String::new, |id| {
         format!(r#"<input type="hidden" name="parent_post_id" value="{id}">"#)
     });
     let csrf = csrf.unwrap_or_default();
     let input_id = parent.map_or_else(|| "post-text".to_owned(), |id| format!("reply-text-{id}"));
+    let mention_menu_id = format!("{input_id}-mention-menu");
     let media_id = parent.map_or_else(|| "post-media".to_owned(), |id| format!("reply-media-{id}"));
     let nsfw_id = parent.map_or_else(|| "post-nsfw".to_owned(), |id| format!("reply-nsfw-{id}"));
     let placeholder = if parent.is_some() {
@@ -727,11 +1211,12 @@ pub fn composer(csrf: Option<&str>, parent: Option<i64>, max_text_chars: usize)
         "What's happening?"
     };
     format!(
-        r#"<section class="composer" id="reply" aria-labelledby="composer-title"><div class="section-heading"><h1 id="composer-title">{}</h1><span class="muted" data-character-counter="{}">{} remaining</span></div><form method="post" action="/posts" enctype="multipart/form-data" data-enhance="post-create">
+        r#"<section class="composer" id="reply" aria-labelledby="composer-title"><div class="section-heading"><h1 id="composer-title">{}</h1><span class="muted character-counter character-counter-normal" data-character-counter="{}" aria-live="polite">{} remaining</span></div><form method="post" action="/posts" enctype="multipart/form-data" data-enhance="post-create">
 <input type="hidden" name="csrf" value="{}">{}
 <label class="sr-only" for="{}">What is happening?</label>
 <div class="composer-surface">
-<textarea id="{}" name="text" maxlength="{}" rows="4" data-character-limit="{}" placeholder="{}"></textarea>
+<textarea id="{}" name="text" rows="4" data-character-limit="{}" data-mention-autocomplete aria-autocomplete="list" aria-haspopup="listbox" aria-expanded="false" aria-controls="{}" placeholder="{}"></textarea>
+<div id="{}" class="mention-menu" role="listbox" data-mention-menu hidden></div>
 <div class="composer-footer"><label class="composer-file-control" for="{}"><input class="composer-file-input" id="{}" name="media" type="file" multiple accept="image/*,video/mp4,video/webm,video/quicktime" aria-label="Attach media" data-composer-media><span class="composer-file-button" aria-hidden="true">{}<span>Attach media</span></span></label></div>
 <div class="composer-media-selection" data-composer-media-selection hidden><span class="composer-media-summary" data-composer-media-summary></span><label class="check-row composer-nsfw" for="{}"><input id="{}" name="nsfw" type="checkbox" value="true" data-composer-nsfw> Mark media as NSFW</label><button class="composer-clear-media" type="button" data-composer-clear-media>Clear</button></div>
 </div>
@@ -749,8 +1234,9 @@ pub fn composer(csrf: Option<&str>, parent: Option<i64>, max_text_chars: usize)
         html_escape::encode_double_quoted_attribute(&input_id),
         html_escape::encode_double_quoted_attribute(&input_id),
         max_text_chars,
-        max_text_chars,
+        html_escape::encode_double_quoted_attribute(&mention_menu_id),
         html_escape::encode_double_quoted_attribute(placeholder),
+        html_escape::encode_double_quoted_attribute(&mention_menu_id),
         html_escape::encode_double_quoted_attribute(&media_id),
         html_escape::encode_double_quoted_attribute(&media_id),
         icon_svg("paperclip"),
@@ -762,15 +1248,14 @@ pub fn composer(csrf: Option<&str>, parent: Option<i64>, max_text_chars: usize)
 pub fn quote_composer(csrf: &str, quote: &QuotePreview, max_text_chars: usize) -> String {
     let preview = quote_preview_card(quote);
     format!(
-        r#"<section class="composer quote-composer" aria-labelledby="composer-title"><div class="section-heading"><h1 id="composer-title">Quote post</h1><span class="muted" data-character-counter="quote-text">{max_text_chars} remaining</span></div>{preview}<form method="post" action="/posts/{}/quote" class="quote-form">
+        r#"<section class="composer quote-composer" aria-labelledby="composer-title"><div class="section-heading"><h1 id="composer-title">Quote post</h1><span class="muted character-counter character-counter-normal" data-character-counter="quote-text" aria-live="polite">{max_text_chars} remaining</span></div>{preview}<form method="post" action="/posts/{}/quote" class="quote-form">
 <input type="hidden" name="csrf" value="{}">
 <label class="sr-only" for="quote-text">Add your comment</label>
-<textarea id="quote-text" name="text" maxlength="{}" rows="4" data-character-limit="{}" placeholder="Add your thoughts..." required></textarea>
+<textarea id="quote-text" name="text" rows="4" data-character-limit="{}" placeholder="Add your thoughts..." required></textarea>
 <div class="composer-tools"><span></span><button class="primary" type="submit">Post quote</button></div>
 </form></section>"#,
         quote.id,
         html_escape::encode_double_quoted_attribute(csrf),
-        max_text_chars,
         max_text_chars
     )
 }
@@ -778,8 +1263,8 @@ pub fn quote_composer(csrf: &str, quote: &QuotePreview, max_text_chars: usize) -
 pub fn accounts(accounts: &[AccountView], csrf: &str) -> String {
     if accounts.is_empty() {
         return empty_state(
-            "You are not following anyone yet.",
-            "Follow accounts to build your home feed.",
+            "Follow people to build your feed.",
+            "Accounts you follow will appear here.",
         );
     }
     let rows = accounts
@@ -820,9 +1305,86 @@ pub fn accounts(accounts: &[AccountView], csrf: &str) -> String {
     format!(r#"<section class="account-list">{rows}</section>"#)
 }
 
+pub fn onboarding_page(page: OnboardingPage<'_>) -> String {
+    let picture = page.picture_path.map_or_else(
+        || {
+            r#"<div class="settings-picture-preview placeholder" aria-hidden="true"></div>"#
+                .to_owned()
+        },
+        |path| {
+            format!(
+                r#"<img class="settings-picture-preview" src="{}" alt="">"#,
+                html_escape::encode_double_quoted_attribute(path)
+            )
+        },
+    );
+    let picture_control = if page.allow_profile_pictures {
+        r#"<label class="file-control" for="profile_picture">Choose profile picture<input id="profile_picture" name="profile_picture" type="file" accept="image/*"></label>"#
+            .to_owned()
+    } else {
+        r#"<p class="muted">Profile pictures are disabled.</p>"#.to_owned()
+    };
+    let suggestions = if page.suggestions.is_empty() {
+        r#"<p class="muted">No local accounts to suggest yet.</p>"#.to_owned()
+    } else {
+        page.suggestions
+            .iter()
+            .map(|account| {
+                let avatar = account.profile_picture_path.as_ref().map_or_else(
+                    || {
+                        let initial = account.display_name.chars().next().unwrap_or('R');
+                        format!(
+                            r#"<span class="post-avatar placeholder" aria-hidden="true">{}</span>"#,
+                            html_escape::encode_text(&initial.to_string())
+                        )
+                    },
+                    |path| {
+                        format!(
+                            r#"<img class="post-avatar" src="{}" alt="" loading="lazy">"#,
+                            html_escape::encode_double_quoted_attribute(path)
+                        )
+                    },
+                );
+                let checked = if account.viewer_following {
+                    " checked"
+                } else {
+                    ""
+                };
+                let bio = if account.bio.trim().is_empty() {
+                    String::new()
+                } else {
+                    format!(
+                        r#"<span class="muted">{}</span>"#,
+                        html_escape::encode_text(&account.bio)
+                    )
+                };
+                format!(
+                    r#"<label class="onboarding-suggestion">{avatar}<input type="checkbox" name="follow_user_id" value="{}"{checked}><span><strong>{}</strong> <span class="username">@{}</span>{bio}</span></label>"#,
+                    account.id,
+                    html_escape::encode_text(&account.display_name),
+                    html_escape::encode_text(&account.username),
+                )
+            })
+            .collect::<Vec<_>>()
+            .join("")
+    };
+    format!(
+        r#"<section class="panel onboarding-panel"><p class="eyebrow">First run</p><h1>Set up your account</h1><form method="post" action="/onboarding" enctype="multipart/form-data" class="onboarding-form"><input type="hidden" name="csrf" value="{}"><div class="onboarding-media-row">{picture}<div>{picture_control}</div></div><div class="settings-fields"><label for="display_name">Display name</label><input id="display_name" name="display_name" maxlength="{}" value="{}"><label for="bio">Bio</label><textarea id="bio" name="bio" maxlength="{}">{}</textarea></div><fieldset class="onboarding-suggestions"><legend>Follow accounts</legend>{suggestions}</fieldset><div class="actions"><button class="primary" type="submit" name="intent" value="save">Finish setup</button><button type="submit" name="intent" value="skip">Skip for now</button></div></form></section>"#,
+        html_escape::encode_double_quoted_attribute(page.csrf),
+        page.max_display_name_len,
+        html_escape::encode_double_quoted_attribute(page.display_name),
+        page.max_bio_len,
+        html_escape::encode_text(page.bio),
+    )
+}
+
 pub fn account_links(accounts: &[AccountView], empty_message: &str) -> String {
+    account_links_with_empty_state(accounts, EmptyState::new(empty_message, ""))
+}
+
+pub fn account_links_with_empty_state(accounts: &[AccountView], empty: EmptyState<'_>) -> String {
     if accounts.is_empty() {
-        return empty_state(empty_message, "");
+        return empty_state(empty.title, empty.message);
     }
     let rows = accounts
         .iter()
@@ -855,6 +1417,22 @@ pub fn account_links(accounts: &[AccountView], empty_message: &str) -> String {
     format!(r#"<section class="account-list" data-testid="account-list">{rows}</section>"#)
 }
 
+pub fn edit_post_form(
+    csrf: &str,
+    post_id: i64,
+    text: &str,
+    max_text_chars: usize,
+    return_to: &str,
+) -> String {
+    format!(
+        r#"<section class="composer edit-composer" aria-labelledby="edit-post-title"><div class="section-heading"><h1 id="edit-post-title">Edit post</h1><span class="muted character-counter character-counter-normal" data-character-counter="edit-post-text" aria-live="polite">{max_text_chars} remaining</span></div><form method="post" action="/posts/{post_id}/edit" class="edit-post-form"><input type="hidden" name="csrf" value="{}"><input type="hidden" name="return_to" value="{}"><label class="sr-only" for="edit-post-text">Post text</label><textarea id="edit-post-text" name="text" rows="5" data-character-limit="{max_text_chars}">{}</textarea><div class="composer-tools"><a class="button-link" href="{}">Cancel</a><button class="primary" type="submit">Save edit</button></div></form></section>"#,
+        html_escape::encode_double_quoted_attribute(csrf),
+        html_escape::encode_double_quoted_attribute(return_to),
+        html_escape::encode_text(text),
+        html_escape::encode_double_quoted_attribute(return_to),
+    )
+}
+
 pub fn search_page(
     site_name: &str,
     query: &str,
@@ -862,7 +1440,7 @@ pub fn search_page(
     posts: &[PostView],
     user: Option<&CurrentUser>,
     csrf: Option<&str>,
-    blur_nsfw_media: bool,
+    options: SearchRenderOptions,
 ) -> String {
     let form = search_form(site_name, query);
     let state = if query.is_empty() {
@@ -871,9 +1449,9 @@ pub fn search_page(
             "Search for posts, usernames, mentions, or hashtags.",
         )
     } else if users.is_empty() && posts.is_empty() {
-        empty_state("No results found", &format!(r#"No matches for "{query}"."#))
+        empty_state("No matching posts or users found.", "Try another search.")
     } else {
-        search_results(query, users, posts, user, csrf, blur_nsfw_media)
+        search_results(query, users, posts, user, csrf, options)
     };
     format!("{form}{state}")
 }
@@ -892,7 +1470,7 @@ fn search_results(
     posts: &[PostView],
     user: Option<&CurrentUser>,
     csrf: Option<&str>,
-    blur_nsfw_media: bool,
+    options: SearchRenderOptions,
 ) -> String {
     let total = users.len() + posts.len();
     let plural = if total == 1 { "result" } else { "results" };
@@ -912,9 +1490,11 @@ fn search_results(
                 user,
                 csrf,
                 PostRenderOptions {
-                    blur_nsfw_media,
+                    blur_nsfw_media: options.blur_nsfw_media,
                     ..PostRenderOptions::timeline()
-                }
+                        .with_edit_window(options.post_edit_window_seconds)
+                },
+                EmptyState::default_posts(),
             )
         )
     };
@@ -999,7 +1579,13 @@ pub fn follow_form(user_id: i64, csrf: &str, following: bool) -> String {
 }
 
 pub fn posts(posts: &[PostView], user: Option<&CurrentUser>, csrf: Option<&str>) -> String {
-    posts_with_options(posts, user, csrf, PostRenderOptions::timeline())
+    posts_with_options(
+        posts,
+        user,
+        csrf,
+        PostRenderOptions::timeline(),
+        EmptyState::default_posts(),
+    )
 }
 
 pub fn posts_with_nsfw_blur(
@@ -1016,6 +1602,104 @@ pub fn posts_with_nsfw_blur(
             blur_nsfw_media,
             ..PostRenderOptions::timeline()
         },
+        EmptyState::default_posts(),
+    )
+}
+
+pub fn posts_with_controls(
+    posts: &[PostView],
+    user: Option<&CurrentUser>,
+    csrf: Option<&str>,
+    blur_nsfw_media: bool,
+    post_edit_window_seconds: u64,
+) -> String {
+    posts_with_controls_empty_state(
+        posts,
+        user,
+        csrf,
+        blur_nsfw_media,
+        post_edit_window_seconds,
+        EmptyState::default_posts(),
+    )
+}
+
+pub fn posts_with_controls_empty_state(
+    posts: &[PostView],
+    user: Option<&CurrentUser>,
+    csrf: Option<&str>,
+    blur_nsfw_media: bool,
+    post_edit_window_seconds: u64,
+    empty: EmptyState<'_>,
+) -> String {
+    posts_with_options(
+        posts,
+        user,
+        csrf,
+        PostRenderOptions {
+            blur_nsfw_media,
+            ..PostRenderOptions::timeline().with_edit_window(post_edit_window_seconds)
+        },
+        empty,
+    )
+}
+
+pub fn profile_tabs(username: &str, active: ProfileTimelineTab) -> String {
+    let tabs = [
+        (ProfileTimelineTab::Posts, "Posts"),
+        (ProfileTimelineTab::Replies, "Replies"),
+        (ProfileTimelineTab::Media, "Media"),
+        (ProfileTimelineTab::Likes, "Likes"),
+    ];
+    let links = tabs
+        .iter()
+        .map(|(tab, label)| {
+            let href = profile_tab_href(username, *tab);
+            let active_attrs = if *tab == active {
+                r#" class="active" aria-current="page""#
+            } else {
+                ""
+            };
+            format!(
+                r#"<a href="{}"{}>{}</a>"#,
+                html_escape::encode_double_quoted_attribute(&href),
+                active_attrs,
+                html_escape::encode_text(label)
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("");
+    format!(
+        r#"<nav class="profile-tabs" data-testid="profile-tabs" aria-label="Profile timelines">{links}</nav>"#
+    )
+}
+
+fn profile_tab_href(username: &str, tab: ProfileTimelineTab) -> String {
+    match tab {
+        ProfileTimelineTab::Posts => format!("/users/{username}"),
+        ProfileTimelineTab::Replies => format!("/users/{username}?tab=replies"),
+        ProfileTimelineTab::Media => format!("/users/{username}?tab=media"),
+        ProfileTimelineTab::Likes => format!("/users/{username}?tab=likes"),
+    }
+}
+
+pub fn pinned_post_with_controls(
+    post: &PostView,
+    user: Option<&CurrentUser>,
+    csrf: Option<&str>,
+    blur_nsfw_media: bool,
+    post_edit_window_seconds: u64,
+) -> String {
+    let card = post_card_with_options(
+        post,
+        user,
+        csrf,
+        PostRenderOptions {
+            blur_nsfw_media,
+            ..PostRenderOptions::timeline().with_edit_window(post_edit_window_seconds)
+        },
+    );
+    format!(
+        r#"<section class="timeline pinned-timeline" aria-label="Pinned post"><h2 class="section-title">Pinned post</h2>{card}</section>"#
     )
 }
 
@@ -1040,6 +1724,24 @@ pub fn thread_posts_with_nsfw_blur(
     )
 }
 
+pub fn thread_posts_with_controls(
+    posts: &[PostView],
+    user: Option<&CurrentUser>,
+    csrf: Option<&str>,
+    blur_nsfw_media: bool,
+    post_edit_window_seconds: u64,
+) -> String {
+    thread_posts_with_options(
+        posts,
+        user,
+        csrf,
+        PostRenderOptions {
+            blur_nsfw_media,
+            ..PostRenderOptions::thread().with_edit_window(post_edit_window_seconds)
+        },
+    )
+}
+
 fn thread_posts_with_options(
     posts: &[PostView],
     user: Option<&CurrentUser>,
@@ -1047,10 +1749,8 @@ fn thread_posts_with_options(
     options: PostRenderOptions,
 ) -> String {
     if posts.is_empty() {
-        return empty_state(
-            "No posts yet",
-            "The timeline will fill in once people start posting.",
-        );
+        let empty = EmptyState::default_posts();
+        return empty_state(empty.title, empty.message);
     }
     format!(
         r#"<section class="timeline" aria-label="Posts">{}</section>"#,
@@ -1074,12 +1774,10 @@ fn posts_with_options(
     user: Option<&CurrentUser>,
     csrf: Option<&str>,
     options: PostRenderOptions,
+    empty: EmptyState<'_>,
 ) -> String {
     if posts.is_empty() {
-        return empty_state(
-            "No posts yet",
-            "The timeline will fill in once people start posting.",
-        );
+        return empty_state(empty.title, empty.message);
     }
     format!(
         r#"<section class="timeline" aria-label="Posts">{}</section>"#,
@@ -1112,6 +1810,24 @@ pub fn post_card_with_nsfw_blur(
     )
 }
 
+pub fn post_card_with_controls(
+    post: &PostView,
+    user: Option<&CurrentUser>,
+    csrf: Option<&str>,
+    blur_nsfw_media: bool,
+    post_edit_window_seconds: u64,
+) -> String {
+    post_card_with_options(
+        post,
+        user,
+        csrf,
+        PostRenderOptions {
+            blur_nsfw_media,
+            ..PostRenderOptions::timeline().with_edit_window(post_edit_window_seconds)
+        },
+    )
+}
+
 pub fn thread_post_card(post: &PostView, user: Option<&CurrentUser>, csrf: Option<&str>) -> String {
     post_card_with_options(post, user, csrf, PostRenderOptions::thread())
 }
@@ -1133,6 +1849,24 @@ pub fn thread_post_card_with_nsfw_blur(
     )
 }
 
+pub fn thread_post_card_with_controls(
+    post: &PostView,
+    user: Option<&CurrentUser>,
+    csrf: Option<&str>,
+    blur_nsfw_media: bool,
+    post_edit_window_seconds: u64,
+) -> String {
+    post_card_with_options(
+        post,
+        user,
+        csrf,
+        PostRenderOptions {
+            blur_nsfw_media,
+            ..PostRenderOptions::thread().with_edit_window(post_edit_window_seconds)
+        },
+    )
+}
+
 // Rendering a post card stays centralized because the markup, counts, media,
 // and action controls must remain consistent between timelines and threads.
 #[expect(
@@ -1212,6 +1946,27 @@ fn post_card_with_options(
         } else {
             String::new()
         };
+        let edit = if post.user_id == Some(user.id)
+            && post_edit_available(&post.created_at, options.post_edit_window_seconds)
+        {
+            icon_link(&format!("/posts/{}/edit", post.id), "Edit", "edit")
+        } else {
+            String::new()
+        };
+        let pin = if post.user_id == Some(user.id) {
+            pin_action_form(
+                &format!("/posts/{}/pin", post.id),
+                csrf,
+                if post.pinned_by_author {
+                    "Unpin from profile"
+                } else {
+                    "Pin to profile"
+                },
+                post.pinned_by_author,
+            )
+        } else {
+            String::new()
+        };
         let nsfw = if user.is_admin && !post.media.is_empty() {
             admin_nsfw_form(post, csrf)
         } else {
@@ -1219,7 +1974,7 @@ fn post_card_with_options(
         };
         let reply_link = icon_link(&format!("/posts/{}#reply", post.id), "Reply", "reply");
         format!(
-            r#"<div class="actions" data-testid="post-actions">{}{}{}{}{}{}</div>"#,
+            r#"<div class="actions" data-testid="post-actions">{}{}{}{}{}{}{}{}</div>"#,
             icon_action_form(
                 &format!("/posts/{}/like", post.id),
                 csrf,
@@ -1256,6 +2011,8 @@ fn post_card_with_options(
                 "bookmark",
                 post.viewer_bookmarked
             ),
+            pin,
+            edit,
             delete,
             nsfw,
         )
@@ -1296,12 +2053,15 @@ fn post_card_with_options(
     } else {
         String::new()
     };
+    let edited = post.edited_at.as_ref().map_or_else(String::new, |_| {
+        r#"<span class="edited-marker" title="Post was edited">edited</span>"#.to_owned()
+    });
     let quote = post
         .quote
         .as_ref()
         .map_or_else(String::new, quote_preview_card);
     format!(
-        r#"<article class="{}" data-testid="post-card" id="post-{}" data-post-id="{}" data-event-id="{}"{}>{}{}<header class="post-header"><div class="author-block">{}<div>{}</div></div>{}</header><div class="text">{}</div>{}{}{}<div class="counts"><span data-count="likes">{} likes</span><span data-count="reposts">{} reposts</span><span data-count="replies">{} replies</span>{}</div>{}</article>"#,
+        r#"<article class="{}" data-testid="post-card" id="post-{}" data-post-id="{}" data-event-id="{}"{}>{}{}<header class="post-header"><div class="author-block">{}<div>{}</div></div>{}</header><div class="text">{}</div>{}{}{}<div class="counts"><span data-count="likes">{} likes</span><span data-count="reposts">{} reposts</span><span data-count="replies">{} replies</span>{}{}</div>{}</article>"#,
         post_class,
         post.id,
         post.id,
@@ -1319,11 +2079,26 @@ fn post_card_with_options(
         post.like_count,
         post.repost_count,
         post.reply_count,
+        edited,
         permalink,
         controls
     )
 }
 
+fn post_edit_available(created_at: &str, window_seconds: u64) -> bool {
+    if window_seconds == 0 {
+        return false;
+    }
+    let Some(created) = parse_timestamp(created_at) else {
+        return false;
+    };
+    let Ok(window_seconds) = i64::try_from(window_seconds) else {
+        return false;
+    };
+    let elapsed = Utc::now().signed_duration_since(created);
+    elapsed.num_seconds() >= 0 && elapsed.num_seconds() <= window_seconds
+}
+
 fn repost_action_with_quote(
     action: &str,
     quote_href: &str,
@@ -1373,6 +2148,20 @@ fn icon_action_form(
     )
 }
 
+fn pin_action_form(action: &str, csrf: &str, label: &str, active: bool) -> String {
+    format!(
+        r#"<form method="post" action="{}"><input type="hidden" name="csrf" value="{}"><button class="icon-button{}" type="submit" aria-pressed="{}" aria-label="{}" title="{}">{}<span class="sr-only">{}</span></button></form>"#,
+        html_escape::encode_double_quoted_attribute(action),
+        html_escape::encode_double_quoted_attribute(csrf),
+        if active { " active" } else { "" },
+        if active { "true" } else { "false" },
+        html_escape::encode_double_quoted_attribute(label),
+        html_escape::encode_double_quoted_attribute(label),
+        icon_svg("pin"),
+        html_escape::encode_text(label)
+    )
+}
+
 fn icon_link(href: &str, label: &str, icon: &str) -> String {
     format!(
         r#"<a class="icon-button" href="{}" aria-label="{}" title="{}">{}<span class="sr-only">{}</span></a>"#,
@@ -1433,7 +2222,7 @@ fn quote_preview_card(quote: &QuotePreview) -> String {
     )
 }
 
-fn icon_svg(icon: &str) -> &'static str {
+pub(crate) fn icon_svg(icon: &str) -> &'static str {
     match icon {
         "home" => {
             r#"<svg aria-hidden="true" viewBox="0 0 24 24"><path d="M3 11.3 12 3l9 8.3-2 2.1-1.1-1V20h-4.6v-5.2h-2.6V20H6.1v-7.6l-1.1 1-2-2.1z"/></svg>"#
@@ -1480,6 +2269,12 @@ fn icon_svg(icon: &str) -> &'static str {
         "trash" => {
             r#"<svg aria-hidden="true" viewBox="0 0 24 24"><path d="M9 3h6l1 2h4v3H4V5h4l1-2zm-3 7h12l-1 11H7L6 10zm4 2v7h2v-7h-2zm4 0v7h2v-7h-2z"/></svg>"#
         }
+        "edit" => {
+            r#"<svg aria-hidden="true" viewBox="0 0 24 24"><path d="M4 17.8V21h3.2L18.7 9.5l-3.2-3.2L4 17.8zM17.1 4.7l3.2 3.2 1.4-1.4c.4-.4.4-1 0-1.4l-1.8-1.8c-.4-.4-1-.4-1.4 0l-1.4 1.4z"/></svg>"#
+        }
+        "pin" => {
+            r#"<svg aria-hidden="true" viewBox="0 0 24 24"><path d="M14 2l8 8-2.1 2.1-1.4-1.4-4.2 4.2.7 4.9-1.6 1.6-4.2-4.2L4.4 22 2 19.6l4.8-4.8-4.2-4.2L4.2 9l4.9.7 4.2-4.2L11.9 4 14 2z"/></svg>"#
+        }
         "paperclip" => {
             r#"<svg aria-hidden="true" viewBox="0 0 24 24"><path d="M8.2 20.5a5.2 5.2 0 0 1-3.7-8.9l7.8-7.8a3.7 3.7 0 0 1 5.2 5.2l-7.8 7.8a2.2 2.2 0 0 1-3.1-3.1l7.3-7.3L16 8.5l-7.3 7.3.2.2 7.8-7.8a.7.7 0 0 0-1-1l-7.8 7.8a2.2 2.2 0 0 0 3.1 3.1l8.2-8.2 2.1 2.1-8.2 8.2a5.2 5.2 0 0 1-3.7 1.5c-.4 0-.8 0-1.2-.1z"/></svg>"#
         }
@@ -1500,7 +2295,7 @@ fn render_media(media: &MediaView, post_id: i64, index: usize, blur_nsfw_media:
     }
     let toggle_id = format!("nsfw-media-{post_id}-{index}");
     format!(
-        r#"<div class="nsfw-media" data-testid="nsfw-media"><input class="nsfw-toggle sr-only" id="{toggle_id}" type="checkbox" aria-label="Show NSFW media"><div class="nsfw-media-frame">{item}<span class="nsfw-badge">NSFW</span></div><label class="nsfw-show" for="{toggle_id}">Show<span class="sr-only"> NSFW media</span></label><a class="nsfw-open" href="{path}">Open media</a></div>"#
+        r#"<div class="nsfw-media" data-testid="nsfw-media"><input class="nsfw-toggle sr-only" id="{toggle_id}" type="checkbox" aria-label="Show NSFW media"><div class="nsfw-media-frame">{item}<span class="nsfw-badge">NSFW</span></div><label class="nsfw-show" for="{toggle_id}">Show<span class="sr-only"> NSFW media</span></label></div>"#
     )
 }
 
@@ -1686,13 +2481,39 @@ pub fn linkify(text: &str) -> String {
 }
 
 pub fn empty_state(title: &str, message: &str) -> String {
+    let message = empty_state_message(message);
     format!(
-        r#"<section class="empty-state"><h2>{}</h2><p>{}</p></section>"#,
+        r#"<section class="empty-state" data-testid="empty-state"><h2>{}</h2>{message}</section>"#,
+        html_escape::encode_text(title),
+    )
+}
+
+pub fn compact_empty_state(title: &str, message: &str) -> String {
+    compact_empty_state_with_class("", title, message)
+}
+
+pub fn compact_empty_state_with_class(extra_class: &str, title: &str, message: &str) -> String {
+    let class = if extra_class.trim().is_empty() {
+        "compact-empty".to_owned()
+    } else {
+        format!("compact-empty {}", extra_class.trim())
+    };
+    let message = empty_state_message(message);
+    format!(
+        r#"<div class="{}"><strong>{}</strong>{message}</div>"#,
+        html_escape::encode_double_quoted_attribute(&class),
         html_escape::encode_text(title),
-        html_escape::encode_text(message)
     )
 }
 
+fn empty_state_message(message: &str) -> String {
+    if message.trim().is_empty() {
+        String::new()
+    } else {
+        format!(r#"<p>{}</p>"#, html_escape::encode_text(message))
+    }
+}
+
 pub fn page_header(title: &str, subtitle: &str) -> String {
     format!(
         r#"<section class="page-header"><h1>{}</h1><p>{}</p></section>"#,
@@ -1702,7 +2523,7 @@ pub fn page_header(title: &str, subtitle: &str) -> String {
 }
 
 pub fn notifications_page(
-    notifications: &[NotificationView],
+    notifications: &[NotificationGroupView],
     unread_count: i64,
     csrf: &str,
 ) -> String {
@@ -1730,10 +2551,7 @@ pub fn notifications_page(
         return format!(
             "{}{}",
             header,
-            empty_state(
-                "No notifications yet",
-                "Replies, likes, reposts, follows, and mentions will appear here."
-            )
+            empty_state("No notifications.", "New activity will appear here.")
         );
     }
     let caught_up = if unread_count == 0 {
@@ -1745,11 +2563,11 @@ pub fn notifications_page(
         "{}{}<section class=\"notifications-list\" aria-label=\"Notifications\">{}</section>",
         header,
         caught_up,
-        grouped_notification_rows(notifications)
+        grouped_notification_rows(notifications, csrf)
     )
 }
 
-fn grouped_notification_rows(notifications: &[NotificationView]) -> String {
+fn grouped_notification_rows(notifications: &[NotificationGroupView], csrf: &str) -> String {
     let mut current_group = "";
     let mut html = String::new();
     for notification in notifications {
@@ -1761,13 +2579,13 @@ fn grouped_notification_rows(notifications: &[NotificationView]) -> String {
                 html_escape::encode_text(group)
             ));
         }
-        html.push_str(&notification_row(notification));
+        html.push_str(&notification_row(notification, csrf));
     }
     html
 }
 
-fn notification_group(notification: &NotificationView) -> &'static str {
-    if notification.read_at.is_none() {
+fn notification_group(notification: &NotificationGroupView) -> &'static str {
+    if notification.unread_count > 0 {
         "New"
     } else if is_today(&notification.created_at) {
         "Today"
@@ -1776,52 +2594,142 @@ fn notification_group(notification: &NotificationView) -> &'static str {
     }
 }
 
-fn notification_row(notification: &NotificationView) -> String {
-    let unread = notification.read_at.is_none();
+fn notification_row(notification: &NotificationGroupView, csrf: &str) -> String {
+    let unread = notification.unread_count > 0;
     let target = notification_target(notification);
-    let target_attrs = target.as_ref().map_or_else(String::new, |href| {
+    let form_id = format!("notification-open-{}", notification.id);
+    let target_attrs = target.as_ref().map_or_else(String::new, |_href| {
         format!(
-            r#" data-card-href="{}""#,
-            html_escape::encode_double_quoted_attribute(href)
+            r#" data-card-form="{}" tabindex="0""#,
+            html_escape::encode_double_quoted_attribute(&form_id)
         )
     });
     let preview = notification_preview(notification, target.as_deref());
     let unread_marker = if unread {
-        r#"<span class="unread-dot" aria-label="Unread"></span>"#
+        format!(
+            r#"<span class="unread-dot" aria-label="{}"></span>"#,
+            html_escape::encode_double_quoted_attribute(&notification_unread_label(
+                notification.unread_count
+            ))
+        )
     } else {
-        ""
+        String::new()
     };
+    let details = notification_actor_details(notification);
+    let open_control = notification_open_control(notification, target.as_deref(), &form_id, csrf);
     format!(
-        r#"<article class="notification-row{}"{}><div class="notification-kind" aria-hidden="true">{}</div><div class="notification-body"><p class="notification-line">{} <span>{}</span></p>{}<p class="notification-meta"><time datetime="{}">{}</time></p></div>{}</article>"#,
+        r#"<article class="notification-row{}"{}><div class="notification-kind" aria-hidden="true">{}</div><div class="notification-body"><p class="notification-line">{}</p>{}{}<p class="notification-meta"><time datetime="{}">{}</time>{}</p></div>{}{}</article>"#,
         if unread { " unread" } else { "" },
         target_attrs,
         html_escape::encode_text(notification_kind_label(&notification.kind)),
-        notification_actor(notification),
-        html_escape::encode_text(notification_action_text(&notification.kind)),
+        notification_line(notification),
         preview,
+        details,
         html_escape::encode_double_quoted_attribute(&notification.created_at),
         html_escape::encode_text(&relative_time(&notification.created_at)),
+        notification_count_meta(notification),
+        open_control,
         unread_marker
     )
 }
 
-fn notification_actor(notification: &NotificationView) -> String {
-    match (
-        notification.actor_username.as_deref(),
-        notification.actor_display_name.as_deref(),
-    ) {
+fn notification_line(notification: &NotificationGroupView) -> String {
+    if notification.total_count == 1 {
+        return format!(
+            "{} <span>{}</span>",
+            notification_actor(
+                notification
+                    .actors
+                    .first()
+                    .and_then(|actor| actor.username.as_deref()),
+                notification
+                    .actors
+                    .first()
+                    .and_then(|actor| actor.display_name.as_deref()),
+                notification.actors.first().and_then(|actor| actor.user_id)
+            ),
+            html_escape::encode_text(notification_action_text(&notification.kind))
+        );
+    }
+    format!(
+        r#"<strong>{}</strong> <span>{}</span>"#,
+        html_escape::encode_text(&notification_people_label(notification.total_count)),
+        html_escape::encode_text(notification_group_action_text(&notification.kind))
+    )
+}
+
+fn notification_actor(
+    username: Option<&str>,
+    display_name: Option<&str>,
+    user_id: Option<i64>,
+) -> String {
+    match (username, display_name) {
         (Some(username), display_name) => format!(
             r#"<a class="author-name" href="/users/{}">{}</a> <span class="username">@{}</span>"#,
             html_escape::encode_double_quoted_attribute(username),
             html_escape::encode_text(display_name.unwrap_or(username)),
             html_escape::encode_text(username)
         ),
-        (None, _) if notification.actor_user_id.is_some() => "Deleted account".to_owned(),
+        (None, _) if user_id.is_some() => "Deleted account".to_owned(),
         _ => "Someone".to_owned(),
     }
 }
 
-fn notification_preview(notification: &NotificationView, target: Option<&str>) -> String {
+fn notification_actor_details(notification: &NotificationGroupView) -> String {
+    if notification.total_count <= 1 {
+        return String::new();
+    }
+    let actors = notification
+        .actors
+        .iter()
+        .map(|actor| {
+            format!(
+                r#"<li>{}</li>"#,
+                notification_actor(
+                    actor.username.as_deref(),
+                    actor.display_name.as_deref(),
+                    actor.user_id
+                )
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("");
+    format!(
+        r#"<details class="notification-actors"><summary>View people</summary><ul>{actors}</ul></details>"#
+    )
+}
+
+fn notification_open_control(
+    notification: &NotificationGroupView,
+    target: Option<&str>,
+    form_id: &str,
+    csrf: &str,
+) -> String {
+    let Some(target) = target else {
+        return String::new();
+    };
+    let notification_ids = notification
+        .notification_ids
+        .iter()
+        .map(i64::to_string)
+        .collect::<Vec<_>>()
+        .join(",");
+    let group_target = notification
+        .group_target_post_id
+        .map_or_else(String::new, |id| {
+            format!(r#"<input type="hidden" name="group_target_post_id" value="{id}">"#)
+        });
+    format!(
+        r#"<form id="{}" class="notification-open-form" method="post" action="/notifications/open"><input type="hidden" name="csrf" value="{}"><input type="hidden" name="notification_ids" value="{}"><input type="hidden" name="group_kind" value="{}">{group_target}<input type="hidden" name="return_to" value="{}"><button class="button-link notification-open" type="submit">Open</button></form>"#,
+        html_escape::encode_double_quoted_attribute(form_id),
+        html_escape::encode_double_quoted_attribute(csrf),
+        html_escape::encode_double_quoted_attribute(&notification_ids),
+        html_escape::encode_double_quoted_attribute(&notification.kind),
+        html_escape::encode_double_quoted_attribute(target)
+    )
+}
+
+fn notification_preview(notification: &NotificationGroupView, target: Option<&str>) -> String {
     if notification.kind == "follow" {
         return String::new();
     }
@@ -1849,10 +2757,12 @@ fn notification_preview(notification: &NotificationView, target: Option<&str>) -
     }
 }
 
-fn notification_target(notification: &NotificationView) -> Option<String> {
+fn notification_target(notification: &NotificationGroupView) -> Option<String> {
     if notification.kind == "follow" {
         return notification
-            .actor_username
+            .actors
+            .first()
+            .and_then(|actor| actor.username.as_ref())
             .as_ref()
             .map(|username| format!("/users/{username}"));
     }
@@ -1863,6 +2773,47 @@ fn notification_target(notification: &NotificationView) -> Option<String> {
         .map(|post_id| format!("/posts/{post_id}"))
 }
 
+fn notification_count_meta(notification: &NotificationGroupView) -> String {
+    if notification.total_count <= 1 && notification.unread_count == 0 {
+        return String::new();
+    }
+    let mut parts = Vec::new();
+    if notification.total_count > 1 {
+        parts.push(notification_items_label(notification.total_count));
+    }
+    if notification.unread_count > 0 {
+        parts.push(notification_unread_label(notification.unread_count));
+    }
+    format!(
+        r#" <span class="notification-counts">{}</span>"#,
+        html_escape::encode_text(&parts.join(" / "))
+    )
+}
+
+fn notification_people_label(count: usize) -> String {
+    if count == 1 {
+        "1 person".to_owned()
+    } else {
+        format!("{count} people")
+    }
+}
+
+fn notification_items_label(count: usize) -> String {
+    if count == 1 {
+        "1 notification".to_owned()
+    } else {
+        format!("{count} notifications")
+    }
+}
+
+fn notification_unread_label(count: i64) -> String {
+    if count == 1 {
+        "1 unread".to_owned()
+    } else {
+        format!("{count} unread")
+    }
+}
+
 fn notification_action_text(kind: &str) -> &'static str {
     match kind {
         "reply" => "replied to your post",
@@ -1875,6 +2826,18 @@ fn notification_action_text(kind: &str) -> &'static str {
     }
 }
 
+fn notification_group_action_text(kind: &str) -> &'static str {
+    match kind {
+        "reply" => "replied to your post",
+        "like" => "liked your post",
+        "repost" => "reposted your post",
+        "quote" => "quoted your post",
+        "follow" => "followed you",
+        "mention" => "mentioned you in a post",
+        _ => "sent you notifications",
+    }
+}
+
 fn notification_kind_label(kind: &str) -> &'static str {
     match kind {
         "reply" => "R",
@@ -1965,13 +2928,13 @@ pub fn error_page(status: StatusCode, message: &str) -> String {
 }
 
 const CSS: &str = r#"
-:root{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color-scheme:light;line-height:1.5;--bg:#f5f6f1;--surface:#fff;--surface-subtle:#fbfcfa;--surface-muted:#f4f5f2;--header-bg:rgba(255,255,255,.96);--text:#202124;--text-strong:#172017;--muted:#667064;--muted-strong:#59625a;--border:#dfe4dc;--border-strong:#b9c2b8;--link:#1f5f8b;--link-strong:#24445f;--brand:#163b2f;--brand-hover:#235544;--brand-text:#fff;--hover:#eef3f0;--focus:#93c5fd;--shadow:rgba(20,35,30,.04);--reply-border:#c8d8d0;--avatar-bg:#eef3f0;--danger:#8a3d2d;--danger-strong:#6f2f22;--danger-bg:#fff8f5;--danger-border:#e6b8a8;--success-bg:#f4fbf5;--success-border:#add7b4;--media-bg:#f6f7f4;--shell-side:240px;--shell-primary:640px;--shell-gap:1.25rem;--shell-max:1160px;--header-padding-y:.8rem;--header-brand-size:2rem;--hairline:1px;--rail-sticky-top:calc(var(--header-brand-size) + var(--header-padding-y) + var(--header-padding-y) + var(--shell-gap) + var(--hairline))}
-:root[data-theme="dark"]{color-scheme:dark;--bg:#111827;--surface:#182231;--surface-subtle:#1d2939;--surface-muted:#233044;--header-bg:rgba(17,24,39,.96);--text:#eef4fb;--text-strong:#f8fafc;--muted:#c3cfdd;--muted-strong:#d4deea;--border:#344256;--border-strong:#596b83;--link:#8fc7ff;--link-strong:#badcff;--brand:#4f8fc7;--brand-hover:#6aa8df;--brand-text:#06111f;--hover:#243349;--focus:#fbbf24;--shadow:rgba(0,0,0,.26);--reply-border:#4f6680;--avatar-bg:#243349;--danger:#ffb4a2;--danger-strong:#ffd2c7;--danger-bg:#3a2020;--danger-border:#8f4d43;--success-bg:#163321;--success-border:#4c8a61;--media-bg:#0f172a}
+:root{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color-scheme:light;line-height:1.5;--bg:#f5f6f1;--surface:#fff;--surface-subtle:#fbfcfa;--surface-muted:#f4f5f2;--header-bg:rgba(255,255,255,.96);--text:#202124;--text-strong:#172017;--muted:#667064;--muted-strong:#59625a;--border:#dfe4dc;--border-strong:#b9c2b8;--link:#1f5f8b;--link-strong:#24445f;--brand:#163b2f;--brand-hover:#235544;--brand-text:#fff;--hover:#eef3f0;--focus:#93c5fd;--shadow:rgba(20,35,30,.04);--reply-border:#c8d8d0;--avatar-bg:#eef3f0;--warning:#9a5a00;--danger:#8a3d2d;--danger-strong:#6f2f22;--danger-bg:#fff8f5;--danger-border:#e6b8a8;--success-bg:#f4fbf5;--success-border:#add7b4;--media-bg:#f6f7f4;--shell-side:240px;--shell-primary:640px;--shell-gap:1.25rem;--shell-max:1160px;--header-padding-y:.8rem;--header-brand-size:2rem;--hairline:1px;--rail-sticky-top:calc(var(--header-brand-size) + var(--header-padding-y) + var(--header-padding-y) + var(--shell-gap) + var(--hairline))}
+:root[data-theme="dark"]{color-scheme:dark;--bg:#111827;--surface:#182231;--surface-subtle:#1d2939;--surface-muted:#233044;--header-bg:rgba(17,24,39,.96);--text:#eef4fb;--text-strong:#f8fafc;--muted:#c3cfdd;--muted-strong:#d4deea;--border:#344256;--border-strong:#596b83;--link:#8fc7ff;--link-strong:#badcff;--brand:#4f8fc7;--brand-hover:#6aa8df;--brand-text:#06111f;--hover:#243349;--focus:#fbbf24;--shadow:rgba(0,0,0,.26);--reply-border:#4f6680;--avatar-bg:#243349;--warning:#f6c36b;--danger:#ffb4a2;--danger-strong:#ffd2c7;--danger-bg:#3a2020;--danger-border:#8f4d43;--success-bg:#163321;--success-border:#4c8a61;--media-bg:#0f172a}
 *{box-sizing:border-box}body{margin:0;min-width:320px;color:var(--text);background:var(--bg)}a{color:var(--link);text-decoration:none}a:hover{text-decoration:underline}
 .site-header{position:sticky;top:0;z-index:10;background:var(--header-bg);border-bottom:1px solid var(--border);backdrop-filter:blur(8px)}
 .header-inner{max-width:var(--shell-max);margin:0 auto;padding:var(--header-padding-y) 1rem;display:flex;align-items:center;justify-content:space-between;gap:1rem}
 .header-brand-row{display:flex;align-items:center;gap:.75rem;min-width:0;max-width:100%}.brand{display:flex;align-items:center;gap:.55rem;font-weight:800;color:var(--text-strong);min-width:0}.brand span:last-child{overflow-wrap:anywhere}.brand-mark{display:inline-grid;place-items:center;width:var(--header-brand-size);height:var(--header-brand-size);border-radius:7px;background:var(--brand);color:var(--brand-text);flex:0 0 auto}
-.tor-indicator{display:inline-flex;align-items:center;gap:.28rem;min-width:0;max-width:min(28rem,100%);flex:1 1 14rem;min-height:2rem;border-left:1px solid var(--border);padding:.05rem 0 .05rem .7rem;color:var(--muted-strong);font-size:.86rem;line-height:1;white-space:nowrap;overflow:hidden}.tor-label{flex:0 0 auto;color:var(--muted);font-weight:800}.tor-address-link{display:inline-flex;align-items:center;min-width:0;max-width:100%;flex:1 1 auto;min-height:1.9rem;padding:0 .1rem;color:var(--link-strong);font-weight:750}.tor-address-link:hover{color:var(--text-strong);text-decoration:underline}.tor-summary-text{display:block;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-variant-numeric:tabular-nums}.tor-copy-button{display:none;flex:0 0 auto;min-width:2.55rem;min-height:1.9rem;border:1px solid transparent;border-radius:6px;background:transparent;color:var(--muted-strong);padding:.18rem .35rem;font-size:.82rem;font-weight:800;line-height:1;box-shadow:none}.js-enabled .tor-copy-button{display:inline-flex;align-items:center;justify-content:center}.tor-copy-button:hover{background:var(--hover);color:var(--link-strong)}
+.tor-indicator{position:relative;display:inline-flex;align-items:center;min-width:0;max-width:min(18rem,100%);flex:0 1 auto;color:var(--muted-strong);font-size:.84rem;line-height:1;white-space:nowrap}.tor-disclosure{position:relative;min-width:0;max-width:100%;flex:0 1 auto}.tor-pill{display:inline-flex;align-items:center;gap:.38rem;max-width:100%;min-height:2.15rem;border:1px solid var(--border);border-radius:999px;padding:.25rem .68rem;background:var(--surface-subtle);color:var(--link-strong);font-weight:800;cursor:pointer;list-style:none;overflow:hidden}.js-enabled .tor-pill{padding-right:3.85rem}.tor-pill::-webkit-details-marker{display:none}.tor-pill::marker{content:""}.tor-pill:hover{background:var(--hover);text-decoration:none}.tor-pill-label{flex:0 0 auto;color:var(--muted);font-weight:900}.tor-summary-text{display:block;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-variant-numeric:tabular-nums}.tor-details{position:absolute;z-index:12;left:0;top:calc(100% + .35rem);width:max-content;max-width:min(30rem,calc(100vw - 2rem));padding:.55rem .65rem;border:1px solid var(--border-strong);border-radius:8px;background:var(--surface);box-shadow:0 8px 24px var(--shadow);white-space:normal}.tor-full-link{display:block;max-width:min(28rem,calc(100vw - 3.5rem));overflow-wrap:anywhere;color:var(--text-strong);font-weight:800;line-height:1.3}.tor-full-link:hover{color:var(--link-strong)}.tor-copy-button{display:none;position:absolute;z-index:13;right:.22rem;top:50%;transform:translateY(-50%);align-items:center;justify-content:center;width:3.25rem;min-height:1.65rem;border:1px solid var(--border);border-radius:999px;background:var(--surface);color:var(--link-strong);padding:.12rem .35rem;font-size:.78rem;font-weight:850;line-height:1;box-shadow:none}.js-enabled .tor-copy-button{display:inline-flex}.tor-copy-button:hover{background:var(--hover);color:var(--text-strong)}
 nav{display:flex;gap:.35rem;align-items:center;flex-wrap:wrap;justify-content:flex-end}nav a,nav button,.button-link{display:inline-flex;align-items:center;gap:.35rem;min-height:2.15rem;border-radius:7px;padding:.42rem .65rem;color:var(--link-strong);border:1px solid transparent;background:transparent}
 nav a:hover,nav button:hover,.button-link:hover{background:var(--hover);text-decoration:none}nav form,.actions form{display:inline}
 nav svg{width:1.05rem;height:1.05rem;fill:currentColor;flex:0 0 auto}
@@ -1979,21 +2942,23 @@ nav svg{width:1.05rem;height:1.05rem;fill:currentColor;flex:0 0 auto}
 main{padding:var(--shell-gap)}.app-shell{width:min(100%,var(--shell-max));margin:0 auto;display:grid;grid-template-columns:var(--shell-side) minmax(0,var(--shell-primary)) var(--shell-side);gap:var(--shell-gap);align-items:start;justify-content:center}.primary-column{min-width:0;width:100%}.left-rail,.right-rail{min-width:0;position:sticky;top:var(--rail-sticky-top);display:grid;gap:.75rem;align-items:start}.side-rail-card,.rail-nav{background:var(--surface);border:1px solid var(--border);border-radius:8px;color:var(--muted-strong);box-shadow:0 1px 2px var(--shadow)}.side-rail-card{padding:.85rem}.side-rail-card h2{margin:.1rem 0 .6rem;font-size:1rem;color:var(--text)}.rail-nav{display:grid;grid-template-columns:minmax(0,1fr);gap:.2rem;width:100%;padding:.35rem;justify-content:stretch}.rail-nav a,.rail-nav button{width:100%;min-height:2.35rem;justify-content:flex-start;padding:.5rem .65rem}.rail-nav form{display:block}.mobile-nav{display:none}.dashboard-list{display:grid;grid-template-columns:auto minmax(0,1fr);gap:.45rem .75rem;margin:.25rem 0 .85rem}.dashboard-list dt{font-weight:800;color:var(--text)}.dashboard-list dd{margin:0;overflow-wrap:anywhere}.dashboard-account{color:var(--text)}.dashboard-account:hover{text-decoration:none}.dashboard-actions{display:flex;flex-wrap:wrap;gap:.4rem}.site-footer{max-width:var(--shell-max);margin:0 auto;padding:1rem;color:var(--muted);font-size:.9rem}
 .page-header,.post,.composer,.panel,.empty-state,.notice{background:var(--surface);border:1px solid var(--border);border-radius:8px;margin:0 0 .7rem;padding:.85rem;box-shadow:0 1px 2px var(--shadow)}
 .page-header h1,.section-heading h1,.panel h1{margin:0;font-size:1.45rem;line-height:1.2}.panel h1+table,.panel h1+form,.panel h1+p,.panel h1+dl{margin-top:.85rem}.page-header p,.muted,.empty-state p{color:var(--muted);margin:.35rem 0 0}.section-heading{display:flex;justify-content:space-between;gap:1rem;align-items:baseline;margin-bottom:.8rem}
-.notifications-hero{background:var(--surface);border:1px solid var(--border);border-radius:8px;margin:0 0 .7rem;padding:1rem;box-shadow:0 1px 2px var(--shadow);display:flex;align-items:center;justify-content:space-between;gap:1rem}.notifications-hero h1{margin:0;font-size:1.55rem;line-height:1.15}.notifications-hero p:not(.eyebrow){margin:.35rem 0 0;color:var(--muted-strong)}.caught-up-pill{display:inline-flex;align-items:center;min-height:2rem;border:1px solid var(--success-border);border-radius:999px;background:var(--success-bg);color:var(--text-strong);padding:.32rem .75rem;font-weight:800}.caught-up{padding:.75rem .85rem}.caught-up p{margin:0}.notifications-list{display:grid;gap:.5rem}.notification-group{margin:.8rem .15rem .2rem;color:var(--muted);font-size:.82rem;text-transform:uppercase;letter-spacing:.08em}.notification-row{position:relative;display:grid;grid-template-columns:auto minmax(0,1fr) auto;gap:.75rem;align-items:start;background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:.8rem;box-shadow:0 1px 2px var(--shadow)}.notification-row.unread{border-color:var(--border-strong);background:var(--surface-subtle)}.js-enabled .notification-row[data-card-href]{cursor:pointer}.js-enabled .notification-row[data-card-href]:hover{border-color:var(--border-strong);background:var(--hover)}.notification-kind{display:grid;place-items:center;width:2rem;height:2rem;border-radius:7px;background:var(--surface-muted);color:var(--link-strong);font-weight:900;font-size:.8rem}.notification-row.unread .notification-kind{background:var(--brand);color:var(--brand-text)}.notification-body{min-width:0}.notification-line{margin:0;overflow-wrap:anywhere}.notification-meta{margin:.35rem 0 0;color:var(--muted);font-size:.88rem}.notification-preview{display:block;margin:.5rem 0 0;border:1px solid var(--border);border-radius:7px;padding:.55rem .65rem;background:var(--surface-subtle);color:var(--muted-strong);overflow-wrap:anywhere}.notification-preview:hover{background:var(--surface);text-decoration:none}.notification-preview.unavailable{border-style:dashed}.unread-dot{width:.65rem;height:.65rem;border-radius:999px;background:var(--brand);margin-top:.7rem}
+.character-counter{display:inline-block;flex:0 0 auto;min-width:8.5rem;text-align:right;white-space:nowrap;font-variant-numeric:tabular-nums}.character-counter-normal{color:var(--muted)}.character-counter-warning{color:var(--warning)}.character-counter-danger{color:var(--danger)}
+.notifications-hero{background:var(--surface);border:1px solid var(--border);border-radius:8px;margin:0 0 .7rem;padding:1rem;box-shadow:0 1px 2px var(--shadow);display:flex;align-items:center;justify-content:space-between;gap:1rem}.notifications-hero h1{margin:0;font-size:1.55rem;line-height:1.15}.notifications-hero p:not(.eyebrow){margin:.35rem 0 0;color:var(--muted-strong)}.caught-up-pill{display:inline-flex;align-items:center;min-height:2rem;border:1px solid var(--success-border);border-radius:999px;background:var(--success-bg);color:var(--text-strong);padding:.32rem .75rem;font-weight:800}.caught-up{padding:.75rem .85rem}.caught-up p{margin:0}.notifications-list{display:grid;gap:.5rem}.notification-group{margin:.8rem .15rem .2rem;color:var(--muted);font-size:.82rem;text-transform:uppercase;letter-spacing:.08em}.notification-row{position:relative;display:grid;grid-template-columns:auto minmax(0,1fr) auto auto;gap:.75rem;align-items:start;background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:.8rem;box-shadow:0 1px 2px var(--shadow)}.notification-row.unread{border-color:var(--border-strong);background:var(--surface-subtle)}.js-enabled .notification-row[data-card-href],.js-enabled .notification-row[data-card-form]{cursor:pointer}.js-enabled .notification-row[data-card-href]:hover,.js-enabled .notification-row[data-card-form]:hover{border-color:var(--border-strong);background:var(--hover)}.notification-kind{display:grid;place-items:center;width:2rem;height:2rem;border-radius:7px;background:var(--surface-muted);color:var(--link-strong);font-weight:900;font-size:.8rem}.notification-row.unread .notification-kind{background:var(--brand);color:var(--brand-text)}.notification-body{min-width:0}.notification-line{margin:0;overflow-wrap:anywhere}.notification-meta{margin:.35rem 0 0;color:var(--muted);font-size:.88rem}.notification-counts{color:var(--muted-strong);font-weight:800}.notification-preview{display:block;margin:.5rem 0 0;border:1px solid var(--border);border-radius:7px;padding:.55rem .65rem;background:var(--surface-subtle);color:var(--muted-strong);overflow-wrap:anywhere}.notification-preview:hover{background:var(--surface);text-decoration:none}.notification-preview.unavailable{border-style:dashed}.notification-actors{margin:.45rem 0 0}.notification-actors summary{display:inline-flex;align-items:center;min-height:1.7rem;color:var(--link-strong);font-weight:800;cursor:pointer}.notification-actors ul{list-style:none;margin:.25rem 0 0;padding:0;display:flex;flex-wrap:wrap;gap:.35rem}.notification-actors li{border:1px solid var(--border);border-radius:999px;background:var(--surface-subtle);padding:.16rem .5rem;font-size:.88rem}.notification-open-form{display:flex;align-items:flex-start}.notification-open{min-height:2rem;padding:.3rem .55rem;background:var(--surface);border-color:var(--border)}.unread-dot{width:.65rem;height:.65rem;border-radius:999px;background:var(--brand);margin-top:.7rem}
 label{display:block;font-weight:700;margin:.85rem 0 .35rem}input,textarea,button,select{font:inherit}input[type=text],input[type=search],input[type=password],input[type=url],input:not([type]),textarea,select{width:100%;padding:.72rem .8rem;border:1px solid var(--border-strong);border-radius:7px;background:var(--surface);color:var(--text)}textarea{resize:vertical;min-height:7rem}::placeholder{color:var(--muted)}
 input[type=checkbox]{accent-color:var(--brand)}.check-row,.theme-toggle{display:flex;align-items:center;gap:.55rem;font-weight:700;color:var(--text)}.theme-toggle{padding:.65rem .75rem;border:1px solid var(--border);border-radius:8px;background:var(--surface-subtle)}.theme-toggle input{width:auto}
 input[type=text].password-visible{padding-right:.8rem}.password-control{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:.45rem;align-items:center}.password-control input{min-width:0}.password-toggle{display:none;background:var(--surface);color:var(--link-strong);border-color:var(--border);min-width:4.5rem}.js-enabled .password-toggle{display:inline-block}.auth-submit{margin-top:1.15rem}.auth-form{margin-top:.35rem}.auth-form .field-help{margin:.15rem 0 .4rem;color:var(--muted-strong)}
 .search-panel h1{margin-bottom:.75rem}.search-form{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:.55rem;align-items:center}.search-form input{min-width:0}.search-results{display:grid;gap:.65rem}.section-title{margin:.2rem 0 .65rem;font-size:1.05rem;color:var(--text)}.search-users{margin-bottom:0}.search-users .section-title{margin-top:0}.search-account{grid-template-columns:auto minmax(0,1fr)}
-input:focus,textarea:focus,select:focus,button:focus-visible,a:focus-visible{outline:3px solid var(--focus);outline-offset:2px}button,.primary{border:1px solid var(--brand);background:var(--brand);color:var(--brand-text);border-radius:7px;padding:.5rem .8rem;cursor:pointer;font-weight:700}button:hover,.primary:hover{background:var(--brand-hover);text-decoration:none}
+input:focus,textarea:focus,select:focus,button:focus-visible,a:focus-visible{outline:3px solid var(--focus);outline-offset:2px}button,.primary{border:1px solid var(--brand);background:var(--brand);color:var(--brand-text);border-radius:7px;padding:.5rem .8rem;cursor:pointer;font-weight:700}button:hover,.primary:hover{background:var(--brand-hover);text-decoration:none}button:disabled,.primary:disabled,button:disabled:hover,.primary:disabled:hover{border-color:var(--border);background:var(--surface-muted);color:var(--muted);cursor:not-allowed;opacity:1}
 nav button{border-color:transparent;background:transparent;color:var(--link-strong);padding:.42rem .65rem}.rail-nav button{border-color:transparent;background:transparent;color:var(--link-strong);padding:.5rem .65rem}.rail-nav button:hover,.mobile-nav button:hover{background:var(--hover);color:var(--link-strong)}
-.composer-surface{border:1px solid var(--border-strong);border-radius:7px;background:var(--surface);overflow:hidden}.composer-surface textarea{border:0;border-radius:0;background:transparent;min-height:7rem;resize:vertical}.composer-surface textarea:focus{outline:0;box-shadow:inset 0 0 0 3px var(--focus)}.composer-footer{display:flex;align-items:center;justify-content:space-between;gap:.55rem;border-top:1px solid var(--border);padding:.42rem .5rem;background:var(--surface-subtle)}.composer-file-control{position:relative;display:inline-flex;align-items:center;gap:.45rem;max-width:100%;margin:0;color:var(--link-strong);font-weight:800}.composer-file-input{max-width:100%;color:var(--muted-strong)}.composer-file-input::file-selector-button{border:1px solid var(--border);border-radius:7px;background:var(--surface);color:var(--link-strong);padding:.34rem .58rem;font-weight:800;cursor:pointer}.composer-file-input::file-selector-button:hover{background:var(--hover);color:var(--text-strong)}.composer-file-button{display:none}.js-enabled .composer-file-input{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.js-enabled .composer-file-button{display:inline-flex;align-items:center;gap:.38rem;min-height:2rem;border:1px solid var(--border);border-radius:7px;background:var(--surface);color:var(--link-strong);padding:.3rem .55rem;cursor:pointer}.composer-file-button svg{width:1rem;height:1rem;fill:currentColor;flex:0 0 auto}.js-enabled .composer-file-control:hover .composer-file-button{background:var(--hover);color:var(--text-strong)}.js-enabled .composer-file-input:focus-visible+.composer-file-button{outline:3px solid var(--focus);outline-offset:2px}.composer-media-selection[hidden]{display:none}.composer-media-selection{display:flex;align-items:center;gap:.7rem;flex-wrap:wrap;border-top:1px solid var(--border);padding:.5rem;background:var(--surface)}.composer-media-summary{font-weight:800;color:var(--muted-strong);overflow-wrap:anywhere}.composer-nsfw{margin:0}.composer-clear-media{background:var(--surface);color:var(--link-strong);border-color:var(--border);padding:.32rem .55rem}.composer-clear-media:hover{background:var(--hover);color:var(--text-strong)}.composer-tools{display:flex;align-items:center;justify-content:space-between;gap:.75rem;margin-top:.85rem}
+.composer-surface{position:relative;border:1px solid var(--border-strong);border-radius:7px;background:var(--surface);overflow:visible}.composer-surface textarea{border:0;border-radius:0;background:transparent;min-height:7rem;resize:vertical}.composer-surface textarea:focus{outline:0;box-shadow:inset 0 0 0 3px var(--focus)}.mention-menu[hidden]{display:none}.mention-menu{position:absolute;z-index:9;left:.55rem;right:.55rem;top:3.1rem;max-height:12rem;overflow:auto;border:1px solid var(--border-strong);border-radius:7px;background:var(--surface);box-shadow:0 8px 24px var(--shadow);padding:.25rem}.mention-option{display:grid;width:100%;grid-template-columns:minmax(0,1fr) auto;gap:.65rem;align-items:center;border:0;border-radius:6px;background:transparent;color:var(--text);padding:.42rem .5rem;text-align:left}.mention-option:hover,.mention-option[aria-selected="true"]{background:var(--hover);color:var(--text-strong)}.mention-name{font-weight:800;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.mention-handle{color:var(--muted);font-size:.9rem}.composer-footer{display:flex;align-items:center;justify-content:space-between;gap:.55rem;border-top:1px solid var(--border);padding:.42rem .5rem;background:var(--surface-subtle)}.composer-file-control{position:relative;display:inline-flex;align-items:center;gap:.45rem;max-width:100%;margin:0;color:var(--link-strong);font-weight:800}.composer-file-input{max-width:100%;color:var(--muted-strong)}.composer-file-input::file-selector-button{border:1px solid var(--border);border-radius:7px;background:var(--surface);color:var(--link-strong);padding:.34rem .58rem;font-weight:800;cursor:pointer}.composer-file-input::file-selector-button:hover{background:var(--hover);color:var(--text-strong)}.composer-file-button{display:none}.js-enabled .composer-file-input{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.js-enabled .composer-file-button{display:inline-flex;align-items:center;gap:.38rem;min-height:2rem;border:1px solid var(--border);border-radius:7px;background:var(--surface);color:var(--link-strong);padding:.3rem .55rem;cursor:pointer}.composer-file-button svg{width:1rem;height:1rem;fill:currentColor;flex:0 0 auto}.js-enabled .composer-file-control:hover .composer-file-button{background:var(--hover);color:var(--text-strong)}.js-enabled .composer-file-input:focus-visible+.composer-file-button{outline:3px solid var(--focus);outline-offset:2px}.composer-media-selection[hidden]{display:none}.composer-media-selection{display:flex;align-items:center;gap:.7rem;flex-wrap:wrap;border-top:1px solid var(--border);padding:.5rem;background:var(--surface)}.composer-media-summary{font-weight:800;color:var(--muted-strong);overflow-wrap:anywhere}.composer-nsfw{margin:0}.composer-clear-media{background:var(--surface);color:var(--link-strong);border-color:var(--border);padding:.32rem .55rem}.composer-clear-media:hover{background:var(--hover);color:var(--text-strong)}.composer-tools{display:flex;align-items:center;justify-content:space-between;gap:.75rem;margin-top:.85rem}
 .thread-nav{display:flex;margin:0 0 .45rem .85rem}.thread-back{width:2rem;height:2rem;display:inline-flex;align-items:center;justify-content:center;border-radius:999px;color:var(--link-strong)}.thread-back svg{width:1.2rem;height:1.2rem;fill:currentColor}.thread-back:hover{background:var(--hover);text-decoration:none}
-.timeline{display:grid;gap:.65rem}.post{overflow:hidden;position:relative}.js-enabled .post[data-card-href]{cursor:pointer}.js-enabled .post[data-card-href]:hover{border-color:var(--border-strong)}.reply-post{margin-left:1.1rem;border-left:4px solid var(--reply-border);background:var(--surface-subtle)}.reply-post::before{content:"";position:absolute;left:-1.1rem;top:1.25rem;width:1.1rem;border-top:2px solid var(--reply-border)}.anchor-target{position:absolute;top:-5rem}.post-header{display:flex;justify-content:space-between;gap:.65rem;align-items:flex-start}.author-block{display:flex;gap:.55rem;align-items:center;min-width:0}.post-avatar{width:2rem;height:2rem;object-fit:cover;border-radius:999px;border:1px solid var(--border);background:var(--avatar-bg);flex:0 0 auto;margin:0}.post-avatar.placeholder{display:inline-grid;place-items:center;color:var(--muted-strong);font-weight:800}.author-name{font-weight:800;color:var(--text-strong)}.username,.post-time,.counts{color:var(--muted);font-size:.92rem}.text{white-space:pre-wrap;margin:.55rem 0;line-height:1.5;overflow-wrap:anywhere}.post img,.post video{display:block;max-width:100%;border-radius:8px;border:1px solid var(--border);margin-top:.5rem;background:var(--media-bg)}.post img.post-avatar{display:block;margin:0;border-radius:999px}.youtube-previews{display:grid;gap:.45rem;margin:.35rem 0 .55rem}.youtube-preview-card{display:grid;grid-template-columns:minmax(5.5rem,7.5rem) minmax(0,1fr);gap:.65rem;align-items:center;min-height:4.5rem;border:1px solid var(--border);border-radius:7px;background:var(--surface-subtle);color:var(--text);overflow:hidden}.youtube-preview-card:hover{border-color:var(--border-strong);background:var(--hover);text-decoration:none}.youtube-thumbnail-frame{position:relative;display:block;width:100%;aspect-ratio:16/9;overflow:hidden;background:var(--media-bg)}.post img.youtube-thumbnail{width:100%;height:100%;object-fit:cover;margin:0;border:0;border-radius:0}.youtube-play{position:absolute;left:50%;top:50%;width:2rem;height:2rem;border-radius:999px;background:rgba(0,0,0,.68);transform:translate(-50%,-50%)}.youtube-play::before{content:"";position:absolute;left:.78rem;top:.55rem;border-top:.45rem solid transparent;border-bottom:.45rem solid transparent;border-left:.65rem solid #fff}.youtube-preview-body{display:grid;gap:.08rem;min-width:0;padding:.45rem .55rem .45rem 0}.youtube-preview-source{color:var(--muted);font-size:.78rem;font-weight:900;text-transform:uppercase}.youtube-preview-title{color:var(--text-strong);font-weight:850;overflow-wrap:anywhere}.youtube-preview-url{color:var(--muted-strong);font-size:.86rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.nsfw-media{position:relative;margin-top:.5rem}.nsfw-media .post img,.nsfw-media .post video{margin-top:0}.nsfw-media-frame{position:relative;display:block;overflow:hidden;border-radius:8px}.nsfw-media-frame img,.nsfw-media-frame video{margin-top:0;filter:blur(24px);transform:scale(1.02)}.nsfw-toggle:checked+.nsfw-media-frame img,.nsfw-toggle:checked+.nsfw-media-frame video{filter:none;transform:none}.nsfw-badge{position:absolute;left:.55rem;bottom:.55rem;border-radius:999px;padding:.18rem .5rem;background:rgba(0,0,0,.72);color:#fff;font-size:.78rem;font-weight:900;letter-spacing:.03em}.nsfw-show{position:absolute;right:.55rem;bottom:.55rem;margin:0;border:1px solid var(--border-strong);border-radius:7px;background:var(--surface);color:var(--text-strong);padding:.32rem .65rem;font-weight:900;box-shadow:0 1px 2px var(--shadow);cursor:pointer}.nsfw-show:hover{background:var(--hover)}.nsfw-toggle:focus-visible~.nsfw-show{outline:3px solid var(--focus);outline-offset:2px}.nsfw-toggle:checked~.nsfw-show,.nsfw-toggle:checked+.nsfw-media-frame .nsfw-badge{display:none}.nsfw-open{display:block;margin:.35rem 0 0;font-size:.9rem;font-weight:700}
-.counts{display:flex;gap:.5rem;flex-wrap:wrap;margin-top:.3rem;min-height:1.4rem}.post-permalink{font-weight:700;color:var(--link-strong)}.js-enabled .post-permalink{display:none}.actions{display:inline-flex;gap:.25rem;flex-wrap:wrap;align-items:center;margin-top:.5rem;max-width:100%}.icon-button{width:2.2rem;height:2.2rem;display:inline-flex;align-items:center;justify-content:center;border:1px solid var(--border);border-radius:7px;background:var(--surface);color:var(--link-strong);padding:0}.icon-button svg{width:1.05rem;height:1.05rem;fill:currentColor}.icon-button:hover,.icon-button.active{background:var(--hover);color:var(--text-strong);text-decoration:none}.icon-button.disabled,.icon-button:disabled{color:var(--muted);background:var(--surface-muted);border-color:var(--border);cursor:not-allowed;opacity:.75}.icon-button.disabled:hover,.icon-button:disabled:hover{background:var(--surface-muted);color:var(--muted)}.admin-nsfw-button{min-height:2.2rem;padding:.3rem .55rem;background:var(--surface);color:var(--link-strong);border-color:var(--border);font-size:.86rem}.admin-nsfw-button:hover{background:var(--hover);color:var(--text-strong)}.repost-control{position:relative;display:inline-flex;align-items:center;gap:.25rem}.repost-menu{position:absolute;z-index:8;left:0;top:calc(100% + .25rem);min-width:8.5rem;padding:.3rem;border:1px solid var(--border-strong);border-radius:7px;background:var(--surface);box-shadow:0 6px 18px var(--shadow)}.repost-menu a{display:inline-flex;align-items:center;gap:.35rem;width:100%;min-height:2rem;border-radius:6px;padding:.32rem .55rem;color:var(--link-strong);font-weight:700}.repost-menu a svg{width:1rem;height:1rem;fill:currentColor;flex:0 0 auto}.repost-menu a:hover,.quote-fallback:hover{background:var(--hover);text-decoration:none}.quote-preview{display:block;margin:.6rem 0 .25rem;border:1px solid var(--border);border-radius:7px;background:var(--surface-subtle);overflow:hidden}.quote-preview p{margin:.65rem;color:var(--muted-strong)}.quote-link{display:grid;gap:.2rem;padding:.6rem;color:var(--text)}.quote-link:hover{background:var(--hover);text-decoration:none}.quote-author{font-weight:800}.quote-text{white-space:pre-wrap;overflow-wrap:anywhere}.quote-time{color:var(--muted);font-size:.86rem}.follow-button{min-width:6.6rem}.follow-button.active{background:var(--hover);color:var(--text-strong);border-color:var(--border-strong)}.profile-actions{margin-top:0}.profile-secondary button{background:var(--surface);color:var(--danger);border-color:var(--danger-border);padding:.32rem .5rem;min-height:1.85rem;font-size:.86rem}.profile-secondary button:hover{background:var(--danger-bg);color:var(--danger-strong)}.profile-title-row{display:flex;align-items:flex-start;justify-content:space-between;gap:.75rem}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.repost-banner{color:var(--muted-strong);font-size:.9rem;font-weight:800;margin-bottom:.35rem}.unavailable{color:var(--muted)}.empty-state{text-align:center;padding:2rem 1rem}.empty-state h2{margin:0;font-size:1.2rem}.notice.error,.error-panel{border-color:var(--danger-border);background:var(--danger-bg)}.notice.success{border-color:var(--success-border);background:var(--success-bg)}.eyebrow{text-transform:uppercase;letter-spacing:.08em;font-weight:800;color:var(--muted);font-size:.78rem}.noscript-banner{max-width:1100px;margin:.7rem auto 0;padding:.65rem .85rem;border:1px solid var(--border);border-radius:8px;background:var(--surface-subtle);color:var(--muted-strong)}.js-enabled .noscript-banner{display:none}
-.profile-banner{width:100%;max-height:220px;object-fit:cover;border-radius:8px;border:1px solid var(--border);background:var(--surface-muted)}.profile-heading{display:flex;gap:1rem;align-items:flex-start;margin-top:.85rem}.profile-main{min-width:0;flex:1}.profile-picture{width:88px;height:88px;object-fit:cover;border-radius:999px;border:3px solid var(--surface);background:var(--avatar-bg);flex:0 0 auto}.profile-meta{color:var(--muted-strong);margin:.45rem 0 0}.settings-profile-editor{padding:0;overflow:hidden}.settings-editor-bar{display:flex;justify-content:space-between;align-items:center;gap:1rem;padding:.85rem;border-bottom:1px solid var(--border)}.settings-editor-bar h1{margin:0}.settings-editor-bar .primary{flex:0 0 auto}.settings-profile-form{padding:0 .85rem .85rem}.settings-profile-media{margin:0 -.85rem .85rem}.settings-banner-wrap{background:var(--media-bg)}.settings-banner-preview{display:block;width:100%;height:220px;object-fit:cover;background:linear-gradient(135deg,var(--surface-muted),var(--hover));border:0;border-radius:0}.settings-banner-preview.placeholder::before{content:"";display:block;width:100%;height:100%}.settings-picture-row{display:grid;grid-template-columns:auto minmax(0,1fr);gap:1rem;align-items:end;padding:0 .85rem .85rem;margin-top:-48px}.settings-picture-preview{width:112px;height:112px;object-fit:cover;border-radius:999px;border:5px solid var(--surface);background:var(--avatar-bg);box-shadow:0 1px 4px var(--shadow)}.settings-picture-preview.placeholder{display:block}.settings-media-controls{display:grid;gap:.5rem;align-content:end;padding-top:3.25rem}.media-control-row{display:flex;align-items:center;gap:.75rem;flex-wrap:wrap}.settings-fields{display:grid;gap:.25rem}.settings-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:.7rem}.deep-settings-panel{padding:0;overflow:hidden}.deep-settings-form{padding:.85rem;display:grid;gap:.85rem}.deep-settings-group{border:1px solid var(--border);border-radius:8px;padding:.8rem;display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:.7rem}.deep-settings-group legend{font-weight:800;padding:0 .35rem}.deep-settings-field{display:grid;gap:.25rem;align-content:start}.deep-settings-field label{font-weight:800}.deep-settings-field input,.deep-settings-field select{min-width:0}.field-help{font-size:.88rem}.deep-settings-confirm .settings-item-list li{display:block}.compact-panel h2,.danger-panel h2{margin:0 0 .65rem;font-size:1.1rem}.inline-settings-form{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:.55rem;align-items:center;margin:.2rem 0 .75rem}.inline-settings-form input{min-width:0}.settings-password-form button[type=submit]{margin-top:.9rem}.settings-item-list{list-style:none;margin:.25rem 0 0;padding:0;display:grid;gap:.45rem}.settings-item-list li{display:flex;justify-content:space-between;align-items:center;gap:.75rem;border:1px solid var(--border);border-radius:7px;padding:.55rem .65rem;background:var(--surface-subtle)}.settings-item-list form{flex:0 0 auto}.settings-item-list button{padding:.32rem .55rem;background:var(--surface);color:var(--link-strong);border-color:var(--border)}.compact-empty{border:1px dashed var(--border);border-radius:7px;padding:.75rem;background:var(--surface-subtle);color:var(--muted-strong)}.compact-empty p{margin:.25rem 0 0}.danger-panel{border-color:var(--danger-border);background:var(--danger-bg)}.danger,.danger-link{border-color:var(--danger-border);background:var(--danger);color:var(--brand-text)}.danger:hover,.danger-link:hover{background:var(--danger-strong);color:var(--brand-text);text-decoration:none}.delete-account-panel p{max-width:62ch}.favicon-preview{width:32px;height:32px;object-fit:contain;border:1px solid var(--border);border-radius:6px;background:var(--surface)}.admin-user-search{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr) auto;gap:.65rem;align-items:end;margin-top:.75rem}.admin-user-search label{margin-top:0}.admin-user-search-actions{display:flex;gap:.4rem;align-items:center;margin-bottom:.05rem}.admin-user-row{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:.75rem;border:1px solid var(--border);border-radius:8px;padding:.75rem;margin-top:.65rem;background:var(--surface-subtle)}.admin-user-heading{overflow-wrap:anywhere}.admin-user-statuses,.admin-user-matches{display:flex;flex-wrap:wrap;gap:.35rem;margin-top:.45rem}.admin-user-pill,.admin-user-match{display:inline-flex;align-items:center;min-height:1.55rem;border:1px solid var(--border);border-radius:999px;padding:.15rem .5rem;background:var(--surface);font-size:.82rem;font-weight:800;color:var(--muted-strong)}.admin-user-match{border-color:var(--success-border);background:var(--success-bg);color:var(--text)}.admin-user-meta{margin:.6rem 0 0}.admin-post-preview{margin:.55rem 0 0;color:var(--muted-strong);overflow-wrap:anywhere}.admin-user-actions{display:flex;align-items:flex-start}.admin-users-empty{margin-top:.75rem}.account-list{display:grid;gap:.65rem}.account-row{display:grid;grid-template-columns:auto minmax(0,1fr) auto;gap:.75rem;align-items:center;background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:.85rem}.account-row p{margin:.3rem 0 0;color:var(--muted-strong);overflow-wrap:anywhere}.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:.85rem}.item-list{margin:.75rem 0 0;padding-left:1.2rem}.item-list li{margin:.45rem 0}.panel dl:not(.dashboard-list){display:grid;grid-template-columns:max-content minmax(0,1fr);gap:.45rem .85rem}.panel dl:not(.dashboard-list) dt{font-weight:800}.panel dl:not(.dashboard-list) dd{margin:0;overflow-wrap:anywhere}table{width:100%;border-collapse:collapse}td,th{border-bottom:1px solid var(--border);text-align:left;padding:.55rem;vertical-align:top}pre{white-space:pre-wrap;overflow:auto;max-width:100%}
+.timeline{display:grid;gap:.65rem}.post{overflow:hidden;position:relative}.js-enabled .post[data-card-href]{cursor:pointer}.js-enabled .post[data-card-href]:hover{border-color:var(--border-strong)}.reply-post{margin-left:1.1rem;border-left:4px solid var(--reply-border);background:var(--surface-subtle)}.reply-post::before{content:"";position:absolute;left:-1.1rem;top:1.25rem;width:1.1rem;border-top:2px solid var(--reply-border)}.anchor-target{position:absolute;top:-5rem}.post-header{display:flex;justify-content:space-between;gap:.65rem;align-items:flex-start}.author-block{display:flex;gap:.55rem;align-items:center;min-width:0}.post-avatar{width:2rem;height:2rem;object-fit:cover;border-radius:999px;border:1px solid var(--border);background:var(--avatar-bg);flex:0 0 auto;margin:0}.post-avatar.placeholder{display:inline-grid;place-items:center;color:var(--muted-strong);font-weight:800}.author-name{font-weight:800;color:var(--text-strong)}.username,.post-time,.counts{color:var(--muted);font-size:.92rem}.text{white-space:pre-wrap;margin:.55rem 0;line-height:1.5;overflow-wrap:anywhere}.post img,.post video{display:block;max-width:100%;border-radius:8px;border:1px solid var(--border);margin-top:.5rem;background:var(--media-bg)}.post img.post-avatar{display:block;margin:0;border-radius:999px}.youtube-previews{display:grid;gap:.45rem;margin:.35rem 0 .55rem}.youtube-preview-card{display:grid;grid-template-columns:minmax(5.5rem,7.5rem) minmax(0,1fr);gap:.65rem;align-items:center;min-height:4.5rem;border:1px solid var(--border);border-radius:7px;background:var(--surface-subtle);color:var(--text);overflow:hidden}.youtube-preview-card:hover{border-color:var(--border-strong);background:var(--hover);text-decoration:none}.youtube-thumbnail-frame{position:relative;display:block;width:100%;aspect-ratio:16/9;overflow:hidden;background:var(--media-bg)}.post img.youtube-thumbnail{width:100%;height:100%;object-fit:cover;margin:0;border:0;border-radius:0}.youtube-play{position:absolute;left:50%;top:50%;width:2rem;height:2rem;border-radius:999px;background:rgba(0,0,0,.68);transform:translate(-50%,-50%)}.youtube-play::before{content:"";position:absolute;left:.78rem;top:.55rem;border-top:.45rem solid transparent;border-bottom:.45rem solid transparent;border-left:.65rem solid #fff}.youtube-preview-body{display:grid;gap:.08rem;min-width:0;padding:.45rem .55rem .45rem 0}.youtube-preview-source{color:var(--muted);font-size:.78rem;font-weight:900;text-transform:uppercase}.youtube-preview-title{color:var(--text-strong);font-weight:850;overflow-wrap:anywhere}.youtube-preview-url{color:var(--muted-strong);font-size:.86rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.nsfw-media{position:relative;margin-top:.5rem}.nsfw-media .post img,.nsfw-media .post video{margin-top:0}.nsfw-media-frame{position:relative;display:block;overflow:hidden;border-radius:8px}.nsfw-media-frame img,.nsfw-media-frame video{margin-top:0;filter:blur(24px);transform:scale(1.02)}.nsfw-toggle:checked+.nsfw-media-frame img,.nsfw-toggle:checked+.nsfw-media-frame video{filter:none;transform:none}.nsfw-badge{position:absolute;left:.55rem;bottom:.55rem;border-radius:999px;padding:.18rem .5rem;background:rgba(0,0,0,.72);color:#fff;font-size:.78rem;font-weight:900;letter-spacing:.03em}.nsfw-show{position:absolute;right:.55rem;bottom:.55rem;margin:0;border:1px solid var(--border-strong);border-radius:7px;background:var(--surface);color:var(--text-strong);padding:.32rem .65rem;font-weight:900;box-shadow:0 1px 2px var(--shadow);cursor:pointer}.nsfw-show:hover{background:var(--hover)}.nsfw-toggle:focus-visible~.nsfw-show{outline:3px solid var(--focus);outline-offset:2px}.nsfw-toggle:checked~.nsfw-show,.nsfw-toggle:checked+.nsfw-media-frame .nsfw-badge{display:none}
+.counts{display:flex;gap:.5rem;flex-wrap:wrap;margin-top:.3rem;min-height:1.4rem}.edited-marker{font-weight:800;color:var(--muted-strong)}.post-permalink{font-weight:700;color:var(--link-strong)}.js-enabled .post-permalink{display:none}.actions{display:inline-flex;gap:.25rem;flex-wrap:wrap;align-items:center;margin-top:.5rem;max-width:100%}.icon-button{width:2.2rem;height:2.2rem;display:inline-flex;align-items:center;justify-content:center;border:1px solid var(--border);border-radius:7px;background:var(--surface);color:var(--link-strong);padding:0}.icon-button svg{width:1.05rem;height:1.05rem;fill:currentColor}.icon-button:hover,.icon-button.active{background:var(--hover);color:var(--text-strong);text-decoration:none}.icon-button.disabled,.icon-button:disabled{color:var(--muted);background:var(--surface-muted);border-color:var(--border);cursor:not-allowed;opacity:.75}.icon-button.disabled:hover,.icon-button:disabled:hover{background:var(--surface-muted);color:var(--muted)}.admin-nsfw-button{min-height:2.2rem;padding:.3rem .55rem;background:var(--surface);color:var(--link-strong);border-color:var(--border);font-size:.86rem}.admin-nsfw-button:hover{background:var(--hover);color:var(--text-strong)}.repost-control{position:relative;display:inline-flex;align-items:center;gap:.25rem}.repost-menu{position:absolute;z-index:8;left:0;top:calc(100% + .25rem);min-width:8.5rem;padding:.3rem;border:1px solid var(--border-strong);border-radius:7px;background:var(--surface);box-shadow:0 6px 18px var(--shadow)}.repost-menu a{display:inline-flex;align-items:center;gap:.35rem;width:100%;min-height:2rem;border-radius:6px;padding:.32rem .55rem;color:var(--link-strong);font-weight:700}.repost-menu a svg{width:1rem;height:1rem;fill:currentColor;flex:0 0 auto}.repost-menu a:hover,.quote-fallback:hover{background:var(--hover);text-decoration:none}.quote-preview{display:block;margin:.6rem 0 .25rem;border:1px solid var(--border);border-radius:7px;background:var(--surface-subtle);overflow:hidden}.quote-preview p{margin:.65rem;color:var(--muted-strong)}.quote-link{display:grid;gap:.2rem;padding:.6rem;color:var(--text)}.quote-link:hover{background:var(--hover);text-decoration:none}.quote-author{font-weight:800}.quote-text{white-space:pre-wrap;overflow-wrap:anywhere}.quote-time{color:var(--muted);font-size:.86rem}.follow-button{min-width:6.6rem}.follow-button.active{background:var(--hover);color:var(--text-strong);border-color:var(--border-strong)}.profile-actions{margin-top:0}.profile-secondary button{background:var(--surface);color:var(--danger);border-color:var(--danger-border);padding:.32rem .5rem;min-height:1.85rem;font-size:.86rem}.profile-secondary button:hover{background:var(--danger-bg);color:var(--danger-strong)}.profile-title-row{display:flex;align-items:flex-start;justify-content:space-between;gap:.75rem}.profile-tabs{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:.35rem;margin:.65rem 0;border-bottom:1px solid var(--border)}.profile-tabs a{display:flex;align-items:center;justify-content:center;min-height:2.6rem;border-radius:7px 7px 0 0;color:var(--muted-strong);font-weight:850}.profile-tabs a:hover{background:var(--hover);color:var(--text-strong);text-decoration:none}.profile-tabs a.active{color:var(--text-strong);background:var(--surface);box-shadow:inset 0 -3px 0 var(--brand)}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.repost-banner{color:var(--muted-strong);font-size:.9rem;font-weight:800;margin-bottom:.35rem}.unavailable{color:var(--muted)}.empty-state{text-align:center;padding:2rem 1rem}.empty-state h2{margin:0;font-size:1.2rem}.notice.error,.error-panel{border-color:var(--danger-border);background:var(--danger-bg)}.notice.success{border-color:var(--success-border);background:var(--success-bg)}.eyebrow{text-transform:uppercase;letter-spacing:.08em;font-weight:800;color:var(--muted);font-size:.78rem}.noscript-banner{max-width:1100px;margin:.7rem auto 0;padding:.65rem .85rem;border:1px solid var(--border);border-radius:8px;background:var(--surface-subtle);color:var(--muted-strong)}
+.profile-banner{width:100%;max-height:220px;object-fit:cover;border-radius:8px;border:1px solid var(--border);background:var(--surface-muted)}.profile-heading{display:flex;gap:1rem;align-items:flex-start;margin-top:.85rem}.profile-main{min-width:0;flex:1}.profile-picture{width:88px;height:88px;object-fit:cover;border-radius:999px;border:3px solid var(--surface);background:var(--avatar-bg);flex:0 0 auto}.profile-meta{color:var(--muted-strong);margin:.45rem 0 0}.settings-profile-editor{padding:0;overflow:hidden}.settings-editor-bar{display:flex;justify-content:space-between;align-items:center;gap:1rem;padding:.85rem;border-bottom:1px solid var(--border)}.settings-editor-bar h1{margin:0}.settings-editor-bar .primary{flex:0 0 auto}.settings-profile-form{padding:.85rem;display:grid;gap:1rem}.settings-section{display:grid;gap:.75rem;min-width:0}.settings-section+.settings-section{border-top:1px solid var(--border);padding-top:1rem}.settings-section-heading{display:grid;gap:.18rem}.settings-section-heading h2,.settings-list-panel h2,.settings-security-panel h2,.danger-panel h2{margin:0;font-size:1.05rem;line-height:1.25;color:var(--text-strong)}.settings-section-help,.settings-switch-help{margin:0;color:var(--muted-strong);font-size:.9rem;line-height:1.35;overflow-wrap:anywhere}.settings-profile-fields{gap:.28rem}.settings-profile-fields label,.settings-password-form label{margin:.55rem 0 .28rem}.settings-profile-media{display:grid;gap:.65rem;min-width:0}.settings-banner-wrap{background:var(--media-bg);border-radius:8px;overflow:hidden}.settings-banner-preview{display:block;width:100%;height:170px;object-fit:cover;object-position:left center;background:linear-gradient(135deg,var(--surface-muted),var(--hover));border:1px solid var(--border);border-radius:8px}.settings-banner-preview.placeholder::before{content:"";display:block;width:100%;height:100%}.settings-picture-row{display:grid;grid-template-columns:auto minmax(0,1fr);gap:1rem;align-items:end;margin-top:-42px;padding:0 .75rem .2rem}.settings-picture-preview{width:104px;height:104px;object-fit:cover;border-radius:999px;border:5px solid var(--surface);background:var(--avatar-bg);box-shadow:0 1px 4px var(--shadow)}.settings-picture-preview.placeholder{display:block}.settings-media-controls{display:grid;gap:.45rem;align-content:end;padding-top:2.85rem;min-width:0}.media-control-row{display:flex;align-items:center;gap:.65rem;flex-wrap:wrap;min-width:0}.media-control-row .file-control{display:flex;align-items:center;gap:.35rem;flex-wrap:wrap;margin:0;max-width:100%;overflow-wrap:anywhere}.media-control-row .file-control input[type=file]{max-width:100%}.media-control-row .check-row{margin:0}.settings-switch-list{display:grid;gap:0;border:1px solid var(--border);border-radius:8px;background:var(--surface-subtle);overflow:hidden}.settings-switch-row{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:.85rem;align-items:center;margin:0;padding:.75rem .8rem;color:var(--text);cursor:pointer}.settings-switch-row+.settings-switch-row{border-top:1px solid var(--border)}.settings-switch-copy{display:grid;gap:.12rem;min-width:0}.settings-switch-label{font-weight:800;color:var(--text-strong);overflow-wrap:anywhere}.settings-switch-toggle{position:relative;display:inline-grid;width:2.75rem;height:1.55rem;justify-self:end;flex:0 0 auto}.settings-switch-input{position:absolute;inset:0;z-index:1;width:100%;height:100%;padding:0;margin:0;opacity:0;cursor:pointer}.settings-switch-control{position:relative;display:block;width:2.75rem;height:1.55rem;border:1px solid var(--border-strong);border-radius:999px;background:var(--surface-muted);box-shadow:inset 0 0 0 1px var(--shadow);transition:background-color .15s ease,border-color .15s ease}.settings-switch-control::before{content:"";position:absolute;left:.16rem;top:50%;width:1.15rem;height:1.15rem;border-radius:999px;background:var(--surface);box-shadow:0 1px 3px var(--shadow);transform:translateY(-50%);transition:transform .15s ease}.settings-switch-input:checked+.settings-switch-control{border-color:var(--brand);background:var(--brand)}.settings-switch-input:checked+.settings-switch-control::before{transform:translate(1.2rem,-50%)}.settings-switch-input:focus-visible+.settings-switch-control{outline:3px solid var(--focus);outline-offset:2px}.settings-form-actions{display:flex;justify-content:flex-end;gap:.5rem;border-top:1px solid var(--border);padding-top:.85rem}.onboarding-panel{overflow:hidden}.onboarding-form{display:grid;gap:.9rem}.onboarding-media-row{display:grid;grid-template-columns:auto minmax(0,1fr);gap:1rem;align-items:center}.onboarding-suggestions{border:1px solid var(--border);border-radius:8px;padding:.75rem;display:grid;gap:.55rem}.onboarding-suggestions legend{font-weight:800;padding:0 .35rem}.onboarding-suggestion{display:grid;grid-template-columns:auto auto minmax(0,1fr);gap:.6rem;align-items:center;margin:0;border:1px solid var(--border);border-radius:7px;padding:.55rem;background:var(--surface-subtle);cursor:pointer}.onboarding-suggestion input{margin:0}.settings-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:.7rem}.deep-settings-panel{padding:0;overflow:hidden}.deep-settings-form{padding:.85rem;display:grid;gap:.85rem}.deep-settings-group{border:1px solid var(--border);border-radius:8px;padding:.8rem;display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:.7rem}.deep-settings-group legend{font-weight:800;padding:0 .35rem}.deep-settings-field{display:grid;gap:.25rem;align-content:start}.deep-settings-field label{font-weight:800}.deep-settings-field input,.deep-settings-field select{min-width:0}.field-help{font-size:.88rem;margin:.05rem 0 .35rem;color:var(--muted-strong)}.deep-settings-confirm .settings-item-list li{display:block}.compact-panel h2,.danger-panel h2{margin:0;font-size:1.05rem}.inline-settings-form{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:.55rem;align-items:center;margin:.65rem 0 .75rem}.inline-settings-form input{min-width:0}.settings-password-form{display:grid;gap:0;margin-top:.65rem}.settings-password-form button[type=submit]{margin-top:0}.settings-list-panel,.settings-security-panel{display:grid;gap:.55rem}.settings-item-list{list-style:none;margin:.25rem 0 0;padding:0;display:grid;gap:.45rem}.settings-item-list li{display:flex;justify-content:space-between;align-items:center;gap:.75rem;border:1px solid var(--border);border-radius:7px;padding:.55rem .65rem;background:var(--surface-subtle)}.settings-item-list li>span{min-width:0;overflow-wrap:anywhere}.settings-item-list form{flex:0 0 auto}.settings-item-list button{padding:.32rem .55rem;background:var(--surface);color:var(--link-strong);border-color:var(--border)}.compact-empty{border:1px dashed var(--border);border-radius:7px;padding:.75rem;background:var(--surface-subtle);color:var(--muted-strong)}.compact-empty p{margin:.25rem 0 0}.danger-panel{border-color:var(--danger-border);background:var(--danger-bg)}.danger,.danger-link{border-color:var(--danger-border);background:var(--danger);color:var(--brand-text)}.danger:hover,.danger-link:hover{background:var(--danger-strong);color:var(--brand-text);text-decoration:none}.delete-account-panel p,.danger-panel p{max-width:62ch}.settings-danger-action{margin:.7rem 0 0}.favicon-preview{width:32px;height:32px;object-fit:contain;border:1px solid var(--border);border-radius:6px;background:var(--surface)}.admin-user-search{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr) auto;gap:.65rem;align-items:end;margin-top:.75rem}.admin-user-search label{margin-top:0}.admin-user-search-actions{display:flex;gap:.4rem;align-items:center;margin-bottom:.05rem}.admin-user-row{display:grid;grid-template-columns:minmax(0,1fr) auto;gap:.75rem;border:1px solid var(--border);border-radius:8px;padding:.75rem;margin-top:.65rem;background:var(--surface-subtle)}.admin-user-heading{overflow-wrap:anywhere}.admin-user-statuses,.admin-user-matches{display:flex;flex-wrap:wrap;gap:.35rem;margin-top:.45rem}.admin-user-pill,.admin-user-match{display:inline-flex;align-items:center;min-height:1.55rem;border:1px solid var(--border);border-radius:999px;padding:.15rem .5rem;background:var(--surface);font-size:.82rem;font-weight:800;color:var(--muted-strong)}.admin-user-match{border-color:var(--success-border);background:var(--success-bg);color:var(--text)}.admin-user-meta{margin:.6rem 0 0}.admin-post-preview{margin:.55rem 0 0;color:var(--muted-strong);overflow-wrap:anywhere}.admin-user-actions{display:flex;align-items:flex-start}.admin-users-empty{margin-top:.75rem}.account-list{display:grid;gap:.65rem}.account-row{display:grid;grid-template-columns:auto minmax(0,1fr) auto;gap:.75rem;align-items:center;background:var(--surface);border:1px solid var(--border);border-radius:8px;padding:.85rem}.account-row p{margin:.3rem 0 0;color:var(--muted-strong);overflow-wrap:anywhere}.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:.85rem}.item-list{margin:.75rem 0 0;padding-left:1.2rem}.item-list li{margin:.45rem 0}.panel dl:not(.dashboard-list){display:grid;grid-template-columns:max-content minmax(0,1fr);gap:.45rem .85rem}.panel dl:not(.dashboard-list) dt{font-weight:800}.panel dl:not(.dashboard-list) dd{margin:0;overflow-wrap:anywhere}table{width:100%;border-collapse:collapse}td,th{border-bottom:1px solid var(--border);text-align:left;padding:.55rem;vertical-align:top}pre{white-space:pre-wrap;overflow:auto;max-width:100%}
+.settings-media-frame{position:relative;min-width:0}.settings-picture-row{display:flex;align-items:flex-end;gap:0}.settings-picture-wrap{display:inline-block;max-width:100%;line-height:0}.settings-picture-preview{display:block}.settings-media-actions{position:absolute;z-index:2;display:flex;gap:.35rem;align-items:center}.settings-banner-actions{top:.55rem;right:.55rem}.settings-picture-actions{left:50%;bottom:.45rem;transform:translateX(-50%)}.settings-media-control{position:relative;display:inline-flex}.settings-media-input,.settings-media-delete-input{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.settings-media-icon-button{display:inline-flex;align-items:center;justify-content:center;width:2rem;height:2rem;margin:0;border:1px solid rgba(255,255,255,.62);border-radius:999px;background:rgba(23,32,23,.56);color:#fff;padding:0;box-shadow:0 1px 4px rgba(0,0,0,.22);cursor:pointer;opacity:.72;transition:opacity .15s ease,background-color .15s ease,border-color .15s ease,transform .15s ease}.settings-media-icon-button svg{width:1rem;height:1rem;fill:currentColor}.settings-media-frame:hover .settings-media-icon-button,.settings-media-frame:focus-within .settings-media-icon-button,.settings-media-icon-button:hover{opacity:1}.settings-media-icon-button:hover{background:rgba(23,32,23,.82);text-decoration:none}.settings-media-input:focus-visible+.settings-media-icon-button,.settings-media-delete-input:focus-visible+.settings-media-icon-button{outline:3px solid var(--focus);outline-offset:2px;opacity:1}.settings-media-delete-input:checked+.settings-media-icon-button,.settings-media-removing .settings-media-remove{background:var(--danger);border-color:var(--danger-border);color:var(--brand-text);opacity:1}.settings-media-has-file .settings-media-change{background:var(--brand);border-color:rgba(255,255,255,.72);color:var(--brand-text);opacity:1}.settings-media-disabled{position:absolute;right:.55rem;bottom:.55rem;max-width:calc(100% - 1.1rem);margin:0;border:1px solid rgba(255,255,255,.5);border-radius:999px;background:rgba(23,32,23,.62);color:#fff;padding:.22rem .55rem;font-size:.82rem;font-weight:800;line-height:1.2;overflow-wrap:anywhere}
 @media (max-width:1100px){.app-shell{--shell-side:220px;--shell-max:880px;grid-template-columns:var(--shell-side) minmax(0,var(--shell-primary))}.right-rail{display:none}}
 @media (max-width:820px){.app-shell{grid-template-columns:minmax(0,680px)}.left-rail,.right-rail{display:none}.mobile-nav{display:flex}}
-@media (max-width:600px){main{padding:.75rem}.header-inner{align-items:flex-start;flex-direction:column}.header-brand-row{align-items:center;width:100%;gap:.55rem}.tor-indicator{max-width:calc(100% - 7rem);margin-left:auto}.tor-details{left:auto;right:0;max-width:calc(100vw - 1.5rem)}.site-header{position:static}nav{justify-content:flex-start}.mobile-nav{width:100%}.search-form,.inline-settings-form,.settings-grid,.deep-settings-group,.admin-user-search,.admin-user-row{grid-template-columns:1fr}.search-form button,.inline-settings-form button{width:100%}.composer-tools,.post-header,.profile-heading,.profile-title-row,.account-row,.settings-editor-bar,.notifications-hero{align-items:stretch;grid-template-columns:1fr;flex-direction:column}.composer-footer,.composer-media-selection{align-items:flex-start;flex-direction:column}.composer-file-input{max-width:100%}.settings-banner-preview{height:150px}.settings-picture-row{grid-template-columns:1fr;margin-top:-38px;gap:.5rem}.settings-picture-preview{width:92px;height:92px}.settings-media-controls{padding-top:0}.media-control-row{align-items:flex-start}.settings-item-list li{align-items:stretch;flex-direction:column}.admin-user-search-actions,.admin-user-actions{align-items:stretch;flex-direction:column}.admin-user-search-actions button,.admin-user-search-actions .button-link,.admin-user-actions button{width:100%;justify-content:center}.panel dl:not(.dashboard-list){grid-template-columns:1fr}table{display:block;max-width:100%;overflow-x:auto}.author-block{align-items:flex-start}.reply-post{margin-left:.65rem;padding-left:.8rem}.reply-post::before{left:-.65rem;width:.65rem}.button-link{padding:.42rem .55rem}.counts{gap:.45rem}.page-header h1,.section-heading h1,.panel h1,.notifications-hero h1{font-size:1.25rem}.notification-row{grid-template-columns:auto minmax(0,1fr);gap:.6rem}.unread-dot{position:absolute;right:.75rem;top:.75rem;margin:0}.notification-preview{padding:.5rem}}
+@media (max-width:600px){main{padding:.75rem}.header-inner{align-items:flex-start;flex-direction:column}.header-brand-row{align-items:center;width:100%;gap:.55rem}.tor-indicator{max-width:calc(100% - 7rem);margin-left:auto}.tor-details{left:auto;right:0;max-width:calc(100vw - 1.5rem)}.site-header{position:static}nav{justify-content:flex-start}.mobile-nav{width:100%}.search-form,.inline-settings-form,.settings-grid,.deep-settings-group,.admin-user-search,.admin-user-row,.onboarding-media-row{grid-template-columns:1fr}.search-form button,.inline-settings-form button{width:100%}.composer-tools,.post-header,.profile-heading,.profile-title-row,.account-row,.settings-editor-bar,.notifications-hero{align-items:stretch;grid-template-columns:1fr;flex-direction:column}.composer-footer,.composer-media-selection{align-items:flex-start;flex-direction:column}.composer-file-input{max-width:100%}.settings-banner-preview{height:150px}.settings-picture-row{grid-template-columns:1fr;margin-top:-38px;gap:.5rem}.settings-picture-preview{width:92px;height:92px}.settings-media-controls{padding-top:0}.media-control-row{align-items:flex-start}.settings-switch-row{grid-template-columns:1fr;gap:.55rem}.settings-switch-toggle,.settings-switch-control{justify-self:start}.settings-form-actions{justify-content:stretch}.settings-form-actions button,.settings-danger-action .button-link{width:100%;justify-content:center}.settings-item-list li{align-items:stretch;flex-direction:column}.admin-user-search-actions,.admin-user-actions{align-items:stretch;flex-direction:column}.admin-user-search-actions button,.admin-user-search-actions .button-link,.admin-user-actions button{width:100%;justify-content:center}.panel dl:not(.dashboard-list){grid-template-columns:1fr}table{display:block;max-width:100%;overflow-x:auto}.author-block{align-items:flex-start}.reply-post{margin-left:.65rem;padding-left:.8rem}.reply-post::before{left:-.65rem;width:.65rem}.button-link{padding:.42rem .55rem}.counts{gap:.45rem}.page-header h1,.section-heading h1,.panel h1,.notifications-hero h1{font-size:1.25rem}.notification-row{grid-template-columns:auto minmax(0,1fr);gap:.6rem}.unread-dot{position:absolute;right:.75rem;top:.75rem;margin:0}.notification-preview{padding:.5rem}}
 "#;
 
 #[cfg(test)]
@@ -2035,16 +3000,27 @@ mod tests {
     }
 
     #[test]
-    fn layout_includes_no_javascript_status_and_styles() {
+    fn layout_includes_no_javascript_status_as_noscript_only() {
         let body = layout(None, "Home Feed", "<p>body</p>", "My Microblog");
 
-        assert!(body.contains(r#"class="noscript-banner" role="status""#));
-        assert!(body.contains(".js-enabled .noscript-banner"));
+        assert!(body.contains(r#"<noscript><section class="noscript-banner" role="status">"#));
+        assert!(!body.contains(r#"<body><section class="noscript-banner""#));
+        assert!(!body.contains(".js-enabled .noscript-banner"));
         assert!(body.contains(".js-enabled .post-permalink"));
         assert!(body.contains("display:none"));
         assert!(
             client_script().contains(r#"document.documentElement.classList.add("js-enabled")"#)
         );
+        assert!(client_script().contains("data-mention-autocomplete"));
+        assert!(client_script().contains("textContent = suggestion.display_name"));
+        assert!(!client_script().contains("innerHTML = suggestion"));
+        assert!(
+            client_boot_script()
+                .contains(r#"document.documentElement.classList.add("js-enabled")"#)
+        );
+        assert!(
+            body.find(r#"<script src="/assets/rustpost-boot.js"></script>"#) < body.find("<style>")
+        );
         assert!(body.contains("JavaScript is disabled."));
         assert!(body.contains("RustPost will use standard links and forms."));
     }
@@ -2203,17 +3179,23 @@ mod tests {
         );
         assert!(with_tor.contains("examplehiddenservice.onion"));
         assert!(with_tor.contains("tor-header-indicator"));
+        assert!(with_tor.contains(r#"<details class="tor-disclosure">"#));
+        assert!(with_tor.contains(r#"<summary class="tor-pill""#));
+        assert!(with_tor.contains(r#"data-testid="tor-pill""#));
+        assert!(with_tor.contains(r#"data-testid="tor-popover""#));
+        assert!(with_tor.contains(r#"data-testid="tor-full-address""#));
         assert!(with_tor.contains("tor-summary-text"));
-        assert!(with_tor.contains(r#"<span class="tor-label">Tor:</span>"#));
+        assert!(with_tor.contains(r#"<span class="tor-pill-label">Tor</span>"#));
         assert!(with_tor.contains(r#"href="http://examplehiddenservice.onion""#));
         assert!(with_tor.contains(r#"title="Open Tor mirror: examplehiddenservice.onion""#));
         assert!(with_tor.contains(r#"aria-label="Open Tor mirror at examplehiddenservice.onion""#));
         assert!(with_tor.contains("exampl...ice.onion"));
         assert!(with_tor.contains(r#"data-copy-text="examplehiddenservice.onion""#));
         assert!(with_tor.contains(r#"aria-label="Copy Tor onion address""#));
+        assert!(with_tor.contains(r#"</details><button class="tor-copy-button""#));
+        assert!(with_tor.contains(r#"<span data-copy-feedback aria-live="polite">Copy</span>"#));
         assert!(!with_tor.contains("footer-onion"));
-        assert!(!with_tor.contains("<details"));
-        assert!(!with_tor.contains("<summary"));
+        assert!(!with_tor.contains("tor-address-link"));
         assert!(!with_tor.contains("Tor mirror: <code>"));
         assert!(!with_tor.contains("Onion: <code>"));
     }
@@ -2235,8 +3217,14 @@ mod tests {
     fn composer_has_live_remaining_counter_and_contextual_placeholder() {
         let post = composer(Some("csrf"), None, 512);
         assert!(post.contains("512 remaining"));
+        assert!(post.contains(r#"class="muted character-counter character-counter-normal""#));
+        assert!(post.contains(r#"aria-live="polite""#));
         assert!(post.contains("data-character-limit=\"512\""));
-        assert!(post.contains("maxlength=\"512\""));
+        assert!(post.contains("data-mention-autocomplete"));
+        assert!(post.contains(r#"aria-autocomplete="list""#));
+        assert!(post.contains(r#"role="listbox" data-mention-menu hidden"#));
+        assert!(post.contains(r#"aria-controls="post-text-mention-menu""#));
+        assert!(!post.contains("maxlength="));
         assert!(post.contains("What is happening?"));
         assert!(post.contains(r#"placeholder="What's happening?""#));
         assert!(post.contains(r#"<div class="composer-surface">"#));
@@ -2253,6 +3241,8 @@ mod tests {
 
         let reply = composer(Some("csrf"), Some(10), 512);
         assert!(reply.contains(r#"id="reply-text-10""#));
+        assert!(reply.contains(r#"data-character-counter="reply-text-10""#));
+        assert!(reply.contains(r#"aria-controls="reply-text-10-mention-menu""#));
         assert!(reply.contains(r#"id="reply-media-10" name="media" type="file""#));
         assert!(reply.contains(r#"id="reply-nsfw-10" name="nsfw" type="checkbox""#));
         assert!(reply.contains(r#"placeholder="Write a reply...""#));
@@ -2273,8 +3263,10 @@ mod tests {
 
         assert!(body.contains(r#"id="quote-text""#));
         assert!(body.contains(r#"placeholder="Add your thoughts...""#));
+        assert!(body.contains(r#"class="muted character-counter character-counter-normal""#));
+        assert!(body.contains(r#"aria-live="polite""#));
         assert!(body.contains("data-character-limit=\"512\""));
-        assert!(body.contains("maxlength=\"512\""));
+        assert!(!body.contains("maxlength="));
     }
 
     #[test]
@@ -2355,13 +3347,30 @@ mod tests {
         );
     }
 
+    #[test]
+    fn empty_state_escapes_text_and_omits_empty_description() {
+        let body = empty_state(r#"<missing>"#, "");
+
+        assert!(body.contains("&lt;missing&gt;"));
+        assert!(!body.contains("<missing>"));
+        assert!(!body.contains("<p></p>"));
+    }
+
     #[test]
     fn search_page_preserves_and_escapes_query() {
-        let body = search_page("RustPost", r#"<rust> "query""#, &[], &[], None, None, true);
+        let body = search_page(
+            "RustPost",
+            r#"<rust> "query""#,
+            &[],
+            &[],
+            None,
+            None,
+            SearchRenderOptions::default(),
+        );
 
         assert!(body.contains(r#"value="&lt;rust&gt; &quot;query&quot;""#));
-        assert!(body.contains("No results found"));
-        assert!(body.contains("No matches for"));
+        assert!(body.contains("No matching posts or users found."));
+        assert!(body.contains("Try another search."));
         assert!(body.contains("&lt;rust&gt;"));
         assert!(body.contains("&quot;query&quot;"));
         assert!(!body.contains(r#"<rust> "query""#));
@@ -2379,7 +3388,15 @@ mod tests {
             viewer_following: false,
         };
 
-        let body = search_page("RustPost", "ada", &[account], &[post], None, None, true);
+        let body = search_page(
+            "RustPost",
+            "ada",
+            &[account],
+            &[post],
+            None,
+            None,
+            SearchRenderOptions::default(),
+        );
 
         assert!(body.contains(r#"2 results for "ada""#));
         assert!(body.contains(r#"id="search-users-title">People"#));
@@ -2506,7 +3523,7 @@ mod tests {
         assert!(body.contains(r#"data-testid="nsfw-media""#));
         assert!(body.contains(r#"aria-label="Show NSFW media""#));
         assert!(body.contains(">Show<span"));
-        assert!(body.contains(r#"href="/uploads/images/flagged.webp">Open media</a>"#));
+        assert!(!body.contains(r#"class="nsfw-open""#));
     }
 
     #[test]
@@ -2656,6 +3673,7 @@ mod tests {
             text: "hello".to_owned(),
             parent_post_id: None,
             created_at: "2026-05-18 10:30".to_owned(),
+            edited_at: None,
             event_created_at: "2026-05-18 10:30".to_owned(),
             like_count: 1,
             repost_count: 2,
@@ -2664,6 +3682,7 @@ mod tests {
             viewer_bookmarked: false,
             viewer_reposted: false,
             viewer_can_repost: false,
+            pinned_by_author: false,
             original_unavailable: false,
             reposted_by_user_id: None,
             reposted_by_username: None,
diff --git a/src/server.rs b/src/server.rs
index 398698f..99fa492 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -60,18 +60,22 @@ pub fn router(state: Arc<AppState>) -> Router {
     let upload_body_limit = upload_body_limit(&state.settings);
     Router::new()
         .route("/", get(home))
+        .route("/assets/rustpost-boot.js", get(client_boot_script))
         .route("/assets/rustpost.js", get(client_script))
         .route("/favicon.ico", get(site_favicon))
         .route("/local", get(local_redirect))
         .route("/home", get(home))
         .route("/login", get(login_form).post(login))
         .route("/register", get(register_form).post(register))
+        .route("/onboarding", get(onboarding).post(onboarding_update))
         .route("/logout", post(logout))
         .route("/posts", post(create_post))
         .route("/posts/{id}", get(thread))
+        .route("/posts/{id}/edit", get(edit_post_form).post(edit_post))
         .route("/posts/{id}/delete", get(delete_confirm).post(delete_post))
         .route("/posts/{id}/like", post(toggle_like))
         .route("/posts/{id}/bookmark", post(toggle_bookmark))
+        .route("/posts/{id}/pin", post(toggle_pin_post))
         .route("/posts/{id}/repost", post(repost))
         .route("/posts/{id}/quote", get(quote_form).post(quote_post))
         .route("/posts/{id}/reply", post(reply_redirect))
@@ -97,7 +101,9 @@ pub fn router(state: Arc<AppState>) -> Router {
         .route("/following", get(following))
         .route("/bookmarks", get(bookmarks))
         .route("/notifications", get(notifications))
+        .route("/notifications/open", post(open_notification_group))
         .route("/notifications/read", post(mark_notifications_read))
+        .route("/mentions", get(mention_suggestions))
         .route("/search", get(search))
         .route("/tags/{tag}", get(tag))
         .route("/admin", get(admin_dashboard))
@@ -160,6 +166,17 @@ async fn client_script() -> Response {
         .into_response()
 }
 
+async fn client_boot_script() -> Response {
+    (
+        [(
+            header::CONTENT_TYPE,
+            "application/javascript; charset=utf-8",
+        )],
+        render::client_boot_script(),
+    )
+        .into_response()
+}
+
 async fn site_favicon(State(state): State<Arc<AppState>>) -> Response {
     favicon::response(&state.paths).await
 }
@@ -184,6 +201,15 @@ struct CsrfForm {
     csrf: String,
 }
 
+#[derive(Deserialize)]
+struct NotificationOpenForm {
+    csrf: String,
+    notification_ids: String,
+    group_kind: Option<String>,
+    group_target_post_id: Option<String>,
+    return_to: String,
+}
+
 #[derive(Deserialize)]
 struct QuoteForm {
     csrf: String,
@@ -201,11 +227,32 @@ struct DeleteQuery {
     return_to: Option<String>,
 }
 
+#[derive(Deserialize)]
+struct ReturnQuery {
+    return_to: Option<String>,
+}
+
 #[derive(Deserialize)]
 struct SearchQuery {
     q: Option<String>,
 }
 
+#[derive(Deserialize)]
+struct ProfileQuery {
+    tab: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct MentionSuggestionsQuery {
+    q: Option<String>,
+}
+
+#[derive(Serialize)]
+struct MentionSuggestionResponse {
+    username: String,
+    display_name: String,
+}
+
 #[derive(Deserialize)]
 struct AdminUsersQuery {
     user_q: Option<String>,
@@ -254,6 +301,7 @@ struct ParsedProfileUpdate {
     delete_profile_picture: bool,
     delete_banner: bool,
     nsfw_blur_enabled: bool,
+    liked_posts_public: bool,
     profile_picture_media_id: Option<i64>,
     banner_media_id: Option<i64>,
 }
@@ -270,12 +318,28 @@ struct ParsedPostCreate {
     is_nsfw: bool,
 }
 
+struct ParsedOnboardingUpdate {
+    csrf_token: String,
+    intent: String,
+    display_name: String,
+    bio: String,
+    profile_picture_media_id: Option<i64>,
+    follow_user_ids: Vec<i64>,
+}
+
 #[derive(Deserialize)]
 struct AdminNsfwForm {
     csrf: String,
     nsfw: String,
 }
 
+#[derive(Deserialize)]
+struct EditPostForm {
+    csrf: String,
+    text: String,
+    return_to: Option<String>,
+}
+
 struct DeletePreview {
     text: String,
     username: Option<String>,
@@ -283,6 +347,11 @@ struct DeletePreview {
     parent_post_id: Option<i64>,
 }
 
+struct EditPreview {
+    text: String,
+    parent_post_id: Option<i64>,
+}
+
 #[derive(Serialize)]
 struct FollowActionResponse {
     kind: &'static str,
@@ -335,11 +404,12 @@ async fn home(State(state): State<Arc<AppState>>, headers: HeaderMap) -> AppResu
         "{}{}{}",
         render::page_header("Home Feed", "All posts"),
         composer,
-        render::posts_with_nsfw_blur(
+        render::posts_with_controls(
             &posts,
             user.as_ref(),
             csrf.as_deref(),
             blur_nsfw_media(&state, user.as_ref()),
+            state.settings.posts.post_edit_window_seconds,
         )
     );
     Ok(Html(
@@ -531,7 +601,7 @@ async fn register(
         }
     };
     let session = auth::create_session(&state.pool, user_id).await?;
-    let mut response = Redirect::to("/home").into_response();
+    let mut response = Redirect::to("/onboarding").into_response();
     response.headers_mut().insert(
         header::SET_COOKIE,
         HeaderValue::from_str(&auth::set_session_cookie(
@@ -582,6 +652,271 @@ async fn register_form_body(state: &AppState, message: Option<&str>) -> AppResul
     ))
 }
 
+async fn onboarding(State(state): State<Arc<AppState>>, headers: HeaderMap) -> AppResult<Response> {
+    let user = require_user(&state, &headers).await?;
+    if onboarding_completed(&state.pool, user.id).await? {
+        return Ok(Redirect::to("/home").into_response());
+    }
+    let csrf = form_csrf(&state, &headers).await.unwrap_or_default();
+    Ok(Html(onboarding_page(&state, &user, &csrf).await?).into_response())
+}
+
+async fn onboarding_update(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    multipart: Multipart,
+) -> AppResult<Response> {
+    let user = require_user(&state, &headers).await?;
+    let form = parse_onboarding_update(&state, user.id, multipart).await?;
+    if let Err(err) = validate_csrf(&state.pool, &headers, &form.csrf_token).await {
+        cleanup_onboarding_uploads(&state, &form).await;
+        return Err(err);
+    }
+    if form.intent == "skip" {
+        cleanup_onboarding_uploads(&state, &form).await;
+        mark_onboarding_complete(&state.pool, user.id).await?;
+        return Ok(Redirect::to("/home").into_response());
+    }
+    if form.intent != "save" {
+        cleanup_onboarding_uploads(&state, &form).await;
+        return onboarding_response(
+            &state,
+            &user,
+            &headers,
+            StatusCode::BAD_REQUEST,
+            "Unknown onboarding action.",
+        )
+        .await;
+    }
+    if let Err(err) =
+        crate::validation::validate_profile_text(&form.display_name, &form.bio, &state.settings)
+    {
+        cleanup_onboarding_uploads(&state, &form).await;
+        return onboarding_response(
+            &state,
+            &user,
+            &headers,
+            StatusCode::BAD_REQUEST,
+            &err.to_string(),
+        )
+        .await;
+    }
+    update_onboarding_profile(&state.pool, user.id, &form.display_name, &form.bio).await?;
+    if let Some(media_id) = form.profile_picture_media_id {
+        media::set_profile_media(
+            &state.pool,
+            user.id,
+            media::ProfileMediaSlot::Picture,
+            media_id,
+        )
+        .await?;
+    }
+    let follow_user_ids = dedup_user_ids(form.follow_user_ids, user.id);
+    let follow_user_ids = social::active_follow_targets(&state.pool, &follow_user_ids).await?;
+    for followed_id in follow_user_ids {
+        social::follow(&state.pool, user.id, followed_id)
+            .await
+            .map_err(|err| AppError::BadRequest(err.to_string()))?;
+    }
+    mark_onboarding_complete(&state.pool, user.id).await?;
+    Ok(Redirect::to("/home").into_response())
+}
+
+async fn cleanup_onboarding_uploads(state: &AppState, form: &ParsedOnboardingUpdate) {
+    if let Some(media_id) = form.profile_picture_media_id
+        && let Err(error) = media::delete_media(&state.pool, media_id).await
+    {
+        tracing::warn!(
+            media_id,
+            error = %error,
+            "failed to clean up rejected onboarding profile picture"
+        );
+    }
+}
+
+async fn onboarding_response(
+    state: &AppState,
+    user: &CurrentUser,
+    headers: &HeaderMap,
+    status: StatusCode,
+    message: &str,
+) -> AppResult<Response> {
+    let csrf = form_csrf(state, headers).await.unwrap_or_default();
+    let body = format!(
+        "{}{}",
+        render::notice("error", message),
+        onboarding_page_body(state, user, &csrf).await?
+    );
+    Ok((
+        status,
+        Html(page_layout(state, Some(user), Some(&csrf), "Onboarding", &body).await?),
+    )
+        .into_response())
+}
+
+async fn onboarding_page(state: &AppState, user: &CurrentUser, csrf: &str) -> AppResult<String> {
+    let body = onboarding_page_body(state, user, csrf).await?;
+    page_layout(state, Some(user), Some(csrf), "Onboarding", &body).await
+}
+
+async fn onboarding_page_body(
+    state: &AppState,
+    user: &CurrentUser,
+    csrf: &str,
+) -> AppResult<String> {
+    let profile = settings_profile(&state.pool, user.id).await?;
+    let suggestions = social::onboarding_suggestions(&state.pool, user.id, 6).await?;
+    Ok(render::onboarding_page(render::OnboardingPage {
+        csrf,
+        display_name: &profile.display_name,
+        bio: &profile.bio,
+        picture_path: profile.picture_path.as_deref(),
+        suggestions: &suggestions,
+        allow_profile_pictures: state.settings.accounts.allow_profile_pictures,
+        max_display_name_len: state.settings.accounts.max_display_name_len,
+        max_bio_len: state.settings.accounts.max_bio_len,
+    }))
+}
+
+async fn parse_onboarding_update(
+    state: &AppState,
+    user_id: i64,
+    mut multipart: Multipart,
+) -> AppResult<ParsedOnboardingUpdate> {
+    let mut form = ParsedOnboardingUpdate {
+        csrf_token: String::new(),
+        intent: "save".to_owned(),
+        display_name: String::new(),
+        bio: String::new(),
+        profile_picture_media_id: None,
+        follow_user_ids: Vec::new(),
+    };
+    while let Some(field) = multipart
+        .next_field()
+        .await
+        .map_err(|err| AppError::BadRequest(err.to_string()))?
+    {
+        let Some(name) = field.name().map(ToOwned::to_owned) else {
+            continue;
+        };
+        match name.as_str() {
+            "csrf" => {
+                form.csrf_token = field
+                    .text()
+                    .await
+                    .map_err(|err| AppError::BadRequest(err.to_string()))?;
+            }
+            "intent" => {
+                form.intent = field
+                    .text()
+                    .await
+                    .map_err(|err| AppError::BadRequest(err.to_string()))?;
+            }
+            "display_name" => {
+                form.display_name = field
+                    .text()
+                    .await
+                    .map_err(|err| AppError::BadRequest(err.to_string()))?;
+            }
+            "bio" => {
+                form.bio = field
+                    .text()
+                    .await
+                    .map_err(|err| AppError::BadRequest(err.to_string()))?;
+            }
+            "follow_user_id" => {
+                let value = field
+                    .text()
+                    .await
+                    .map_err(|err| AppError::BadRequest(err.to_string()))?;
+                form.follow_user_ids
+                    .push(value.trim().parse::<i64>().map_err(|_parse_err| {
+                        AppError::BadRequest("follow suggestion is invalid".to_owned())
+                    })?);
+            }
+            "profile_picture" if field.file_name().is_some() => {
+                if !state.settings.accounts.allow_profile_pictures {
+                    return Err(AppError::Forbidden);
+                }
+                if field.file_name().is_none_or(|name| name.trim().is_empty()) {
+                    continue;
+                }
+                form.profile_picture_media_id = Some(
+                    media::save_profile_picture_upload(
+                        &state.pool,
+                        &state.settings,
+                        &state.paths,
+                        &state.ffmpeg,
+                        user_id,
+                        field,
+                    )
+                    .await
+                    .map_err(|err| AppError::BadRequest(err.to_string()))?,
+                );
+            }
+            _ => {}
+        }
+    }
+    Ok(form)
+}
+
+async fn update_onboarding_profile(
+    pool: &SqlitePool,
+    user_id: i64,
+    display_name: &str,
+    bio: &str,
+) -> AppResult<()> {
+    let display_name = display_name.trim().to_owned();
+    let bio = bio.trim().to_owned();
+    pool.call(move |conn| {
+        conn.execute(
+            "UPDATE users SET display_name = ?, bio = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND is_deleted = 0",
+            params![display_name, bio, user_id],
+        )?;
+        Ok(())
+    })
+    .await?;
+    Ok(())
+}
+
+async fn mark_onboarding_complete(pool: &SqlitePool, user_id: i64) -> AppResult<()> {
+    pool.call(move |conn| {
+        conn.execute(
+            "UPDATE users SET onboarding_completed_at = COALESCE(onboarding_completed_at, CURRENT_TIMESTAMP), updated_at = CURRENT_TIMESTAMP WHERE id = ? AND is_deleted = 0",
+            [user_id],
+        )?;
+        Ok(())
+    })
+    .await?;
+    Ok(())
+}
+
+async fn onboarding_completed(pool: &SqlitePool, user_id: i64) -> AppResult<bool> {
+    Ok(pool
+        .call(move |conn| {
+            conn.query_row(
+                "SELECT onboarding_completed_at IS NOT NULL FROM users WHERE id = ? AND is_deleted = 0",
+                [user_id],
+                |row| row.get::<_, i64>(0),
+            )
+            .optional()
+            .map(|value| value.unwrap_or(0) != 0)
+            .map_err(Into::into)
+        })
+        .await?)
+}
+
+fn dedup_user_ids(ids: Vec<i64>, current_user_id: i64) -> Vec<i64> {
+    let mut deduped = Vec::new();
+    for id in ids {
+        if id == current_user_id || deduped.contains(&id) {
+            continue;
+        }
+        deduped.push(id);
+    }
+    deduped
+}
+
 async fn logout(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
@@ -684,18 +1019,20 @@ async fn create_post(
             parent_post_id: form.parent_post_id,
             redirect,
             html: if form.parent_post_id.is_some() {
-                render::thread_post_card_with_nsfw_blur(
+                render::thread_post_card_with_controls(
                     post,
                     user.as_ref(),
                     form_csrf(&state, &headers).await.as_deref(),
                     blur_nsfw_media(&state, user.as_ref()),
+                    state.settings.posts.post_edit_window_seconds,
                 )
             } else {
-                render::post_card_with_nsfw_blur(
+                render::post_card_with_controls(
                     post,
                     user.as_ref(),
                     form_csrf(&state, &headers).await.as_deref(),
                     blur_nsfw_media(&state, user.as_ref()),
+                    state.settings.posts.post_edit_window_seconds,
                 )
             },
         })
@@ -824,11 +1161,12 @@ async fn thread(
     let body = format!(
         "{}{}{}",
         render::thread_back_control(),
-        render::thread_posts_with_nsfw_blur(
+        render::thread_posts_with_controls(
             &posts,
             user.as_ref(),
             csrf.as_deref(),
             blur_nsfw_media(&state, user.as_ref()),
+            state.settings.posts.post_edit_window_seconds,
         ),
         composer
     );
@@ -837,46 +1175,111 @@ async fn thread(
     ))
 }
 
-async fn delete_confirm(
+async fn edit_post_form(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
     Path(id): Path<i64>,
-    Query(query): Query<DeleteQuery>,
+    Query(query): Query<ReturnQuery>,
 ) -> AppResult<Html<String>> {
-    let user = require_user(&state, &headers).await?;
+    let user = require_active_user(&state, &headers).await?;
     let csrf = form_csrf(&state, &headers).await.unwrap_or_default();
-    let preview = delete_preview(&state.pool, user.id, user.is_admin, id).await?;
-    let fallback = delete_return_fallback(&headers, id, preview.parent_post_id);
+    let preview = edit_preview(
+        &state.pool,
+        user.id,
+        id,
+        state.settings.posts.post_edit_window_seconds,
+    )
+    .await?;
+    let fallback = edit_return_fallback(&headers, id, preview.parent_post_id);
     let return_to = query
         .return_to
         .as_deref()
-        .and_then(|target| safe_delete_return_target(target, id))
+        .and_then(|target| safe_edit_return_target(target, id))
         .unwrap_or(fallback);
-    let author = preview
-        .display_name
-        .as_deref()
-        .or(preview.username.as_deref())
-        .unwrap_or("Deleted user");
     let body = format!(
-        r#"<section class="panel"><h1>Delete post?</h1><p class="muted">This will remove the post from timelines and threads.</p><blockquote>{}</blockquote><p class="muted">By {}</p><div class="actions"><form method="post"><input type="hidden" name="csrf" value="{}"><input type="hidden" name="return_to" value="{}"><button class="danger" type="submit">Confirm delete</button></form><a class="button-link" href="{}">Cancel</a></div></section>"#,
-        html_escape::encode_text(&preview.text),
-        html_escape::encode_text(author),
-        html_escape::encode_double_quoted_attribute(&csrf),
-        html_escape::encode_double_quoted_attribute(&return_to),
-        html_escape::encode_double_quoted_attribute(&return_to)
+        "{}{}",
+        render::thread_back_control(),
+        render::edit_post_form(
+            &csrf,
+            id,
+            &preview.text,
+            state.settings.posts.max_text_chars,
+            &return_to,
+        )
     );
     Ok(Html(
-        page_layout(&state, Some(&user), Some(&csrf), "Delete post", &body).await?,
+        page_layout(&state, Some(&user), Some(&csrf), "Edit post", &body).await?,
     ))
 }
 
-async fn delete_post(
+async fn edit_post(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
     Path(id): Path<i64>,
-    Form(form): Form<DeleteForm>,
+    Form(form): Form<EditPostForm>,
 ) -> AppResult<Response> {
-    let user = require_user(&state, &headers).await?;
+    let user = require_active_user(&state, &headers).await?;
+    validate_csrf(&state.pool, &headers, &form.csrf).await?;
+    match social::edit_post(&state.pool, &state.settings, user.id, id, &form.text).await {
+        Ok(_changed) => {
+            let target = form
+                .return_to
+                .as_deref()
+                .and_then(|target| safe_edit_return_target(target, id))
+                .unwrap_or_else(|| format!("/posts/{id}"));
+            Ok(Redirect::to(&target).into_response())
+        }
+        Err(social::EditPostError::NotFound) => Err(AppError::NotFound),
+        Err(social::EditPostError::Forbidden) => Err(AppError::Forbidden),
+        Err(
+            err @ (social::EditPostError::WindowExpired | social::EditPostError::Validation(_)),
+        ) => bad_request_page(&state, Some(&user), &err.to_string()).await,
+        Err(social::EditPostError::Database(message)) => {
+            Err(AppError::Anyhow(anyhow::anyhow!(message)))
+        }
+    }
+}
+
+async fn delete_confirm(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Path(id): Path<i64>,
+    Query(query): Query<DeleteQuery>,
+) -> AppResult<Html<String>> {
+    let user = require_user(&state, &headers).await?;
+    let csrf = form_csrf(&state, &headers).await.unwrap_or_default();
+    let preview = delete_preview(&state.pool, user.id, user.is_admin, id).await?;
+    let fallback = delete_return_fallback(&headers, id, preview.parent_post_id);
+    let return_to = query
+        .return_to
+        .as_deref()
+        .and_then(|target| safe_delete_return_target(target, id))
+        .unwrap_or(fallback);
+    let author = preview
+        .display_name
+        .as_deref()
+        .or(preview.username.as_deref())
+        .unwrap_or("Deleted user");
+    let body = format!(
+        r#"<section class="panel"><h1>Delete post?</h1><p class="muted">This will remove the post from timelines and threads.</p><blockquote>{}</blockquote><p class="muted">By {}</p><div class="actions"><form method="post"><input type="hidden" name="csrf" value="{}"><input type="hidden" name="return_to" value="{}"><button class="danger" type="submit">Confirm delete</button></form><a class="button-link" href="{}">Cancel</a></div></section>"#,
+        html_escape::encode_text(&preview.text),
+        html_escape::encode_text(author),
+        html_escape::encode_double_quoted_attribute(&csrf),
+        html_escape::encode_double_quoted_attribute(&return_to),
+        html_escape::encode_double_quoted_attribute(&return_to)
+    );
+    Ok(Html(
+        page_layout(&state, Some(&user), Some(&csrf), "Delete post", &body).await?,
+    ))
+}
+
+async fn delete_post(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Path(id): Path<i64>,
+    Form(form): Form<DeleteForm>,
+) -> AppResult<Response> {
+    let user = require_user(&state, &headers).await?;
     validate_csrf(&state.pool, &headers, &form.csrf).await?;
     let preview = match delete_preview(&state.pool, user.id, user.is_admin, id).await {
         Ok(preview) => preview,
@@ -937,6 +1340,31 @@ async fn toggle_bookmark(
     Ok(redirect_to_post_anchor(&headers, id, is_reply).into_response())
 }
 
+async fn toggle_pin_post(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Path(id): Path<i64>,
+    Form(form): Form<CsrfForm>,
+) -> AppResult<Response> {
+    let user = require_active_user(&state, &headers).await?;
+    validate_csrf(&state.pool, &headers, &form.csrf).await?;
+    let is_reply = post_is_reply(&state.pool, id).await?;
+    if social::pinned_post_id(&state.pool, user.id).await? == Some(id) {
+        social::unpin_post(&state.pool, user.id, id).await?;
+    } else {
+        social::pin_post(&state.pool, user.id, id)
+            .await
+            .map_err(|err| match err {
+                social::PinPostError::NotFound => AppError::NotFound,
+                social::PinPostError::Forbidden => AppError::Forbidden,
+                social::PinPostError::Database(message) => {
+                    AppError::Anyhow(anyhow::anyhow!(message))
+                }
+            })?;
+    }
+    Ok(redirect_to_post_anchor(&headers, id, is_reply).into_response())
+}
+
 async fn repost(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
@@ -1026,6 +1454,33 @@ async fn reply_redirect(Path(id): Path<i64>) -> Redirect {
     Redirect::to(&format!("/posts/{id}"))
 }
 
+fn profile_tab_from_query(tab: Option<&str>) -> social::ProfileTimelineTab {
+    match tab {
+        Some("replies") => social::ProfileTimelineTab::Replies,
+        Some("media") => social::ProfileTimelineTab::Media,
+        Some("likes") => social::ProfileTimelineTab::Likes,
+        _ => social::ProfileTimelineTab::Posts,
+    }
+}
+
+fn profile_tab_empty_state(tab: social::ProfileTimelineTab) -> render::EmptyState<'static> {
+    match tab {
+        social::ProfileTimelineTab::Posts => {
+            render::EmptyState::new("No posts yet.", "This profile has not posted yet.")
+        }
+        social::ProfileTimelineTab::Replies => {
+            render::EmptyState::new("No replies yet.", "This profile has not replied yet.")
+        }
+        social::ProfileTimelineTab::Media => render::EmptyState::new(
+            "No media posts yet.",
+            "Media posts and replies will appear here.",
+        ),
+        social::ProfileTimelineTab::Likes => {
+            render::EmptyState::new("No likes yet.", "Liked posts will appear here.")
+        }
+    }
+}
+
 #[expect(
     clippy::too_many_lines,
     reason = "profile rendering combines existing viewer controls and page assembly in one route handler"
@@ -1034,8 +1489,10 @@ async fn profile(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
     Path(username): Path<String>,
+    Query(query): Query<ProfileQuery>,
 ) -> AppResult<Html<String>> {
     let user = current(&state, &headers).await?;
+    let active_tab = profile_tab_from_query(query.tab.as_deref());
     let profile = state
         .pool
         .call(move |conn| {
@@ -1043,7 +1500,9 @@ async fn profile(
                 r#"
         SELECT u.id, u.username, u.display_name, u.bio, u.location, u.website,
           pic.public_path AS profile_picture_path,
-          banner.public_path AS banner_path
+          banner.public_path AS banner_path,
+          u.liked_posts_public,
+          u.is_suspended
         FROM users u
         LEFT JOIN media pic ON pic.id = u.profile_picture_media_id
         LEFT JOIN media banner ON banner.id = u.banner_media_id
@@ -1060,6 +1519,8 @@ async fn profile(
                         row.get::<_, String>(5)?,
                         row.get::<_, Option<String>>(6)?,
                         row.get::<_, Option<String>>(7)?,
+                        row.get::<_, i64>(8)? != 0,
+                        row.get::<_, i64>(9)? != 0,
                     ))
                 },
             )
@@ -1076,13 +1537,36 @@ async fn profile(
         website,
         picture_path,
         banner_path,
+        liked_posts_public,
+        is_suspended,
     )) = profile
     else {
         return Err(AppError::NotFound);
     };
     let csrf = form_csrf(&state, &headers).await;
-    let posts =
-        social::profile_timeline(&state.pool, user.as_ref().map(|u| u.id), profile_id).await?;
+    let viewer_id = user.as_ref().map(|u| u.id);
+    let owner_or_admin =
+        viewer_id == Some(profile_id) || user.as_ref().is_some_and(|viewer| viewer.is_admin);
+    let activity_visible = (!is_suspended || owner_or_admin)
+        && social::profile_activity_visible(&state.pool, viewer_id, profile_id).await?;
+    let likes_visible = activity_visible && (liked_posts_public || viewer_id == Some(profile_id));
+    let pinned_post = if active_tab == social::ProfileTimelineTab::Posts && activity_visible {
+        social::profile_pinned_post(&state.pool, viewer_id, profile_id).await?
+    } else {
+        None
+    };
+    let mut posts = if !activity_visible
+        || (active_tab == social::ProfileTimelineTab::Likes && !likes_visible)
+    {
+        Vec::new()
+    } else {
+        social::profile_tab_timeline(&state.pool, viewer_id, profile_id, active_tab).await?
+    };
+    if let Some(pinned) = pinned_post.as_ref() {
+        posts.retain(|post| {
+            !(post.event_kind == social::TimelineEventKind::Post && post.id == pinned.id)
+        });
+    }
     let (followers, following) = social::follow_counts(&state.pool, profile_id).await?;
     let controls = profile_controls(&state, user.as_ref(), csrf.as_deref(), profile_id).await?;
     let picture = picture_path.map_or_else(
@@ -1120,8 +1604,39 @@ async fn profile(
             html_escape::encode_text(location.as_str())
         )
     };
+    let pinned = pinned_post.as_ref().map_or_else(String::new, |post| {
+        render::pinned_post_with_controls(
+            post,
+            user.as_ref(),
+            csrf.as_deref(),
+            blur_nsfw_media(&state, user.as_ref()),
+            state.settings.posts.post_edit_window_seconds,
+        )
+    });
+    let tabs = render::profile_tabs(&profile_username, active_tab);
+    let timeline = if !activity_visible {
+        render::posts_with_controls_empty_state(
+            &posts,
+            user.as_ref(),
+            csrf.as_deref(),
+            blur_nsfw_media(&state, user.as_ref()),
+            state.settings.posts.post_edit_window_seconds,
+            profile_tab_empty_state(active_tab),
+        )
+    } else if active_tab == social::ProfileTimelineTab::Likes && !likes_visible {
+        render::empty_state("This user’s likes are private", "")
+    } else {
+        render::posts_with_controls_empty_state(
+            &posts,
+            user.as_ref(),
+            csrf.as_deref(),
+            blur_nsfw_media(&state, user.as_ref()),
+            state.settings.posts.post_edit_window_seconds,
+            profile_tab_empty_state(active_tab),
+        )
+    };
     let body = format!(
-        r#"<section class="panel profile">{}<div class="profile-heading">{}<div class="profile-main"><div class="profile-title-row"><div><h1>{}</h1><p class="muted">@{}</p></div>{}</div><p class="counts"><span data-profile-followers="{}">{} followers</span><span data-profile-following="{}">{} following</span></p>{}<p>{}</p>{}</div></div></section>{}"#,
+        r#"<section class="panel profile">{}<div class="profile-heading">{}<div class="profile-main"><div class="profile-title-row"><div><h1>{}</h1><p class="muted">@{}</p></div>{}</div><p class="counts"><span data-profile-followers="{}">{} followers</span><span data-profile-following="{}">{} following</span></p>{}<p>{}</p>{}</div></div></section>{}{}{}"#,
         banner,
         picture,
         html_escape::encode_text(display_name.as_str()),
@@ -1134,12 +1649,9 @@ async fn profile(
         location_line,
         html_escape::encode_text(bio.as_str()),
         website_link,
-        render::posts_with_nsfw_blur(
-            &posts,
-            user.as_ref(),
-            csrf.as_deref(),
-            blur_nsfw_media(&state, user.as_ref()),
-        )
+        pinned,
+        tabs,
+        timeline
     );
     Ok(Html(
         page_layout(
@@ -1195,7 +1707,10 @@ async fn profile_followers(
             &format!("{display_name} followers"),
             &format!("Users who follow @{profile_username}.")
         ),
-        render::account_links(&accounts, "No followers yet.")
+        render::account_links_with_empty_state(
+            &accounts,
+            render::EmptyState::new("No followers yet.", "Followers will appear here.",),
+        )
     );
     Ok(Html(
         page_layout(
@@ -1233,7 +1748,13 @@ async fn profile_following(
             &format!("{display_name} following"),
             &format!("Users @{profile_username} follows.")
         ),
-        render::account_links(&accounts, "Not following anyone yet.")
+        render::account_links_with_empty_state(
+            &accounts,
+            render::EmptyState::new(
+                "Not following anyone yet.",
+                "Followed accounts will appear here.",
+            ),
+        )
     );
     Ok(Html(
         page_layout(
@@ -1363,6 +1884,7 @@ struct SettingsProfile {
     website: String,
     theme: String,
     nsfw_blur_enabled: bool,
+    liked_posts_public: bool,
     picture_path: Option<String>,
     banner_path: Option<String>,
 }
@@ -1372,6 +1894,7 @@ async fn settings_profile(pool: &SqlitePool, user_id: i64) -> AppResult<Settings
         conn.query_row(
             r#"
         SELECT u.display_name, u.bio, u.location, u.website, u.theme, u.nsfw_blur_enabled,
+          u.liked_posts_public,
           pic.public_path AS profile_picture_path,
           banner.public_path AS banner_path
         FROM users u
@@ -1388,8 +1911,9 @@ async fn settings_profile(pool: &SqlitePool, user_id: i64) -> AppResult<Settings
                     website: row.get(3)?,
                     theme: row.get(4)?,
                     nsfw_blur_enabled: row.get::<_, i64>(5)? != 0,
-                    picture_path: row.get(6)?,
-                    banner_path: row.get(7)?,
+                    liked_posts_public: row.get::<_, i64>(6)? != 0,
+                    picture_path: row.get(7)?,
+                    banner_path: row.get(8)?,
                 })
             },
         )
@@ -1429,30 +1953,83 @@ fn settings_profile_media(
             )
         },
     );
-    let banner_control = if allow_profile_banners {
-        let delete = banner_path.map_or_else(String::new, |_| {
-            r#"<label class="check-row"><input type="checkbox" name="delete_banner" value="true"> Remove banner</label>"#
-                .to_owned()
-        });
-        format!(
-            r#"<div class="media-control-row"><label class="file-control" for="banner">Change banner<input id="banner" name="banner" type="file" accept="image/*"></label>{delete}</div>"#
+    let banner_controls = if allow_profile_banners {
+        settings_media_actions(
+            "settings-banner-actions",
+            "banner",
+            "banner",
+            "Change banner",
+            banner_path.map(|_| ("delete_banner", "delete_banner", "Remove banner")),
         )
     } else {
-        r#"<p class="muted">Profile banners are disabled.</p>"#.to_owned()
+        settings_media_disabled("Profile banners are disabled.")
     };
-    let picture_control = if allow_profile_pictures {
-        let delete = picture_path.map_or_else(String::new, |_| {
-            r#"<label class="check-row"><input type="checkbox" name="delete_profile_picture" value="true"> Remove profile picture</label>"#
-                .to_owned()
-        });
-        format!(
-            r#"<div class="media-control-row"><label class="file-control" for="profile_picture">Change profile picture<input id="profile_picture" name="profile_picture" type="file" accept="image/*"></label>{delete}</div>"#
+    let picture_controls = if allow_profile_pictures {
+        settings_media_actions(
+            "settings-picture-actions",
+            "profile_picture",
+            "profile_picture",
+            "Change profile picture",
+            picture_path.map(|_| {
+                (
+                    "delete_profile_picture",
+                    "delete_profile_picture",
+                    "Remove profile picture",
+                )
+            }),
         )
     } else {
-        r#"<p class="muted">Profile pictures are disabled.</p>"#.to_owned()
+        settings_media_disabled("Profile pictures are disabled.")
     };
     format!(
-        r#"<div class="settings-profile-media"><div class="settings-banner-wrap">{banner}</div><div class="settings-picture-row">{picture}<div class="settings-media-controls">{banner_control}{picture_control}</div></div></div>"#
+        r#"<div class="settings-profile-media"><div class="settings-banner-wrap settings-media-frame" data-profile-media-frame>{banner}{banner_controls}</div><div class="settings-picture-row"><div class="settings-picture-wrap settings-media-frame" data-profile-media-frame>{picture}{picture_controls}</div></div></div>"#
+    )
+}
+
+fn settings_media_actions(
+    action_class: &str,
+    file_id: &str,
+    file_name: &str,
+    change_label: &str,
+    delete: Option<(&str, &str, &str)>,
+) -> String {
+    let delete_control =
+        delete.map_or_else(String::new, |(delete_id, delete_name, delete_label)| {
+            settings_media_delete_control(delete_id, delete_name, delete_label)
+        });
+    format!(
+        r#"<div class="settings-media-actions {action_class}">{}{delete_control}</div><span class="sr-only" aria-live="polite" data-profile-media-status></span>"#,
+        settings_media_file_control(file_id, file_name, change_label),
+        action_class = html_escape::encode_double_quoted_attribute(action_class),
+    )
+}
+
+fn settings_media_file_control(input_id: &str, name: &str, label: &str) -> String {
+    let input_id = html_escape::encode_double_quoted_attribute(input_id);
+    let name = html_escape::encode_double_quoted_attribute(name);
+    let label_attr = html_escape::encode_double_quoted_attribute(label);
+    let label_text = html_escape::encode_text(label);
+    format!(
+        r#"<span class="settings-media-control"><input class="settings-media-input" id="{input_id}" name="{name}" type="file" accept="image/*" aria-label="{label_attr}" data-profile-media-file><label class="settings-media-icon-button settings-media-change" for="{input_id}" title="{label_attr}">{}<span class="sr-only">{label_text}</span></label></span>"#,
+        render::icon_svg("edit"),
+    )
+}
+
+fn settings_media_delete_control(input_id: &str, name: &str, label: &str) -> String {
+    let input_id = html_escape::encode_double_quoted_attribute(input_id);
+    let name = html_escape::encode_double_quoted_attribute(name);
+    let label_attr = html_escape::encode_double_quoted_attribute(label);
+    let label_text = html_escape::encode_text(label);
+    format!(
+        r#"<span class="settings-media-control"><input class="settings-media-delete-input" id="{input_id}" name="{name}" type="checkbox" value="true" aria-label="{label_attr}" data-profile-media-delete><label class="settings-media-icon-button settings-media-remove" for="{input_id}" title="{label_attr}">{}<span class="sr-only">{label_text}</span></label></span>"#,
+        render::icon_svg("trash"),
+    )
+}
+
+fn settings_media_disabled(message: &str) -> String {
+    format!(
+        r#"<p class="settings-media-disabled">{}</p>"#,
+        html_escape::encode_text(message),
     )
 }
 
@@ -1465,7 +2042,7 @@ fn settings_user_list(
     empty_message: &str,
 ) -> String {
     if users.is_empty() {
-        return compact_empty_state(empty_title, empty_message);
+        return render::compact_empty_state(empty_title, empty_message);
     }
     let rows = users
         .iter()
@@ -1484,7 +2061,7 @@ fn settings_user_list(
 
 fn settings_muted_word_list(words: &[social::MutedWord], csrf: &str) -> String {
     if words.is_empty() {
-        return compact_empty_state(
+        return render::compact_empty_state(
             "No muted words",
             "Posts containing muted words will be hidden.",
         );
@@ -1508,14 +2085,6 @@ fn settings_muted_word_list(words: &[social::MutedWord], csrf: &str) -> String {
     format!(r#"<ul class="settings-item-list">{rows}</ul>"#)
 }
 
-fn compact_empty_state(title: &str, message: &str) -> String {
-    format!(
-        r#"<div class="compact-empty"><strong>{}</strong><p>{}</p></div>"#,
-        html_escape::encode_text(title),
-        html_escape::encode_text(message)
-    )
-}
-
 fn validate_profile_location(location: &str) -> AppResult<()> {
     if location.chars().count() > 100 {
         return Err(AppError::BadRequest("location is too long".to_owned()));
@@ -1578,16 +2147,6 @@ async fn settings_page(
     let blocked = social::blocked_users(&state.pool, user.id).await?;
     let muted = social::muted_users(&state.pool, user.id).await?;
     let muted_words = social::muted_words(&state.pool, user.id).await?;
-    let dark_checked = if Theme::from(profile.theme.as_str()) == Theme::Dark {
-        " checked"
-    } else {
-        ""
-    };
-    let nsfw_checked = if profile.nsfw_blur_enabled {
-        " checked"
-    } else {
-        ""
-    };
     let notice_html =
         notice.map_or_else(String::new, |(kind, message)| render::notice(kind, message));
     let password_hint = if state.settings.accounts.min_password_length == 0 {
@@ -1612,16 +2171,40 @@ async fn settings_page(
         state.settings.accounts.allow_profile_pictures,
         state.settings.accounts.allow_profile_banners,
     );
-    let body = format!(
-        r#"{notice_html}<section class="panel settings-card settings-profile-editor" data-testid="settings-card"><div class="settings-editor-bar"><div><h1>Account settings</h1><p class="muted">Profile, privacy, and account controls.</p></div><button class="primary" type="submit" form="profile-settings-form">Save settings</button></div><form id="profile-settings-form" method="post" enctype="multipart/form-data" class="settings-profile-form"><input type="hidden" name="csrf" value="{}">{}<label class="theme-toggle" for="dark_mode"><input id="dark_mode" name="dark_mode" type="checkbox" value="true"{}> Dark mode</label><label class="theme-toggle" for="nsfw_blur_enabled"><input id="nsfw_blur_enabled" name="nsfw_blur_enabled" type="checkbox" value="true"{}> Blur NSFW media</label><div class="settings-fields"><label for="display_name">Display name</label><input id="display_name" name="display_name" value="{}"><label for="bio">Bio</label><textarea id="bio" name="bio">{}</textarea><label for="location">Location</label><input id="location" name="location" value="{}"><label for="website">Website</label><input id="website" type="url" name="website" value="{}"></div></form></section><div class="settings-grid"><section class="panel settings-card compact-panel" data-testid="settings-card"><h2>Blocked users</h2>{}</section><section class="panel settings-card compact-panel" data-testid="settings-card"><h2>Muted users</h2>{}</section></div><section class="panel settings-card compact-panel" data-testid="settings-card"><h2>Muted words</h2><form method="post" action="/settings/muted-words" class="inline-settings-form"><input type="hidden" name="csrf" value="{}"><label class="sr-only" for="muted-word">Word or phrase to mute</label><input id="muted-word" name="term" placeholder="Word or phrase" required><button type="submit">Add muted word</button></form>{}</section><section class="panel settings-card compact-panel" data-testid="settings-card"><h2>Change password</h2><form method="post" action="/settings/password" class="settings-password-form"><input type="hidden" name="csrf" value="{}"><label for="current_password">Current password</label><div class="password-control"><input id="current_password" name="current_password" type="password" autocomplete="current-password"><button type="button" class="password-toggle" data-password-toggle="current_password" aria-label="Show current password">Show</button></div><label for="new_password">New password</label><p class="field-help" id="new-password-requirement">{}</p><div class="password-control"><input id="new_password" name="new_password" type="password" autocomplete="new-password"{}><button type="button" class="password-toggle" data-password-toggle="new_password" aria-label="Show new password">Show</button></div><label for="confirm_new_password">Confirm new password</label><p class="field-help" id="confirm-new-password-requirement">{}</p><div class="password-control"><input id="confirm_new_password" name="confirm_new_password" type="password" autocomplete="new-password"{}><button type="button" class="password-toggle" data-password-toggle="confirm_new_password" aria-label="Show new password confirmation">Show</button></div><button type="submit">Change password</button></form></section><section class="panel settings-card danger-panel" data-testid="settings-card"><h2>Delete account</h2><p>This permanently removes your profile, posts, media, sessions, and account relationships.</p><p><a class="button-link danger-link" href="/settings/delete">Start delete account flow</a></p></section>"#,
-        html_escape::encode_double_quoted_attribute(&csrf),
-        profile_media,
-        dark_checked,
-        nsfw_checked,
+    let profile_fields = format!(
+        r#"<div class="settings-fields settings-profile-fields"><label for="display_name">Display name</label><input id="display_name" name="display_name" value="{}"><label for="bio">Bio</label><textarea id="bio" name="bio">{}</textarea><label for="location">Location</label><input id="location" name="location" value="{}"><label for="website">Website</label><input id="website" type="url" name="website" value="{}"></div>"#,
         html_escape::encode_double_quoted_attribute(profile.display_name.as_str()),
         html_escape::encode_text(profile.bio.as_str()),
         html_escape::encode_double_quoted_attribute(profile.location.as_str()),
         html_escape::encode_double_quoted_attribute(profile.website.as_str()),
+    );
+    let preference_switches = [
+        settings_switch(
+            "dark_mode",
+            Theme::from(profile.theme.as_str()) == Theme::Dark,
+            "Dark mode",
+            "Use the darker color theme for your signed-in session.",
+        ),
+        settings_switch(
+            "nsfw_blur_enabled",
+            profile.nsfw_blur_enabled,
+            "Blur NSFW media",
+            "Hide NSFW media previews behind a reveal control.",
+        ),
+        settings_switch(
+            "liked_posts_public",
+            profile.liked_posts_public,
+            "Make liked posts public",
+            "Allow other people to view your Likes tab on your profile.",
+        ),
+    ]
+    .join("");
+    let body = format!(
+        r#"{notice_html}<section class="panel settings-card settings-profile-editor" data-testid="settings-card"><div class="settings-editor-bar"><div><h1>Account settings</h1><p class="muted">Profile, privacy, media, and account controls.</p></div></div><form id="profile-settings-form" method="post" enctype="multipart/form-data" class="settings-profile-form"><input type="hidden" name="csrf" value="{}"><div class="settings-section settings-section-media"><div class="settings-section-heading"><h2>Profile media</h2><p class="settings-section-help">Avatar and banner images for your profile header.</p></div>{}</div><div class="settings-section settings-section-profile"><div class="settings-section-heading"><h2>Profile</h2><p class="settings-section-help">Your name, bio, location, and link as shown on your profile.</p></div>{}</div><div class="settings-section settings-section-preferences"><div class="settings-section-heading"><h2>Preferences and privacy</h2><p class="settings-section-help">Control your display theme, NSFW media blur, and profile activity visibility.</p></div><div class="settings-switch-list">{}</div></div><div class="settings-form-actions"><button class="primary" type="submit">Save profile settings</button></div></form></section><div class="settings-grid"><section class="panel settings-card compact-panel settings-list-panel" data-testid="settings-card"><h2>Blocked users</h2><p class="settings-section-help">Blocked accounts cannot follow or interact with you.</p>{}</section><section class="panel settings-card compact-panel settings-list-panel" data-testid="settings-card"><h2>Muted users</h2><p class="settings-section-help">Muted accounts stay hidden from your views.</p>{}</section></div><section class="panel settings-card compact-panel settings-list-panel" data-testid="settings-card"><h2>Muted words</h2><p class="settings-section-help">Hide posts containing specific words or phrases.</p><form method="post" action="/settings/muted-words" class="inline-settings-form"><input type="hidden" name="csrf" value="{}"><label class="sr-only" for="muted-word">Word or phrase to mute</label><input id="muted-word" name="term" placeholder="Word or phrase" required><button type="submit">Add muted word</button></form>{}</section><section class="panel settings-card compact-panel settings-security-panel" data-testid="settings-card"><h2>Change password</h2><p class="settings-section-help">Update the password used to sign in to this account.</p><form method="post" action="/settings/password" class="settings-password-form"><input type="hidden" name="csrf" value="{}"><label for="current_password">Current password</label><div class="password-control"><input id="current_password" name="current_password" type="password" autocomplete="current-password"><button type="button" class="password-toggle" data-password-toggle="current_password" aria-label="Show current password">Show</button></div><label for="new_password">New password</label><p class="field-help" id="new-password-requirement">{}</p><div class="password-control"><input id="new_password" name="new_password" type="password" autocomplete="new-password"{}><button type="button" class="password-toggle" data-password-toggle="new_password" aria-label="Show new password">Show</button></div><label for="confirm_new_password">Confirm new password</label><p class="field-help" id="confirm-new-password-requirement">{}</p><div class="password-control"><input id="confirm_new_password" name="confirm_new_password" type="password" autocomplete="new-password"{}><button type="button" class="password-toggle" data-password-toggle="confirm_new_password" aria-label="Show new password confirmation">Show</button></div><div class="settings-form-actions"><button type="submit">Change password</button></div></form></section><section class="panel settings-card danger-panel" data-testid="settings-card"><h2>Delete account</h2><p>This permanently removes your profile, posts, media, sessions, and account relationships.</p><p class="settings-danger-action"><a class="button-link danger-link" href="/settings/delete">Start delete account flow</a></p></section>"#,
+        html_escape::encode_double_quoted_attribute(&csrf),
+        profile_media,
+        profile_fields,
+        preference_switches,
         settings_user_list(
             &blocked,
             "/unblock",
@@ -1649,6 +2232,18 @@ async fn settings_page(
     page_layout(state, Some(user), Some(csrf), "Settings", &body).await
 }
 
+fn settings_switch(id: &str, checked: bool, label: &str, help: &str) -> String {
+    let checked_attr = if checked { " checked" } else { "" };
+    let help_id = format!("{id}-help");
+    format!(
+        r#"<label class="settings-switch-row" for="{id}"><span class="settings-switch-copy"><span class="settings-switch-label">{label}</span><span class="settings-switch-help" id="{help_id}">{help}</span></span><span class="settings-switch-toggle"><input class="settings-switch-input" id="{id}" name="{id}" type="checkbox" role="switch" value="true"{checked_attr} aria-describedby="{help_id}"><span class="settings-switch-control" aria-hidden="true"></span></span></label>"#,
+        id = html_escape::encode_double_quoted_attribute(id),
+        help_id = html_escape::encode_double_quoted_attribute(&help_id),
+        label = html_escape::encode_text(label),
+        help = html_escape::encode_text(help),
+    )
+}
+
 async fn settings_update(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
@@ -1665,12 +2260,22 @@ async fn settings_update(
     let website = form.website.trim().to_owned();
     let theme = form.theme.as_str().to_owned();
     let nsfw_blur_enabled = i64::from(form.nsfw_blur_enabled);
+    let liked_posts_public = i64::from(form.liked_posts_public);
     state
         .pool
         .call(move |conn| {
             conn.execute(
-                "UPDATE users SET display_name = ?, bio = ?, location = ?, website = ?, theme = ?, nsfw_blur_enabled = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
-                params![display_name, bio, location, website, theme, nsfw_blur_enabled, user.id],
+                "UPDATE users SET display_name = ?, bio = ?, location = ?, website = ?, theme = ?, nsfw_blur_enabled = ?, liked_posts_public = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
+                params![
+                    display_name,
+                    bio,
+                    location,
+                    website,
+                    theme,
+                    nsfw_blur_enabled,
+                    liked_posts_public,
+                    user.id
+                ],
             )?;
             Ok(())
         })
@@ -2018,6 +2623,7 @@ async fn parse_profile_update(
         delete_profile_picture: false,
         delete_banner: false,
         nsfw_blur_enabled: false,
+        liked_posts_public: false,
         profile_picture_media_id: None,
         banner_media_id: None,
     };
@@ -2066,6 +2672,9 @@ async fn parse_profile_update(
             "nsfw_blur_enabled" => {
                 form.nsfw_blur_enabled = true;
             }
+            "liked_posts_public" => {
+                form.liked_posts_public = true;
+            }
             "delete_profile_picture" => {
                 form.delete_profile_picture = true;
             }
@@ -2190,6 +2799,65 @@ async fn delete_preview(
     })
 }
 
+async fn edit_preview(
+    pool: &SqlitePool,
+    actor_id: i64,
+    post_id: i64,
+    edit_window_seconds: u64,
+) -> AppResult<EditPreview> {
+    let edit_window_modifier = edit_window_modifier(edit_window_seconds);
+    let preview = pool
+        .call(move |conn| {
+            conn.query_row(
+                r#"
+                SELECT p.user_id, p.text, p.parent_post_id,
+                  CASE
+                    WHEN ? IS NULL THEN 0
+                    ELSE p.created_at >= datetime('now', ?)
+                  END AS within_window
+                FROM posts p
+                WHERE p.id = ? AND p.is_deleted = 0
+                "#,
+                params![edit_window_modifier.clone(), edit_window_modifier, post_id],
+                |row| {
+                    Ok((
+                        row.get::<_, Option<i64>>(0)?,
+                        row.get::<_, String>(1)?,
+                        row.get::<_, Option<i64>>(2)?,
+                        row.get::<_, i64>(3)? != 0,
+                    ))
+                },
+            )
+            .optional()
+            .map_err(Into::into)
+        })
+        .await?;
+    let Some((owner, text, parent_post_id, within_window)) = preview else {
+        return Err(AppError::NotFound);
+    };
+    if owner != Some(actor_id) {
+        return Err(AppError::Forbidden);
+    }
+    if !within_window {
+        return Err(AppError::BadRequest(
+            "the edit window for this post has expired".to_owned(),
+        ));
+    }
+    Ok(EditPreview {
+        text,
+        parent_post_id,
+    })
+}
+
+fn edit_window_modifier(seconds: u64) -> Option<String> {
+    if seconds == 0 {
+        return None;
+    }
+    i64::try_from(seconds)
+        .ok()
+        .map(|seconds| format!("-{seconds} seconds"))
+}
+
 async fn post_is_reply(pool: &SqlitePool, post_id: i64) -> AppResult<bool> {
     Ok(pool
         .call(move |conn| {
@@ -2248,7 +2916,12 @@ async fn post_action_response(
             conn.query_row(
                 r#"
                 SELECT
-                  (SELECT COUNT(*) FROM likes WHERE post_id = p.id),
+                  (
+                    SELECT COUNT(*)
+                    FROM likes l
+                    JOIN users u ON u.id = l.user_id AND u.is_deleted = 0
+                    WHERE l.post_id = p.id AND (u.liked_posts_public != 0 OR l.user_id = ?)
+                  ),
                   ((SELECT COUNT(*) FROM reposts WHERE post_id = p.id) +
                    (SELECT COUNT(*) FROM posts qp WHERE qp.quote_post_id = p.id AND qp.is_deleted = 0)),
                   (SELECT COUNT(*) FROM posts replies WHERE replies.parent_post_id = p.id AND replies.is_deleted = 0),
@@ -2258,7 +2931,7 @@ async fn post_action_response(
                 FROM posts p
                 WHERE p.id = ? AND p.is_deleted = 0
                 "#,
-                params![viewer_id, viewer_id, viewer_id, post_id],
+                params![viewer_id, viewer_id, viewer_id, viewer_id, post_id],
                 |row| {
                     Ok(PostActionResponse {
                         kind: "post-action",
@@ -2339,6 +3012,27 @@ fn delete_return_fallback(
     )
 }
 
+fn edit_return_fallback(headers: &HeaderMap, post_id: i64, parent_post_id: Option<i64>) -> String {
+    let fallback = anchored_return(headers, post_id, parent_post_id.is_some(), "/home");
+    if safe_edit_return_target(&fallback, post_id).is_some() {
+        return fallback;
+    }
+    parent_post_id.map_or_else(
+        || format!("/posts/{post_id}"),
+        |parent_id| format!("/posts/{parent_id}#reply-{post_id}"),
+    )
+}
+
+fn safe_edit_return_target(value: &str, post_id: i64) -> Option<String> {
+    let target = safe_return_target(value)?;
+    let self_path = format!("/posts/{post_id}/edit");
+    if path_without_query_or_fragment(&target) == self_path {
+        None
+    } else {
+        Some(target)
+    }
+}
+
 fn safe_delete_return_target(value: &str, post_id: i64) -> Option<String> {
     let target = safe_return_target(value)?;
     let self_path = format!("/posts/{post_id}/delete");
@@ -2351,6 +3045,62 @@ fn safe_delete_return_target(value: &str, post_id: i64) -> Option<String> {
     }
 }
 
+fn parse_notification_ids(value: &str) -> AppResult<Vec<i64>> {
+    if value.len() > 1024 {
+        return Err(AppError::BadRequest(
+            "notification group is too large".to_owned(),
+        ));
+    }
+    let mut ids = Vec::new();
+    for part in value.split(',') {
+        let trimmed = part.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        let id = trimmed
+            .parse::<i64>()
+            .map_err(|_err| AppError::BadRequest("notification group is invalid".to_owned()))?;
+        if id <= 0 {
+            return Err(AppError::BadRequest(
+                "notification group is invalid".to_owned(),
+            ));
+        }
+        if !ids.contains(&id) {
+            ids.push(id);
+        }
+        if ids.len() > 80 {
+            return Err(AppError::BadRequest(
+                "notification group is too large".to_owned(),
+            ));
+        }
+    }
+    if ids.is_empty() {
+        return Err(AppError::BadRequest(
+            "notification group is invalid".to_owned(),
+        ));
+    }
+    Ok(ids)
+}
+
+fn parse_notification_group_target(value: Option<&str>) -> AppResult<Option<i64>> {
+    let Some(value) = value else {
+        return Ok(None);
+    };
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return Ok(None);
+    }
+    let target = trimmed
+        .parse::<i64>()
+        .map_err(|_err| AppError::BadRequest("notification group target is invalid".to_owned()))?;
+    if target <= 0 {
+        return Err(AppError::BadRequest(
+            "notification group target is invalid".to_owned(),
+        ));
+    }
+    Ok(Some(target))
+}
+
 fn path_without_query_or_fragment(target: &str) -> &str {
     target.split(['?', '#']).next().unwrap_or_default()
 }
@@ -2403,11 +3153,13 @@ async fn bookmarks(
     let body = format!(
         "{}{}",
         render::page_header("Bookmarks", "Posts you saved for later."),
-        render::posts_with_nsfw_blur(
+        render::posts_with_controls_empty_state(
             &posts,
             Some(&user),
             csrf.as_deref(),
             blur_nsfw_media(&state, Some(&user)),
+            state.settings.posts.post_edit_window_seconds,
+            render::EmptyState::new("No bookmarks yet.", "Saved posts will appear here."),
         )
     );
     Ok(Html(
@@ -2438,7 +3190,7 @@ async fn notifications(
 ) -> AppResult<Html<String>> {
     let user = require_user(&state, &headers).await?;
     let csrf = form_csrf(&state, &headers).await.unwrap_or_default();
-    let items = social::notifications(&state.pool, user.id).await?;
+    let items = social::notification_groups(&state.pool, user.id).await?;
     let unread_count = social::unread_notification_count(&state.pool, user.id).await?;
     let body = render::notifications_page(&items, unread_count, &csrf);
     Ok(Html(
@@ -2446,6 +3198,24 @@ async fn notifications(
     ))
 }
 
+async fn open_notification_group(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Form(form): Form<NotificationOpenForm>,
+) -> AppResult<Response> {
+    let user = require_user(&state, &headers).await?;
+    validate_csrf(&state.pool, &headers, &form.csrf).await?;
+    if let Some(kind) = form.group_kind.as_deref() {
+        let target_post_id = parse_notification_group_target(form.group_target_post_id.as_deref())?;
+        social::mark_notification_group_read(&state.pool, user.id, kind, target_post_id).await?;
+    } else {
+        let notification_ids = parse_notification_ids(&form.notification_ids)?;
+        social::mark_notification_ids_read(&state.pool, user.id, &notification_ids).await?;
+    }
+    let target = safe_return_target(&form.return_to).unwrap_or_else(|| "/notifications".to_owned());
+    Ok(Redirect::to(&target).into_response())
+}
+
 async fn mark_notifications_read(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
@@ -2457,6 +3227,29 @@ async fn mark_notifications_read(
     Ok(Redirect::to("/notifications").into_response())
 }
 
+async fn mention_suggestions(
+    State(state): State<Arc<AppState>>,
+    headers: HeaderMap,
+    Query(query): Query<MentionSuggestionsQuery>,
+) -> AppResult<Json<Vec<MentionSuggestionResponse>>> {
+    let user = current(&state, &headers).await?;
+    let suggestions = social::mention_suggestions(
+        &state.pool,
+        user.as_ref().map(|user| user.id),
+        query.q.as_deref().unwrap_or_default(),
+    )
+    .await?;
+    Ok(Json(
+        suggestions
+            .into_iter()
+            .map(|suggestion| MentionSuggestionResponse {
+                username: suggestion.username,
+                display_name: suggestion.display_name,
+            })
+            .collect(),
+    ))
+}
+
 async fn search(
     State(state): State<Arc<AppState>>,
     headers: HeaderMap,
@@ -2477,7 +3270,10 @@ async fn search(
         &posts,
         user.as_ref(),
         csrf.as_deref(),
-        blur_nsfw_media(&state, user.as_ref()),
+        render::SearchRenderOptions {
+            blur_nsfw_media: blur_nsfw_media(&state, user.as_ref()),
+            post_edit_window_seconds: state.settings.posts.post_edit_window_seconds,
+        },
     );
     Ok(Html(
         page_layout(&state, user.as_ref(), csrf.as_deref(), "Search", &body).await?,
@@ -2694,9 +3490,10 @@ fn admin_user_rows(rows: &[admin::AdminUserInvestigation], csrf: &str, searched:
         } else {
             "No users found."
         };
-        return format!(
-            r#"<div class="compact-empty admin-users-empty"><strong>{}</strong><p>Try a different username, handle, display name, or post keyword.</p></div>"#,
-            html_escape::encode_text(message)
+        return render::compact_empty_state_with_class(
+            "admin-users-empty",
+            message,
+            "Try a different username, handle, display name, or post keyword.",
         );
     }
 
@@ -3842,7 +4639,344 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn logged_in_ui_post_succeeds_with_empty_media_part_and_appears_on_home_feed() {
+    async fn registration_redirects_to_onboarding_with_session() {
+        let server = spawn_test_server().await;
+
+        let registered = request(
+            &server.base_url,
+            "POST",
+            "/register",
+            &[("content-type", "application/x-www-form-urlencoded")],
+            b"username=alice&password=very%20secure%20password&confirm_password=very%20secure%20password".to_vec(),
+        )
+        .await;
+
+        assert_eq!(registered.status, 303);
+        assert_eq!(location(&registered), "/onboarding");
+        let cookie = session_cookie(&registered);
+        let onboarding = get_with_cookie(&server, "/onboarding", &cookie).await;
+        assert_eq!(onboarding.status, 200);
+        assert!(onboarding.body.contains("<h1>Set up your account</h1>"));
+    }
+
+    #[tokio::test]
+    async fn onboarding_saves_profile_avatar_follows_and_marks_complete() {
+        let server = spawn_test_server().await;
+        let _bob_cookie = register_test_user(&server, "bob").await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+        let onboarding = get_with_cookie(&server, "/onboarding", &alice_cookie).await;
+        assert_eq!(onboarding.status, 200);
+        assert!(onboarding.body.contains("@bob"));
+        let csrf = csrf_token(&onboarding.body);
+
+        let body = multipart_body_with_file(
+            "onboarding-boundary",
+            &[
+                ("csrf", csrf.as_str()),
+                ("intent", "save"),
+                ("display_name", "Alice Display"),
+                ("bio", "building a local RustPost"),
+                ("follow_user_id", "1"),
+            ],
+            "profile_picture",
+            "avatar.png",
+            "image/png",
+            &tiny_png_bytes(),
+        );
+        let saved = request(
+            &server.base_url,
+            "POST",
+            "/onboarding",
+            &[
+                ("cookie", &alice_cookie),
+                (
+                    "content-type",
+                    "multipart/form-data; boundary=onboarding-boundary",
+                ),
+            ],
+            body,
+        )
+        .await;
+
+        assert_eq!(saved.status, 303);
+        assert_eq!(location(&saved), "/home");
+        let (display_name, bio, completed, has_avatar, follows_bob): (
+            String,
+            String,
+            i64,
+            i64,
+            i64,
+        ) = server
+            .pool
+            .call(|conn| {
+                let profile = conn.query_row(
+                    r#"
+                    SELECT display_name, bio, onboarding_completed_at IS NOT NULL,
+                      profile_picture_media_id IS NOT NULL
+                    FROM users WHERE normalized_username = 'alice'
+                    "#,
+                    [],
+                    |row| {
+                        Ok((
+                            row.get::<_, String>(0)?,
+                            row.get::<_, String>(1)?,
+                            row.get::<_, i64>(2)?,
+                            row.get::<_, i64>(3)?,
+                        ))
+                    },
+                )?;
+                let follows_bob = conn.query_row(
+                    "SELECT COUNT(*) FROM follows WHERE follower_id = 2 AND followed_id = 1",
+                    [],
+                    |row| row.get::<_, i64>(0),
+                )?;
+                Ok((profile.0, profile.1, profile.2, profile.3, follows_bob))
+            })
+            .await
+            .expect("profile state");
+        assert_eq!(display_name, "Alice Display");
+        assert_eq!(bio, "building a local RustPost");
+        assert_eq!(completed, 1);
+        assert_eq!(has_avatar, 1);
+        assert_eq!(follows_bob, 1);
+    }
+
+    #[tokio::test]
+    async fn onboarding_can_skip_optional_steps() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "charlie").await;
+        let onboarding = get_with_cookie(&server, "/onboarding", &cookie).await;
+        let csrf = csrf_token(&onboarding.body);
+
+        let skipped = request(
+            &server.base_url,
+            "POST",
+            "/onboarding",
+            &[
+                ("cookie", &cookie),
+                (
+                    "content-type",
+                    "multipart/form-data; boundary=onboarding-boundary",
+                ),
+            ],
+            multipart_body(
+                "onboarding-boundary",
+                &[("csrf", csrf.as_str()), ("intent", "skip")],
+                false,
+            ),
+        )
+        .await;
+
+        assert_eq!(skipped.status, 303);
+        assert_eq!(location(&skipped), "/home");
+        let (display_name, completed): (String, i64) = server
+            .pool
+            .call(|conn| {
+                Ok(conn.query_row(
+                    "SELECT display_name, onboarding_completed_at IS NOT NULL FROM users WHERE normalized_username = 'charlie'",
+                    [],
+                    |row| Ok((row.get(0)?, row.get(1)?)),
+                )?)
+            })
+            .await
+            .expect("onboarding completion");
+        assert_eq!(display_name, "charlie");
+        assert_eq!(completed, 1);
+
+        let onboarding = get_with_cookie(&server, "/onboarding", &cookie).await;
+        assert_eq!(onboarding.status, 303);
+        assert_eq!(location(&onboarding), "/home");
+    }
+
+    #[tokio::test]
+    async fn onboarding_suggestions_exclude_current_user() {
+        let server = spawn_test_server().await;
+        let _bob_cookie = register_test_user(&server, "bob").await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+
+        let onboarding = get_with_cookie(&server, "/onboarding", &alice_cookie).await;
+
+        assert_eq!(onboarding.status, 200);
+        assert!(onboarding.body.contains("@bob"));
+        let suggestions = onboarding
+            .body
+            .split_once(r#"<fieldset class="onboarding-suggestions">"#)
+            .and_then(|(_, rest)| rest.split_once("</fieldset>"))
+            .map(|(section, _)| section)
+            .expect("suggestions section");
+        assert!(!suggestions.contains(r#"value="2""#));
+        assert!(!suggestions.contains("@alice"));
+    }
+
+    #[tokio::test]
+    async fn onboarding_ignores_unavailable_suggested_follow_ids() {
+        let server = spawn_test_server().await;
+        let _bob_cookie = register_test_user(&server, "bob").await;
+        let _carol_cookie = register_test_user(&server, "carol").await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+        let (bob_id, carol_id, alice_id): (i64, i64, i64) = server
+            .pool
+            .call(|conn| {
+                conn.execute(
+                    "UPDATE users SET is_suspended = 1 WHERE normalized_username = 'bob'",
+                    [],
+                )?;
+                conn.execute(
+                    "UPDATE users SET is_deleted = 1 WHERE normalized_username = 'carol'",
+                    [],
+                )?;
+                let bob_id = conn.query_row(
+                    "SELECT id FROM users WHERE normalized_username = 'bob'",
+                    [],
+                    |row| row.get(0),
+                )?;
+                let carol_id = conn.query_row(
+                    "SELECT id FROM users WHERE normalized_username = 'carol'",
+                    [],
+                    |row| row.get(0),
+                )?;
+                let alice_id = conn.query_row(
+                    "SELECT id FROM users WHERE normalized_username = 'alice'",
+                    [],
+                    |row| row.get(0),
+                )?;
+                Ok((bob_id, carol_id, alice_id))
+            })
+            .await
+            .expect("users");
+
+        let onboarding = get_with_cookie(&server, "/onboarding", &alice_cookie).await;
+
+        assert_eq!(onboarding.status, 200);
+        assert!(!onboarding.body.contains("@bob"));
+        assert!(!onboarding.body.contains("@carol"));
+        assert!(
+            onboarding
+                .body
+                .contains("No local accounts to suggest yet.")
+        );
+        let csrf = csrf_token(&onboarding.body);
+        let bob_id = bob_id.to_string();
+        let carol_id = carol_id.to_string();
+        let saved = request(
+            &server.base_url,
+            "POST",
+            "/onboarding",
+            &[
+                ("cookie", &alice_cookie),
+                (
+                    "content-type",
+                    "multipart/form-data; boundary=onboarding-boundary",
+                ),
+            ],
+            multipart_body(
+                "onboarding-boundary",
+                &[
+                    ("csrf", csrf.as_str()),
+                    ("intent", "save"),
+                    ("display_name", "Alice"),
+                    ("bio", ""),
+                    ("follow_user_id", bob_id.as_str()),
+                    ("follow_user_id", carol_id.as_str()),
+                ],
+                false,
+            ),
+        )
+        .await;
+
+        assert_eq!(saved.status, 303);
+        let follows: i64 = server
+            .pool
+            .call(move |conn| {
+                Ok(conn.query_row(
+                    "SELECT COUNT(*) FROM follows WHERE follower_id = ?",
+                    [alice_id],
+                    |row| row.get(0),
+                )?)
+            })
+            .await
+            .expect("follow count");
+        assert_eq!(follows, 0);
+    }
+
+    #[tokio::test]
+    async fn onboarding_rejects_non_image_avatar_without_media_row() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+        let onboarding = get_with_cookie(&server, "/onboarding", &cookie).await;
+        let csrf = csrf_token(&onboarding.body);
+        let body = multipart_body_with_file(
+            "onboarding-boundary",
+            &[
+                ("csrf", csrf.as_str()),
+                ("intent", "save"),
+                ("display_name", "Alice"),
+                ("bio", ""),
+            ],
+            "profile_picture",
+            "avatar.mp4",
+            "video/mp4",
+            &tiny_mp4_bytes(),
+        );
+
+        let saved = request(
+            &server.base_url,
+            "POST",
+            "/onboarding",
+            &[
+                ("cookie", &cookie),
+                (
+                    "content-type",
+                    "multipart/form-data; boundary=onboarding-boundary",
+                ),
+            ],
+            body,
+        )
+        .await;
+
+        assert_eq!(saved.status, 400);
+        assert_eq!(media_row_count(&server).await, 0);
+    }
+
+    #[tokio::test]
+    async fn onboarding_cleans_uploaded_avatar_when_csrf_fails() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+        let body = multipart_body_with_file(
+            "onboarding-boundary",
+            &[
+                ("csrf", "invalid"),
+                ("intent", "save"),
+                ("display_name", "Alice"),
+                ("bio", ""),
+            ],
+            "profile_picture",
+            "avatar.png",
+            "image/png",
+            &tiny_png_bytes(),
+        );
+
+        let saved = request(
+            &server.base_url,
+            "POST",
+            "/onboarding",
+            &[
+                ("cookie", &cookie),
+                (
+                    "content-type",
+                    "multipart/form-data; boundary=onboarding-boundary",
+                ),
+            ],
+            body,
+        )
+        .await;
+
+        assert_eq!(saved.status, 403);
+        assert_eq!(media_row_count(&server).await, 0);
+    }
+
+    #[tokio::test]
+    async fn logged_in_ui_post_succeeds_with_empty_media_part_and_appears_on_home_feed() {
         let server = spawn_test_server().await;
         let registered = request(
             &server.base_url,
@@ -3933,57 +5067,290 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn post_auth_csrf_anonymous_and_validation_fail_cleanly() {
+    async fn post_edit_succeeds_within_default_window_and_marks_edited() {
         let server = spawn_test_server().await;
-        let registered = request(
-            &server.base_url,
-            "POST",
-            "/register",
-            &[("content-type", "application/x-www-form-urlencoded")],
-            b"username=bob&password=very%20secure%20password&confirm_password=very%20secure%20password".to_vec(),
+        let cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &cookie, "original text").await;
+        set_post_created_seconds_ago(&server, 1, 0).await;
+
+        let home = get_with_cookie(&server, "/home", &cookie).await;
+        assert!(home.body.contains(r#"href="/posts/1/edit""#));
+        let edit = get_with_cookie(&server, "/posts/1/edit", &cookie).await;
+        assert_eq!(edit.status, 200);
+        assert!(
+            edit.body
+                .contains("<h1 id=\"edit-post-title\">Edit post</h1>")
+        );
+        assert!(edit.body.contains("original text"));
+        let csrf = csrf_token(&edit.body);
+        let edited = post_form_with_cookie(
+            &server,
+            "/posts/1/edit",
+            &cookie,
+            &format!(
+                "csrf={}&text={}&return_to={}",
+                form_encode(&csrf),
+                form_encode("edited text"),
+                form_encode("/home#post-1")
+            ),
         )
         .await;
-        assert_eq!(registered.status, 303);
-        let cookie = session_cookie(&registered);
 
-        let missing_csrf = request(
-            &server.base_url,
-            "POST",
-            "/posts",
-            &[
-                ("cookie", &cookie),
-                (
-                    "content-type",
-                    "multipart/form-data; boundary=post-boundary",
-                ),
-            ],
-            multipart_body("post-boundary", &[("text", "missing csrf")], false),
+        assert_eq!(edited.status, 303);
+        assert_eq!(location(&edited), "/home#post-1");
+        let home = get_with_cookie(&server, "/home", &cookie).await;
+        assert!(home.body.contains("edited text"));
+        assert!(!home.body.contains("original text"));
+        assert!(home.body.contains(r#"<span class="edited-marker""#));
+        let edited_at: Option<String> = server
+            .pool
+            .call(|conn| {
+                conn.query_row("SELECT edited_at FROM posts WHERE id = 1", [], |row| {
+                    row.get(0)
+                })
+                .map_err(Into::into)
+            })
+            .await
+            .expect("edited_at");
+        assert!(edited_at.is_some());
+    }
+
+    #[tokio::test]
+    async fn post_edit_is_rejected_after_default_window_expires() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &cookie, "too old").await;
+        set_post_created_seconds_ago(&server, 1, 20).await;
+
+        let home = get_with_cookie(&server, "/home", &cookie).await;
+        assert!(!home.body.contains(r#"href="/posts/1/edit""#));
+        let edit = get_with_cookie(&server, "/posts/1/edit", &cookie).await;
+        assert_eq!(edit.status, 400);
+
+        let home = get_with_cookie(&server, "/home", &cookie).await;
+        let csrf = csrf_token(&home.body);
+        let edited = post_form_with_cookie(
+            &server,
+            "/posts/1/edit",
+            &cookie,
+            &format!("csrf={}&text=late", form_encode(&csrf)),
         )
         .await;
-        assert_eq!(missing_csrf.status, 403);
-        assert!(missing_csrf.body.contains("Access denied"));
-        assert!(!missing_csrf.body.contains("missing csrf session"));
+        assert_eq!(edited.status, 400);
+        assert!(edited.body.contains("edit window"));
+        let text: String = server
+            .pool
+            .call(|conn| {
+                conn.query_row("SELECT text FROM posts WHERE id = 1", [], |row| row.get(0))
+                    .map_err(Into::into)
+            })
+            .await
+            .expect("post text");
+        assert_eq!(text, "too old");
+    }
 
-        let logged_out = request(
-            &server.base_url,
-            "POST",
-            "/posts",
-            &[(
-                "content-type",
-                "multipart/form-data; boundary=post-boundary",
-            )],
-            multipart_body("post-boundary", &[("text", "logged out")], false),
+    #[tokio::test]
+    async fn edit_controls_do_not_appear_for_other_users() {
+        let server = spawn_test_server().await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &alice_cookie, "alice post").await;
+        let bob_cookie = register_test_user(&server, "bob").await;
+
+        let bob_home = get_with_cookie(&server, "/home", &bob_cookie).await;
+
+        assert_eq!(bob_home.status, 200);
+        assert!(bob_home.body.contains("alice post"));
+        assert!(!bob_home.body.contains(r#"href="/posts/1/edit""#));
+        let edit = get_with_cookie(&server, "/posts/1/edit", &bob_cookie).await;
+        assert_eq!(edit.status, 403);
+    }
+
+    #[tokio::test]
+    async fn no_js_edit_form_is_still_server_window_enforced() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &cookie, "fallback edit").await;
+        let edit = get_with_cookie(&server, "/posts/1/edit", &cookie).await;
+        assert_eq!(edit.status, 200);
+        assert!(
+            edit.body
+                .contains(r#"method="post" action="/posts/1/edit""#)
+        );
+        assert!(!edit.body.contains(r#"data-enhance"#));
+        let csrf = csrf_token(&edit.body);
+        set_post_created_seconds_ago(&server, 1, 20).await;
+
+        let expired = post_form_with_cookie(
+            &server,
+            "/posts/1/edit",
+            &cookie,
+            &format!(
+                "csrf={}&text={}",
+                form_encode(&csrf),
+                form_encode("late fallback")
+            ),
         )
         .await;
-        assert_eq!(logged_out.status, 403);
-        assert!(logged_out.body.contains("Access denied"));
 
-        let anonymous_home = request(&server.base_url, "GET", "/home", &[], Vec::new()).await;
-        assert_eq!(anonymous_home.status, 200);
-        assert!(!anonymous_home.body.contains(r#"action="/posts""#));
+        assert_eq!(expired.status, 400);
+        assert!(expired.body.contains("edit window"));
+        let thread = get_with_cookie(&server, "/posts/1", &cookie).await;
+        assert!(thread.body.contains("fallback edit"));
+        assert!(!thread.body.contains("late fallback"));
+    }
 
-        let home = request(
-            &server.base_url,
+    #[tokio::test]
+    async fn configured_post_edit_window_is_respected() {
+        let mut settings = Settings::default();
+        settings.posts.post_edit_window_seconds = 30;
+        let server = spawn_test_server_with_settings(settings).await;
+        let cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &cookie, "still editable").await;
+        set_post_created_seconds_ago(&server, 1, 20).await;
+
+        let home = get_with_cookie(&server, "/home", &cookie).await;
+        assert!(home.body.contains(r#"href="/posts/1/edit""#));
+        let csrf = csrf_token(&home.body);
+        let edited = post_form_with_cookie(
+            &server,
+            "/posts/1/edit",
+            &cookie,
+            &format!(
+                "csrf={}&text={}",
+                form_encode(&csrf),
+                form_encode("edited in 30")
+            ),
+        )
+        .await;
+
+        assert_eq!(edited.status, 303);
+        let thread = get_with_cookie(&server, "/posts/1", &cookie).await;
+        assert!(thread.body.contains("edited in 30"));
+    }
+
+    #[tokio::test]
+    async fn zero_post_edit_window_disables_get_post_and_controls() {
+        let mut settings = Settings::default();
+        settings.posts.post_edit_window_seconds = 0;
+        let server = spawn_test_server_with_settings(settings).await;
+        let cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &cookie, "not editable").await;
+        set_post_created_seconds_ago(&server, 1, 0).await;
+
+        let home = get_with_cookie(&server, "/home", &cookie).await;
+        assert!(!home.body.contains(r#"href="/posts/1/edit""#));
+        let edit = get_with_cookie(&server, "/posts/1/edit", &cookie).await;
+        assert_eq!(edit.status, 400);
+        let csrf = csrf_token(&home.body);
+        let edited = post_form_with_cookie(
+            &server,
+            "/posts/1/edit",
+            &cookie,
+            &format!("csrf={}&text=changed", form_encode(&csrf)),
+        )
+        .await;
+
+        assert_eq!(edited.status, 400);
+        let text: String = server
+            .pool
+            .call(|conn| {
+                conn.query_row("SELECT text FROM posts WHERE id = 1", [], |row| row.get(0))
+                    .map_err(Into::into)
+            })
+            .await
+            .expect("post text");
+        assert_eq!(text, "not editable");
+    }
+
+    #[tokio::test]
+    async fn editing_to_same_clean_text_does_not_mark_post_edited() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &cookie, "same text").await;
+        set_post_created_seconds_ago(&server, 1, 0).await;
+        let edit = get_with_cookie(&server, "/posts/1/edit", &cookie).await;
+        let csrf = csrf_token(&edit.body);
+
+        let edited = post_form_with_cookie(
+            &server,
+            "/posts/1/edit",
+            &cookie,
+            &format!(
+                "csrf={}&text={}",
+                form_encode(&csrf),
+                form_encode("same text")
+            ),
+        )
+        .await;
+
+        assert_eq!(edited.status, 303);
+        let edited_at: Option<String> = server
+            .pool
+            .call(|conn| {
+                conn.query_row("SELECT edited_at FROM posts WHERE id = 1", [], |row| {
+                    row.get(0)
+                })
+                .map_err(Into::into)
+            })
+            .await
+            .expect("edited_at");
+        assert!(edited_at.is_none());
+        let home = get_with_cookie(&server, "/home", &cookie).await;
+        assert!(!home.body.contains(r#"<span class="edited-marker""#));
+    }
+
+    #[tokio::test]
+    async fn post_auth_csrf_anonymous_and_validation_fail_cleanly() {
+        let server = spawn_test_server().await;
+        let registered = request(
+            &server.base_url,
+            "POST",
+            "/register",
+            &[("content-type", "application/x-www-form-urlencoded")],
+            b"username=bob&password=very%20secure%20password&confirm_password=very%20secure%20password".to_vec(),
+        )
+        .await;
+        assert_eq!(registered.status, 303);
+        let cookie = session_cookie(&registered);
+
+        let missing_csrf = request(
+            &server.base_url,
+            "POST",
+            "/posts",
+            &[
+                ("cookie", &cookie),
+                (
+                    "content-type",
+                    "multipart/form-data; boundary=post-boundary",
+                ),
+            ],
+            multipart_body("post-boundary", &[("text", "missing csrf")], false),
+        )
+        .await;
+        assert_eq!(missing_csrf.status, 403);
+        assert!(missing_csrf.body.contains("Access denied"));
+        assert!(!missing_csrf.body.contains("missing csrf session"));
+
+        let logged_out = request(
+            &server.base_url,
+            "POST",
+            "/posts",
+            &[(
+                "content-type",
+                "multipart/form-data; boundary=post-boundary",
+            )],
+            multipart_body("post-boundary", &[("text", "logged out")], false),
+        )
+        .await;
+        assert_eq!(logged_out.status, 403);
+        assert!(logged_out.body.contains("Access denied"));
+
+        let anonymous_home = request(&server.base_url, "GET", "/home", &[], Vec::new()).await;
+        assert_eq!(anonymous_home.status, 200);
+        assert!(!anonymous_home.body.contains(r#"action="/posts""#));
+
+        let home = request(
+            &server.base_url,
             "GET",
             "/home",
             &[("cookie", &cookie)],
@@ -4716,85 +6083,730 @@ mod tests {
         assert!(replied.body.contains(r#"reply-post"#));
     }
 
-    #[tokio::test]
-    async fn follow_profile_stays_on_profile_and_renders_following_state() {
-        let server = spawn_test_server().await;
-        let bob = request(
-            &server.base_url,
-            "POST",
-            "/register",
-            &[("content-type", "application/x-www-form-urlencoded")],
-            b"username=bob&password=very%20secure%20password&confirm_password=very%20secure%20password".to_vec(),
-        )
-        .await;
-        assert_eq!(bob.status, 303);
-        let alice = request(
+    #[tokio::test]
+    async fn follow_profile_stays_on_profile_and_renders_following_state() {
+        let server = spawn_test_server().await;
+        let bob = request(
+            &server.base_url,
+            "POST",
+            "/register",
+            &[("content-type", "application/x-www-form-urlencoded")],
+            b"username=bob&password=very%20secure%20password&confirm_password=very%20secure%20password".to_vec(),
+        )
+        .await;
+        assert_eq!(bob.status, 303);
+        let alice = request(
+            &server.base_url,
+            "POST",
+            "/register",
+            &[("content-type", "application/x-www-form-urlencoded")],
+            b"username=alice&password=very%20secure%20password&confirm_password=very%20secure%20password".to_vec(),
+        )
+        .await;
+        assert_eq!(alice.status, 303);
+        let alice_cookie = session_cookie(&alice);
+
+        let profile = request(
+            &server.base_url,
+            "GET",
+            "/users/bob",
+            &[("cookie", &alice_cookie)],
+            Vec::new(),
+        )
+        .await;
+        assert_eq!(profile.status, 200);
+        assert!(profile.body.contains(r#"class="actions profile-actions""#));
+        assert!(profile.body.contains(r#"class="follow-button""#));
+        assert!(profile.body.contains(r#">Follow</button>"#));
+        assert!(
+            profile
+                .body
+                .contains(r#"data-profile-followers="1">0 followers"#)
+        );
+        assert!(
+            profile
+                .body
+                .contains(r#"class="actions profile-secondary""#)
+        );
+        let csrf = csrf_token(&profile.body);
+
+        let followed = request(
+            &server.base_url,
+            "POST",
+            "/users/1/follow",
+            &[
+                ("cookie", &alice_cookie),
+                ("referer", "/users/bob"),
+                ("content-type", "application/x-www-form-urlencoded"),
+            ],
+            format!("csrf={csrf}").into_bytes(),
+        )
+        .await;
+        assert_eq!(followed.status, 303);
+        assert_eq!(location(&followed), "/users/bob");
+
+        let profile = request(
+            &server.base_url,
+            "GET",
+            "/users/bob",
+            &[("cookie", &alice_cookie)],
+            Vec::new(),
+        )
+        .await;
+        assert_eq!(profile.status, 200);
+        assert!(profile.body.contains(r#"class="follow-button active""#));
+        assert!(profile.body.contains(r#">Following</button>"#));
+        assert!(
+            profile
+                .body
+                .contains(r#"data-profile-followers="1">1 followers"#)
+        );
+        assert!(!profile.body.contains(">Unfollow</button>"));
+    }
+
+    #[tokio::test]
+    async fn profile_tabs_render_labels_active_state_and_plain_links() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+
+        let profile = get_with_cookie(&server, "/users/alice", &cookie).await;
+        assert_eq!(profile.status, 200);
+        assert!(profile.body.contains(r#"data-testid="profile-tabs""#));
+        assert!(
+            profile
+                .body
+                .contains(r#"<a href="/users/alice" class="active" aria-current="page">Posts</a>"#)
+        );
+        assert!(
+            profile
+                .body
+                .contains(r#"<a href="/users/alice?tab=replies">Replies</a>"#)
+        );
+        assert!(
+            profile
+                .body
+                .contains(r#"<a href="/users/alice?tab=media">Media</a>"#)
+        );
+        assert!(
+            profile
+                .body
+                .contains(r#"<a href="/users/alice?tab=likes">Likes</a>"#)
+        );
+        assert_eq!(profile.body.matches(r#"aria-current="page""#).count(), 1);
+
+        let replies = request(
+            &server.base_url,
+            "GET",
+            "/users/alice?tab=replies",
+            &[
+                ("cookie", &cookie),
+                ("user-agent", "Mozilla/5.0 Firefox/115.0"),
+            ],
+            Vec::new(),
+        )
+        .await;
+        assert_eq!(replies.status, 200);
+        assert!(replies.body.contains(
+            r#"<a href="/users/alice?tab=replies" class="active" aria-current="page">Replies</a>"#
+        ));
+        assert_eq!(replies.body.matches(r#"aria-current="page""#).count(), 1);
+    }
+
+    #[tokio::test]
+    async fn profile_likes_tab_respects_public_and_private_visibility() {
+        let (server, alice_cookie, bob_cookie) = liked_profile_fixture().await;
+
+        let public_likes = get_with_cookie(&server, "/users/bob?tab=likes", &alice_cookie).await;
+        assert_eq!(public_likes.status, 200);
+        assert!(public_likes.body.contains("privacy target post"));
+        assert!(!public_likes.body.contains("This user’s likes are private"));
+
+        let settings = get_with_cookie(&server, "/settings", &bob_cookie).await;
+        assert_eq!(settings.status, 200);
+        assert!(settings.body.contains(
+            r#"id="liked_posts_public" name="liked_posts_public" type="checkbox" role="switch" value="true" checked aria-describedby="liked_posts_public-help""#
+        ));
+        let saved = save_profile_settings(
+            &server,
+            &bob_cookie,
+            &[
+                ("display_name", "bob"),
+                ("bio", ""),
+                ("location", ""),
+                ("website", ""),
+            ],
+        )
+        .await;
+        assert_eq!(saved.status, 303);
+
+        let private_likes = get_with_cookie(&server, "/users/bob?tab=likes", &alice_cookie).await;
+        assert_eq!(private_likes.status, 200);
+        assert_empty_state(&private_likes.body, "This user’s likes are private", "");
+        assert!(!private_likes.body.contains("privacy target post"));
+        assert!(!private_likes.body.contains("liked by bob"));
+        assert!(!private_likes.body.contains("bob liked"));
+
+        let owner_likes = get_with_cookie(&server, "/users/bob?tab=likes", &bob_cookie).await;
+        assert_eq!(owner_likes.status, 200);
+        assert!(owner_likes.body.contains("privacy target post"));
+        assert!(!owner_likes.body.contains("This user’s likes are private"));
+
+        let anonymous_likes = request(
+            &server.base_url,
+            "GET",
+            "/users/bob?tab=likes&offset=999",
+            &[],
+            Vec::new(),
+        )
+        .await;
+        assert_eq!(anonymous_likes.status, 200);
+        assert_empty_state(&anonymous_likes.body, "This user’s likes are private", "");
+        assert!(!anonymous_likes.body.contains("privacy target post"));
+    }
+
+    #[test]
+    fn settings_profile_media_mounts_controls_on_preview_frames() {
+        let body = settings_profile_media(
+            Some("/uploads/profile.webp"),
+            Some("/uploads/banner.webp"),
+            true,
+            true,
+        );
+
+        assert!(body.contains(
+            r#"class="settings-banner-wrap settings-media-frame" data-profile-media-frame"#
+        ));
+        assert!(body.contains(r#"class="settings-picture-wrap settings-media-frame""#));
+        assert!(
+            body.contains(r#"class="settings-media-input" id="banner" name="banner" type="file""#)
+        );
+        assert!(body.contains(
+            r#"class="settings-media-delete-input" id="delete_banner" name="delete_banner" type="checkbox" value="true""#
+        ));
+        assert!(body.contains(
+            r#"class="settings-media-input" id="profile_picture" name="profile_picture" type="file""#
+        ));
+        assert!(body.contains(
+            r#"class="settings-media-delete-input" id="delete_profile_picture" name="delete_profile_picture" type="checkbox" value="true""#
+        ));
+        assert!(body.contains(r#"for="banner" title="Change banner""#));
+        assert!(body.contains(r#"for="delete_banner" title="Remove banner""#));
+        assert!(body.contains(r#"for="profile_picture" title="Change profile picture""#));
+        assert!(body.contains(r#"for="delete_profile_picture" title="Remove profile picture""#));
+        assert!(!body.contains("media-control-row"));
+        assert!(!body.contains("file-control"));
+        assert!(!body.contains("check-row"));
+    }
+
+    #[tokio::test]
+    async fn settings_page_places_profile_media_before_profile_fields() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+
+        let settings = get_with_cookie(&server, "/settings", &cookie).await;
+        assert_eq!(settings.status, 200);
+        let media = settings
+            .body
+            .find("settings-section settings-section-media")
+            .expect("profile media section");
+        let profile = settings
+            .body
+            .find("settings-section settings-section-profile")
+            .expect("profile fields section");
+        let form_start = settings
+            .body
+            .find(r#"<form id="profile-settings-form""#)
+            .expect("settings form");
+        let form_end = settings.body[form_start..]
+            .find("</form>")
+            .expect("settings form end");
+        let settings_form = &settings.body[form_start..form_start + form_end];
+
+        assert!(media < profile);
+        assert!(
+            settings
+                .body
+                .contains(r#"class="settings-media-input" id="banner" name="banner" type="file""#)
+        );
+        assert!(settings.body.contains(
+            r#"class="settings-media-input" id="profile_picture" name="profile_picture" type="file""#
+        ));
+        assert!(!settings_form.contains("media-control-row"));
+        assert!(!settings_form.contains("check-row"));
+    }
+
+    #[tokio::test]
+    async fn private_likes_reject_bypass_notifications_and_json_count_leaks() {
+        let (server, alice_cookie, bob_cookie) = liked_profile_fixture().await;
+        let saved = save_profile_settings(
+            &server,
+            &bob_cookie,
+            &[
+                ("display_name", "bob"),
+                ("bio", ""),
+                ("location", ""),
+                ("website", ""),
+            ],
+        )
+        .await;
+        assert_eq!(saved.status, 303);
+
+        for path in [
+            "/users/bob?tab=likes&page=2",
+            "/users/bob?tab=likes&cursor=1",
+        ] {
+            let bypass = get_with_cookie(&server, path, &alice_cookie).await;
+            assert_eq!(bypass.status, 200);
+            assert_empty_state(&bypass.body, "This user’s likes are private", "");
+            assert!(!bypass.body.contains("privacy target post"));
+        }
+
+        let invalid_tab = get_with_cookie(&server, "/users/bob?tab=LIKES", &alice_cookie).await;
+        assert_eq!(invalid_tab.status, 200);
+        assert!(invalid_tab.body.contains("bob fallback post"));
+        assert!(!invalid_tab.body.contains("privacy target post"));
+        assert!(
+            invalid_tab
+                .body
+                .contains(r#"<a href="/users/bob" class="active" aria-current="page">Posts</a>"#)
+        );
+
+        let notifications = get_with_cookie(&server, "/notifications", &alice_cookie).await;
+        assert_eq!(notifications.status, 200);
+        assert!(!notifications.body.contains("bob"));
+        assert!(!notifications.body.contains("liked your post"));
+        assert!(!notifications.body.contains("privacy target post"));
+
+        let alice_home = get_with_cookie(&server, "/home", &alice_cookie).await;
+        let csrf = csrf_token(&alice_home.body);
+        let alice_json = request(
+            &server.base_url,
+            "POST",
+            "/posts/1/bookmark",
+            &[
+                ("cookie", &alice_cookie),
+                ("content-type", "application/x-www-form-urlencoded"),
+                ("accept", "application/json"),
+                ("x-rustpost-enhance", "1"),
+            ],
+            format!("csrf={csrf}").into_bytes(),
+        )
+        .await;
+        assert_eq!(alice_json.status, 200);
+        assert!(alice_json.body.contains(r#""likes":0"#));
+
+        let bob_home = get_with_cookie(&server, "/home", &bob_cookie).await;
+        let csrf = csrf_token(&bob_home.body);
+        let bob_json = request(
+            &server.base_url,
+            "POST",
+            "/posts/1/bookmark",
+            &[
+                ("cookie", &bob_cookie),
+                ("content-type", "application/x-www-form-urlencoded"),
+                ("accept", "application/json"),
+                ("x-rustpost-enhance", "1"),
+            ],
+            format!("csrf={csrf}").into_bytes(),
+        )
+        .await;
+        assert_eq!(bob_json.status, 200);
+        assert!(bob_json.body.contains(r#""likes":1"#));
+    }
+
+    #[tokio::test]
+    async fn liked_posts_public_setting_persists_without_changing_other_preferences() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+
+        let saved_private = save_profile_settings(
+            &server,
+            &cookie,
+            &[
+                ("dark_mode", "true"),
+                ("nsfw_blur_enabled", "true"),
+                ("display_name", "Alice"),
+                ("bio", "same bio"),
+                ("location", "same place"),
+                ("website", "https://example.test"),
+            ],
+        )
+        .await;
+        assert_eq!(saved_private.status, 303);
+
+        let private_state = user_settings_state(&server, "alice").await;
+        assert_eq!(
+            private_state,
+            (
+                "dark".to_owned(),
+                1,
+                0,
+                "Alice".to_owned(),
+                "same bio".to_owned(),
+                "same place".to_owned(),
+                "https://example.test".to_owned(),
+            )
+        );
+
+        let settings = get_with_cookie(&server, "/settings", &cookie).await;
+        assert_eq!(settings.status, 200);
+        assert!(
+            settings.body.contains(
+                r#"id="dark_mode" name="dark_mode" type="checkbox" role="switch" value="true" checked aria-describedby="dark_mode-help""#
+            )
+        );
+        assert!(settings.body.contains(
+            r#"id="nsfw_blur_enabled" name="nsfw_blur_enabled" type="checkbox" role="switch" value="true" checked aria-describedby="nsfw_blur_enabled-help""#
+        ));
+        assert!(!settings.body.contains(
+            r#"id="liked_posts_public" name="liked_posts_public" type="checkbox" role="switch" value="true" checked"#
+        ));
+
+        let saved_public = save_profile_settings(
+            &server,
+            &cookie,
+            &[
+                ("dark_mode", "true"),
+                ("nsfw_blur_enabled", "true"),
+                ("liked_posts_public", "true"),
+                ("display_name", "Alice"),
+                ("bio", "same bio"),
+                ("location", "same place"),
+                ("website", "https://example.test"),
+            ],
+        )
+        .await;
+        assert_eq!(saved_public.status, 303);
+
+        let (theme, nsfw_blur_enabled, liked_posts_public, ..) =
+            user_settings_state(&server, "alice").await;
+        assert_eq!(
+            (theme, nsfw_blur_enabled, liked_posts_public),
+            ("dark".to_owned(), 1, 1)
+        );
+    }
+
+    #[tokio::test]
+    async fn profile_tabs_apply_relationship_and_suspended_visibility() {
+        let server = spawn_test_server().await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &alice_cookie, "relationship liked target").await;
+        let bob_cookie = register_test_user(&server, "bob").await;
+        create_text_post(&server, &bob_cookie, "relationship bob post").await;
+
+        let bob_home = get_with_cookie(&server, "/home", &bob_cookie).await;
+        let csrf = csrf_token(&bob_home.body);
+        let liked = post_form_with_cookie(
+            &server,
+            "/posts/1/like",
+            &bob_cookie,
+            &format!("csrf={csrf}"),
+        )
+        .await;
+        assert_eq!(liked.status, 303);
+
+        let visible_likes = get_with_cookie(&server, "/users/bob?tab=likes", &alice_cookie).await;
+        assert_eq!(visible_likes.status, 200);
+        assert!(visible_likes.body.contains("relationship liked target"));
+
+        let bob_id = server
+            .pool
+            .call(|conn| {
+                conn.query_row(
+                    "SELECT id FROM users WHERE normalized_username = 'bob'",
+                    [],
+                    |row| row.get::<_, i64>(0),
+                )
+                .map_err(Into::into)
+            })
+            .await
+            .expect("bob id");
+        let alice_id = server
+            .pool
+            .call(|conn| {
+                conn.query_row(
+                    "SELECT id FROM users WHERE normalized_username = 'alice'",
+                    [],
+                    |row| row.get::<_, i64>(0),
+                )
+                .map_err(Into::into)
+            })
+            .await
+            .expect("alice id");
+        social::block(&server.pool, bob_id, alice_id)
+            .await
+            .expect("bob blocks alice");
+
+        let blocked_likes = get_with_cookie(&server, "/users/bob?tab=likes", &alice_cookie).await;
+        assert_eq!(blocked_likes.status, 200);
+        assert!(!blocked_likes.body.contains("relationship liked target"));
+        assert!(!blocked_likes.body.contains("This user’s likes are private"));
+        let blocked_posts = get_with_cookie(&server, "/users/bob", &alice_cookie).await;
+        assert_eq!(blocked_posts.status, 200);
+        assert!(!blocked_posts.body.contains("relationship bob post"));
+
+        server
+            .pool
+            .call(move |conn| {
+                conn.execute(
+                    "DELETE FROM blocks WHERE blocker_id = ? AND blocked_id = ?",
+                    params![bob_id, alice_id],
+                )?;
+                conn.execute("UPDATE users SET is_suspended = 1 WHERE id = ?", [bob_id])?;
+                Ok(())
+            })
+            .await
+            .expect("suspend bob");
+
+        let suspended_likes = request(
+            &server.base_url,
+            "GET",
+            "/users/bob?tab=likes",
+            &[],
+            Vec::new(),
+        )
+        .await;
+        assert_eq!(suspended_likes.status, 200);
+        assert!(!suspended_likes.body.contains("relationship liked target"));
+        assert!(
+            !suspended_likes
+                .body
+                .contains("This user’s likes are private")
+        );
+        let suspended_posts = request(&server.base_url, "GET", "/users/bob", &[], Vec::new()).await;
+        assert_eq!(suspended_posts.status, 200);
+        assert!(!suspended_posts.body.contains("relationship bob post"));
+    }
+
+    #[tokio::test]
+    async fn profile_owner_can_pin_and_replace_one_profile_post() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &cookie, "first profile post").await;
+        create_text_post(&server, &cookie, "second profile post").await;
+
+        let profile = get_with_cookie(&server, "/users/alice", &cookie).await;
+        assert_eq!(profile.status, 200);
+        assert!(profile.body.contains(r#"action="/posts/1/pin""#));
+        assert!(profile.body.contains(r#"aria-label="Pin to profile""#));
+        let csrf = csrf_token(&profile.body);
+        let pinned = request(
+            &server.base_url,
+            "POST",
+            "/posts/1/pin",
+            &[
+                ("cookie", &cookie),
+                ("referer", "/users/alice"),
+                ("content-type", "application/x-www-form-urlencoded"),
+            ],
+            format!("csrf={}", form_encode(&csrf)).into_bytes(),
+        )
+        .await;
+
+        assert_eq!(pinned.status, 303);
+        assert_eq!(location(&pinned), "/users/alice#post-1");
+        let profile = get_with_cookie(&server, "/users/alice", &cookie).await;
+        assert!(profile.body.contains(r#"aria-label="Pinned post""#));
+        assert!(
+            profile
+                .body
+                .contains(r#"<h2 class="section-title">Pinned post</h2>"#)
+        );
+        assert!(profile.body.contains(r#"aria-label="Unpin from profile""#));
+        assert_eq!(profile.body.matches(r#"id="post-1""#).count(), 1);
+        let first_index = profile.body.find("first profile post").expect("first post");
+        let second_index = profile
+            .body
+            .find("second profile post")
+            .expect("second post");
+        assert!(first_index < second_index);
+
+        let csrf = csrf_token(&profile.body);
+        let replaced = request(
+            &server.base_url,
+            "POST",
+            "/posts/2/pin",
+            &[
+                ("cookie", &cookie),
+                ("referer", "/users/alice"),
+                ("content-type", "application/x-www-form-urlencoded"),
+            ],
+            format!("csrf={}", form_encode(&csrf)).into_bytes(),
+        )
+        .await;
+
+        assert_eq!(replaced.status, 303);
+        assert_eq!(location(&replaced), "/users/alice#post-2");
+        let profile = get_with_cookie(&server, "/users/alice", &cookie).await;
+        assert_eq!(profile.body.matches(r#"id="post-2""#).count(), 1);
+        let first_index = profile.body.find("first profile post").expect("first post");
+        let second_index = profile
+            .body
+            .find("second profile post")
+            .expect("second post");
+        assert!(second_index < first_index);
+        assert_eq!(pinned_post_id_for_user(&server, "alice").await, Some(2));
+    }
+
+    #[tokio::test]
+    async fn users_cannot_pin_someone_elses_post() {
+        let server = spawn_test_server().await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &alice_cookie, "alice post").await;
+        let bob_cookie = register_test_user(&server, "bob").await;
+        let bob_home = get_with_cookie(&server, "/home", &bob_cookie).await;
+        let csrf = csrf_token(&bob_home.body);
+
+        let pinned = post_form_with_cookie(
+            &server,
+            "/posts/1/pin",
+            &bob_cookie,
+            &format!("csrf={}", form_encode(&csrf)),
+        )
+        .await;
+
+        assert_eq!(pinned.status, 403);
+        assert_eq!(pinned_post_id_for_user(&server, "alice").await, None);
+        assert_eq!(pinned_post_id_for_user(&server, "bob").await, None);
+    }
+
+    #[tokio::test]
+    async fn deleting_pinned_post_clears_profile_pin() {
+        let server = spawn_test_server().await;
+        let cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &cookie, "temporary pinned post").await;
+        let profile = get_with_cookie(&server, "/users/alice", &cookie).await;
+        let csrf = csrf_token(&profile.body);
+        let pinned = post_form_with_cookie(
+            &server,
+            "/posts/1/pin",
+            &cookie,
+            &format!("csrf={}", form_encode(&csrf)),
+        )
+        .await;
+        assert_eq!(pinned.status, 303);
+        assert_eq!(pinned_post_id_for_user(&server, "alice").await, Some(1));
+
+        let profile = get_with_cookie(&server, "/users/alice", &cookie).await;
+        let csrf = csrf_token(&profile.body);
+        let deleted = post_form_with_cookie(
+            &server,
+            "/posts/1/delete",
+            &cookie,
+            &format!(
+                "csrf={}&return_to={}",
+                form_encode(&csrf),
+                form_encode("/users/alice")
+            ),
+        )
+        .await;
+
+        assert_eq!(deleted.status, 303);
+        assert_eq!(location(&deleted), "/users/alice");
+        assert_eq!(pinned_post_id_for_user(&server, "alice").await, None);
+        let profile = get_with_cookie(&server, "/users/alice", &cookie).await;
+        assert!(!profile.body.contains(r#"aria-label="Pinned post""#));
+        assert!(!profile.body.contains("temporary pinned post"));
+    }
+
+    #[tokio::test]
+    async fn empty_states_render_for_empty_feeds_lists_and_search() {
+        let server = spawn_test_server().await;
+
+        let public_home = request(&server.base_url, "GET", "/home", &[], Vec::new()).await;
+        assert_eq!(public_home.status, 200);
+        assert_empty_state(
+            &public_home.body,
+            "No posts yet.",
+            "The timeline will fill in once people start posting.",
+        );
+
+        let alice_cookie = register_test_user(&server, "alice").await;
+
+        let home = get_with_cookie(&server, "/home", &alice_cookie).await;
+        assert_eq!(home.status, 200);
+        assert_empty_state(
+            &home.body,
+            "No posts yet.",
+            "The timeline will fill in once people start posting.",
+        );
+
+        let profile = get_with_cookie(&server, "/users/alice", &alice_cookie).await;
+        assert_eq!(profile.status, 200);
+        assert_empty_state(
+            &profile.body,
+            "No posts yet.",
+            "This profile has not posted yet.",
+        );
+
+        let following = get_with_cookie(&server, "/following", &alice_cookie).await;
+        assert_eq!(following.status, 200);
+        assert_empty_state(
+            &following.body,
+            "Follow people to build your feed.",
+            "Accounts you follow will appear here.",
+        );
+
+        let followers = request(
             &server.base_url,
-            "POST",
-            "/register",
-            &[("content-type", "application/x-www-form-urlencoded")],
-            b"username=alice&password=very%20secure%20password&confirm_password=very%20secure%20password".to_vec(),
+            "GET",
+            "/users/alice/followers",
+            &[],
+            Vec::new(),
         )
         .await;
-        assert_eq!(alice.status, 303);
-        let alice_cookie = session_cookie(&alice);
+        assert_eq!(followers.status, 200);
+        assert_empty_state(
+            &followers.body,
+            "No followers yet.",
+            "Followers will appear here.",
+        );
 
-        let profile = request(
+        let profile_following = request(
             &server.base_url,
             "GET",
-            "/users/bob",
-            &[("cookie", &alice_cookie)],
+            "/users/alice/following",
+            &[],
             Vec::new(),
         )
         .await;
-        assert_eq!(profile.status, 200);
-        assert!(profile.body.contains(r#"class="actions profile-actions""#));
-        assert!(profile.body.contains(r#"class="follow-button""#));
-        assert!(profile.body.contains(r#">Follow</button>"#));
-        assert!(
-            profile
-                .body
-                .contains(r#"data-profile-followers="1">0 followers"#)
+        assert_eq!(profile_following.status, 200);
+        assert_empty_state(
+            &profile_following.body,
+            "Not following anyone yet.",
+            "Followed accounts will appear here.",
         );
-        assert!(
-            profile
-                .body
-                .contains(r#"class="actions profile-secondary""#)
+
+        let bookmarks = get_with_cookie(&server, "/bookmarks", &alice_cookie).await;
+        assert_eq!(bookmarks.status, 200);
+        assert_empty_state(
+            &bookmarks.body,
+            "No bookmarks yet.",
+            "Saved posts will appear here.",
         );
-        let csrf = csrf_token(&profile.body);
 
-        let followed = request(
-            &server.base_url,
-            "POST",
-            "/users/1/follow",
-            &[
-                ("cookie", &alice_cookie),
-                ("referer", "/users/bob"),
-                ("content-type", "application/x-www-form-urlencoded"),
-            ],
-            format!("csrf={csrf}").into_bytes(),
-        )
-        .await;
-        assert_eq!(followed.status, 303);
-        assert_eq!(location(&followed), "/users/bob");
+        let notifications = get_with_cookie(&server, "/notifications", &alice_cookie).await;
+        assert_eq!(notifications.status, 200);
+        assert_empty_state(
+            &notifications.body,
+            "No notifications.",
+            "New activity will appear here.",
+        );
 
-        let profile = request(
+        let search = request(
             &server.base_url,
             "GET",
-            "/users/bob",
-            &[("cookie", &alice_cookie)],
+            "/search?q=missing",
+            &[],
             Vec::new(),
         )
         .await;
-        assert_eq!(profile.status, 200);
-        assert!(profile.body.contains(r#"class="follow-button active""#));
-        assert!(profile.body.contains(r#">Following</button>"#));
-        assert!(
-            profile
-                .body
-                .contains(r#"data-profile-followers="1">1 followers"#)
+        assert_eq!(search.status, 200);
+        assert_empty_state(
+            &search.body,
+            "No matching posts or users found.",
+            "Try another search.",
         );
-        assert!(!profile.body.contains(">Unfollow</button>"));
     }
 
     #[tokio::test]
@@ -4940,6 +6952,130 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn mention_suggestions_endpoint_returns_bounded_json_for_visible_users() {
+        let server = spawn_test_server().await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+        crate::auth::register_user(
+            &server.pool,
+            &Settings::default(),
+            "bob",
+            "very secure password",
+            false,
+        )
+        .await
+        .expect("bob");
+        crate::auth::register_user(
+            &server.pool,
+            &Settings::default(),
+            "bobby",
+            "very secure password",
+            false,
+        )
+        .await
+        .expect("bobby");
+        let suspended = crate::auth::register_user(
+            &server.pool,
+            &Settings::default(),
+            "bot_suspended",
+            "very secure password",
+            false,
+        )
+        .await
+        .expect("suspended");
+        server
+            .pool
+            .call(move |conn| {
+                conn.execute(
+                    "UPDATE users SET display_name = '<b>Bob</b>' WHERE normalized_username = 'bob'",
+                    [],
+                )?;
+                conn.execute("UPDATE users SET is_suspended = 1 WHERE id = ?", [suspended])?;
+                Ok(())
+            })
+            .await
+            .expect("update users");
+
+        let response = get_with_cookie(&server, "/mentions?q=BO", &alice_cookie).await;
+
+        assert_eq!(response.status, 200);
+        assert_header(&response, "content-type", "application/json");
+        assert!(response.body.starts_with('['));
+        assert!(response.body.contains(r#""username":"bob""#));
+        assert!(response.body.contains(r#""display_name":"<b>Bob</b>""#));
+        assert!(response.body.contains(r#""username":"bobby""#));
+        assert!(!response.body.contains("bot_suspended"));
+    }
+
+    #[tokio::test]
+    async fn grouped_notification_open_marks_group_read() {
+        let server = spawn_test_server().await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &alice_cookie, "grouped notification target").await;
+        let bob_cookie = register_test_user(&server, "bob").await;
+        let carol_cookie = register_test_user(&server, "carol").await;
+        let bob_home = get_with_cookie(&server, "/home", &bob_cookie).await;
+        let bob_csrf = csrf_token(&bob_home.body);
+        let carol_home = get_with_cookie(&server, "/home", &carol_cookie).await;
+        let carol_csrf = csrf_token(&carol_home.body);
+
+        let bob_liked = post_form_with_cookie(
+            &server,
+            "/posts/1/like",
+            &bob_cookie,
+            &format!("csrf={}", form_encode(&bob_csrf)),
+        )
+        .await;
+        assert_eq!(bob_liked.status, 303);
+        let carol_liked = post_form_with_cookie(
+            &server,
+            "/posts/1/like",
+            &carol_cookie,
+            &format!("csrf={}", form_encode(&carol_csrf)),
+        )
+        .await;
+        assert_eq!(carol_liked.status, 303);
+
+        let notifications = get_with_cookie(&server, "/notifications", &alice_cookie).await;
+        assert_eq!(notifications.status, 200);
+        assert!(notifications.body.contains("2 unread notifications"));
+        assert!(notifications.body.contains("2 people"));
+        assert!(notifications.body.contains("liked your post"));
+        assert!(notifications.body.contains("View people"));
+        assert_eq!(
+            notifications
+                .body
+                .matches(r#"class="notification-row unread""#)
+                .count(),
+            1
+        );
+        let csrf = csrf_token(&notifications.body);
+        let notification_ids = hidden_value(&notifications.body, "notification_ids");
+
+        let opened = post_form_with_cookie(
+            &server,
+            "/notifications/open",
+            &alice_cookie,
+            &format!(
+                "csrf={}&notification_ids={}&return_to={}",
+                form_encode(&csrf),
+                form_encode(&notification_ids),
+                form_encode("/posts/1")
+            ),
+        )
+        .await;
+
+        assert_eq!(opened.status, 303);
+        assert_eq!(location(&opened), "/posts/1");
+        let notifications = get_with_cookie(&server, "/notifications", &alice_cookie).await;
+        assert!(notifications.body.contains("No unread notifications"));
+        assert!(
+            !notifications
+                .body
+                .contains(r#"class="notification-row unread""#)
+        );
+    }
+
     #[tokio::test]
     async fn notifications_page_has_polished_empty_state() {
         let server = spawn_test_server().await;
@@ -4950,11 +7086,11 @@ mod tests {
         assert_eq!(notifications.status, 200);
         assert!(notifications.body.contains(r#"class="notifications-hero""#));
         assert!(notifications.body.contains("No unread notifications"));
-        assert!(notifications.body.contains("No notifications yet"));
+        assert!(notifications.body.contains("No notifications."));
         assert!(
             notifications
                 .body
-                .contains("Replies, likes, reposts, follows, and mentions will appear here.")
+                .contains("New activity will appear here.")
         );
     }
 
@@ -5115,7 +7251,7 @@ mod tests {
         assert!(home.body.contains(r#"data-testid="nsfw-media""#));
         assert!(home.body.contains(r#"aria-label="Show NSFW media""#));
         assert!(home.body.contains(">Show<span"));
-        assert!(home.body.contains("Open media"));
+        assert!(!home.body.contains(r#"class="nsfw-open""#));
     }
 
     #[tokio::test]
@@ -5542,6 +7678,7 @@ mod tests {
         assert!(response.body.contains("<legend>Accounts</legend>"));
         assert!(response.body.contains("<legend>Media</legend>"));
         assert!(response.body.contains(r#"name="allow_reposts""#));
+        assert!(response.body.contains(r#"name="post_edit_window_seconds""#));
         assert!(
             response
                 .body
@@ -5684,6 +7821,7 @@ mod tests {
                 "confirm",
                 &[
                     ("max_bio_len", "300"),
+                    ("post_edit_window_seconds", "20"),
                     ("allow_profile_pictures", "false"),
                     ("nsfw_blur_enabled", "false"),
                     ("registration_captcha_enabled", "true"),
@@ -5696,6 +7834,7 @@ mod tests {
         assert_eq!(response.status, 200);
         assert!(response.body.contains("Settings saved successfully"));
         assert_eq!(saved.accounts.max_bio_len, 300);
+        assert_eq!(saved.posts.post_edit_window_seconds, 20);
         assert!(!saved.accounts.allow_profile_pictures);
         assert!(!saved.media.nsfw_blur_enabled);
         assert!(saved.accounts.registration_captcha_enabled);
@@ -5711,6 +7850,9 @@ mod tests {
         assert!(fresh.body.contains(
             r#"name="max_bio_len" type="text" inputmode="numeric" pattern="[0-9]+" value="300""#
         ));
+        assert!(fresh.body.contains(
+            r#"name="post_edit_window_seconds" type="text" inputmode="numeric" pattern="[0-9]+" value="20""#
+        ));
         assert!(
             fresh
                 .body
@@ -5757,6 +7899,45 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn invalid_post_edit_window_deep_setting_is_rejected_without_writing() {
+        let server = spawn_test_server_with_admin().await;
+        let cookie = admin_session_cookie(&server).await;
+        let page = request(
+            &server.base_url,
+            "GET",
+            "/admin/deep-settings",
+            &[("cookie", &cookie)],
+            Vec::new(),
+        )
+        .await;
+        let csrf = csrf_token(&page.body);
+        let before =
+            std::fs::read_to_string(server.data_dir.join("settings.toml")).expect("settings");
+
+        let response = request(
+            &server.base_url,
+            "POST",
+            "/admin/deep-settings",
+            &[
+                ("cookie", &cookie),
+                ("content-type", "application/x-www-form-urlencoded"),
+            ],
+            deep_settings_form_body(&csrf, "preview", &[("post_edit_window_seconds", "999")]),
+        )
+        .await;
+        let after =
+            std::fs::read_to_string(server.data_dir.join("settings.toml")).expect("settings");
+
+        assert_eq!(response.status, 200);
+        assert_eq!(before, after);
+        assert!(
+            response
+                .body
+                .contains("Post edit window must be 300 seconds or less")
+        );
+    }
+
     #[tokio::test]
     async fn favicon_upload_rejects_unsupported_content_and_unsafe_names() {
         let server = spawn_test_server_with_admin().await;
@@ -6192,6 +8373,39 @@ mod tests {
         ]
     }
 
+    fn tiny_mp4_bytes() -> Vec<u8> {
+        let mut bytes = vec![
+            0x00, 0x00, 0x00, 0x18, b'f', b't', b'y', b'p', b'i', b's', b'o', b'm', 0x00, 0x00,
+            0x00, 0x00, b'i', b's', b'o', b'm', b'm', b'p', b'4', b'2',
+        ];
+        bytes.extend_from_slice(b"rustpost-test-video");
+        bytes
+    }
+
+    async fn media_row_count(server: &TestServer) -> i64 {
+        server
+            .pool
+            .call(|conn| Ok(conn.query_row("SELECT COUNT(*) FROM media", [], |row| row.get(0))?))
+            .await
+            .expect("media count")
+    }
+
+    async fn pinned_post_id_for_user(server: &TestServer, username: &str) -> Option<i64> {
+        let username = username.to_owned();
+        server
+            .pool
+            .call(move |conn| {
+                conn.query_row(
+                    "SELECT pinned_post_id FROM users WHERE normalized_username = ?",
+                    [username],
+                    |row| row.get(0),
+                )
+                .map_err(Into::into)
+            })
+            .await
+            .expect("pinned post")
+    }
+
     async fn register_test_user(server: &TestServer, username: &str) -> String {
         let body = format!(
             "username={}&password=very%20secure%20password&confirm_password=very%20secure%20password",
@@ -6220,6 +8434,25 @@ mod tests {
         .await
     }
 
+    async fn liked_profile_fixture() -> (TestServer, String, String) {
+        let server = spawn_test_server().await;
+        let alice_cookie = register_test_user(&server, "alice").await;
+        create_text_post(&server, &alice_cookie, "privacy target post").await;
+        let bob_cookie = register_test_user(&server, "bob").await;
+        create_text_post(&server, &bob_cookie, "bob fallback post").await;
+        let bob_home = get_with_cookie(&server, "/home", &bob_cookie).await;
+        let csrf = csrf_token(&bob_home.body);
+        let liked = post_form_with_cookie(
+            &server,
+            "/posts/1/like",
+            &bob_cookie,
+            &format!("csrf={csrf}"),
+        )
+        .await;
+        assert_eq!(liked.status, 303);
+        (server, alice_cookie, bob_cookie)
+    }
+
     async fn post_form_with_cookie(
         server: &TestServer,
         path: &str,
@@ -6239,6 +8472,64 @@ mod tests {
         .await
     }
 
+    async fn save_profile_settings(
+        server: &TestServer,
+        cookie: &str,
+        fields: &[(&str, &str)],
+    ) -> TestResponse {
+        let settings = get_with_cookie(server, "/settings", cookie).await;
+        let csrf = csrf_token(&settings.body);
+        let mut all_fields = Vec::with_capacity(fields.len() + 1);
+        all_fields.push(("csrf", csrf.as_str()));
+        all_fields.extend_from_slice(fields);
+        request(
+            &server.base_url,
+            "POST",
+            "/settings",
+            &[
+                ("cookie", cookie),
+                (
+                    "content-type",
+                    "multipart/form-data; boundary=settings-boundary",
+                ),
+            ],
+            multipart_body("settings-boundary", &all_fields, false),
+        )
+        .await
+    }
+
+    async fn user_settings_state(
+        server: &TestServer,
+        username: &str,
+    ) -> (String, i64, i64, String, String, String, String) {
+        let username = username.to_owned();
+        server
+            .pool
+            .call(move |conn| {
+                Ok(conn.query_row(
+                    r#"
+                    SELECT theme, nsfw_blur_enabled, liked_posts_public,
+                      display_name, bio, location, website
+                    FROM users WHERE normalized_username = ?
+                    "#,
+                    [username],
+                    |row| {
+                        Ok((
+                            row.get(0)?,
+                            row.get(1)?,
+                            row.get(2)?,
+                            row.get(3)?,
+                            row.get(4)?,
+                            row.get(5)?,
+                            row.get(6)?,
+                        ))
+                    },
+                )?)
+            })
+            .await
+            .expect("user settings state")
+    }
+
     async fn create_text_post(server: &TestServer, cookie: &str, text: &str) {
         let home = get_with_cookie(server, "/home", cookie).await;
         let csrf = csrf_token(&home.body);
@@ -6263,6 +8554,21 @@ mod tests {
         assert_eq!(posted.status, 303);
     }
 
+    async fn set_post_created_seconds_ago(server: &TestServer, post_id: i64, seconds: i64) {
+        let modifier = format!("-{seconds} seconds");
+        server
+            .pool
+            .call(move |conn| {
+                conn.execute(
+                    "UPDATE posts SET created_at = datetime('now', ?), edited_at = NULL WHERE id = ?",
+                    params![modifier, post_id],
+                )?;
+                Ok(())
+            })
+            .await
+            .expect("set post age");
+    }
+
     fn assert_populated_notifications_page(body: &str) {
         assert!(body.contains("4 unread notifications"));
         assert!(
@@ -6281,9 +8587,20 @@ mod tests {
         assert!(body.contains("reposted your post"));
         assert!(body.contains("followed you"));
         assert!(body.contains("alice original post"));
-        assert!(body.contains(r#"data-card-href="/posts/1""#));
-        assert!(body.contains(r#"data-card-href="/posts/2""#));
-        assert!(body.contains(r#"data-card-href="/users/bob""#));
+        assert!(body.contains(r#"data-card-form="notification-open-"#));
+        assert!(body.contains(r#"name="return_to" value="/posts/1""#));
+        assert!(body.contains(r#"name="return_to" value="/posts/2""#));
+        assert!(body.contains(r#"name="return_to" value="/users/bob""#));
+    }
+
+    fn assert_empty_state(body: &str, title: &str, message: &str) {
+        assert!(body.contains(r#"class="empty-state" data-testid="empty-state""#));
+        assert!(body.contains(&format!("<h2>{title}</h2>")));
+        if message.is_empty() {
+            assert!(!body.contains(r#"<section class="empty-state" data-testid="empty-state"><h2></h2><p></p></section>"#));
+        } else {
+            assert!(body.contains(&format!("<p>{message}</p>")));
+        }
     }
 
     fn quote_form_body(response: &TestResponse, text: &str) -> String {
diff --git a/src/social.rs b/src/social.rs
index 9cbafdc..567717a 100644
--- a/src/social.rs
+++ b/src/social.rs
@@ -1,3 +1,5 @@
+use std::collections::BTreeSet;
+
 use rusqlite::{Connection, OptionalExtension as _, Row, params, params_from_iter};
 
 use crate::config::Settings;
@@ -27,6 +29,7 @@ pub struct PostView {
     pub text: String,
     pub parent_post_id: Option<i64>,
     pub created_at: String,
+    pub edited_at: Option<String>,
     pub event_created_at: String,
     pub like_count: i64,
     pub repost_count: i64,
@@ -35,6 +38,7 @@ pub struct PostView {
     pub viewer_bookmarked: bool,
     pub viewer_reposted: bool,
     pub viewer_can_repost: bool,
+    pub pinned_by_author: bool,
     pub original_unavailable: bool,
     pub reposted_by_user_id: Option<i64>,
     pub reposted_by_username: Option<String>,
@@ -61,6 +65,23 @@ pub enum TimelineEventKind {
     Repost,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProfileTimelineTab {
+    Posts,
+    Replies,
+    Media,
+    Likes,
+}
+
+impl ProfileTimelineTab {
+    const fn repost_mode(self) -> &'static str {
+        match self {
+            Self::Media => "profile_media",
+            Self::Posts | Self::Replies | Self::Likes => "profile",
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct MediaView {
     pub public_path: String,
@@ -84,12 +105,41 @@ pub struct NotificationView {
     pub actor_username: Option<String>,
     pub actor_display_name: Option<String>,
     pub post_id: Option<i64>,
+    pub group_target_post_id: Option<i64>,
     pub post_text: Option<String>,
     pub post_available: bool,
     pub read_at: Option<String>,
     pub created_at: String,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MentionSuggestion {
+    pub username: String,
+    pub display_name: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct NotificationActorView {
+    pub user_id: Option<i64>,
+    pub username: Option<String>,
+    pub display_name: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct NotificationGroupView {
+    pub id: i64,
+    pub kind: String,
+    pub group_target_post_id: Option<i64>,
+    pub post_id: Option<i64>,
+    pub post_text: Option<String>,
+    pub post_available: bool,
+    pub unread_count: i64,
+    pub total_count: usize,
+    pub notification_ids: Vec<i64>,
+    pub actors: Vec<NotificationActorView>,
+    pub created_at: String,
+}
+
 #[derive(Debug)]
 struct PostRow {
     event_kind: String,
@@ -109,10 +159,11 @@ struct PostRow {
     text: String,
     parent_post_id: Option<i64>,
     created_at: String,
-    like_count: i64,
+    edited_at: Option<String>,
     repost_count: i64,
     reply_count: i64,
     quote_post_id: Option<i64>,
+    pinned_by_author: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -121,6 +172,59 @@ pub struct QuotePostOutcome {
     pub created: bool,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EditPostError {
+    NotFound,
+    Forbidden,
+    WindowExpired,
+    Validation(String),
+    Database(String),
+}
+
+impl std::fmt::Display for EditPostError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::NotFound => formatter.write_str("post not found"),
+            Self::Forbidden => formatter.write_str("cannot edit this post"),
+            Self::WindowExpired => formatter.write_str("the edit window for this post has expired"),
+            Self::Validation(message) | Self::Database(message) => formatter.write_str(message),
+        }
+    }
+}
+
+impl std::error::Error for EditPostError {}
+
+impl From<rusqlite::Error> for EditPostError {
+    fn from(error: rusqlite::Error) -> Self {
+        Self::Database(error.to_string())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PinPostError {
+    NotFound,
+    Forbidden,
+    Database(String),
+}
+
+impl std::fmt::Display for PinPostError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::NotFound => formatter.write_str("post not found"),
+            Self::Forbidden => formatter.write_str("cannot pin this post"),
+            Self::Database(message) => formatter.write_str(message),
+        }
+    }
+}
+
+impl std::error::Error for PinPostError {}
+
+impl From<rusqlite::Error> for PinPostError {
+    fn from(error: rusqlite::Error) -> Self {
+        Self::Database(error.to_string())
+    }
+}
+
 pub async fn create_post(
     pool: &SqlitePool,
     settings: &Settings,
@@ -188,6 +292,84 @@ pub async fn create_post(
     .await
 }
 
+pub async fn edit_post(
+    pool: &SqlitePool,
+    settings: &Settings,
+    user_id: i64,
+    post_id: i64,
+    text: &str,
+) -> Result<bool, EditPostError> {
+    let max_text_chars = settings.posts.max_text_chars;
+    let edit_window_modifier = edit_window_modifier(settings.posts.post_edit_window_seconds);
+    let raw_text = text.to_owned();
+    pool.call(move |conn| {
+        let result: Result<bool, EditPostError> = (|| {
+            let tx = conn.transaction()?;
+            let row = tx
+                .query_row(
+                    r#"
+                    SELECT p.user_id, p.text,
+                      CASE
+                        WHEN ? IS NULL THEN 0
+                        ELSE p.created_at >= datetime('now', ?)
+                      END AS within_window,
+                      (SELECT COUNT(*) FROM post_media WHERE post_id = p.id) AS media_count
+                    FROM posts p
+                    WHERE p.id = ? AND p.is_deleted = 0
+                    "#,
+                    params![
+                        edit_window_modifier.clone(),
+                        edit_window_modifier,
+                        post_id
+                    ],
+                    |row| {
+                        Ok((
+                            row.get::<_, Option<i64>>(0)?,
+                            row.get::<_, String>(1)?,
+                            row.get::<_, i64>(2)? != 0,
+                            row.get::<_, i64>(3)?,
+                        ))
+                    },
+                )
+                .optional()?;
+            let Some((owner, current_text, within_window, media_count)) = row else {
+                return Err(EditPostError::NotFound);
+            };
+            if owner != Some(user_id) {
+                return Err(EditPostError::Forbidden);
+            }
+            if !within_window {
+                return Err(EditPostError::WindowExpired);
+            }
+            let media_count = usize::try_from(media_count).unwrap_or(usize::MAX);
+            let text = clean_post_text(&raw_text, max_text_chars, media_count)
+                .map_err(|err| EditPostError::Validation(err.to_string()))?;
+            if text == current_text {
+                tx.commit()?;
+                return Ok(false);
+            }
+            tx.execute(
+                "UPDATE posts SET text = ?, edited_at = CURRENT_TIMESTAMP WHERE id = ? AND user_id = ? AND is_deleted = 0",
+                params![text, post_id, user_id],
+            )?;
+            tx.commit()?;
+            Ok(true)
+        })();
+        Ok(result)
+    })
+    .await
+    .map_err(|err| EditPostError::Database(err.to_string()))?
+}
+
+fn edit_window_modifier(seconds: u64) -> Option<String> {
+    if seconds == 0 {
+        return None;
+    }
+    i64::try_from(seconds)
+        .ok()
+        .map(|seconds| format!("-{seconds} seconds"))
+}
+
 pub async fn timeline(
     pool: &SqlitePool,
     viewer_id: Option<i64>,
@@ -213,8 +395,27 @@ pub async fn profile_timeline(
     viewer_id: Option<i64>,
     user_id: i64,
 ) -> anyhow::Result<Vec<PostView>> {
-    let mut posts = post_events_for_user(pool, viewer_id, user_id).await?;
-    posts.extend(repost_events(pool, viewer_id, "profile", Some(user_id)).await?);
+    profile_tab_timeline(pool, viewer_id, user_id, ProfileTimelineTab::Posts).await
+}
+
+pub async fn profile_tab_timeline(
+    pool: &SqlitePool,
+    viewer_id: Option<i64>,
+    user_id: i64,
+    tab: ProfileTimelineTab,
+) -> anyhow::Result<Vec<PostView>> {
+    if !profile_activity_visible(pool, viewer_id, user_id).await? {
+        return Ok(Vec::new());
+    }
+    let mut posts = match tab {
+        ProfileTimelineTab::Posts => post_events_for_user(pool, viewer_id, user_id).await?,
+        ProfileTimelineTab::Replies => reply_events_for_user(pool, viewer_id, user_id).await?,
+        ProfileTimelineTab::Media => media_events_for_user(pool, viewer_id, user_id).await?,
+        ProfileTimelineTab::Likes => liked_events_for_user(pool, viewer_id, user_id).await?,
+    };
+    if matches!(tab, ProfileTimelineTab::Posts | ProfileTimelineTab::Media) {
+        posts.extend(repost_events(pool, viewer_id, tab.repost_mode(), Some(user_id)).await?);
+    }
     posts.sort_by(|left, right| {
         right
             .event_created_at
@@ -225,6 +426,53 @@ pub async fn profile_timeline(
     Ok(posts)
 }
 
+pub async fn profile_activity_visible(
+    pool: &SqlitePool,
+    viewer_id: Option<i64>,
+    user_id: i64,
+) -> anyhow::Result<bool> {
+    let Some(viewer_id) = viewer_id else {
+        return Ok(true);
+    };
+    if viewer_id == user_id {
+        return Ok(true);
+    }
+    pool.call(move |conn| {
+        let hidden: i64 = conn.query_row(
+            r#"
+            SELECT
+              EXISTS(SELECT 1 FROM blocks WHERE blocker_id = ? AND blocked_id = ?)
+              OR EXISTS(SELECT 1 FROM mutes WHERE muter_id = ? AND muted_id = ?)
+              OR EXISTS(SELECT 1 FROM blocks WHERE blocker_id = ? AND blocked_id = ?)
+            "#,
+            params![viewer_id, user_id, viewer_id, user_id, user_id, viewer_id],
+            |row| row.get(0),
+        )?;
+        Ok(hidden == 0)
+    })
+    .await
+}
+
+pub async fn profile_pinned_post(
+    pool: &SqlitePool,
+    viewer_id: Option<i64>,
+    user_id: i64,
+) -> anyhow::Result<Option<PostView>> {
+    let mut sql = base_post_query();
+    sql.push_str(
+        " AND p.id = (SELECT pinned_post_id FROM users WHERE id = ? AND is_deleted = 0) AND p.user_id = ?",
+    );
+    append_viewer_filters(&mut sql, "p.user_id", viewer_id);
+    sql.push_str(" LIMIT 1");
+    let mut bindings = vec![user_id, user_id];
+    push_viewer_filter_bindings(&mut bindings, viewer_id);
+    let rows = pool
+        .call(move |conn| query_post_rows(conn, &sql, params_from_iter(bindings)))
+        .await?;
+    let mut posts = rows_to_posts(pool, rows, viewer_id).await?;
+    Ok(posts.pop())
+}
+
 pub async fn post_thread(
     pool: &SqlitePool,
     viewer_id: Option<i64>,
@@ -370,6 +618,18 @@ pub async fn follow(pool: &SqlitePool, follower_id: i64, followed_id: i64) -> an
     }
     pool.call(move |conn| {
         let tx = conn.transaction()?;
+        let target_available = tx
+            .query_row(
+                "SELECT is_deleted = 0 AND is_suspended = 0 FROM users WHERE id = ?",
+                [followed_id],
+                |row| row.get::<_, i64>(0),
+            )
+            .optional()?
+            .unwrap_or(0)
+            != 0;
+        if !target_available {
+            anyhow::bail!("account cannot be followed");
+        }
         let changed = tx.execute(
             "INSERT OR IGNORE INTO follows (follower_id, followed_id) VALUES (?, ?)",
             params![follower_id, followed_id],
@@ -390,6 +650,36 @@ pub async fn follow(pool: &SqlitePool, follower_id: i64, followed_id: i64) -> an
     .await
 }
 
+pub async fn active_follow_targets(pool: &SqlitePool, ids: &[i64]) -> anyhow::Result<Vec<i64>> {
+    if ids.is_empty() {
+        return Ok(Vec::new());
+    }
+    let placeholders = vec!["?"; ids.len()].join(", ");
+    let sql = format!(
+        "SELECT id FROM users WHERE id IN ({placeholders}) AND is_deleted = 0 AND is_suspended = 0"
+    );
+    let candidate_ids = ids.to_vec();
+    let query_ids = candidate_ids.clone();
+    let available = pool
+        .call(move |conn| {
+            let mut stmt = conn.prepare(&sql)?;
+            let rows = stmt
+                .query_map(params_from_iter(query_ids.iter()), |row| {
+                    row.get::<_, i64>(0)
+                })?
+                .collect::<Result<Vec<_>, _>>()?;
+            Ok(rows)
+        })
+        .await?
+        .into_iter()
+        .collect::<BTreeSet<_>>();
+    Ok(candidate_ids
+        .iter()
+        .copied()
+        .filter(|id| available.contains(id))
+        .collect())
+}
+
 pub async fn unfollow(
     pool: &SqlitePool,
     follower_id: i64,
@@ -488,6 +778,47 @@ pub async fn following_accounts(
     .await
 }
 
+pub async fn onboarding_suggestions(
+    pool: &SqlitePool,
+    viewer_id: i64,
+    limit: usize,
+) -> anyhow::Result<Vec<AccountView>> {
+    let limit = i64::try_from(limit)?;
+    pool.call(move |conn| {
+        let mut stmt = conn.prepare(
+            r#"
+            SELECT u.id, u.username, u.display_name, u.bio,
+              COALESCE(pic.thumbnail_public_path, pic.public_path),
+              EXISTS(
+                SELECT 1 FROM follows vf
+                WHERE vf.follower_id = ? AND vf.followed_id = u.id
+              )
+            FROM users u
+            LEFT JOIN media pic ON pic.id = u.profile_picture_media_id
+            WHERE u.id != ?
+              AND u.is_deleted = 0
+              AND u.is_suspended = 0
+            ORDER BY lower(u.username), u.id
+            LIMIT ?
+            "#,
+        )?;
+        let rows = stmt
+            .query_map(params![viewer_id, viewer_id, limit], |row| {
+                Ok(AccountView {
+                    id: row.get(0)?,
+                    username: row.get(1)?,
+                    display_name: row.get(2)?,
+                    bio: row.get(3)?,
+                    profile_picture_path: row.get(4)?,
+                    viewer_following: row.get::<_, i64>(5)? != 0,
+                })
+            })?
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(rows)
+    })
+    .await
+}
+
 pub async fn followers_accounts(
     pool: &SqlitePool,
     account_id: i64,
@@ -792,6 +1123,61 @@ pub async fn unbookmark(pool: &SqlitePool, user_id: i64, post_id: i64) -> anyhow
     .await
 }
 
+pub async fn pinned_post_id(pool: &SqlitePool, user_id: i64) -> anyhow::Result<Option<i64>> {
+    pool.call(move |conn| {
+        conn.query_row(
+            "SELECT pinned_post_id FROM users WHERE id = ? AND is_deleted = 0",
+            [user_id],
+            |row| row.get(0),
+        )
+        .optional()
+        .map(std::option::Option::flatten)
+        .map_err(Into::into)
+    })
+    .await
+}
+
+pub async fn pin_post(pool: &SqlitePool, user_id: i64, post_id: i64) -> Result<(), PinPostError> {
+    pool.call(move |conn| {
+        let result: Result<(), PinPostError> = (|| {
+            let tx = conn.transaction()?;
+            let owner = tx
+                .query_row(
+                    "SELECT user_id FROM posts WHERE id = ? AND is_deleted = 0",
+                    [post_id],
+                    |row| row.get::<_, Option<i64>>(0),
+                )
+                .optional()?;
+            let Some(owner) = owner else {
+                return Err(PinPostError::NotFound);
+            };
+            if owner != Some(user_id) {
+                return Err(PinPostError::Forbidden);
+            }
+            tx.execute(
+                "UPDATE users SET pinned_post_id = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND is_deleted = 0",
+                params![post_id, user_id],
+            )?;
+            tx.commit()?;
+            Ok(())
+        })();
+        Ok(result)
+    })
+    .await
+    .map_err(|err| PinPostError::Database(err.to_string()))?
+}
+
+pub async fn unpin_post(pool: &SqlitePool, user_id: i64, post_id: i64) -> anyhow::Result<bool> {
+    pool.call(move |conn| {
+        let changed = conn.execute(
+            "UPDATE users SET pinned_post_id = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND pinned_post_id = ?",
+            params![user_id, post_id],
+        )?;
+        Ok(changed > 0)
+    })
+    .await
+}
+
 pub async fn delete_post(
     pool: &SqlitePool,
     actor_id: i64,
@@ -817,6 +1203,10 @@ pub async fn delete_post(
             "UPDATE posts SET is_deleted = 1, deleted_at = CURRENT_TIMESTAMP WHERE id = ?",
             [post_id],
         )?;
+        conn.execute(
+            "UPDATE users SET pinned_post_id = NULL, updated_at = CURRENT_TIMESTAMP WHERE pinned_post_id = ?",
+            [post_id],
+        )?;
         Ok(())
     })
     .await
@@ -912,6 +1302,103 @@ pub async fn search(
     Ok((users, rows_to_posts(pool, rows, viewer_id).await?))
 }
 
+const MENTION_SUGGESTION_LIMIT: usize = 8;
+const MENTION_QUERY_MAX_CHARS: usize = 32;
+
+pub async fn mention_suggestions(
+    pool: &SqlitePool,
+    viewer_id: Option<i64>,
+    query: &str,
+) -> anyhow::Result<Vec<MentionSuggestion>> {
+    let Some(fragment) = mention_query_fragment(query) else {
+        return Ok(Vec::new());
+    };
+    let username_query = format!("{}%", escape_like_prefix(&fragment));
+    let limit = i64::try_from(MENTION_SUGGESTION_LIMIT)?;
+    pool.call(move |conn| {
+        if let Some(viewer_id) = viewer_id {
+            let mut stmt = conn.prepare(
+                r#"
+                SELECT username, display_name
+                FROM users u
+                WHERE u.is_deleted = 0
+                  AND u.is_suspended = 0
+                  AND u.normalized_username LIKE ? ESCAPE '\'
+                  AND u.id NOT IN (SELECT blocked_id FROM blocks WHERE blocker_id = ?)
+                  AND u.id NOT IN (SELECT muted_id FROM mutes WHERE muter_id = ?)
+                  AND NOT EXISTS (
+                    SELECT 1 FROM blocks
+                    WHERE blocker_id = u.id AND blocked_id = ?
+                  )
+                ORDER BY u.normalized_username, u.id
+                LIMIT ?
+                "#,
+            )?;
+            let rows = stmt
+                .query_map(
+                    params![username_query, viewer_id, viewer_id, viewer_id, limit],
+                    |row| {
+                        Ok(MentionSuggestion {
+                            username: row.get(0)?,
+                            display_name: row.get(1)?,
+                        })
+                    },
+                )?
+                .collect::<Result<Vec<_>, _>>()?;
+            Ok(rows)
+        } else {
+            let mut stmt = conn.prepare(
+                r#"
+                SELECT username, display_name
+                FROM users u
+                WHERE u.is_deleted = 0
+                  AND u.is_suspended = 0
+                  AND u.normalized_username LIKE ? ESCAPE '\'
+                ORDER BY u.normalized_username, u.id
+                LIMIT ?
+                "#,
+            )?;
+            let rows = stmt
+                .query_map(params![username_query, limit], |row| {
+                    Ok(MentionSuggestion {
+                        username: row.get(0)?,
+                        display_name: row.get(1)?,
+                    })
+                })?
+                .collect::<Result<Vec<_>, _>>()?;
+            Ok(rows)
+        }
+    })
+    .await
+}
+
+fn mention_query_fragment(query: &str) -> Option<String> {
+    let fragment = query.trim().trim_start_matches('@');
+    if fragment.chars().any(|character| {
+        !(character.is_ascii_alphanumeric() || character == '_' || character == '-')
+    }) {
+        return None;
+    }
+    Some(
+        fragment
+            .chars()
+            .take(MENTION_QUERY_MAX_CHARS)
+            .collect::<String>()
+            .to_ascii_lowercase(),
+    )
+}
+
+fn escape_like_prefix(value: &str) -> String {
+    let mut escaped = String::with_capacity(value.len());
+    for character in value.chars() {
+        if matches!(character, '\\' | '%' | '_') {
+            escaped.push('\\');
+        }
+        escaped.push(character);
+    }
+    escaped
+}
+
 fn user_query_from_input(query: &str) -> Option<String> {
     let trimmed = query.trim().trim_start_matches('@').trim();
     let value = trimmed
@@ -954,33 +1441,49 @@ pub async fn notifications(
         let mut stmt = conn.prepare(
             r#"
             SELECT n.id, n.kind, n.actor_user_id, u.username, u.display_name,
-              n.post_id, p.text, p.is_deleted, n.read_at, n.created_at
+              n.post_id, p.text, p.is_deleted, p.parent_post_id, p.quote_post_id,
+              n.read_at, n.created_at
             FROM notifications n
             LEFT JOIN users u ON u.id = n.actor_user_id AND u.is_deleted = 0
             LEFT JOIN posts p ON p.id = n.post_id
             WHERE n.user_id = ?
+              AND (
+                n.kind != 'like'
+                OR n.actor_user_id IS NULL
+                OR COALESCE(u.liked_posts_public, 0) != 0
+              )
             ORDER BY n.id DESC
             LIMIT 80
             "#,
         )?;
         let rows = stmt
             .query_map([user_id], |row| {
+                let kind = row.get::<_, String>(1)?;
+                let post_id = row.get::<_, Option<i64>>(5)?;
                 let post_is_deleted = row
                     .get::<_, Option<i64>>(7)?
                     .is_some_and(|value| value != 0);
+                let parent_post_id = row.get::<_, Option<i64>>(8)?;
+                let quote_post_id = row.get::<_, Option<i64>>(9)?;
+                let group_target_post_id = match kind.as_str() {
+                    "reply" => parent_post_id.or(post_id),
+                    "quote" => quote_post_id.or(post_id),
+                    _ => post_id,
+                };
                 Ok(NotificationView {
                     id: row.get(0)?,
-                    kind: row.get(1)?,
+                    kind,
                     actor_user_id: row.get(2)?,
                     actor_username: row.get(3)?,
                     actor_display_name: row.get(4)?,
-                    post_id: row.get(5)?,
+                    post_id,
+                    group_target_post_id,
                     post_text: row.get(6)?,
                     post_available: row
                         .get::<_, Option<i64>>(7)?
                         .is_some_and(|_| !post_is_deleted),
-                    read_at: row.get(8)?,
-                    created_at: row.get(9)?,
+                    read_at: row.get(10)?,
+                    created_at: row.get(11)?,
                 })
             })?
             .collect::<Result<Vec<_>, _>>()?;
@@ -989,10 +1492,110 @@ pub async fn notifications(
     .await
 }
 
+pub async fn notification_groups(
+    pool: &SqlitePool,
+    user_id: i64,
+) -> anyhow::Result<Vec<NotificationGroupView>> {
+    let notifications = notifications(pool, user_id).await?;
+    let mut groups = group_notifications(&notifications);
+    refresh_notification_group_counts(pool, user_id, &mut groups).await?;
+    Ok(groups)
+}
+
+fn group_notifications(notifications: &[NotificationView]) -> Vec<NotificationGroupView> {
+    let mut groups: Vec<(NotificationGroupKey, NotificationGroupView)> = Vec::new();
+    for notification in notifications {
+        let key = notification_group_key(notification);
+        if let Some((_key, group)) = groups
+            .iter_mut()
+            .find(|(existing_key, _group)| *existing_key == key)
+        {
+            push_notification_group_item(group, notification);
+        } else {
+            groups.push((key, notification_group_from_item(notification)));
+        }
+    }
+    groups.into_iter().map(|(_key, group)| group).collect()
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct NotificationGroupKey {
+    kind: String,
+    target: NotificationGroupTarget,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum NotificationGroupTarget {
+    Follow,
+    Post(i64),
+    Notification(i64),
+}
+
+fn notification_group_key(notification: &NotificationView) -> NotificationGroupKey {
+    let target = match notification.kind.as_str() {
+        "follow" => NotificationGroupTarget::Follow,
+        "like" | "repost" | "reply" | "mention" | "quote" => {
+            notification.group_target_post_id.map_or(
+                NotificationGroupTarget::Notification(notification.id),
+                NotificationGroupTarget::Post,
+            )
+        }
+        _ => NotificationGroupTarget::Notification(notification.id),
+    };
+    NotificationGroupKey {
+        kind: notification.kind.clone(),
+        target,
+    }
+}
+
+fn notification_group_from_item(notification: &NotificationView) -> NotificationGroupView {
+    let mut group = NotificationGroupView {
+        id: notification.id,
+        kind: notification.kind.clone(),
+        group_target_post_id: notification.group_target_post_id,
+        post_id: notification.post_id,
+        post_text: notification.post_text.clone(),
+        post_available: notification.post_available,
+        unread_count: 0,
+        total_count: 0,
+        notification_ids: Vec::new(),
+        actors: Vec::new(),
+        created_at: notification.created_at.clone(),
+    };
+    push_notification_group_item(&mut group, notification);
+    group
+}
+
+fn push_notification_group_item(
+    group: &mut NotificationGroupView,
+    notification: &NotificationView,
+) {
+    group.total_count += 1;
+    group.notification_ids.push(notification.id);
+    if notification.read_at.is_none() {
+        group.unread_count += 1;
+    }
+    group.actors.push(NotificationActorView {
+        user_id: notification.actor_user_id,
+        username: notification.actor_username.clone(),
+        display_name: notification.actor_display_name.clone(),
+    });
+}
+
 pub async fn unread_notification_count(pool: &SqlitePool, user_id: i64) -> anyhow::Result<i64> {
     pool.call(move |conn| {
         Ok(conn.query_row(
-            "SELECT COUNT(*) FROM notifications WHERE user_id = ? AND read_at IS NULL",
+            r#"
+            SELECT COUNT(*)
+            FROM notifications n
+            LEFT JOIN users u ON u.id = n.actor_user_id AND u.is_deleted = 0
+            WHERE n.user_id = ? AND n.read_at IS NULL
+              AND (
+                n.kind != 'like'
+                OR n.actor_user_id IS NULL
+                OR COALESCE(u.liked_posts_public, 0) != 0
+              )
+            "#,
             [user_id],
             |row| row.get(0),
         )?)
@@ -1000,7 +1603,113 @@ pub async fn unread_notification_count(pool: &SqlitePool, user_id: i64) -> anyho
     .await
 }
 
-pub async fn mark_notifications_read(pool: &SqlitePool, user_id: i64) -> anyhow::Result<()> {
+pub async fn mark_notification_ids_read(
+    pool: &SqlitePool,
+    user_id: i64,
+    notification_ids: &[i64],
+) -> anyhow::Result<()> {
+    let notification_ids = notification_ids.to_vec();
+    pool.call(move |conn| {
+        let tx = conn.transaction()?;
+        for notification_id in notification_ids {
+            tx.execute(
+                "UPDATE notifications SET read_at = CURRENT_TIMESTAMP WHERE user_id = ? AND id = ? AND read_at IS NULL",
+                params![user_id, notification_id],
+            )?;
+        }
+        tx.commit()?;
+        Ok(())
+    })
+    .await
+}
+
+async fn refresh_notification_group_counts(
+    pool: &SqlitePool,
+    user_id: i64,
+    groups: &mut [NotificationGroupView],
+) -> anyhow::Result<()> {
+    let descriptors = groups
+        .iter()
+        .enumerate()
+        .filter(|(_index, group)| {
+            group.kind == "follow"
+                || (notification_group_target_expr(&group.kind).is_some()
+                    && group.group_target_post_id.is_some())
+        })
+        .map(|(index, group)| (index, group.kind.clone(), group.group_target_post_id))
+        .collect::<Vec<_>>();
+    let counts = pool
+        .call(move |conn| {
+            let mut counts = Vec::with_capacity(descriptors.len());
+            for (index, kind, target_post_id) in descriptors {
+                let (total_count, unread_count) =
+                    notification_group_counts_tx(conn, user_id, &kind, target_post_id)?;
+                counts.push((index, total_count, unread_count));
+            }
+            Ok(counts)
+        })
+        .await?;
+    for (index, total_count, unread_count) in counts {
+        groups[index].total_count = usize::try_from(total_count)?;
+        groups[index].unread_count = unread_count;
+    }
+    Ok(())
+}
+
+fn notification_group_counts_tx(
+    conn: &Connection,
+    user_id: i64,
+    kind: &str,
+    target_post_id: Option<i64>,
+) -> anyhow::Result<(i64, i64)> {
+    if kind == "follow" {
+        return Ok(conn.query_row(
+            r#"
+            SELECT COUNT(*), COALESCE(SUM(CASE WHEN read_at IS NULL THEN 1 ELSE 0 END), 0)
+            FROM notifications
+            WHERE user_id = ? AND kind = 'follow'
+            "#,
+            [user_id],
+            |row| Ok((row.get(0)?, row.get(1)?)),
+        )?);
+    }
+    let Some(target_expr) = notification_group_target_expr(kind) else {
+        return Ok((0, 0));
+    };
+    let Some(target_post_id) = target_post_id else {
+        return Ok((0, 0));
+    };
+    let sql = format!(
+        r#"
+        SELECT COUNT(*), COALESCE(SUM(CASE WHEN n.read_at IS NULL THEN 1 ELSE 0 END), 0)
+        FROM notifications n
+        LEFT JOIN users actor ON actor.id = n.actor_user_id AND actor.is_deleted = 0
+        LEFT JOIN posts p ON p.id = n.post_id
+        WHERE n.user_id = ? AND n.kind = ? AND {target_expr} = ?
+          AND (
+            n.kind != 'like'
+            OR n.actor_user_id IS NULL
+            OR COALESCE(actor.liked_posts_public, 0) != 0
+          )
+        "#
+    );
+    Ok(
+        conn.query_row(&sql, params![user_id, kind, target_post_id], |row| {
+            Ok((row.get(0)?, row.get(1)?))
+        })?,
+    )
+}
+
+fn notification_group_target_expr(kind: &str) -> Option<&'static str> {
+    match kind {
+        "like" | "repost" | "mention" => Some("n.post_id"),
+        "reply" => Some("COALESCE(p.parent_post_id, n.post_id)"),
+        "quote" => Some("COALESCE(p.quote_post_id, n.post_id)"),
+        _ => None,
+    }
+}
+
+pub async fn mark_notifications_read(pool: &SqlitePool, user_id: i64) -> anyhow::Result<()> {
     pool.call(move |conn| {
         conn.execute(
             "UPDATE notifications SET read_at = CURRENT_TIMESTAMP WHERE user_id = ? AND read_at IS NULL",
@@ -1011,6 +1720,45 @@ pub async fn mark_notifications_read(pool: &SqlitePool, user_id: i64) -> anyhow:
     .await
 }
 
+pub async fn mark_notification_group_read(
+    pool: &SqlitePool,
+    user_id: i64,
+    kind: &str,
+    target_post_id: Option<i64>,
+) -> anyhow::Result<()> {
+    let kind = kind.to_owned();
+    pool.call(move |conn| {
+        if kind == "follow" {
+            conn.execute(
+                "UPDATE notifications SET read_at = CURRENT_TIMESTAMP WHERE user_id = ? AND kind = 'follow' AND read_at IS NULL",
+                [user_id],
+            )?;
+            return Ok(());
+        }
+        let Some(target_expr) = notification_group_target_expr(&kind) else {
+            anyhow::bail!("notification group kind is invalid");
+        };
+        let Some(target_post_id) = target_post_id else {
+            anyhow::bail!("notification group target is invalid");
+        };
+        let sql = format!(
+            r#"
+            UPDATE notifications
+            SET read_at = CURRENT_TIMESTAMP
+            WHERE user_id = ? AND read_at IS NULL AND id IN (
+              SELECT n.id
+              FROM notifications n
+              LEFT JOIN posts p ON p.id = n.post_id
+              WHERE n.user_id = ? AND n.kind = ? AND {target_expr} = ?
+            )
+            "#
+        );
+        conn.execute(&sql, params![user_id, user_id, kind, target_post_id])?;
+        Ok(())
+    })
+    .await
+}
+
 fn base_post_query() -> String {
     r#"
     SELECT 'post' AS event_kind, 'p:' || p.id AS event_id, p.created_at AS event_created_at,
@@ -1019,11 +1767,12 @@ fn base_post_query() -> String {
       p.id, p.user_id, u.username, u.display_name,
       COALESCE(pic.thumbnail_public_path, pic.public_path) AS profile_picture_path,
       p.anonymous_label, p.text, p.parent_post_id, p.created_at,
-      (SELECT COUNT(*) FROM likes WHERE post_id = p.id) AS like_count,
+      p.edited_at,
       ((SELECT COUNT(*) FROM reposts WHERE post_id = p.id) +
        (SELECT COUNT(*) FROM posts qp WHERE qp.quote_post_id = p.id AND qp.is_deleted = 0)) AS repost_count,
       (SELECT COUNT(*) FROM posts r WHERE r.parent_post_id = p.id AND r.is_deleted = 0) AS reply_count,
-      p.quote_post_id
+      p.quote_post_id,
+      COALESCE(u.pinned_post_id = p.id, 0) AS pinned_by_author
     FROM posts p
     LEFT JOIN users u ON u.id = p.user_id
     LEFT JOIN media pic ON pic.id = u.profile_picture_media_id
@@ -1039,13 +1788,14 @@ fn base_repost_query() -> String {
       COALESCE(p.id, r.post_id) AS id, p.user_id, u.username, u.display_name,
       COALESCE(pic.thumbnail_public_path, pic.public_path) AS profile_picture_path, p.anonymous_label,
       COALESCE(p.text, '') AS text, p.parent_post_id, COALESCE(p.created_at, r.created_at) AS created_at,
-      CASE WHEN p.id IS NULL OR p.is_deleted != 0 THEN 0 ELSE (SELECT COUNT(*) FROM likes WHERE post_id = p.id) END AS like_count,
+      p.edited_at,
       CASE WHEN p.id IS NULL OR p.is_deleted != 0 THEN 0 ELSE
         ((SELECT COUNT(*) FROM reposts WHERE post_id = p.id) +
          (SELECT COUNT(*) FROM posts qp WHERE qp.quote_post_id = p.id AND qp.is_deleted = 0))
       END AS repost_count,
       CASE WHEN p.id IS NULL OR p.is_deleted != 0 THEN 0 ELSE (SELECT COUNT(*) FROM posts replies WHERE replies.parent_post_id = p.id AND replies.is_deleted = 0) END AS reply_count,
-      p.quote_post_id
+      p.quote_post_id,
+      CASE WHEN p.id IS NULL OR p.is_deleted != 0 THEN 0 ELSE COALESCE(u.pinned_post_id = p.id, 0) END AS pinned_by_author
     FROM reposts r
     JOIN users ru ON ru.id = r.user_id
     LEFT JOIN posts p ON p.id = r.post_id
@@ -1110,6 +1860,61 @@ async fn post_events_for_user(
     rows_to_posts(pool, rows, viewer_id).await
 }
 
+async fn reply_events_for_user(
+    pool: &SqlitePool,
+    viewer_id: Option<i64>,
+    user_id: i64,
+) -> anyhow::Result<Vec<PostView>> {
+    let mut sql = base_post_query();
+    sql.push_str(" AND p.user_id = ? AND p.parent_post_id IS NOT NULL");
+    append_viewer_filters(&mut sql, "p.user_id", viewer_id);
+    sql.push_str(" ORDER BY p.id DESC LIMIT 40");
+    let mut bindings = vec![user_id];
+    push_viewer_filter_bindings(&mut bindings, viewer_id);
+    let rows = pool
+        .call(move |conn| query_post_rows(conn, &sql, params_from_iter(bindings)))
+        .await?;
+    rows_to_posts(pool, rows, viewer_id).await
+}
+
+async fn media_events_for_user(
+    pool: &SqlitePool,
+    viewer_id: Option<i64>,
+    user_id: i64,
+) -> anyhow::Result<Vec<PostView>> {
+    let mut sql = base_post_query();
+    sql.push_str(" AND p.user_id = ? AND ");
+    sql.push_str(&media_surface_condition("p.id", "p.text"));
+    append_viewer_filters(&mut sql, "p.user_id", viewer_id);
+    sql.push_str(" ORDER BY p.id DESC LIMIT 40");
+    let mut bindings = vec![user_id];
+    push_viewer_filter_bindings(&mut bindings, viewer_id);
+    let rows = pool
+        .call(move |conn| query_post_rows(conn, &sql, params_from_iter(bindings)))
+        .await?;
+    rows_to_posts(pool, rows, viewer_id).await
+}
+
+async fn liked_events_for_user(
+    pool: &SqlitePool,
+    viewer_id: Option<i64>,
+    user_id: i64,
+) -> anyhow::Result<Vec<PostView>> {
+    let mut sql = base_post_query();
+    sql.push_str(" AND p.id IN (SELECT post_id FROM likes WHERE user_id = ?)");
+    append_viewer_filters(&mut sql, "p.user_id", viewer_id);
+    sql.push_str(
+        " ORDER BY (SELECT created_at FROM likes WHERE user_id = ? AND post_id = p.id) DESC, p.id DESC LIMIT 40",
+    );
+    let mut bindings = vec![user_id];
+    push_viewer_filter_bindings(&mut bindings, viewer_id);
+    bindings.push(user_id);
+    let rows = pool
+        .call(move |conn| query_post_rows(conn, &sql, params_from_iter(bindings)))
+        .await?;
+    rows_to_posts(pool, rows, viewer_id).await
+}
+
 async fn repost_events(
     pool: &SqlitePool,
     viewer_id: Option<i64>,
@@ -1122,6 +1927,10 @@ async fn repost_events(
             " AND (r.user_id = ? OR r.user_id IN (SELECT followed_id FROM follows WHERE follower_id = ?))",
         ),
         "profile" => sql.push_str(" AND r.user_id = ?"),
+        "profile_media" => {
+            sql.push_str(" AND r.user_id = ? AND ");
+            sql.push_str(&media_surface_condition("p.id", "COALESCE(p.text, '')"));
+        }
         _ => {}
     }
     if viewer_id.is_some() {
@@ -1149,6 +1958,12 @@ async fn repost_events(
     rows_to_posts(pool, rows, viewer_id).await
 }
 
+fn media_surface_condition(post_id_column: &str, text_column: &str) -> String {
+    format!(
+        "(EXISTS (SELECT 1 FROM post_media pm WHERE pm.post_id = {post_id_column}) OR instr(lower({text_column}), 'youtube.com/') > 0 OR instr(lower({text_column}), 'youtu.be/') > 0)"
+    )
+}
+
 fn append_viewer_filters(sql: &mut String, user_column: &str, viewer_id: Option<i64>) {
     if viewer_id.is_some() {
         sql.push_str(&format!(
@@ -1201,10 +2016,11 @@ fn map_post_row(row: &Row<'_>) -> rusqlite::Result<PostRow> {
         text: row.get(14)?,
         parent_post_id: row.get(15)?,
         created_at: row.get(16)?,
-        like_count: row.get(17)?,
+        edited_at: row.get(17)?,
         repost_count: row.get(18)?,
         reply_count: row.get(19)?,
         quote_post_id: row.get(20)?,
+        pinned_by_author: row.get::<_, i64>(21)? != 0,
     })
 }
 
@@ -1237,6 +2053,11 @@ async fn rows_to_posts(
         } else {
             false
         };
+        let like_count = if original_unavailable {
+            0
+        } else {
+            visible_like_count(pool, viewer_id, id).await?
+        };
         let viewer_can_repost =
             viewer_id.is_some_and(|user_id| !original_unavailable && row.user_id != Some(user_id));
         let quote = quote_preview_for_post(pool, row.quote_post_id, viewer_id).await?;
@@ -1256,14 +2077,16 @@ async fn rows_to_posts(
             text: row.text,
             parent_post_id: row.parent_post_id,
             created_at: row.created_at,
+            edited_at: row.edited_at,
             event_created_at: row.event_created_at,
-            like_count: row.like_count,
+            like_count,
             repost_count: row.repost_count,
             reply_count: row.reply_count,
             viewer_liked,
             viewer_bookmarked,
             viewer_reposted,
             viewer_can_repost,
+            pinned_by_author: row.pinned_by_author,
             original_unavailable,
             reposted_by_user_id: row.repost_user_id,
             reposted_by_username: row.repost_username,
@@ -1276,6 +2099,27 @@ async fn rows_to_posts(
     Ok(posts)
 }
 
+async fn visible_like_count(
+    pool: &SqlitePool,
+    viewer_id: Option<i64>,
+    post_id: i64,
+) -> anyhow::Result<i64> {
+    let viewer_id = viewer_id.unwrap_or(-1);
+    pool.call(move |conn| {
+        Ok(conn.query_row(
+            r#"
+            SELECT COUNT(*)
+            FROM likes l
+            JOIN users u ON u.id = l.user_id AND u.is_deleted = 0
+            WHERE l.post_id = ? AND (u.liked_posts_public != 0 OR l.user_id = ?)
+            "#,
+            params![post_id, viewer_id],
+            |row| row.get(0),
+        )?)
+    })
+    .await
+}
+
 async fn quote_preview_for_post(
     pool: &SqlitePool,
     quote_post_id: Option<i64>,
@@ -1446,12 +2290,24 @@ fn notify_post_owner_tx(
     if let Some(owner) = owner
         && owner != actor_id
         && !is_blocked_tx(tx, owner, actor_id)?
+        && (kind != "like" || likes_public_tx(tx, actor_id)?)
     {
         create_notification_tx(tx, owner, Some(actor_id), Some(link_post_id), kind, message)?;
     }
     Ok(owner)
 }
 
+fn likes_public_tx(tx: &rusqlite::Transaction<'_>, user_id: i64) -> anyhow::Result<bool> {
+    Ok(tx
+        .query_row(
+            "SELECT liked_posts_public FROM users WHERE id = ? AND is_deleted = 0",
+            [user_id],
+            |row| row.get::<_, i64>(0),
+        )
+        .optional()?
+        .is_some_and(|value| value != 0))
+}
+
 fn notify_mentioned_users_tx(
     tx: &rusqlite::Transaction<'_>,
     text: &str,
@@ -2054,6 +2910,215 @@ mod tests {
         assert!(profile_for_bob[0].viewer_can_repost);
     }
 
+    #[tokio::test]
+    async fn profile_posts_tab_includes_originals_and_reposts_but_excludes_plain_replies() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let original = create_post(&pool, &settings, Some(bob), "bob original", None, &[])
+            .await
+            .expect("original");
+        let parent = create_post(&pool, &settings, Some(alice), "alice parent", None, &[])
+            .await
+            .expect("parent");
+        let reply = create_post(&pool, &settings, Some(bob), "bob reply", Some(parent), &[])
+            .await
+            .expect("reply");
+        repost(&pool, bob, parent).await.expect("repost");
+
+        let posts = profile_tab_timeline(&pool, Some(alice), bob, ProfileTimelineTab::Posts)
+            .await
+            .expect("posts tab");
+
+        assert!(posts.iter().any(|post| post.id == original));
+        assert!(
+            posts
+                .iter()
+                .any(|post| { post.id == parent && post.event_kind == TimelineEventKind::Repost })
+        );
+        assert!(!posts.iter().any(|post| post.id == reply));
+    }
+
+    #[tokio::test]
+    async fn profile_replies_tab_includes_plain_replies() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let top_level = create_post(&pool, &settings, Some(bob), "bob original", None, &[])
+            .await
+            .expect("top-level");
+        let parent = create_post(&pool, &settings, Some(alice), "alice parent", None, &[])
+            .await
+            .expect("parent");
+        let reply = create_post(&pool, &settings, Some(bob), "bob reply", Some(parent), &[])
+            .await
+            .expect("reply");
+
+        let replies = profile_tab_timeline(&pool, Some(alice), bob, ProfileTimelineTab::Replies)
+            .await
+            .expect("replies tab");
+
+        assert_eq!(replies.len(), 1);
+        assert_eq!(replies[0].id, reply);
+        assert_eq!(replies[0].parent_post_id, Some(parent));
+        assert!(!replies.iter().any(|post| post.id == top_level));
+    }
+
+    #[tokio::test]
+    async fn profile_media_tab_includes_only_profile_user_media_posts_and_replies() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let plain = create_post(&pool, &settings, Some(bob), "plain", None, &[])
+            .await
+            .expect("plain");
+        let media_post = create_post(&pool, &settings, Some(bob), "with media", None, &[])
+            .await
+            .expect("media post");
+        attach_test_media(&pool, bob, media_post).await;
+        let embedded = create_post(
+            &pool,
+            &settings,
+            Some(bob),
+            "https://youtu.be/dQw4w9WgXcQ",
+            None,
+            &[],
+        )
+        .await
+        .expect("embedded");
+        let parent = create_post(&pool, &settings, Some(alice), "alice parent", None, &[])
+            .await
+            .expect("parent");
+        let media_reply = create_post(
+            &pool,
+            &settings,
+            Some(bob),
+            "reply media",
+            Some(parent),
+            &[],
+        )
+        .await
+        .expect("media reply");
+        attach_test_media(&pool, bob, media_reply).await;
+        let liked_media = create_post(&pool, &settings, Some(alice), "liked media", None, &[])
+            .await
+            .expect("liked media");
+        attach_test_media(&pool, alice, liked_media).await;
+        like(&pool, bob, liked_media).await.expect("like");
+        let reposted_media =
+            create_post(&pool, &settings, Some(alice), "reposted media", None, &[])
+                .await
+                .expect("reposted media");
+        attach_test_media(&pool, alice, reposted_media).await;
+        repost(&pool, bob, reposted_media)
+            .await
+            .expect("repost media");
+
+        let media = profile_tab_timeline(&pool, Some(alice), bob, ProfileTimelineTab::Media)
+            .await
+            .expect("media tab");
+
+        assert!(media.iter().any(|post| post.id == media_post));
+        assert!(media.iter().any(|post| post.id == embedded));
+        assert!(media.iter().any(|post| post.id == media_reply));
+        assert!(!media.iter().any(|post| post.id == plain));
+        assert!(!media.iter().any(|post| post.id == liked_media));
+        assert!(media.iter().any(|post| {
+            post.id == reposted_media && post.event_kind == TimelineEventKind::Repost
+        }));
+    }
+
+    #[tokio::test]
+    async fn profile_likes_tab_shows_liked_posts_themselves() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let liked = create_post(&pool, &settings, Some(alice), "liked by bob", None, &[])
+            .await
+            .expect("liked");
+        let not_liked = create_post(&pool, &settings, Some(bob), "not liked by bob", None, &[])
+            .await
+            .expect("not liked");
+        like(&pool, bob, liked).await.expect("like");
+
+        let likes = profile_tab_timeline(&pool, Some(alice), bob, ProfileTimelineTab::Likes)
+            .await
+            .expect("likes tab");
+
+        assert_eq!(likes.len(), 1);
+        assert_eq!(likes[0].id, liked);
+        assert_eq!(likes[0].user_id, Some(alice));
+        assert!(!likes.iter().any(|post| post.id == not_liked));
+    }
+
+    #[tokio::test]
+    async fn profile_tabs_hide_activity_when_profile_user_blocks_viewer() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let original = create_post(&pool, &settings, Some(bob), "blocked original", None, &[])
+            .await
+            .expect("original");
+        let reply_target = create_post(&pool, &settings, Some(alice), "reply target", None, &[])
+            .await
+            .expect("reply target");
+        create_post(
+            &pool,
+            &settings,
+            Some(bob),
+            "blocked reply",
+            Some(reply_target),
+            &[],
+        )
+        .await
+        .expect("reply");
+        let liked = create_post(&pool, &settings, Some(alice), "blocked like", None, &[])
+            .await
+            .expect("liked");
+        like(&pool, bob, liked).await.expect("like");
+        let media_post = create_post(&pool, &settings, Some(bob), "blocked media", None, &[])
+            .await
+            .expect("media");
+        attach_test_media(&pool, bob, media_post).await;
+
+        let visible = profile_tab_timeline(&pool, Some(alice), bob, ProfileTimelineTab::Posts)
+            .await
+            .expect("visible posts");
+        assert!(visible.iter().any(|post| post.id == original));
+
+        block(&pool, bob, alice).await.expect("block viewer");
+
+        for tab in [
+            ProfileTimelineTab::Posts,
+            ProfileTimelineTab::Replies,
+            ProfileTimelineTab::Media,
+            ProfileTimelineTab::Likes,
+        ] {
+            let posts = profile_tab_timeline(&pool, Some(alice), bob, tab)
+                .await
+                .expect("blocked profile tab");
+            assert!(posts.is_empty(), "{tab:?} should be hidden");
+        }
+    }
+
+    #[tokio::test]
+    async fn profile_likes_tab_hides_activity_when_viewer_mutes_profile_user() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let liked = create_post(
+            &pool,
+            &settings,
+            Some(alice),
+            "muted profile like",
+            None,
+            &[],
+        )
+        .await
+        .expect("liked");
+        like(&pool, bob, liked).await.expect("like");
+
+        let visible = profile_tab_timeline(&pool, Some(alice), bob, ProfileTimelineTab::Likes)
+            .await
+            .expect("visible likes");
+        assert_eq!(visible.len(), 1);
+
+        mute(&pool, alice, bob).await.expect("mute profile");
+
+        let hidden = profile_tab_timeline(&pool, Some(alice), bob, ProfileTimelineTab::Likes)
+            .await
+            .expect("muted likes");
+        assert!(hidden.is_empty());
+    }
+
     #[tokio::test]
     async fn deleted_original_repost_renders_as_unavailable_event() {
         let (pool, settings, alice, bob) = fixture().await;
@@ -2100,6 +3165,23 @@ mod tests {
         .expect("profile picture");
     }
 
+    async fn attach_test_media(pool: &SqlitePool, owner_user_id: i64, post_id: i64) {
+        pool.call(move |conn| {
+            conn.execute(
+                "INSERT INTO media (owner_user_id, original_filename, stored_path, public_path, mime_type, media_kind, byte_len) VALUES (?, 'media.webp', '/tmp/media.webp', '/uploads/images/media.webp', 'image/webp', 'image', 1)",
+                params![owner_user_id],
+            )?;
+            let media_id = conn.last_insert_rowid();
+            conn.execute(
+                "INSERT INTO post_media (post_id, media_id, position) VALUES (?, ?, 0)",
+                params![post_id, media_id],
+            )?;
+            Ok(())
+        })
+        .await
+        .expect("attach media");
+    }
+
     async fn notification_count(
         pool: &SqlitePool,
         user_id: i64,
@@ -2177,6 +3259,102 @@ mod tests {
         assert_eq!(notifications, 1);
     }
 
+    #[tokio::test]
+    async fn private_likes_do_not_create_or_render_like_notifications() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let first_post = create_post(&pool, &settings, Some(alice), "first", None, &[])
+            .await
+            .expect("first post");
+        let second_post = create_post(&pool, &settings, Some(alice), "second", None, &[])
+            .await
+            .expect("second post");
+
+        like(&pool, bob, first_post).await.expect("public like");
+        let public_groups = notification_groups(&pool, alice)
+            .await
+            .expect("public notifications");
+        assert_eq!(public_groups.len(), 1);
+        assert_eq!(public_groups[0].kind, "like");
+        assert_eq!(public_groups[0].total_count, 1);
+
+        pool.call(move |conn| {
+            conn.execute(
+                "UPDATE users SET liked_posts_public = 0 WHERE id = ?",
+                [bob],
+            )?;
+            Ok(())
+        })
+        .await
+        .expect("make likes private");
+
+        let hidden_groups = notification_groups(&pool, alice)
+            .await
+            .expect("private notifications");
+        assert!(hidden_groups.is_empty());
+        assert_eq!(
+            unread_notification_count(&pool, alice)
+                .await
+                .expect("unread count"),
+            0
+        );
+
+        like(&pool, bob, second_post).await.expect("private like");
+        let raw_like_notifications = notification_count(&pool, alice, "like")
+            .await
+            .expect("raw notification count");
+        assert_eq!(raw_like_notifications, 1);
+        let hidden_groups = notification_groups(&pool, alice)
+            .await
+            .expect("private notifications after private like");
+        assert!(hidden_groups.is_empty());
+    }
+
+    #[tokio::test]
+    async fn private_like_counts_are_visible_only_to_liker() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let post = create_post(&pool, &settings, Some(alice), "private count", None, &[])
+            .await
+            .expect("post");
+        pool.call(move |conn| {
+            conn.execute(
+                "UPDATE users SET liked_posts_public = 0 WHERE id = ?",
+                [bob],
+            )?;
+            Ok(())
+        })
+        .await
+        .expect("make likes private");
+        like(&pool, bob, post).await.expect("private like");
+
+        let alice_timeline = timeline(&pool, Some(alice), "local", None)
+            .await
+            .expect("alice timeline");
+        let alice_post = alice_timeline
+            .iter()
+            .find(|item| item.id == post)
+            .expect("alice post");
+        assert_eq!(alice_post.like_count, 0);
+
+        let anonymous_timeline = timeline(&pool, None, "local", None)
+            .await
+            .expect("anonymous timeline");
+        let anonymous_post = anonymous_timeline
+            .iter()
+            .find(|item| item.id == post)
+            .expect("anonymous post");
+        assert_eq!(anonymous_post.like_count, 0);
+
+        let bob_timeline = timeline(&pool, Some(bob), "local", None)
+            .await
+            .expect("bob timeline");
+        let bob_post = bob_timeline
+            .iter()
+            .find(|item| item.id == post)
+            .expect("bob post");
+        assert_eq!(bob_post.like_count, 1);
+        assert!(bob_post.viewer_liked);
+    }
+
     #[tokio::test]
     async fn own_actions_do_not_create_notifications() {
         let (pool, settings, alice, _) = fixture().await;
@@ -2223,6 +3401,314 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn mention_suggestions_match_visible_usernames_safely() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let carol = auth::register_user(&pool, &settings, "carol", "very secure password", false)
+            .await
+            .expect("carol");
+        let _alex = auth::register_user(&pool, &settings, "al_ex", "very secure password", false)
+            .await
+            .expect("alex");
+        let alx = auth::register_user(&pool, &settings, "alxex", "very secure password", false)
+            .await
+            .expect("alx");
+        let deleted = auth::register_user(
+            &pool,
+            &settings,
+            "al-deleted",
+            "very secure password",
+            false,
+        )
+        .await
+        .expect("deleted");
+        let muted =
+            auth::register_user(&pool, &settings, "al-muted", "very secure password", false)
+                .await
+                .expect("muted");
+        let blocker = auth::register_user(
+            &pool,
+            &settings,
+            "al-blocker",
+            "very secure password",
+            false,
+        )
+        .await
+        .expect("blocker");
+        pool.call(move |conn| {
+            conn.execute("UPDATE users SET is_suspended = 1 WHERE id = ?", [carol])?;
+            conn.execute("UPDATE users SET is_deleted = 1 WHERE id = ?", [deleted])?;
+            conn.execute(
+                "UPDATE users SET display_name = '<b>Alice</b>' WHERE id = ?",
+                [alice],
+            )?;
+            conn.execute(
+                "INSERT INTO blocks (blocker_id, blocked_id) VALUES (?, ?)",
+                params![bob, alx],
+            )?;
+            conn.execute(
+                "INSERT INTO mutes (muter_id, muted_id) VALUES (?, ?)",
+                params![bob, muted],
+            )?;
+            conn.execute(
+                "INSERT INTO blocks (blocker_id, blocked_id) VALUES (?, ?)",
+                params![blocker, bob],
+            )?;
+            Ok(())
+        })
+        .await
+        .expect("mark users");
+
+        let suggestions = mention_suggestions(&pool, Some(bob), "AL")
+            .await
+            .expect("suggestions");
+        assert_eq!(
+            suggestions,
+            vec![
+                MentionSuggestion {
+                    username: "al_ex".to_owned(),
+                    display_name: "al_ex".to_owned(),
+                },
+                MentionSuggestion {
+                    username: "alice".to_owned(),
+                    display_name: "<b>Alice</b>".to_owned(),
+                },
+            ]
+        );
+
+        let escaped = mention_suggestions(&pool, Some(bob), "al_")
+            .await
+            .expect("escaped suggestions");
+        assert_eq!(
+            escaped
+                .iter()
+                .map(|suggestion| suggestion.username.as_str())
+                .collect::<Vec<_>>(),
+            vec!["al_ex"]
+        );
+        assert!(
+            !escaped
+                .iter()
+                .any(|suggestion| suggestion.username == "alxex")
+        );
+
+        for wildcard_query in ["%", "_", "al%"] {
+            let wildcard = mention_suggestions(&pool, Some(bob), wildcard_query)
+                .await
+                .expect("wildcard query");
+            assert!(
+                wildcard.is_empty(),
+                "{wildcard_query:?} should not broaden mention suggestions"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn notification_groups_count_unread_and_mark_group_read() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let carol = auth::register_user(&pool, &settings, "carol", "very secure password", false)
+            .await
+            .expect("carol");
+        let dave = auth::register_user(&pool, &settings, "dave", "very secure password", false)
+            .await
+            .expect("dave");
+        let first_post = create_post(&pool, &settings, Some(alice), "first post", None, &[])
+            .await
+            .expect("first post");
+        let second_post = create_post(&pool, &settings, Some(alice), "second post", None, &[])
+            .await
+            .expect("second post");
+
+        like(&pool, bob, first_post).await.expect("bob like");
+        like(&pool, carol, second_post).await.expect("carol like");
+        like(&pool, dave, first_post).await.expect("dave like");
+
+        let groups = notification_groups(&pool, alice).await.expect("groups");
+
+        assert_eq!(groups.len(), 2);
+        assert_eq!(groups[0].kind, "like");
+        assert_eq!(groups[0].post_id, Some(first_post));
+        assert_eq!(groups[0].total_count, 2);
+        assert_eq!(groups[0].unread_count, 2);
+        assert_eq!(
+            groups[0]
+                .actors
+                .iter()
+                .filter_map(|actor| actor.username.as_deref())
+                .collect::<Vec<_>>(),
+            vec!["dave", "bob"]
+        );
+        assert_eq!(groups[1].post_id, Some(second_post));
+        assert_eq!(groups[1].unread_count, 1);
+
+        mark_notification_ids_read(&pool, alice, &groups[0].notification_ids)
+            .await
+            .expect("mark group read");
+
+        assert_eq!(
+            unread_notification_count(&pool, alice)
+                .await
+                .expect("unread count"),
+            1
+        );
+        let groups = notification_groups(&pool, alice).await.expect("groups");
+        let first_group = groups
+            .iter()
+            .find(|group| group.post_id == Some(first_post))
+            .expect("first post group");
+        let second_group = groups
+            .iter()
+            .find(|group| group.post_id == Some(second_post))
+            .expect("second post group");
+        assert_eq!(first_group.unread_count, 0);
+        assert_eq!(second_group.unread_count, 1);
+    }
+
+    #[tokio::test]
+    async fn notification_group_counts_and_read_transition_include_older_rows() {
+        let (pool, settings, alice, _bob) = fixture().await;
+        let post = create_post(&pool, &settings, Some(alice), "busy post", None, &[])
+            .await
+            .expect("post");
+        pool.call(move |conn| {
+            let tx = conn.transaction()?;
+            for _ in 0..85 {
+                tx.execute(
+                    "INSERT INTO notifications (user_id, actor_user_id, post_id, kind, message) VALUES (?, NULL, ?, 'like', 'liked your post')",
+                    params![alice, post],
+                )?;
+            }
+            tx.commit()?;
+            Ok(())
+        })
+        .await
+        .expect("notifications");
+
+        let groups = notification_groups(&pool, alice).await.expect("groups");
+        assert_eq!(groups.len(), 1);
+        assert_eq!(groups[0].total_count, 85);
+        assert_eq!(groups[0].unread_count, 85);
+        assert_eq!(groups[0].notification_ids.len(), 80);
+
+        mark_notification_group_read(&pool, alice, "like", Some(post))
+            .await
+            .expect("mark group read");
+
+        assert_eq!(
+            unread_notification_count(&pool, alice)
+                .await
+                .expect("unread count"),
+            0
+        );
+        let groups = notification_groups(&pool, alice).await.expect("groups");
+        assert_eq!(groups[0].total_count, 85);
+        assert_eq!(groups[0].unread_count, 0);
+    }
+
+    #[tokio::test]
+    async fn notification_groups_keep_types_and_targets_separate() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let carol = auth::register_user(&pool, &settings, "carol", "very secure password", false)
+            .await
+            .expect("carol");
+        let post = create_post(&pool, &settings, Some(alice), "group target", None, &[])
+            .await
+            .expect("post");
+
+        like(&pool, bob, post).await.expect("bob like");
+        like(&pool, carol, post).await.expect("carol like");
+        repost(&pool, bob, post).await.expect("bob repost");
+        repost(&pool, carol, post).await.expect("carol repost");
+        create_post(&pool, &settings, Some(bob), "reply one", Some(post), &[])
+            .await
+            .expect("reply one");
+        create_post(&pool, &settings, Some(carol), "reply two", Some(post), &[])
+            .await
+            .expect("reply two");
+        follow(&pool, bob, alice).await.expect("bob follow");
+        follow(&pool, carol, alice).await.expect("carol follow");
+
+        let groups = notification_groups(&pool, alice).await.expect("groups");
+
+        let like_group = groups
+            .iter()
+            .find(|group| group.kind == "like")
+            .expect("like group");
+        let repost_group = groups
+            .iter()
+            .find(|group| group.kind == "repost")
+            .expect("repost group");
+        let reply_group = groups
+            .iter()
+            .find(|group| group.kind == "reply")
+            .expect("reply group");
+        let follow_group = groups
+            .iter()
+            .find(|group| group.kind == "follow")
+            .expect("follow group");
+
+        assert_eq!(like_group.total_count, 2);
+        assert_eq!(repost_group.total_count, 2);
+        assert_eq!(reply_group.total_count, 2);
+        assert_eq!(follow_group.total_count, 2);
+        assert_ne!(like_group.notification_ids, repost_group.notification_ids);
+        assert_ne!(like_group.notification_ids, reply_group.notification_ids);
+    }
+
+    #[test]
+    fn notification_grouping_keeps_mentions_on_distinct_targets() {
+        let rows = vec![
+            NotificationView {
+                id: 3,
+                kind: "mention".to_owned(),
+                actor_user_id: Some(3),
+                actor_username: Some("carol".to_owned()),
+                actor_display_name: Some("Carol".to_owned()),
+                post_id: Some(10),
+                group_target_post_id: Some(10),
+                post_text: Some("same target".to_owned()),
+                post_available: true,
+                read_at: None,
+                created_at: "2026-05-24 10:03:00".to_owned(),
+            },
+            NotificationView {
+                id: 2,
+                kind: "mention".to_owned(),
+                actor_user_id: Some(2),
+                actor_username: Some("bob".to_owned()),
+                actor_display_name: Some("Bob".to_owned()),
+                post_id: Some(10),
+                group_target_post_id: Some(10),
+                post_text: Some("same target".to_owned()),
+                post_available: true,
+                read_at: Some("2026-05-24 10:04:00".to_owned()),
+                created_at: "2026-05-24 10:02:00".to_owned(),
+            },
+            NotificationView {
+                id: 1,
+                kind: "mention".to_owned(),
+                actor_user_id: Some(4),
+                actor_username: Some("dave".to_owned()),
+                actor_display_name: Some("Dave".to_owned()),
+                post_id: Some(11),
+                group_target_post_id: Some(11),
+                post_text: Some("other target".to_owned()),
+                post_available: true,
+                read_at: None,
+                created_at: "2026-05-24 10:01:00".to_owned(),
+            },
+        ];
+
+        let groups = group_notifications(&rows);
+
+        assert_eq!(groups.len(), 2);
+        assert_eq!(groups[0].post_id, Some(10));
+        assert_eq!(groups[0].total_count, 2);
+        assert_eq!(groups[0].unread_count, 1);
+        assert_eq!(groups[1].post_id, Some(11));
+        assert_eq!(groups[1].total_count, 1);
+    }
+
     #[tokio::test]
     async fn mark_notifications_read_persists_read_state() {
         let (pool, settings, alice, bob) = fixture().await;
@@ -2289,6 +3775,37 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn follow_rejects_deleted_or_suspended_targets() {
+        let (pool, settings, alice, bob) = fixture().await;
+        let carol = auth::register_user(&pool, &settings, "carol", "very secure password", false)
+            .await
+            .expect("carol");
+        pool.call(move |conn| {
+            conn.execute("UPDATE users SET is_suspended = 1 WHERE id = ?", [bob])?;
+            conn.execute("UPDATE users SET is_deleted = 1 WHERE id = ?", [carol])?;
+            Ok(())
+        })
+        .await
+        .expect("mark unavailable");
+
+        let suspended = follow(&pool, alice, bob).await.expect_err("suspended");
+        let deleted = follow(&pool, alice, carol).await.expect_err("deleted");
+
+        assert_eq!(suspended.to_string(), "account cannot be followed");
+        assert_eq!(deleted.to_string(), "account cannot be followed");
+        assert!(
+            !is_following(&pool, alice, bob)
+                .await
+                .expect("not following")
+        );
+        assert!(
+            !is_following(&pool, alice, carol)
+                .await
+                .expect("not following")
+        );
+    }
+
     #[tokio::test]
     async fn following_accounts_returns_only_viewer_follows() {
         let (pool, settings, alice, bob) = fixture().await;
diff --git a/src/validation.rs b/src/validation.rs
index 4762415..7e5701b 100644
--- a/src/validation.rs
+++ b/src/validation.rs
@@ -1,8 +1,18 @@
 use crate::config::Settings;
 
 const RESERVED_USERNAMES: &[&str] = &[
-    "admin", "api", "assets", "auth", "login", "logout", "register", "search", "settings",
-    "static", "uploads",
+    "admin",
+    "api",
+    "assets",
+    "auth",
+    "login",
+    "logout",
+    "onboarding",
+    "register",
+    "search",
+    "settings",
+    "static",
+    "uploads",
 ];
 
 pub fn normalize_username(username: &str, max_len: usize) -> anyhow::Result<String> {