feat: discoverability (NodeInfo, hashtags) and moderation (domain/actor blocking)

- NodeInfo at /.well-known/nodeinfo + /nodeinfo/2.0
- Hashtags #MoviesDiary + #MovieTitle on review posts; /tags/{tag} redirect
- Domain blocking: blocked_domains table, admin API + HTML, inbox enforcement
- Per-actor blocking: blocked_actors table, user API + HTML, BlockActivity send/receive
- Delivery filter excludes blocked actors and blocked-domain inboxes

crates/adapters/activitypub/src/objects.rs

@@ -5,6 +5,18 @@ use url::Url;
 
 use domain::models::Review;
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ApHashtag {
+    #[serde(rename = "type")]
+    pub(crate) kind: String,
+    pub(crate) href: Url,
+    pub(crate) name: String,
+}
+
+pub(crate) fn normalize_hashtag(title: &str) -> String {
+    title.chars().filter(|c| c.is_alphanumeric()).collect()
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ReviewObject {
@@ -22,6 +34,8 @@ pub struct ReviewObject {
     pub(crate) rating: u8,
     pub(crate) comment: Option<String>,
     pub(crate) watched_at: DateTime<Utc>,
+    #[serde(default)]
+    pub(crate) tag: Vec<ApHashtag>,
 }
 
 /// Serialize a local Review into a ReviewObject for AP delivery.
@@ -33,6 +47,7 @@ pub fn review_to_ap_object(
     movie_title: String,
     release_year: u16,
     poster_url: Option<String>,
+    base_url: &str,
 ) -> ReviewObject {
     let stars: String = "\u{2B50}".repeat(review.rating().value() as usize);
     let comment_text = review.comment().map(|c| c.value().to_string());
@@ -50,6 +65,22 @@ pub fn review_to_ap_object(
         None => format!("{} {}{}\n{}", stars, movie_title, year_str, watched_str),
     };
 
+    let normalized = normalize_hashtag(&movie_title);
+    let tag = vec![
+        ApHashtag {
+            kind: "Hashtag".to_string(),
+            href: Url::parse(&format!("{}/tags/moviesdiary", base_url))
+                .expect("valid base_url"),
+            name: "#MoviesDiary".to_string(),
+        },
+        ApHashtag {
+            kind: "Hashtag".to_string(),
+            href: Url::parse(&format!("{}/tags/{}", base_url, normalized.to_lowercase()))
+                .expect("valid base_url"),
+            name: format!("#{}", normalized),
+        },
+    ];
+
     ReviewObject {
         kind: NoteType::default(),
         id: ap_id,
@@ -62,5 +93,51 @@ pub fn review_to_ap_object(
         rating: review.rating().value(),
         comment: comment_text,
         watched_at: DateTime::from_naive_utc_and_offset(*review.watched_at(), Utc),
+        tag,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn normalize_hashtag_strips_non_alphanumeric() {
+        assert_eq!(normalize_hashtag("The Dark Knight"), "TheDarkKnight");
+        assert_eq!(normalize_hashtag("Schindler's List"), "SchindlersList");
+        assert_eq!(normalize_hashtag("2001: A Space Odyssey"), "2001ASpaceOdyssey");
+    }
+
+    #[test]
+    fn review_to_ap_object_includes_two_hashtags() {
+        use chrono::NaiveDateTime;
+        use domain::{
+            models::{Review, ReviewSource},
+            value_objects::{MovieId, Rating, ReviewId, UserId},
+        };
+
+        let review = Review::from_persistence(
+            ReviewId::generate(),
+            MovieId::from_uuid(uuid::Uuid::new_v4()),
+            UserId::from_uuid(uuid::Uuid::new_v4()),
+            Rating::new(4).unwrap(),
+            None,
+            NaiveDateTime::parse_from_str("2024-01-01 00:00:00", "%Y-%m-%d %H:%M:%S").unwrap(),
+            NaiveDateTime::parse_from_str("2024-01-01 00:00:00", "%Y-%m-%d %H:%M:%S").unwrap(),
+            ReviewSource::Local,
+        );
+        let obj = review_to_ap_object(
+            &review,
+            "https://example.com/reviews/1".parse().unwrap(),
+            "https://example.com/users/1".parse().unwrap(),
+            "Dune".to_string(),
+            2021,
+            None,
+            "https://example.com",
+        );
+        assert_eq!(obj.tag.len(), 2);
+        let names: Vec<&str> = obj.tag.iter().map(|t| t.name.as_str()).collect();
+        assert!(names.contains(&"#MoviesDiary"));
+        assert!(names.contains(&"#Dune"));
     }
 }