FEDERATION.md and CLAUDE.md describe follows, likes, boosts and timelines

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012CzABvBkbcFqoHdmi8b9WB

CLAUDE.md

@@ -81,11 +81,14 @@ PrivaPub/                         ASP.NET Core Web API, net10.0
     Objects/                      Origin, ActivityJson, NoteParser, Addressing, ContentSanitizer
     Moderation/                   DomainBlocks (suspend / silence / reject media)
     Signing/                      HttpSignatures (draft-cavage sign/verify)
-    Inbox/                        InboxReceiver (verify, queue, 202) → InboxProcessor (job) → Handlers/{Follow,Undo,Create,Update,Delete}
+    Inbox/                        InboxReceiver (verify, queue, 202) → InboxProcessor (job) → Handlers/{Follow,Accept,Reject,
-    Outbox/                       DeliveryService (queues jobs) + DeliveryJobHandler
+                                  Undo,Create,Update,Delete,Like,Announce}; RemotePosts (build, fetch parents, FetchAncestors)
+    Outbox/                       OutboxPublisher (who a post goes to), DeliveryService (queues jobs) + DeliveryJobHandler
     Rendering/                    ActivityPubRenderer (Mastodon @context, actors, notes, collections)
   Domain/
     Content/                      ContentRenderer (Markdown or plain text → HTML with h-card mentions and hashtags)
+    Social/                       FollowService (local in-process, remote Follow/Accept), Notifications
+    Timelines/                    Fanout (TimelineEntry rows, Mastodon's home rules), TimelineService
     Privacy/                      VisibilityPolicy (IsPublic expression, CanSee)
   Web/Pages/                      Razor: /@{user}, /@{user}/{id} (public posts only, strict CSP, noindex)
   Services/                       RootUsersService, GroupUsersService, PostsService, AppConfigurationService, …
@@ -162,8 +165,11 @@ cd /var/www/privapub.thepra.dev && sudo -u www-data ASPNETCORE_ENVIRONMENT=Produ
     leased, retried on Mastodon's curve, at most two per host, paused per host by `RemoteInstance`. The inbox answers
     202 once it has verified and queued; a handler must be idempotent (unique `ObjectURI`, job `DedupeKey`).
 11. **Every "may anyone see this" goes through `VisibilityPolicy.IsPublic`;** a persona-specific read uses `CanSee`.
-12. **Remote content is stored only when someone here asked for it:** a local persona addressed or mentioned, a reply to
+12. **Remote content is stored only when someone here asked for it:** a persona follows the author, is addressed or
-    a local post, or a community the author follows. Followers-only is detected by the author's stored `followers` URL.
+    mentioned, it replies to a local post, or it is addressed to a community the author follows; a public parent is
+    fetched as context. Followers-only is detected by the author's stored `followers` URL.
+13. **Home timelines are written, not computed:** every stored or created post goes through `Fanout.Distribute`, and
+    every delete removes its `TimelineEntry` rows. Local deletes are soft (content cleared, 410 Tombstone).
 
 ## Privacy invariants
 

FEDERATION.md

@@ -59,13 +59,17 @@ Received:
 | Activity | Effect |
 |---|---|
 | `Follow` | follows an avatar or community; `Accept` is sent unless the community approves members by hand |
-| `Undo{Follow}` | unfollows |
+| `Accept{Follow}`, `Reject{Follow}` | completes or ends a follow an avatar requested |
-| `Create{Note, Article, Page, Question, …}` | stored when it addresses or mentions a local avatar, replies to a local post, or is addressed to a community the author follows |
+| `Undo{Follow, Like, Announce}` | reverses it |
+| `Create{Note, Article, Page, Question, …}` | stored when a local avatar follows the author, is addressed or mentioned, when it replies to a local post, or when it is addressed to a community the author follows; a public parent is fetched to complete the thread |
 | `Update{Note}` | replaces the content; the previous version is kept |
 | `Update{Person}` | refetches the actor |
+| `Like` | counted and notified, on posts the liker could see |
+| `Announce` | counted and notified for local posts; shown to followers of the announcer, with the original refetched from its origin |
 | `Delete` | deletes the object, or the actor and its follows |
 
-Sent: `Create{Note}`, `Delete{Tombstone}`, `Accept{Follow}`, `Announce` (communities).
+Sent: `Follow`, `Undo{Follow}`, `Create{Note}`, `Update{Note}`, `Update{Person}`, `Delete{Tombstone}`, `Accept{Follow}`,
+`Announce` (communities). A deleted post answers 410 with a `Tombstone`.
 
 A `Create`'s `Note` carries Mastodon's `content`, `contentMap`, `summary` and `sensitive`, plus `Mention` and `Hashtag`
 tags. A post's title becomes `name` and is also the first, bold line of `content`, because Mastodon does not show
@@ -90,6 +94,7 @@ followers-only posts are recognised by the author's own `followers` collection.
 
 ## Known limitations
 
-- Likes, boosts, follow requests to remote accounts, media uploads and polls are not implemented yet.
+- Avatars cannot send likes or boosts yet (that arrives with the Mastodon client API), and media uploads and polls are not
+  implemented.
 - Collections expose counts, not members.
 - Only `rsa-sha256`-style keys are verified. RFC 9421 signatures are planned.

PrivaPub.ClientModels/Post/InsertPostForm.cs

@@ -19,6 +19,32 @@ namespace PrivaPub.ClientModels.Post
 		public string GroupId { get; set; }
 		public string AnsweringToPostId { get; set; }
 		public bool HasContentWarning { get; set; }
+
+		[StringLength(500, ErrorMessageResourceName = "MaxLengthString", ErrorMessageResourceType = typeof(ErrorsResource))]
+		public string SpoilerText { get; set; }
+
+		public string Visibility { get; set; }//public (default), unlisted, followersonly
+	}
+
+	public class UpdatePostForm
+	{
+		[Required(ErrorMessageResourceName = "Required", ErrorMessageResourceType = typeof(ErrorsResource))]
+		public string AvatarId { get; set; }
+
+		[Required(ErrorMessageResourceName = "Required", ErrorMessageResourceType = typeof(ErrorsResource))]
+		public string PostId { get; set; }
+
+		[Required(ErrorMessageResourceName = "Required", ErrorMessageResourceType = typeof(ErrorsResource)),
+			StringLength(5000, ErrorMessageResourceName = "MaxLengthString", ErrorMessageResourceType = typeof(ErrorsResource))]
+		public string Text { get; set; }
+
+		[StringLength(200, ErrorMessageResourceName = "MaxLengthString", ErrorMessageResourceType = typeof(ErrorsResource))]
+		public string Title { get; set; }
+
+		public bool HasContentWarning { get; set; }
+
+		[StringLength(500, ErrorMessageResourceName = "MaxLengthString", ErrorMessageResourceType = typeof(ErrorsResource))]
+		public string SpoilerText { get; set; }
 	}
 
 	public class InsertDmForm

PrivaPub.ClientModels/Post/ViewPost.cs

@@ -16,6 +16,7 @@ namespace PrivaPub.ClientModels.Post
 		public bool HasContentWarning { get; set; }
 		public bool IsFederatedCopy { get; set; }
 		public DateTime CreationDate { get; set; }
+		public ViewPost ReblogOf { get; set; }
 	}
 
 	public class ViewDmGroup

PrivaPub.ClientModels/Social/FollowForm.cs

@@ -0,0 +1,37 @@
+using PrivaPub.ClientModels.Resources;
+
+using System.ComponentModel.DataAnnotations;
+
+namespace PrivaPub.ClientModels.Social
+{
+	public class FollowForm
+	{
+		[Required(ErrorMessageResourceName = "Required", ErrorMessageResourceType = typeof(ErrorsResource))]
+		public string AvatarId { get; set; }
+
+		[Required(ErrorMessageResourceName = "Required", ErrorMessageResourceType = typeof(ErrorsResource)),
+			StringLength(2048, ErrorMessageResourceName = "MaxLengthString", ErrorMessageResourceType = typeof(ErrorsResource))]
+		public string Target { get; set; }//user@host, @user, or an actor URI
+	}
+
+	public class ViewFollowing
+	{
+		public string Id { get; set; }
+		public string TargetActorURI { get; set; }
+		public string TargetAccountId { get; set; }
+		public bool TargetIsLocal { get; set; }
+		public string State { get; set; }
+		public DateTime CreatedAt { get; set; }
+	}
+
+	public class ViewNotification
+	{
+		public string Id { get; set; }
+		public string Type { get; set; }
+		public string FromAccountId { get; set; }
+		public string FromActorURI { get; set; }
+		public string PostId { get; set; }
+		public bool IsRead { get; set; }
+		public DateTime CreatedAt { get; set; }
+	}
+}

PrivaPub.Tests/Domain/FollowTests.cs

@@ -0,0 +1,124 @@
+using MongoDB.Entities;
+
+using PrivaPub.ClientModels.Social;
+using PrivaPub.Models.Federation;
+using PrivaPub.Models.Social;
+using PrivaPub.Tests.Support;
+
+using System.Text.Json.Nodes;
+
+namespace PrivaPub.Tests.Domain
+{
+	[Trait("Category", "Integration")]
+	public sealed class FollowTests : IAsyncLifetime
+	{
+		Harness _harness;
+
+		public async ValueTask InitializeAsync()
+		{
+			Assert.SkipUnless(MongoFixture.Enabled, MongoFixture.Skip);
+			_harness = await Harness.Start();
+		}
+
+		public async ValueTask DisposeAsync()
+		{
+			if (_harness != default)
+				await _harness.DisposeAsync();
+		}
+
+		[Fact]
+		public async Task A_local_follow_is_accepted_at_once_and_notified()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (root, alice) = await _harness.Persona("alice");
+			var (_, bob) = await _harness.Persona("bob");
+
+			var result = await _harness.Follows.Follow(root, new FollowForm { AvatarId = alice.Id, Target = "@" + bob.UserName }, token);
+
+			Assert.True(result.IsValid);
+			var following = await DB.Default.Find<Following>().Match(f => f.AvatarId == alice.Id).ExecuteSingleAsync(token);
+			Assert.Equal(FollowState.Accepted, following.State);
+			Assert.True(following.TargetIsLocal);
+			Assert.True((await DB.Default.Find<Follower>().Match(f => f.LocalActorId == bob.Id && f.ActorURI == alice.Uri).ExecuteSingleAsync(token)).IsAccepted);
+			Assert.Equal(NotificationType.Follow, (await DB.Default.Find<Notification>().Match(n => n.AvatarId == bob.Id).ExecuteSingleAsync(token)).Type);
+			Assert.Empty(await _harness.Outgoing(bob.Inbox));
+		}
+
+		[Fact]
+		public async Task Someone_elses_persona_cannot_be_made_to_follow()
+		{
+			var (_, alice) = await _harness.Persona("alice");
+			var (_, bob) = await _harness.Persona("bob");
+
+			var result = await _harness.Follows.Follow("someone-else", new FollowForm { AvatarId = alice.Id, Target = bob.UserName }, TestContext.Current.CancellationToken);
+
+			Assert.False(result.IsValid);
+			Assert.Equal(404, result.StatusCode);
+		}
+
+		[Fact]
+		public async Task A_remote_follow_is_requested_then_accepted()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (root, alice) = await _harness.Persona("alice");
+			var carol = new RemoteActor(_harness.Peer, "carol");
+
+			await _harness.Follows.Follow(root, new FollowForm { AvatarId = alice.Id, Target = carol.Id }, token);
+
+			var following = await DB.Default.Find<Following>().Match(f => f.AvatarId == alice.Id).ExecuteSingleAsync(token);
+			Assert.Equal(FollowState.Requested, following.State);
+			var follow = Assert.Single(await _harness.Outgoing(carol.Id + "/inbox"));
+			Assert.Equal("Follow", follow["type"]!.GetValue<string>());
+			Assert.Equal(alice.Uri, follow["actor"]!.GetValue<string>());
+			Assert.StartsWith(alice.Uri + "/grunts/follow-", follow["id"]!.GetValue<string>());
+
+			var accept = new JsonObject
+			{
+				["id"] = $"{carol.Id}#accepts/{Guid.NewGuid():N}",
+				["type"] = "Accept",
+				["actor"] = carol.Id,
+				["object"] = follow.DeepClone()
+			};
+			Assert.Equal(202, (await _harness.Deliver(carol, $"/peasants/{alice.UserName}/mouth", accept)).StatusCode);
+			Assert.Equal(FollowState.Accepted, (await DB.Default.Find<Following>().OneAsync(following.ID, token)).State);
+		}
+
+		[Fact]
+		public async Task An_accept_from_someone_else_changes_nothing_and_a_reject_ends_the_request()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (root, alice) = await _harness.Persona("alice");
+			var carol = new RemoteActor(_harness.Peer, "carol");
+			var mallory = new RemoteActor(_harness.Peer, "mallory");
+			await _harness.Follows.Follow(root, new FollowForm { AvatarId = alice.Id, Target = carol.Id }, token);
+			var following = await DB.Default.Find<Following>().Match(f => f.AvatarId == alice.Id).ExecuteSingleAsync(token);
+
+			await _harness.Deliver(mallory, "/human-centipede", new JsonObject
+			{
+				["id"] = $"{mallory.Id}#accepts/{Guid.NewGuid():N}", ["type"] = "Accept", ["actor"] = mallory.Id, ["object"] = following.FollowActivityURI
+			});
+			Assert.Equal(FollowState.Requested, (await DB.Default.Find<Following>().OneAsync(following.ID, token)).State);
+
+			await _harness.Deliver(carol, "/human-centipede", new JsonObject
+			{
+				["id"] = $"{carol.Id}#rejects/{Guid.NewGuid():N}", ["type"] = "Reject", ["actor"] = carol.Id, ["object"] = following.FollowActivityURI
+			});
+			Assert.Null(await DB.Default.Find<Following>().OneAsync(following.ID, token));
+		}
+
+		[Fact]
+		public async Task Unfollowing_a_remote_account_sends_an_undo()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (root, alice) = await _harness.Persona("alice");
+			var carol = new RemoteActor(_harness.Peer, "carol");
+			await _harness.Follows.Follow(root, new FollowForm { AvatarId = alice.Id, Target = carol.Id }, token);
+
+			await _harness.Follows.Unfollow(root, new FollowForm { AvatarId = alice.Id, Target = carol.Id }, token);
+
+			Assert.False(await DB.Default.Find<Following>().Match(f => f.AvatarId == alice.Id).ExecuteAnyAsync(token));
+			var undo = (await _harness.Outgoing(carol.Id + "/inbox")).Single(a => a["type"]!.GetValue<string>() == "Undo");
+			Assert.Equal("Follow", undo["object"]!["type"]!.GetValue<string>());
+		}
+	}
+}

PrivaPub.Tests/Domain/OutboxTests.cs

@@ -0,0 +1,92 @@
+using MongoDB.Entities;
+
+using PrivaPub.ClientModels.Post;
+using PrivaPub.ClientModels;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.User;
+using PrivaPub.Tests.Support;
+
+namespace PrivaPub.Tests.Domain
+{
+	[Trait("Category", "Integration")]
+	public sealed class OutboxTests : IAsyncLifetime
+	{
+		Harness _harness;
+
+		public async ValueTask InitializeAsync()
+		{
+			Assert.SkipUnless(MongoFixture.Enabled, MongoFixture.Skip);
+			_harness = await Harness.Start();
+		}
+
+		public async ValueTask DisposeAsync()
+		{
+			if (_harness != default)
+				await _harness.DisposeAsync();
+		}
+
+		async Task<ForeignAvatar> Known(RemoteActor actor) =>
+			await _harness.Remote.GetActor(actor.Id, refresh: false, TestContext.Current.CancellationToken);
+
+		[Fact]
+		public async Task The_audience_follows_mastodons_table()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (_, alice) = await _harness.Persona("alice");
+			var follower = new RemoteActor(_harness.Peer, "follower");
+			var mentioned = await Known(new RemoteActor(_harness.Peer, "mentioned"));
+			var parentAuthor = await Known(new RemoteActor(_harness.Peer, "parent"));
+			await _harness.FollowedBy(alice, follower);
+			var mention = new PostMention { ActorURI = mentioned.ActorURI };
+
+			async Task<IReadOnlyList<string>> Audience(PostVisibility visibility, string replyTo = default) =>
+				await _harness.Outbox.Audience(alice, new Post { Visibility = visibility, Mentions = new() { mention }, To = new() { mentioned.ActorURI }, InReplyToAccountId = replyTo }, token);
+
+			Assert.Equal(new[] { follower.SharedInbox, mentioned.InboxURL }, await Audience(PostVisibility.Public));
+			Assert.Equal(new[] { follower.SharedInbox, mentioned.InboxURL, parentAuthor.InboxURL }, await Audience(PostVisibility.Unlisted, parentAuthor.ID));
+			Assert.Equal(new[] { follower.SharedInbox, mentioned.InboxURL }, await Audience(PostVisibility.FollowersOnly));
+			Assert.Equal(new[] { mentioned.InboxURL }, await Audience(PostVisibility.Direct, parentAuthor.ID));
+			Assert.Empty(await Audience(PostVisibility.Circle));
+		}
+
+		[Fact]
+		public async Task A_post_is_created_edited_and_deleted_for_its_audience()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (root, alice) = await _harness.Persona("alice");
+			var follower = new RemoteActor(_harness.Peer, "follower");
+			await _harness.FollowedBy(alice, follower);
+
+			var created = await _harness.Posts.InsertPost(root, new InsertPostForm { AvatarId = alice.Id, Text = "first", Visibility = "followersonly" }, token);
+			var postId = ((ViewPost)created.Data).Id;
+			await _harness.Posts.UpdatePost(root, new UpdatePostForm { AvatarId = alice.Id, PostId = postId, Text = "second", SpoilerText = "cw" }, token);
+			await _harness.Posts.DeletePost(root, new DeletePostForm { AvatarId = alice.Id, PostId = postId }, token);
+
+			var sent = await _harness.Outgoing(follower.SharedInbox);
+			Assert.Equal(new[] { "Create", "Update", "Delete" }, sent.Select(a => a["type"]!.GetValue<string>()));
+			Assert.DoesNotContain(sent[0]["to"]!.AsArray(), n => n!.GetValue<string>().EndsWith("#Public"));
+			Assert.Equal("cw", sent[1]["object"]!["summary"]!.GetValue<string>());
+			Assert.NotNull(sent[1]["object"]!["updated"]);
+			Assert.Equal(sent[0]["to"]!.ToJsonString(), sent[2]["to"]!.ToJsonString());
+
+			var stored = await DB.Default.Find<Post>().OneAsync(postId, token);
+			Assert.NotNull(stored.DeletedAt);
+			Assert.Null(stored.ContentHtml);
+			Assert.Empty(stored.Revisions);
+		}
+
+		[Fact]
+		public async Task Someone_elses_post_cannot_be_edited()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (root, alice) = await _harness.Persona("alice");
+			var (otherRoot, bob) = await _harness.Persona("bob");
+			var created = await _harness.Posts.InsertPost(root, new InsertPostForm { AvatarId = alice.Id, Text = "mine" }, token);
+
+			var result = await _harness.Posts.UpdatePost(otherRoot, new UpdatePostForm { AvatarId = bob.Id, PostId = ((ViewPost)created.Data).Id, Text = "yours" }, token);
+
+			Assert.False(result.IsValid);
+			Assert.Equal(404, result.StatusCode);
+		}
+	}
+}

PrivaPub.Tests/Domain/TimelineTests.cs

@@ -0,0 +1,162 @@
+using MongoDB.Entities;
+
+using PrivaPub.ClientModels.Post;
+using PrivaPub.ClientModels.Social;
+using PrivaPub.Federation.Objects;
+using PrivaPub.Models.Social;
+using PrivaPub.Tests.Support;
+
+using System.Text.Json.Nodes;
+
+namespace PrivaPub.Tests.Domain
+{
+	[Trait("Category", "Integration")]
+	public sealed class TimelineTests : IAsyncLifetime
+	{
+		Harness _harness;
+
+		public async ValueTask InitializeAsync()
+		{
+			Assert.SkipUnless(MongoFixture.Enabled, MongoFixture.Skip);
+			_harness = await Harness.Start();
+		}
+
+		public async ValueTask DisposeAsync()
+		{
+			if (_harness != default)
+				await _harness.DisposeAsync();
+		}
+
+		async Task<List<ViewPost>> Home(string root, string avatarId) =>
+			(List<ViewPost>)(await _harness.Timelines.Home(root, avatarId, default, 40, TestContext.Current.CancellationToken)).Data;
+
+		async Task Accepted(string root, string avatarId, RemoteActor target)
+		{
+			await _harness.Follows.Follow(root, new FollowForm { AvatarId = avatarId, Target = target.Id }, TestContext.Current.CancellationToken);
+			await DB.Default.Update<Following>().Match(f => f.AvatarId == avatarId && f.TargetActorURI == target.Id)
+				.Modify(f => f.State, FollowState.Accepted).ExecuteAsync(TestContext.Current.CancellationToken);
+		}
+
+		static JsonObject Create(RemoteActor author, string inReplyTo = default, string text = "hello", params (string Uri, string Name)[] mentions)
+		{
+			var origin = new Uri(author.Id).GetLeftPart(UriPartial.Authority);
+			var note = new JsonObject
+			{
+				["id"] = $"{origin}/notes/{Guid.NewGuid():N}",
+				["type"] = "Note",
+				["attributedTo"] = author.Id,
+				["content"] = $"<p>{text}</p>",
+				["to"] = new JsonArray(Addressing.Public),
+				["cc"] = new JsonArray(mentions.Select(m => (JsonNode)m.Uri).Prepend(author.Id + "/followers").ToArray()),
+				["tag"] = new JsonArray(mentions.Select(m => (JsonNode)new JsonObject { ["type"] = "Mention", ["href"] = m.Uri, ["name"] = m.Name }).ToArray())
+			};
+			if (inReplyTo != default)
+				note["inReplyTo"] = inReplyTo;
+			return new JsonObject { ["id"] = $"{origin}/activities/{Guid.NewGuid():N}", ["type"] = "Create", ["actor"] = author.Id, ["object"] = note };
+		}
+
+		[Fact]
+		public async Task A_local_post_reaches_the_author_and_local_followers_only()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (aliceRoot, alice) = await _harness.Persona("alice");
+			var (bobRoot, bob) = await _harness.Persona("bob");
+			var (carolRoot, carol) = await _harness.Persona("carol");
+			await _harness.Follows.Follow(bobRoot, new FollowForm { AvatarId = bob.Id, Target = alice.UserName }, token);
+
+			await _harness.Posts.InsertPost(aliceRoot, new InsertPostForm { AvatarId = alice.Id, Text = "for my followers" }, token);
+
+			Assert.Single(await Home(aliceRoot, alice.Id));
+			Assert.Equal("<p>for my followers</p>", Assert.Single(await Home(bobRoot, bob.Id)).ContentHtml);
+			Assert.Empty(await Home(carolRoot, carol.Id));
+			Assert.Equal(404, (await _harness.Timelines.Home(carolRoot, bob.Id, default, 20, token)).StatusCode);
+		}
+
+		[Fact]
+		public async Task A_followed_remote_account_is_kept_and_its_replies_follow_mastodons_rule()
+		{
+			var (bobRoot, bob) = await _harness.Persona("bob");
+			var carol = new RemoteActor(_harness.Peer, "carol");
+			var dave = new RemoteActor(_harness.Peer, "dave");
+			await Accepted(bobRoot, bob.Id, carol);
+
+			var top = Create(carol, text: "top");
+			await _harness.Deliver(carol, "/human-centipede", top);
+			await _harness.Deliver(carol, "/human-centipede", Create(carol, top["object"]!["id"]!.GetValue<string>(), "self reply"));
+			await _harness.Deliver(dave, "/human-centipede", Create(dave, text: "dave alone"));
+			var daveRoot = Create(dave, text: "unfollowed root");
+			await _harness.Deliver(carol, "/human-centipede", Create(carol, $"{new Uri(dave.Id).GetLeftPart(UriPartial.Authority)}/notes/unknown", "reply to a stranger"));
+
+			var home = (await Home(bobRoot, bob.Id)).Select(p => p.ContentHtml).ToList();
+			Assert.Contains("<p>top</p>", home);
+			Assert.Contains("<p>self reply</p>", home);
+			Assert.DoesNotContain("<p>dave alone</p>", home);
+			Assert.DoesNotContain("<p>reply to a stranger</p>", home);
+		}
+
+		[Fact]
+		public async Task A_reply_brings_its_public_parent_and_the_grandparent_is_queued()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (bobRoot, bob) = await _harness.Persona("bob");
+			var carol = new RemoteActor(_harness.Peer, "carol");
+			var dave = new RemoteActor(_harness.Peer, "dave");
+			await Accepted(bobRoot, bob.Id, carol);
+			var origin = new Uri(dave.Id).GetLeftPart(UriPartial.Authority);
+			var grandparentId = $"{origin}/notes/{Guid.NewGuid():N}";
+			var parentId = $"{origin}/notes/{Guid.NewGuid():N}";
+			_harness.Peer.Serve(new Uri(parentId).AbsolutePath, new JsonObject
+			{
+				["id"] = parentId, ["type"] = "Note", ["attributedTo"] = dave.Id, ["content"] = "<p>parent</p>",
+				["to"] = new JsonArray(Addressing.Public), ["inReplyTo"] = grandparentId
+			}.ToJsonString());
+
+			await _harness.Deliver(carol, "/human-centipede", Create(carol, parentId, "reply to dave"));
+
+			var parent = await DB.Default.Find<PrivaPub.Models.Post.Post>().Match(p => p.ObjectURI == parentId).ExecuteSingleAsync(token);
+			var reply = await DB.Default.Find<PrivaPub.Models.Post.Post>().Match(p => p.InReplyToURI == parentId).ExecuteSingleAsync(token);
+			Assert.Equal(parent.ID, reply.AnsweringToPostId);
+			Assert.Equal(parent.AuthorAccountId, reply.InReplyToAccountId);
+			Assert.True(await DB.Default.Find<PrivaPub.Models.Jobs.Job>().Match(j => j.DedupeKey == "ancestors|" + parent.ID).ExecuteAnyAsync(token));
+			Assert.DoesNotContain("<p>reply to dave</p>", (await Home(bobRoot, bob.Id)).Select(p => p.ContentHtml));
+			Assert.DoesNotContain("<p>parent</p>", (await Home(bobRoot, bob.Id)).Select(p => p.ContentHtml));
+		}
+
+		[Fact]
+		public async Task A_remote_delete_takes_the_post_out_of_home()
+		{
+			var (bobRoot, bob) = await _harness.Persona("bob");
+			var carol = new RemoteActor(_harness.Peer, "carol");
+			await Accepted(bobRoot, bob.Id, carol);
+			var create = Create(carol, text: "soon gone");
+			await _harness.Deliver(carol, "/human-centipede", create);
+			Assert.Single(await Home(bobRoot, bob.Id));
+
+			await _harness.Deliver(carol, "/human-centipede", new JsonObject
+			{
+				["id"] = $"{new Uri(carol.Id).GetLeftPart(UriPartial.Authority)}/deletes/{Guid.NewGuid():N}", ["type"] = "Delete", ["actor"] = carol.Id,
+				["object"] = new JsonObject { ["id"] = create["object"]!["id"]!.GetValue<string>(), ["type"] = "Tombstone" }
+			});
+
+			Assert.Empty(await Home(bobRoot, bob.Id));
+			Assert.False(await DB.Default.Find<TimelineEntry>().Match(e => e.AvatarId == bob.Id).ExecuteAnyAsync(TestContext.Current.CancellationToken));
+		}
+
+		[Fact]
+		public async Task A_mention_notifies_the_persona()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (bobRoot, bob) = await _harness.Persona("bob");
+			var carol = new RemoteActor(_harness.Peer, "carol");
+
+			await _harness.Deliver(carol, "/human-centipede", Create(carol, mentions: (bob.Uri, "@" + bob.Handle)));
+
+			var notifications = (List<ViewNotification>)(await _harness.Timelines.Notifications(bobRoot, bob.Id, default, 20, token)).Data;
+			var mention = Assert.Single(notifications);
+			Assert.Equal("Mention", mention.Type);
+			Assert.Equal(carol.Id, mention.FromActorURI);
+			await _harness.Timelines.MarkNotificationsRead(bobRoot, bob.Id, token);
+			Assert.True(((List<ViewNotification>)(await _harness.Timelines.Notifications(bobRoot, bob.Id, default, 20, token)).Data).Single().IsRead);
+		}
+	}
+}

PrivaPub.Tests/Federation/InboxScenarioTests.cs

@@ -3,6 +3,7 @@ using Microsoft.Extensions.Logging.Abstractions;
 
 using MongoDB.Entities;
 
+using PrivaPub.Domain.Timelines;
 using PrivaPub.Federation.Actors;
 using PrivaPub.Federation.Inbox.Handlers;
 using PrivaPub.Federation.Inbox;
@@ -52,8 +53,8 @@ namespace PrivaPub.Tests.Federation
 			_processor = new InboxProcessor(remote, new IActivityHandler[]
 			{
 				new FollowHandler(db, _local, remote, delivery),
-				new UndoHandler(db, _local, remote, delivery),
+				new UndoHandler(db, _local),
-				new CreateHandler(db, _local, remote, delivery, _blocks),
+				new CreateHandler(db, _local, remote, delivery, _blocks, new Fanout(db), new RemotePosts(db, _local, remote, _blocks, queue)),
 				new DeleteHandler(db, _local, remote, delivery),
 				new UpdateHandler(db, _local, remote)
 			}, NullLogger<InboxProcessor>.Instance);

PrivaPub.Tests/Federation/InteractionTests.cs

@@ -0,0 +1,137 @@
+using MongoDB.Entities;
+
+using PrivaPub.ClientModels.Post;
+using PrivaPub.ClientModels.Social;
+using PrivaPub.Federation.Objects;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
+using PrivaPub.Tests.Support;
+
+using System.Text.Json.Nodes;
+
+namespace PrivaPub.Tests.Federation
+{
+	[Trait("Category", "Integration")]
+	public sealed class InteractionTests : IAsyncLifetime
+	{
+		Harness _harness;
+
+		public async ValueTask InitializeAsync()
+		{
+			Assert.SkipUnless(MongoFixture.Enabled, MongoFixture.Skip);
+			_harness = await Harness.Start();
+		}
+
+		public async ValueTask DisposeAsync()
+		{
+			if (_harness != default)
+				await _harness.DisposeAsync();
+		}
+
+		async Task<(string Root, Post Post)> LocalPost(string visibility = default)
+		{
+			var (root, alice) = await _harness.Persona("alice");
+			var view = (ViewPost)(await _harness.Posts.InsertPost(root, new InsertPostForm { AvatarId = alice.Id, Text = "like me", Visibility = visibility },
+				TestContext.Current.CancellationToken)).Data;
+			return (root, await DB.Default.Find<Post>().OneAsync(view.Id));
+		}
+
+		static string Origin(RemoteActor actor) => new Uri(actor.Id).GetLeftPart(UriPartial.Authority);
+
+		[Fact]
+		public async Task A_like_counts_once_notifies_and_can_be_undone()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (_, post) = await LocalPost();
+			var carol = new RemoteActor(_harness.Peer, "carol");
+			var like = new JsonObject { ["id"] = $"{Origin(carol)}/likes/{Guid.NewGuid():N}", ["type"] = "Like", ["actor"] = carol.Id, ["object"] = post.ObjectURI };
+
+			await _harness.Deliver(carol, "/human-centipede", like);
+			await _harness.Deliver(carol, "/human-centipede", new JsonObject { ["id"] = $"{Origin(carol)}/likes/{Guid.NewGuid():N}", ["type"] = "Like", ["actor"] = carol.Id, ["object"] = post.ObjectURI });
+
+			Assert.Equal(1, (await DB.Default.Find<Post>().OneAsync(post.ID, token)).FavouritesCount);
+			Assert.Equal(NotificationType.Favourite, (await DB.Default.Find<Notification>().Match(n => n.AvatarId == post.GroupUserId).ExecuteSingleAsync(token)).Type);
+
+			await _harness.Deliver(carol, "/human-centipede", new JsonObject
+			{
+				["id"] = $"{Origin(carol)}/undos/{Guid.NewGuid():N}", ["type"] = "Undo", ["actor"] = carol.Id, ["object"] = like
+			});
+			Assert.Equal(0, (await DB.Default.Find<Post>().OneAsync(post.ID, token)).FavouritesCount);
+		}
+
+		[Fact]
+		public async Task A_stranger_cannot_like_a_followers_only_post()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (_, post) = await LocalPost("followersonly");
+			var mallory = new RemoteActor(_harness.Peer, "mallory");
+
+			await _harness.Deliver(mallory, "/human-centipede", new JsonObject
+			{
+				["id"] = $"{Origin(mallory)}/likes/{Guid.NewGuid():N}", ["type"] = "Like", ["actor"] = mallory.Id, ["object"] = post.ObjectURI
+			});
+
+			Assert.Equal(0, (await DB.Default.Find<Post>().OneAsync(post.ID, token)).FavouritesCount);
+		}
+
+		[Fact]
+		public async Task A_boost_of_a_local_post_counts_notifies_and_can_be_undone()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (_, post) = await LocalPost();
+			var carol = new RemoteActor(_harness.Peer, "carol");
+			var announce = new JsonObject
+			{
+				["id"] = $"{Origin(carol)}/announces/{Guid.NewGuid():N}", ["type"] = "Announce", ["actor"] = carol.Id, ["object"] = post.ObjectURI,
+				["to"] = new JsonArray(Addressing.Public), ["cc"] = new JsonArray(carol.Id + "/followers")
+			};
+
+			await _harness.Deliver(carol, "/human-centipede", announce);
+
+			Assert.Equal(1, (await DB.Default.Find<Post>().OneAsync(post.ID, token)).ReblogsCount);
+			Assert.Equal(NotificationType.Reblog, (await DB.Default.Find<Notification>().Match(n => n.AvatarId == post.GroupUserId).ExecuteSingleAsync(token)).Type);
+
+			await _harness.Deliver(carol, "/human-centipede", new JsonObject
+			{
+				["id"] = $"{Origin(carol)}/undos/{Guid.NewGuid():N}", ["type"] = "Undo", ["actor"] = carol.Id, ["object"] = announce["id"]!.GetValue<string>()
+			});
+			Assert.Equal(0, (await DB.Default.Find<Post>().OneAsync(post.ID, token)).ReblogsCount);
+			Assert.False(await DB.Default.Find<Post>().Match(p => p.ObjectURI == announce["id"]!.GetValue<string>()).ExecuteAnyAsync(token));
+		}
+
+		[Fact]
+		public async Task A_followed_account_boosting_a_remote_post_puts_it_in_home()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (bobRoot, bob) = await _harness.Persona("bob");
+			var carol = new RemoteActor(_harness.Peer, "carol");
+			var dave = new RemoteActor(_harness.Peer, "dave");
+			var stranger = new RemoteActor(_harness.Peer, "stranger");
+			await _harness.Follows.Follow(bobRoot, new FollowForm { AvatarId = bob.Id, Target = carol.Id }, token);
+			await DB.Default.Update<Following>().Match(f => f.AvatarId == bob.Id).Modify(f => f.State, FollowState.Accepted).ExecuteAsync(token);
+			var noteId = $"{Origin(dave)}/notes/{Guid.NewGuid():N}";
+			_harness.Peer.Serve(new Uri(noteId).AbsolutePath, new JsonObject
+			{
+				["id"] = noteId, ["type"] = "Note", ["attributedTo"] = dave.Id, ["content"] = "<p>worth sharing</p>", ["to"] = new JsonArray(Addressing.Public)
+			}.ToJsonString());
+
+			await _harness.Deliver(stranger, "/human-centipede", new JsonObject
+			{
+				["id"] = $"{Origin(stranger)}/announces/{Guid.NewGuid():N}", ["type"] = "Announce", ["actor"] = stranger.Id, ["object"] = noteId,
+				["to"] = new JsonArray(Addressing.Public)
+			});
+			Assert.False(await DB.Default.Find<Post>().Match(p => p.ObjectURI == noteId).ExecuteAnyAsync(token));
+
+			await _harness.Deliver(carol, "/human-centipede", new JsonObject
+			{
+				["id"] = $"{Origin(carol)}/announces/{Guid.NewGuid():N}", ["type"] = "Announce", ["actor"] = carol.Id, ["object"] = noteId,
+				["to"] = new JsonArray(Addressing.Public)
+			});
+
+			var home = (List<ViewPost>)(await _harness.Timelines.Home(bobRoot, bob.Id, default, 20, token)).Data;
+			var boosted = Assert.Single(home);
+			Assert.Equal("<p>worth sharing</p>", boosted.ReblogOf.ContentHtml);
+			Assert.Equal(carol.Id, boosted.AuthorActorURI);
+		}
+	}
+}

PrivaPub.Tests/Support/Harness.cs

@@ -0,0 +1,126 @@
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Localization;
+using Microsoft.Extensions.Logging.Abstractions;
+
+using MongoDB.Entities;
+
+using PrivaPub.Domain.Content;
+using PrivaPub.Domain.Social;
+using PrivaPub.Domain.Timelines;
+using PrivaPub.Federation.Actors;
+using PrivaPub.Federation.Inbox;
+using PrivaPub.Federation.Inbox.Handlers;
+using PrivaPub.Federation.Outbox;
+using PrivaPub.Infrastructure.Jobs;
+using PrivaPub.Models;
+using PrivaPub.Models.Federation;
+using PrivaPub.Models.Jobs;
+using PrivaPub.Models.User;
+using PrivaPub.Resources;
+using PrivaPub.Services;
+using PrivaPub.StaticServices;
+
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace PrivaPub.Tests.Support
+{
+	public sealed class Harness : IAsyncDisposable
+	{
+		public const string Host = "privapub.test";
+		public const string Base = "https://" + Host;
+
+		Harness(Peer peer)
+		{
+			Peer = peer;
+			var cache = new MemoryCache(new MemoryCacheOptions());
+			Local = new LocalActorService(Db, new StaticOptions<AppConfiguration>(new AppConfiguration { BackendBaseAddress = Base }));
+			Remote = new RemoteActorService(Peer.Http(cache), Local, cache, Db);
+			Delivery = new DeliveryService(Db, Queue);
+			Fanout = new Fanout(Db);
+			RemotePosts = new RemotePosts(Db, Local, Remote, new NoBlocks(), Queue);
+			Receiver = new InboxReceiver(Local, Remote, Queue, new NoBlocks(), NullLogger<InboxReceiver>.Instance);
+			Processor = new InboxProcessor(Remote, new IActivityHandler[]
+			{
+				new FollowHandler(Db, Local, Remote, Delivery),
+				new AcceptHandler(Db, Local),
+				new RejectHandler(Db, Local),
+				new UndoHandler(Db, Local),
+				new LikeHandler(Db),
+				new AnnounceHandler(Db, Local, RemotePosts, Fanout),
+				new CreateHandler(Db, Local, Remote, Delivery, new NoBlocks(), Fanout, RemotePosts),
+				new DeleteHandler(Db, Local, Remote, Delivery),
+				new UpdateHandler(Db, Local, Remote)
+			}, NullLogger<InboxProcessor>.Instance);
+			Follows = new FollowService(Db, Local, Remote, Delivery, new KeyLocalizer<GenericRes>(), NullLogger<FollowService>.Instance);
+			Content = new ContentRenderer(Local, Remote);
+			Outbox = new OutboxPublisher(Db, Local, Delivery);
+			Posts = new PostsService(Db, Local, Remote, Delivery, Content, Outbox, Fanout, new KeyLocalizer<GenericRes>(), NullLogger<PostsService>.Instance);
+			Timelines = new TimelineService(Db, new KeyLocalizer<GenericRes>());
+		}
+
+		public Peer Peer { get; }
+		public DbEntities Db { get; } = new();
+		public JobQueue Queue { get; } = new();
+		public LocalActorService Local { get; }
+		public RemoteActorService Remote { get; }
+		public DeliveryService Delivery { get; }
+		public InboxReceiver Receiver { get; }
+		public InboxProcessor Processor { get; }
+		public FollowService Follows { get; }
+		public ContentRenderer Content { get; }
+		public OutboxPublisher Outbox { get; }
+		public PostsService Posts { get; }
+		public Fanout Fanout { get; }
+		public RemotePosts RemotePosts { get; }
+		public TimelineService Timelines { get; }
+
+		public async Task FollowedBy(LocalActor local, RemoteActor follower) =>
+			await DB.Default.SaveAsync(new Follower
+			{
+				LocalActorId = local.Id,
+				LocalActorKind = local.Kind,
+				ActorURI = follower.Id,
+				InboxURL = follower.Id + "/inbox",
+				SharedInboxURL = follower.SharedInbox
+			});
+
+		public static async Task<Harness> Start() => new(await Peer.Start());
+
+		public async Task<(string RootId, LocalActor Avatar)> Persona(string name, string rootId = default)
+		{
+			rootId ??= Guid.NewGuid().ToString("N")[..24];
+			var (privateKey, publicKey) = Keys.NewKeyPair();
+			var avatar = new Avatar { UserName = $"{name}{Guid.NewGuid():N}"[..20], Name = name, PrivateKey = privateKey, PublicKey = publicKey };
+			await DB.Default.SaveAsync(avatar);
+			await DB.Default.SaveAsync(new RootToAvatar { RootId = rootId, AvatarId = avatar.ID });
+			return (rootId, Local.FromAvatar(avatar));
+		}
+
+		public async Task<InboxResult> Deliver(RemoteActor sender, string path, JsonNode activity)
+		{
+			var result = await Receiver.Receive(sender.Post(Host, path, activity), default, CancellationToken.None);
+			var dedupe = "inbox|" + (activity is JsonObject ? activity["id"]?.GetValue<string>() : default);
+			var job = await DB.Default.Find<Job>().Match(j => j.DedupeKey == dedupe).ExecuteFirstAsync();
+			if (job != default)
+				Assert.Equal(JobResult.Done, (await Processor.Handle(job, CancellationToken.None)).Result);
+			return result;
+		}
+
+		public async Task<List<JsonObject>> Outgoing(string inbox) =>
+			(await DB.Default.Find<Job>().Match(j => j.Kind == JobKind.Deliver).ExecuteAsync())
+				.Select(j => JsonSerializer.Deserialize<DeliveryPayload>(j.Payload))
+				.Where(p => p.Inbox == inbox)
+				.Select(p => JsonNode.Parse(p.Body)!.AsObject())
+				.ToList();
+
+		public async ValueTask DisposeAsync() => await Peer.DisposeAsync();
+	}
+
+	public sealed class KeyLocalizer<T> : IStringLocalizer<T>
+	{
+		public LocalizedString this[string name] => new(name, name);
+		public LocalizedString this[string name, params object[] arguments] => new(name, string.Format(name, arguments));
+		public IEnumerable<LocalizedString> GetAllStrings(bool includeParentCultures) => Enumerable.Empty<LocalizedString>();
+	}
+}

PrivaPub.Tests/Support/RemoteActor.cs

@@ -24,6 +24,7 @@ namespace PrivaPub.Tests.Support
 		public string Name { get; }
 		public string Id { get; }
 		public string KeyId => Id + "#main-key";
+		public string SharedInbox => Id.Split("/users/")[0] + "/inbox";
 
 		public JsonObject Document() => new()
 		{

PrivaPub/Controllers/ClientToServer/PostController.cs

@@ -32,6 +32,10 @@ namespace PrivaPub.Controllers.ClientToServer
 		public async Task<IActionResult> Insert(InsertPostForm form, CancellationToken token) =>
 			!ModelState.IsValid ? Invalid() : Answer(await _postsService.InsertPost(User.GetUserId(), form, token));
 
+		[HttpPost, Route("/clientapi/post/update")]
+		public async Task<IActionResult> Update(UpdatePostForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _postsService.UpdatePost(User.GetUserId(), form, token));
+
 		[HttpPost, Route("/clientapi/post/delete")]
 		public async Task<IActionResult> Delete(DeletePostForm form, CancellationToken token) =>
 			!ModelState.IsValid ? Invalid() : Answer(await _postsService.DeletePost(User.GetUserId(), form, token));

PrivaPub/Controllers/ClientToServer/SocialController.cs

@@ -0,0 +1,43 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Localization;
+
+using PrivaPub.ClientModels;
+using PrivaPub.ClientModels.Social;
+using PrivaPub.Domain.Social;
+using PrivaPub.Extensions;
+using PrivaPub.Resources;
+
+namespace PrivaPub.Controllers.ClientToServer
+{
+	[ApiController,
+		Route("clientapi/social"),
+		Authorize(Policy = Policies.IsUser)]
+	public class SocialController : ControllerBase
+	{
+		readonly IFollowService _follows;
+		readonly IStringLocalizer _localizer;
+
+		public SocialController(IFollowService follows, IStringLocalizer<GenericRes> localizer)
+		{
+			_follows = follows;
+			_localizer = localizer;
+		}
+
+		[HttpPost, Route("/clientapi/follow")]
+		public async Task<IActionResult> Follow(FollowForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _follows.Follow(User.GetUserId(), form, token));
+
+		[HttpPost, Route("/clientapi/unfollow")]
+		public async Task<IActionResult> Unfollow(FollowForm form, CancellationToken token) =>
+			!ModelState.IsValid ? Invalid() : Answer(await _follows.Unfollow(User.GetUserId(), form, token));
+
+		[HttpGet, Route("/clientapi/following")]
+		public async Task<IActionResult> Following([FromQuery] string avatarId, CancellationToken token) =>
+			Answer(await _follows.Followings(User.GetUserId(), avatarId, token));
+
+		IActionResult Invalid() => BadRequest(new WebResult().Invalidate(_localizer["Invalid model."]));
+
+		IActionResult Answer(WebResult result) => result.IsValid ? Ok(result.Data) : StatusCode(result.StatusCode, result);
+	}
+}

PrivaPub/Controllers/ClientToServer/TimelineController.cs

@@ -0,0 +1,38 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+using PrivaPub.ClientModels;
+using PrivaPub.Domain.Timelines;
+using PrivaPub.Extensions;
+
+namespace PrivaPub.Controllers.ClientToServer
+{
+	[ApiController,
+		Route("clientapi/timeline"),
+		Authorize(Policy = Policies.IsUser)]
+	public class TimelineController : ControllerBase
+	{
+		readonly ITimelineService _timelines;
+
+		public TimelineController(ITimelineService timelines)
+		{
+			_timelines = timelines;
+		}
+
+		[HttpGet, Route("/clientapi/timeline/home")]
+		public async Task<IActionResult> Home([FromQuery] string avatarId, [FromQuery(Name = "max_id")] string maxId, [FromQuery] int limit = 20,
+			CancellationToken token = default) =>
+			Answer(await _timelines.Home(User.GetUserId(), avatarId, maxId, limit, token));
+
+		[HttpGet, Route("/clientapi/notifications")]
+		public async Task<IActionResult> Notifications([FromQuery] string avatarId, [FromQuery(Name = "max_id")] string maxId, [FromQuery] int limit = 20,
+			CancellationToken token = default) =>
+			Answer(await _timelines.Notifications(User.GetUserId(), avatarId, maxId, limit, token));
+
+		[HttpPost, Route("/clientapi/notifications/read")]
+		public async Task<IActionResult> Read([FromQuery] string avatarId, CancellationToken token) =>
+			Answer(await _timelines.MarkNotificationsRead(User.GetUserId(), avatarId, token));
+
+		IActionResult Answer(WebResult result) => result.IsValid ? Ok(result.Data) : StatusCode(result.StatusCode, result);
+	}
+}

PrivaPub/Domain/Social/FollowService.cs

@@ -0,0 +1,235 @@
+using Microsoft.Extensions.Localization;
+
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.ClientModels;
+using PrivaPub.ClientModels.Social;
+using PrivaPub.Federation.Actors;
+using PrivaPub.Federation.Outbox;
+using PrivaPub.Federation.Rendering;
+using PrivaPub.Models.Federation;
+using PrivaPub.Models.Group;
+using PrivaPub.Models.Social;
+using PrivaPub.Models.User;
+using PrivaPub.Resources;
+using PrivaPub.StaticServices;
+
+using System.Text.Json.Nodes;
+
+using GroupEntity = PrivaPub.Models.Group.Group;
+
+namespace PrivaPub.Domain.Social
+{
+	public interface IFollowService
+	{
+		Task<WebResult> Follow(string rootUserId, FollowForm form, CancellationToken token);
+		Task<WebResult> Unfollow(string rootUserId, FollowForm form, CancellationToken token);
+		Task<WebResult> Followings(string rootUserId, string avatarId, CancellationToken token);
+	}
+
+	public class FollowService : IFollowService
+	{
+		readonly DbEntities _dbEntities;
+		readonly ILocalActorService _localActors;
+		readonly IRemoteActorService _remoteActors;
+		readonly IDeliveryService _delivery;
+		readonly IStringLocalizer<GenericRes> _localizer;
+		readonly ILogger<FollowService> _logger;
+
+		public FollowService(DbEntities dbEntities, ILocalActorService localActors, IRemoteActorService remoteActors, IDeliveryService delivery,
+			IStringLocalizer<GenericRes> localizer, ILogger<FollowService> logger)
+		{
+			_dbEntities = dbEntities;
+			_localActors = localActors;
+			_remoteActors = remoteActors;
+			_delivery = delivery;
+			_localizer = localizer;
+			_logger = logger;
+		}
+
+		public async Task<WebResult> Follow(string rootUserId, FollowForm form, CancellationToken token)
+		{
+			var result = new WebResult();
+			try
+			{
+				var follower = await OwnedAvatar(rootUserId, form.AvatarId, token);
+				if (follower == default)
+					return result.Invalidate(_localizer["Avatar not found."], StatusCodes.Status404NotFound);
+
+				var (local, remote) = await ResolveTarget(form.Target, token);
+				if (local == default && remote == default)
+					return result.Invalidate(_localizer["Account not found."], StatusCodes.Status404NotFound);
+				if (local != default && (local.Id == follower.Id || !local.IsFederated || local.Kind == LocalActorKind.Application))
+					return result.Invalidate(_localizer["Account not found."], StatusCodes.Status404NotFound);
+
+				var targetUri = local?.Uri ?? remote.ActorURI;
+				var existing = await _dbEntities.Followings.Match(f => f.AvatarId == follower.Id && f.TargetActorURI == targetUri).ExecuteFirstAsync(token);
+				if (existing != default)
+				{
+					result.Data = ToView(existing);
+					return result;
+				}
+
+				var following = new Following
+				{
+					AvatarId = follower.Id,
+					TargetActorURI = targetUri,
+					TargetAccountId = local?.Id ?? remote.ID,
+					TargetIsLocal = local != default,
+					TargetInboxURL = local?.Inbox ?? remote.InboxURL,
+					State = local is { ManuallyApprovesFollowers: false } ? FollowState.Accepted : FollowState.Requested
+				};
+				following.ID = (string)following.GenerateNewID();
+				following.FollowActivityURI = follower.ActivityUri($"follow-{following.ID}");
+				try
+				{
+					await DB.Default.SaveAsync(following, token);
+				}
+				catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
+				{
+					result.Data = ToView(await _dbEntities.Followings.Match(f => f.AvatarId == follower.Id && f.TargetActorURI == targetUri).ExecuteFirstAsync(token));
+					return result;
+				}
+
+				if (local != default)
+					await FollowLocally(follower, local, following, token);
+				else
+					await _delivery.Enqueue(follower, new[] { remote.InboxURL }, FollowActivity(follower, following), token);
+
+				result.Data = ToView(following);
+				return result;
+			}
+			catch (Exception ex)
+			{
+				_logger.LogError(ex, $"{nameof(FollowService)}.{nameof(Follow)}");
+				return result.Invalidate(_localizer["Something went wrong."], exception: ex);
+			}
+		}
+
+		public async Task<WebResult> Unfollow(string rootUserId, FollowForm form, CancellationToken token)
+		{
+			var result = new WebResult();
+			try
+			{
+				var follower = await OwnedAvatar(rootUserId, form.AvatarId, token);
+				if (follower == default)
+					return result.Invalidate(_localizer["Avatar not found."], StatusCodes.Status404NotFound);
+
+				var (local, remote) = await ResolveTarget(form.Target, token);
+				var targetUri = local?.Uri ?? remote?.ActorURI ?? form.Target;
+				var following = await _dbEntities.Followings.Match(f => f.AvatarId == follower.Id && f.TargetActorURI == targetUri).ExecuteFirstAsync(token);
+				if (following == default)
+					return result;
+
+				await DB.Default.DeleteAsync<Following>(following.ID);
+				if (following.TargetIsLocal)
+				{
+					await DB.Default.DeleteAsync<Follower>(f => f.LocalActorId == following.TargetAccountId && f.ActorURI == follower.Uri);
+					await DB.Default.Update<GroupEntity>().MatchID(following.TargetAccountId)
+						.Modify(b => b.PullFilter(g => g.Members, m => !m.IsForeign && m.AvatarId == follower.Id && m.Role == GroupRole.Member))
+						.ExecuteAsync(token);
+				}
+				else
+				{
+					var undo = new JsonObject
+					{
+						["@context"] = ActivityPubRenderer.ActivityStreams,
+						["id"] = follower.ActivityUri($"undo-follow-{following.ID}"),
+						["type"] = "Undo",
+						["actor"] = follower.Uri,
+						["object"] = FollowActivity(follower, following)
+					};
+					await _delivery.Enqueue(follower, new[] { following.TargetInboxURL }, undo, token);
+				}
+				return result;
+			}
+			catch (Exception ex)
+			{
+				_logger.LogError(ex, $"{nameof(FollowService)}.{nameof(Unfollow)}");
+				return result.Invalidate(_localizer["Something went wrong."], exception: ex);
+			}
+		}
+
+		public async Task<WebResult> Followings(string rootUserId, string avatarId, CancellationToken token)
+		{
+			var result = new WebResult();
+			var follower = await OwnedAvatar(rootUserId, avatarId, token);
+			if (follower == default)
+				return result.Invalidate(_localizer["Avatar not found."], StatusCodes.Status404NotFound);
+			result.Data = (await _dbEntities.Followings.Match(f => f.AvatarId == follower.Id).Sort(f => f.ID, Order.Descending).ExecuteAsync(token))
+				.Select(ToView).ToList();
+			return result;
+		}
+
+		async Task FollowLocally(LocalActor follower, LocalActor target, Following following, CancellationToken token)
+		{
+			await DB.Default.Update<Follower>()
+				.Match(f => f.LocalActorId == target.Id && f.LocalActorKind == target.Kind && f.ActorURI == follower.Uri)
+				.Modify(f => f.InboxURL, follower.Inbox)
+				.Modify(f => f.SharedInboxURL, follower.SharedInbox)
+				.Modify(f => f.FollowActivityURI, following.FollowActivityURI)
+				.Modify(f => f.IsAccepted, following.State == FollowState.Accepted)
+				.Modify(b => b.SetOnInsert(f => f.CreationDate, DateTime.UtcNow))
+				.Option(o => o.IsUpsert = true)
+				.ExecuteAsync(token);
+
+			if (target.Kind == LocalActorKind.Group && following.State == FollowState.Accepted)
+				await DB.Default.Update<GroupEntity>()
+					.Match(g => g.ID == target.Id && !g.Members.Any(m => !m.IsForeign && m.AvatarId == follower.Id))
+					.Modify(b => b.Push(g => g.Members, new GroupMember { AvatarId = follower.Id }))
+					.ExecuteAsync(token);
+			if (target.Kind == LocalActorKind.Person)
+				await Notifications.Add(target.Id, following.State == FollowState.Accepted ? NotificationType.Follow : NotificationType.FollowRequest,
+					follower.Id, follower.Uri, default, token);
+		}
+
+		async Task<(LocalActor Local, ForeignAvatar Remote)> ResolveTarget(string target, CancellationToken token)
+		{
+			target = target?.Trim();
+			if (string.IsNullOrEmpty(target))
+				return default;
+			if (target.StartsWith("https://", StringComparison.OrdinalIgnoreCase) || target.StartsWith("http://", StringComparison.OrdinalIgnoreCase))
+			{
+				var byUri = await _localActors.FindByUri(target, token);
+				return byUri != default ? (byUri, default) : (default, await _remoteActors.GetActor(target, refresh: false, token));
+			}
+
+			var parts = target.TrimStart('@').Split('@');
+			var localDomain = new Uri(_localActors.BaseAddress).Authority;
+			if (parts.Length == 1 || parts[1].Equals(localDomain, StringComparison.OrdinalIgnoreCase))
+				return (await _localActors.FindByUserName(parts[0], token), default);
+
+			var actorUri = await _remoteActors.ResolveHandle($"{parts[0]}@{parts[1]}", token);
+			return (default, actorUri == default ? default : await _remoteActors.GetActor(actorUri, refresh: false, token));
+		}
+
+		static JsonObject FollowActivity(LocalActor follower, Following following) => new()
+		{
+			["@context"] = ActivityPubRenderer.ActivityStreams,
+			["id"] = following.FollowActivityURI,
+			["type"] = "Follow",
+			["actor"] = follower.Uri,
+			["object"] = following.TargetActorURI
+		};
+
+		async Task<LocalActor> OwnedAvatar(string rootUserId, string avatarId, CancellationToken token)
+		{
+			if (string.IsNullOrEmpty(rootUserId) || string.IsNullOrEmpty(avatarId))
+				return default;
+			if (!await _dbEntities.RootToAvatars.Match(ra => ra.RootId == rootUserId && ra.AvatarId == avatarId).ExecuteAnyAsync(token))
+				return default;
+			return await _localActors.FindById(LocalActorKind.Person, avatarId, token);
+		}
+
+		static ViewFollowing ToView(Following following) => new()
+		{
+			Id = following.ID,
+			TargetActorURI = following.TargetActorURI,
+			TargetAccountId = following.TargetAccountId,
+			TargetIsLocal = following.TargetIsLocal,
+			State = following.State.ToString(),
+			CreatedAt = following.CreatedAt
+		};
+	}
+}

PrivaPub/Domain/Social/Notifications.cs

@@ -0,0 +1,32 @@
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Models.Social;
+
+namespace PrivaPub.Domain.Social
+{
+	public static class Notifications
+	{
+		public static async Task Add(string avatarId, NotificationType type, string fromAccountId, string fromActorUri, string postId,
+			CancellationToken token)
+		{
+			if (string.IsNullOrEmpty(avatarId) || avatarId == fromAccountId)
+				return;
+			try
+			{
+				await DB.Default.SaveAsync(new Notification
+				{
+					AvatarId = avatarId,
+					Type = type,
+					FromAccountId = fromAccountId,
+					FromActorURI = fromActorUri,
+					PostId = postId,
+					DedupeKey = $"{type}|{avatarId}|{fromActorUri}|{postId}"
+				}, token);
+			}
+			catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
+			{
+			}
+		}
+	}
+}

PrivaPub/Domain/Timelines/Fanout.cs

@@ -0,0 +1,93 @@
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Domain.Social;
+using PrivaPub.Models.Group;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
+using PrivaPub.StaticServices;
+
+using GroupEntity = PrivaPub.Models.Group.Group;
+
+namespace PrivaPub.Domain.Timelines
+{
+	public interface IFanout
+	{
+		Task Distribute(Post post, CancellationToken token);
+	}
+
+	public class Fanout : IFanout
+	{
+		readonly DbEntities _dbEntities;
+
+		public Fanout(DbEntities dbEntities)
+		{
+			_dbEntities = dbEntities;
+		}
+
+		public async Task Distribute(Post post, CancellationToken token)
+		{
+			var recipients = new HashSet<string>(StringComparer.Ordinal);
+			if (!post.IsFederatedCopy && !string.IsNullOrEmpty(post.GroupUserId))
+				recipients.Add(post.GroupUserId);
+
+			switch (post.Visibility)
+			{
+				case PostVisibility.Public or PostVisibility.Unlisted or PostVisibility.FollowersOnly:
+					var followers = post.IsFederatedCopy
+						? await _dbEntities.Followings.Match(f => f.TargetActorURI == post.ActorURI && f.State == FollowState.Accepted).ExecuteAsync(token)
+						: await _dbEntities.Followings.Match(f => f.TargetAccountId == post.GroupUserId && f.TargetIsLocal && f.State == FollowState.Accepted).ExecuteAsync(token);
+					foreach (var following in followers)
+						if (await Shows(following, post, token))
+							recipients.Add(following.AvatarId);
+					break;
+				case PostVisibility.Direct when !string.IsNullOrEmpty(post.ConversationId):
+					var conversation = await _dbEntities.DmGroups.MatchID(post.ConversationId).ExecuteFirstAsync(token);
+					foreach (var member in conversation?.Members.Where(m => !m.IsForeign) ?? Enumerable.Empty<GroupMember>())
+						recipients.Add(member.AvatarId);
+					break;
+				case PostVisibility.Circle when !string.IsNullOrEmpty(post.GroupId):
+					var circle = await DB.Default.Find<GroupEntity>().MatchID(post.GroupId).ExecuteFirstAsync(token);
+					foreach (var member in circle?.Members.Where(m => !m.IsForeign) ?? Enumerable.Empty<GroupMember>())
+						recipients.Add(member.AvatarId);
+					break;
+			}
+
+			foreach (var avatarId in recipients)
+			{
+				try
+				{
+					await DB.Default.SaveAsync(new TimelineEntry
+					{
+						AvatarId = avatarId,
+						PostId = post.ID,
+						AuthorAccountId = post.AuthorAccountId ?? post.GroupUserId,
+						ReblogOfPostId = post.ReblogOfPostId
+					}, token);
+				}
+				catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
+				{
+				}
+			}
+
+			if (string.IsNullOrEmpty(post.ReblogOfPostId))
+				foreach (var mention in post.Mentions.Where(m => m.IsLocal && !string.IsNullOrEmpty(m.AccountId)))
+					await Notifications.Add(mention.AccountId, NotificationType.Mention, post.AuthorAccountId ?? post.GroupUserId, post.ActorURI, post.ID, token);
+		}
+
+		async Task<bool> Shows(Following following, Post post, CancellationToken token)
+		{
+			if (!string.IsNullOrEmpty(post.ReblogOfPostId))
+				return following.ShowReblogs;
+			var repliedTo = post.InReplyToAccountId;
+			var author = post.AuthorAccountId ?? post.GroupUserId;
+			if (string.IsNullOrEmpty(post.InReplyToURI) || repliedTo == author || repliedTo == following.AvatarId)
+				return true;
+			if (string.IsNullOrEmpty(repliedTo))
+				return false;
+			return await _dbEntities.Followings
+				.Match(f => f.AvatarId == following.AvatarId && f.TargetAccountId == repliedTo && f.State == FollowState.Accepted)
+				.ExecuteAnyAsync(token);
+		}
+	}
+}

PrivaPub/Domain/Timelines/TimelineService.cs

@@ -0,0 +1,119 @@
+using Microsoft.Extensions.Localization;
+
+using MongoDB.Entities;
+
+using PrivaPub.ClientModels;
+using PrivaPub.ClientModels.Post;
+using PrivaPub.ClientModels.Social;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
+using PrivaPub.Resources;
+using PrivaPub.StaticServices;
+
+namespace PrivaPub.Domain.Timelines
+{
+	public interface ITimelineService
+	{
+		Task<WebResult> Home(string rootUserId, string avatarId, string maxId, int limit, CancellationToken token);
+		Task<WebResult> Notifications(string rootUserId, string avatarId, string maxId, int limit, CancellationToken token);
+		Task<WebResult> MarkNotificationsRead(string rootUserId, string avatarId, CancellationToken token);
+	}
+
+	public class TimelineService : ITimelineService
+	{
+		const int MaxLimit = 40;
+
+		readonly DbEntities _dbEntities;
+		readonly IStringLocalizer<GenericRes> _localizer;
+
+		public TimelineService(DbEntities dbEntities, IStringLocalizer<GenericRes> localizer)
+		{
+			_dbEntities = dbEntities;
+			_localizer = localizer;
+		}
+
+		public async Task<WebResult> Home(string rootUserId, string avatarId, string maxId, int limit, CancellationToken token)
+		{
+			var result = new WebResult();
+			if (!await Owns(rootUserId, avatarId, token))
+				return result.Invalidate(_localizer["Avatar not found."], StatusCodes.Status404NotFound);
+
+			var query = _dbEntities.TimelineEntries.Match(e => e.AvatarId == avatarId);
+			if (!string.IsNullOrEmpty(maxId))
+				query.Match(f => f.Lt(e => e.PostId, maxId));
+			var entries = await query.Sort(e => e.PostId, Order.Descending).Limit(Math.Clamp(limit, 1, MaxLimit)).ExecuteAsync(token);
+
+			var ids = entries.Select(e => e.PostId).Concat(entries.Where(e => e.ReblogOfPostId != default).Select(e => e.ReblogOfPostId)).Distinct().ToList();
+			var posts = ids.Count == 0
+				? new Dictionary<string, Post>()
+				: (await _dbEntities.Posts.Match(p => ids.Contains(p.ID) && !p.DeletedAt.HasValue).ExecuteAsync(token)).ToDictionary(p => p.ID);
+
+			result.Data = entries
+				.Where(e => posts.ContainsKey(e.PostId) && (e.ReblogOfPostId == default || posts.ContainsKey(e.ReblogOfPostId)))
+				.Select(e =>
+				{
+					var view = ToView(posts[e.PostId]);
+					if (e.ReblogOfPostId != default)
+						view.ReblogOf = ToView(posts[e.ReblogOfPostId]);
+					return view;
+				})
+				.ToList();
+			return result;
+		}
+
+		public async Task<WebResult> Notifications(string rootUserId, string avatarId, string maxId, int limit, CancellationToken token)
+		{
+			var result = new WebResult();
+			if (!await Owns(rootUserId, avatarId, token))
+				return result.Invalidate(_localizer["Avatar not found."], StatusCodes.Status404NotFound);
+
+			var query = _dbEntities.Notifications.Match(n => n.AvatarId == avatarId);
+			if (!string.IsNullOrEmpty(maxId))
+				query.Match(f => f.Lt(n => n.ID, maxId));
+			result.Data = (await query.Sort(n => n.ID, Order.Descending).Limit(Math.Clamp(limit, 1, MaxLimit)).ExecuteAsync(token))
+				.Select(n => new ViewNotification
+				{
+					Id = n.ID,
+					Type = n.Type.ToString(),
+					FromAccountId = n.FromAccountId,
+					FromActorURI = n.FromActorURI,
+					PostId = n.PostId,
+					IsRead = n.IsRead,
+					CreatedAt = n.CreatedAt
+				})
+				.ToList();
+			return result;
+		}
+
+		public async Task<WebResult> MarkNotificationsRead(string rootUserId, string avatarId, CancellationToken token)
+		{
+			var result = new WebResult();
+			if (!await Owns(rootUserId, avatarId, token))
+				return result.Invalidate(_localizer["Avatar not found."], StatusCodes.Status404NotFound);
+			await DB.Default.Update<Notification>().Match(n => n.AvatarId == avatarId && !n.IsRead).Modify(n => n.IsRead, true).ExecuteAsync(token);
+			return result;
+		}
+
+		async Task<bool> Owns(string rootUserId, string avatarId, CancellationToken token) =>
+			!string.IsNullOrEmpty(rootUserId) && !string.IsNullOrEmpty(avatarId)
+			&& await _dbEntities.RootToAvatars.Match(ra => ra.RootId == rootUserId && ra.AvatarId == avatarId).ExecuteAnyAsync(token);
+
+		static ViewPost ToView(Post post) => new()
+		{
+			Id = post.ID,
+			ObjectURI = post.ObjectURI,
+			AuthorAvatarId = post.IsFederatedCopy ? default : post.GroupUserId,
+			AuthorActorURI = post.ActorURI,
+			GroupId = post.GroupId,
+			DmGroupId = post.ConversationId,
+			Visibility = post.Visibility.ToString(),
+			AnsweringToPostId = post.AnsweringToPostId,
+			Title = post.Title,
+			Text = post.Text,
+			ContentHtml = post.ContentHtml,
+			HasContentWarning = post.HasContentWarning,
+			IsFederatedCopy = post.IsFederatedCopy,
+			CreationDate = post.CreationDate
+		};
+	}
+}

PrivaPub/Federation/Controllers/PeasantsController.cs

@@ -111,7 +111,7 @@ namespace PrivaPub.Federation.Controllers
 		{
 			var (local, post) = await PublicPost(actor, postId, token);
 			if (post == default)
-				return NotFound();
+				return await Tombstone(actor, postId, token) ?? NotFound();
 			if (WantsHtml())
 				return Redirect(local.PostHtmlUrl(post.ID));
 
@@ -159,6 +159,28 @@ namespace PrivaPub.Federation.Controllers
 			return (local, post);
 		}
 
+		async Task<IActionResult> Tombstone(string actor, string postId, CancellationToken token)
+		{
+			var local = await _localActors.FindByUserName(actor, token);
+			if (local is not { IsFederated: true, Kind: LocalActorKind.Person })
+				return default;
+			var deleted = await _dbEntities.Posts
+				.Match(p => p.ID == postId && p.GroupUserId == local.Id && !p.IsFederatedCopy && p.DeletedAt.HasValue
+					&& (p.Visibility == PostVisibility.Public || p.Visibility == PostVisibility.Unlisted))
+				.ExecuteFirstAsync(token);
+			if (deleted == default)
+				return default;
+			var tombstone = new JsonObject
+			{
+				["@context"] = ActivityPubRenderer.ActivityStreams,
+				["id"] = local.PostUri(deleted.ID),
+				["type"] = "Tombstone",
+				["formerType"] = "Note",
+				["deleted"] = ActivityPubRenderer.Timestamp(deleted.DeletedAt.Value)
+			};
+			return new ContentResult { Content = tombstone.ToJsonString(), ContentType = ActivityContentType, StatusCode = StatusCodes.Status410Gone };
+		}
+
 		async Task<JsonObject> CreateFor(PostEntity post, LocalActor author, CancellationToken token)
 		{
 			var group = string.IsNullOrEmpty(post.GroupId) ? default : await _localActors.FindById(LocalActorKind.Group, post.GroupId, token);

PrivaPub/Federation/Inbox/Handlers/AcceptHandler.cs

@@ -0,0 +1,67 @@
+using MongoDB.Entities;
+
+using PrivaPub.Federation.Actors;
+using PrivaPub.Models.Social;
+using PrivaPub.Models.User;
+using PrivaPub.StaticServices;
+
+using System.Text.Json.Nodes;
+
+using static PrivaPub.Federation.Objects.ActivityJson;
+
+namespace PrivaPub.Federation.Inbox.Handlers
+{
+	public class AcceptHandler : IActivityHandler
+	{
+		readonly DbEntities _dbEntities;
+		readonly ILocalActorService _localActors;
+
+		public AcceptHandler(DbEntities dbEntities, ILocalActorService localActors)
+		{
+			_dbEntities = dbEntities;
+			_localActors = localActors;
+		}
+
+		public virtual string Type => "Accept";
+
+		public async Task Handle(JsonNode activity, ForeignAvatar actor, CancellationToken token)
+		{
+			var following = await FindFollowing(activity["object"], actor, _dbEntities, _localActors, token);
+			if (following == default)
+				return;
+			await Apply(following, token);
+		}
+
+		protected virtual Task Apply(Following following, CancellationToken token) =>
+			DB.Default.Update<Following>().MatchID(following.ID).Modify(f => f.State, FollowState.Accepted).ExecuteAsync(token);
+
+		public static async Task<Following> FindFollowing(JsonNode follow, ForeignAvatar target, DbEntities dbEntities, ILocalActorService localActors,
+			CancellationToken token)
+		{
+			if (follow is JsonObject && Value(follow, "type") is { } type && type != "Follow")
+				return default;
+			var followId = Id(follow);
+			var byId = followId == default
+				? default
+				: await dbEntities.Followings.Match(f => f.FollowActivityURI == followId && f.TargetActorURI == target.ActorURI).ExecuteFirstAsync(token);
+			if (byId != default || follow is not JsonObject)
+				return byId;
+
+			var follower = await localActors.FindByUri(Id(follow["actor"]), token);
+			return follower == default
+				? default
+				: await dbEntities.Followings.Match(f => f.AvatarId == follower.Id && f.TargetActorURI == target.ActorURI).ExecuteFirstAsync(token);
+		}
+	}
+
+	public class RejectHandler : AcceptHandler
+	{
+		public RejectHandler(DbEntities dbEntities, ILocalActorService localActors) : base(dbEntities, localActors)
+		{
+		}
+
+		public override string Type => "Reject";
+
+		protected override Task Apply(Following following, CancellationToken token) => DB.Default.DeleteAsync<Following>(following.ID);
+	}
+}

PrivaPub/Federation/Inbox/Handlers/AnnounceHandler.cs

@@ -0,0 +1,106 @@
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Domain.Social;
+using PrivaPub.Domain.Timelines;
+using PrivaPub.Federation.Actors;
+using PrivaPub.Federation.Objects;
+using PrivaPub.Infrastructure.Ids;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
+using PrivaPub.Models.User;
+using PrivaPub.StaticServices;
+
+using System.Globalization;
+using System.Text.Json.Nodes;
+
+using static PrivaPub.Federation.Objects.ActivityJson;
+
+using PostEntity = PrivaPub.Models.Post.Post;
+
+namespace PrivaPub.Federation.Inbox.Handlers
+{
+	public class AnnounceHandler : IActivityHandler
+	{
+		readonly DbEntities _dbEntities;
+		readonly ILocalActorService _localActors;
+		readonly IRemotePosts _remotePosts;
+		readonly IFanout _fanout;
+
+		public AnnounceHandler(DbEntities dbEntities, ILocalActorService localActors, IRemotePosts remotePosts, IFanout fanout)
+		{
+			_dbEntities = dbEntities;
+			_localActors = localActors;
+			_remotePosts = remotePosts;
+			_fanout = fanout;
+		}
+
+		public string Type => "Announce";
+
+		public async Task Handle(JsonNode activity, ForeignAvatar actor, CancellationToken token)
+		{
+			var inner = activity["object"];
+			if (inner is JsonObject && Value(inner, "type") is "Create" or "Update" or "Delete" or "Like" or "Dislike" or "Undo" or "Add" or "Remove" or "Block")
+				return;
+			var objectUri = Id(inner);
+			var announceId = Id(activity);
+			if (objectUri == default || announceId == default)
+				return;
+			if (await _dbEntities.Posts.Match(p => p.ObjectURI == announceId).ExecuteAnyAsync(token))
+				return;
+
+			var isLocal = objectUri.StartsWith(_localActors.BaseAddress + "/", StringComparison.OrdinalIgnoreCase);
+			var original = await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri && !p.DeletedAt.HasValue && p.ReblogOfPostId == null).ExecuteFirstAsync(token);
+			var followed = await _dbEntities.Followings.Match(f => f.TargetActorURI == actor.ActorURI && f.State == FollowState.Accepted).ExecuteAnyAsync(token);
+			if (original is not { IsFederatedCopy: false } && !followed)
+				return;
+			if (original == default && !isLocal)
+				original = await _remotePosts.StoreContext(objectUri, 0, token);
+			if (original == default || original.Visibility is not (PostVisibility.Public or PostVisibility.Unlisted))
+				return;
+
+			var to = Strings(activity["to"]);
+			var cc = Strings(activity["cc"]);
+			var published = DateTimeOffset.TryParse(Value(activity, "published"), CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out var at)
+				? at.UtcDateTime
+				: DateTime.UtcNow;
+			var reblog = new PostEntity
+			{
+				ID = PrivacyIds.At(published),
+				ObjectURI = announceId,
+				ActivityURI = announceId,
+				ActorURI = actor.ActorURI,
+				AuthorAccountId = actor.ID,
+				ReblogOfPostId = original.ID,
+				Visibility = Addressing.Classify(to, cc, actor.FollowersURL),
+				To = to,
+				Cc = cc,
+				IsFederatedCopy = true,
+				CreationDate = published,
+				UpdateDate = published
+			};
+			if (reblog.Visibility == PostVisibility.Direct)
+				return;
+			try
+			{
+				await DB.Default.SaveAsync(reblog, token);
+			}
+			catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
+			{
+				return;
+			}
+
+			await DB.Default.Update<PostEntity>().MatchID(original.ID).Modify(b => b.Inc(p => p.ReblogsCount, 1)).ExecuteAsync(token);
+			if (!original.IsFederatedCopy)
+				await Notifications.Add(original.GroupUserId, NotificationType.Reblog, actor.ID, actor.ActorURI, original.ID, token);
+			await _fanout.Distribute(reblog, token);
+		}
+
+		static List<string> Strings(JsonNode node) => node switch
+		{
+			JsonArray array => array.Select(Id).Where(id => id != default).ToList(),
+			JsonNode single when Id(single) is { } id => new List<string> { id },
+			_ => new List<string>()
+		};
+	}
+}

PrivaPub/Federation/Inbox/Handlers/CreateHandler.cs

@@ -1,6 +1,7 @@
 using MongoDB.Driver;
 using MongoDB.Entities;
 
+using PrivaPub.Domain.Timelines;
 using PrivaPub.Federation.Actors;
 using PrivaPub.Federation.Moderation;
 using PrivaPub.Federation.Objects;
@@ -10,6 +11,7 @@ using PrivaPub.Federation.Rendering;
 using PrivaPub.Models.Federation;
 using PrivaPub.Models.Group;
 using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
 using PrivaPub.Models.User;
 using PrivaPub.StaticServices;
 
@@ -29,10 +31,14 @@ namespace PrivaPub.Federation.Inbox.Handlers
 		readonly IRemoteActorService _remoteActors;
 		readonly IDeliveryService _delivery;
 		readonly IDomainBlocks _domainBlocks;
+		readonly IFanout _fanout;
+		readonly IRemotePosts _remotePosts;
 
 		public CreateHandler(DbEntities dbEntities, ILocalActorService localActors, IRemoteActorService remoteActors, IDeliveryService delivery,
-			IDomainBlocks domainBlocks)
+			IDomainBlocks domainBlocks, IFanout fanout, IRemotePosts remotePosts)
 		{
+			_fanout = fanout;
+			_remotePosts = remotePosts;
 			_dbEntities = dbEntities;
 			_localActors = localActors;
 			_remoteActors = remoteActors;
@@ -86,21 +92,13 @@ namespace PrivaPub.Federation.Inbox.Handlers
 				group = default;
 
 			var repliesToLocal = parent is { IsFederatedCopy: false } && visibility != PostVisibility.Direct;
-			if (visibility == PostVisibility.Direct ? persons.Count == 0 : group == default && persons.Count == 0 && !repliesToLocal)
+			var followed = visibility != PostVisibility.Direct && await _dbEntities.Followings
+				.Match(f => f.TargetActorURI == author.ActorURI && f.State == FollowState.Accepted)
+				.ExecuteAnyAsync(token);
+			if (visibility == PostVisibility.Direct ? persons.Count == 0 : group == default && persons.Count == 0 && !repliesToLocal && !followed)
 				return;
-
+			if (parent == default && visibility != PostVisibility.Direct)
-			var mentions = new List<PostMention>();
+				parent = await _remotePosts.Parent(note.InReplyTo, 1, token);
-			foreach (var mention in note.Mentions)
-			{
-				var local = await _localActors.FindByUri(mention.ActorURI, token);
-				mentions.Add(new PostMention
-				{
-					ActorURI = mention.ActorURI,
-					Handle = mention.Handle,
-					IsLocal = local != default,
-					AccountId = local?.Id
-				});
-			}
 
 			DmGroup conversation = default;
 			if (visibility == PostVisibility.Direct)
@@ -112,39 +110,10 @@ namespace PrivaPub.Federation.Inbox.Handlers
 				conversation = await FindOrCreateConversation(participants, Origin.Same(note.Context, author.ActorURI) ? note.Context : default, token);
 			}
 
-			var post = new PostEntity
+			var post = await _remotePosts.Build(note, author, visibility, to, cc, parent, token);
-			{
+			post.ActivityURI = Id(activity);
-				ID = PrivacyIds.At(note.Published),
+			post.GroupId = group?.Id;
-				ObjectURI = note.Id,
+			post.ConversationId = conversation?.ID;
-				ActivityURI = Id(activity),
-				ActorURI = author.ActorURI,
-				AuthorAccountId = author.ID,
-				Visibility = visibility,
-				To = to,
-				Cc = cc,
-				Url = note.Url,
-				ContextURI = note.Context,
-				QuoteURI = note.QuoteUri,
-				GroupId = group?.Id,
-				ConversationId = conversation?.ID,
-				Title = note.Title,
-				SpoilerText = note.SpoilerText,
-				HasContentWarning = note.Sensitive,
-				Text = note.ContentHtml,
-				ContentHtml = note.ContentHtml,
-				ContentFormat = ContentFormat.Html,
-				Language = note.Language,
-				Mentions = mentions,
-				Tags = note.Tags.ToList(),
-				Media = _domainBlocks.Find(new Uri(author.ActorURI).Host)?.RejectMedia == true ? new() : note.Attachments.ToList(),
-				InReplyToURI = note.InReplyTo,
-				AnsweringToPostId = parent?.ID,
-				InReplyToAccountId = parent?.AuthorAccountId ?? parent?.GroupUserId,
-				IsFederatedCopy = true,
-				CreationDate = note.Published,
-				UpdateDate = note.Updated ?? note.Published,
-				EditedAt = note.Updated
-			};
 			try
 			{
 				await DB.Default.SaveAsync(post, token);
@@ -156,6 +125,7 @@ namespace PrivaPub.Federation.Inbox.Handlers
 
 			if (parent != default)
 				await DB.Default.Update<PostEntity>().MatchID(parent.ID).Modify(b => b.Inc(p => p.RepliesCount, 1)).ExecuteAsync(token);
+			await _fanout.Distribute(post, token);
 			if (conversation != default)
 				await DB.Default.Update<DmGroup>().MatchID(conversation.ID).Modify(g => g.UpdatedAt, DateTime.UtcNow).ExecuteAsync(token);
 			if (group != default)

PrivaPub/Federation/Inbox/Handlers/DeleteHandler.cs

@@ -7,6 +7,7 @@ using PrivaPub.Federation.Rendering;
 using PrivaPub.Models.Federation;
 using PrivaPub.Models.Group;
 using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
 using PrivaPub.Models.User;
 using PrivaPub.StaticServices;
 
@@ -56,11 +57,19 @@ namespace PrivaPub.Federation.Inbox.Handlers
 					if (follower.LocalActorKind == LocalActorKind.Group)
 						await RemoveForeignMember(follower.LocalActorId, actor.ActorURI, token);
 				}
+				await DB.Default.DeleteAsync<Following>(f => f.TargetActorURI == actor.ActorURI);
+				await DB.Default.DeleteAsync<TimelineEntry>(e => e.AuthorAccountId == actor.ID);
 				return;
 			}
 
-			await DB.Default.DeleteAsync<PostEntity>(p => p.ObjectURI == objectUri && p.ActorURI == actor.ActorURI);
+			var post = await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri && p.ActorURI == actor.ActorURI).ExecuteFirstAsync(token);
-			return;
+			if (post == default)
-				}
+				return;
+			await DB.Default.DeleteAsync<PostEntity>(post.ID);
+			await DB.Default.DeleteAsync<TimelineEntry>(e => e.PostId == post.ID || e.ReblogOfPostId == post.ID);
+			await DB.Default.DeleteAsync<PostEntity>(p => p.ReblogOfPostId == post.ID);
+			if (!string.IsNullOrEmpty(post.AnsweringToPostId))
+				await DB.Default.Update<PostEntity>().MatchID(post.AnsweringToPostId).Modify(b => b.Inc(p => p.RepliesCount, -1)).ExecuteAsync(token);
+		}
 	}
 }

PrivaPub/Federation/Inbox/Handlers/FollowHandler.cs

@@ -1,6 +1,8 @@
 using MongoDB.Entities;
 
+using PrivaPub.Domain.Social;
 using PrivaPub.Federation.Actors;
+using PrivaPub.Models.Social;
 using PrivaPub.Federation.Objects;
 using PrivaPub.Federation.Outbox;
 using PrivaPub.Federation.Rendering;
@@ -60,6 +62,9 @@ namespace PrivaPub.Federation.Inbox.Handlers
 			record.IsAccepted = existing?.IsAccepted == true || !target.ManuallyApprovesFollowers;
 			await DB.Default.SaveAsync(record, token);
 
+			if (target.Kind == LocalActorKind.Person)
+				await Notifications.Add(target.Id, record.IsAccepted ? NotificationType.Follow : NotificationType.FollowRequest,
+					follower.ID, follower.ActorURI, default, token);
 			if (!record.IsAccepted)
 				return;
 

PrivaPub/Federation/Inbox/Handlers/LikeHandler.cs

@@ -0,0 +1,56 @@
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Domain.Social;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
+using PrivaPub.Models.User;
+using PrivaPub.StaticServices;
+
+using System.Text.Json.Nodes;
+
+using static PrivaPub.Federation.Objects.ActivityJson;
+
+using PostEntity = PrivaPub.Models.Post.Post;
+
+namespace PrivaPub.Federation.Inbox.Handlers
+{
+	public class LikeHandler : IActivityHandler
+	{
+		readonly DbEntities _dbEntities;
+
+		public LikeHandler(DbEntities dbEntities)
+		{
+			_dbEntities = dbEntities;
+		}
+
+		public string Type => "Like";
+
+		public async Task Handle(JsonNode activity, ForeignAvatar actor, CancellationToken token)
+		{
+			var objectUri = Id(activity["object"]);
+			var post = objectUri == default
+				? default
+				: await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri && !p.DeletedAt.HasValue && p.ReblogOfPostId == null).ExecuteFirstAsync(token);
+			if (post == default || !MaySee(post, actor))
+				return;
+
+			try
+			{
+				await DB.Default.SaveAsync(new Favourite { AccountId = actor.ID, ActorURI = actor.ActorURI, PostId = post.ID, ActivityURI = Id(activity) }, token);
+			}
+			catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
+			{
+				return;
+			}
+			await DB.Default.Update<PostEntity>().MatchID(post.ID).Modify(b => b.Inc(p => p.FavouritesCount, 1)).ExecuteAsync(token);
+			if (!post.IsFederatedCopy)
+				await Notifications.Add(post.GroupUserId, NotificationType.Favourite, actor.ID, actor.ActorURI, post.ID, token);
+		}
+
+		public static bool MaySee(PostEntity post, ForeignAvatar actor) =>
+			post.Visibility is PostVisibility.Public or PostVisibility.Unlisted
+			|| post.Visibility is PostVisibility.FollowersOnly or PostVisibility.Direct
+				&& (post.To.Contains(actor.ActorURI) || post.Cc.Contains(actor.ActorURI) || post.Mentions.Any(m => m.ActorURI == actor.ActorURI));
+	}
+}

PrivaPub/Federation/Inbox/Handlers/UndoHandler.cs

@@ -1,12 +1,8 @@
 using MongoDB.Entities;
 
 using PrivaPub.Federation.Actors;
-using PrivaPub.Federation.Objects;
-using PrivaPub.Federation.Outbox;
-using PrivaPub.Federation.Rendering;
 using PrivaPub.Models.Federation;
-using PrivaPub.Models.Group;
+using PrivaPub.Models.Social;
-using PrivaPub.Models.Post;
 using PrivaPub.Models.User;
 using PrivaPub.StaticServices;
 
@@ -23,38 +19,37 @@ namespace PrivaPub.Federation.Inbox.Handlers
 	{
 		readonly DbEntities _dbEntities;
 		readonly ILocalActorService _localActors;
-		readonly IRemoteActorService _remoteActors;
-		readonly IDeliveryService _delivery;
 
-		public UndoHandler(DbEntities dbEntities, ILocalActorService localActors, IRemoteActorService remoteActors, IDeliveryService delivery)
+		public UndoHandler(DbEntities dbEntities, ILocalActorService localActors)
 		{
 			_dbEntities = dbEntities;
 			_localActors = localActors;
-			_remoteActors = remoteActors;
-			_delivery = delivery;
 		}
 
 		public string Type => "Undo";
 
 		public async Task Handle(JsonNode activity, ForeignAvatar actor, CancellationToken token)
 		{
-			var undo = activity;
+			var inner = activity["object"];
-
-			var inner = undo["object"];
 			var innerType = inner is JsonObject ? Value(inner, "type") : default;
 			var innerId = Id(inner);
 
-			if (inner is JsonObject && Id(inner["actor"]) != actor.ActorURI)
+			if (innerType is null or "Follow")
-				return;
+				await UndoFollow(inner, innerId, actor, token);
-			if (innerType is not (null or "Follow"))
+			if (innerType is null or "Like")
-				return;
+				await UndoLike(inner, innerId, actor, token);
+			if (innerType is null or "Announce")
+				await UndoAnnounce(innerId, actor, token);
+		}
 
+		async Task UndoFollow(JsonNode inner, string innerId, ForeignAvatar actor, CancellationToken token)
+		{
 			var followers = await _dbEntities.Followers.Match(f => f.ActorURI == actor.ActorURI).ExecuteAsync(token);
 			var targetUri = inner is JsonObject ? Id(inner["object"]) : default;
+			var target = targetUri == default ? default : await _localActors.FindByUri(targetUri, token);
 			foreach (var follower in followers)
 			{
 				var matchesActivity = innerId != default && follower.FollowActivityURI == innerId;
-				var target = targetUri == default ? default : await _localActors.FindByUri(targetUri, token);
 				var matchesTarget = target != default && target.Id == follower.LocalActorId && target.Kind == follower.LocalActorKind;
 				if (!matchesActivity && !matchesTarget)
 					continue;
@@ -63,7 +58,38 @@ namespace PrivaPub.Federation.Inbox.Handlers
 				if (follower.LocalActorKind == LocalActorKind.Group)
 					await RemoveForeignMember(follower.LocalActorId, actor.ActorURI, token);
 			}
-			return;
+		}
-				}
+
+		async Task UndoLike(JsonNode inner, string innerId, ForeignAvatar actor, CancellationToken token)
+		{
+			var favourite = innerId == default
+				? default
+				: await _dbEntities.Favourites.Match(f => f.ActivityURI == innerId && f.ActorURI == actor.ActorURI).ExecuteFirstAsync(token);
+			if (favourite == default && inner is JsonObject && Id(inner["object"]) is { } objectUri)
+			{
+				var post = await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri).ExecuteFirstAsync(token);
+				favourite = post == default
+					? default
+					: await _dbEntities.Favourites.Match(f => f.PostId == post.ID && f.ActorURI == actor.ActorURI).ExecuteFirstAsync(token);
+			}
+			if (favourite == default)
+				return;
+			await DB.Default.DeleteAsync<Favourite>(favourite.ID);
+			await DB.Default.Update<PostEntity>().MatchID(favourite.PostId).Modify(b => b.Inc(p => p.FavouritesCount, -1)).ExecuteAsync(token);
+		}
+
+		async Task UndoAnnounce(string innerId, ForeignAvatar actor, CancellationToken token)
+		{
+			if (innerId == default)
+				return;
+			var reblog = await _dbEntities.Posts
+				.Match(p => p.ObjectURI == innerId && p.ActorURI == actor.ActorURI && p.ReblogOfPostId != null)
+				.ExecuteFirstAsync(token);
+			if (reblog == default)
+				return;
+			await DB.Default.DeleteAsync<PostEntity>(reblog.ID);
+			await DB.Default.DeleteAsync<TimelineEntry>(e => e.PostId == reblog.ID);
+			await DB.Default.Update<PostEntity>().MatchID(reblog.ReblogOfPostId).Modify(b => b.Inc(p => p.ReblogsCount, -1)).ExecuteAsync(token);
+		}
 	}
 }

PrivaPub/Federation/Inbox/RemotePosts.cs

@@ -0,0 +1,173 @@
+using MongoDB.Driver;
+using MongoDB.Entities;
+
+using PrivaPub.Federation.Actors;
+using PrivaPub.Federation.Moderation;
+using PrivaPub.Federation.Objects;
+using PrivaPub.Infrastructure.Ids;
+using PrivaPub.Infrastructure.Jobs;
+using PrivaPub.Models.Jobs;
+using PrivaPub.Models.Post;
+using PrivaPub.Models.User;
+using PrivaPub.StaticServices;
+
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+using PostEntity = PrivaPub.Models.Post.Post;
+
+namespace PrivaPub.Federation.Inbox
+{
+	public sealed record AncestorsPayload(string PostId, int Depth);
+
+	public interface IRemotePosts
+	{
+		Task<PostEntity> Build(NoteDocument note, ForeignAvatar author, PostVisibility visibility, IReadOnlyList<string> to, IReadOnlyList<string> cc,
+			PostEntity parent, CancellationToken token);
+		Task<PostEntity> Parent(string inReplyTo, int depth, CancellationToken token);
+		Task<PostEntity> StoreContext(string objectUri, int depth, CancellationToken token);
+	}
+
+	public class RemotePosts : IRemotePosts
+	{
+		public const int MaxDepth = 10;
+
+		readonly DbEntities _dbEntities;
+		readonly ILocalActorService _localActors;
+		readonly IRemoteActorService _remoteActors;
+		readonly IDomainBlocks _domainBlocks;
+		readonly IJobQueue _queue;
+
+		public RemotePosts(DbEntities dbEntities, ILocalActorService localActors, IRemoteActorService remoteActors, IDomainBlocks domainBlocks,
+			IJobQueue queue)
+		{
+			_dbEntities = dbEntities;
+			_localActors = localActors;
+			_remoteActors = remoteActors;
+			_domainBlocks = domainBlocks;
+			_queue = queue;
+		}
+
+		public async Task<PostEntity> Build(NoteDocument note, ForeignAvatar author, PostVisibility visibility, IReadOnlyList<string> to,
+			IReadOnlyList<string> cc, PostEntity parent, CancellationToken token)
+		{
+			var mentions = new List<PostMention>();
+			foreach (var mention in note.Mentions)
+			{
+				var local = await _localActors.FindByUri(mention.ActorURI, token);
+				mentions.Add(new PostMention { ActorURI = mention.ActorURI, Handle = mention.Handle, IsLocal = local != default, AccountId = local?.Id });
+			}
+
+			return new PostEntity
+			{
+				ID = PrivacyIds.At(note.Published),
+				ObjectURI = note.Id,
+				ActorURI = author.ActorURI,
+				AuthorAccountId = author.ID,
+				Visibility = visibility,
+				To = to.ToList(),
+				Cc = cc.ToList(),
+				Url = note.Url,
+				ContextURI = note.Context,
+				QuoteURI = note.QuoteUri,
+				Title = note.Title,
+				SpoilerText = note.SpoilerText,
+				HasContentWarning = note.Sensitive,
+				Text = note.ContentHtml,
+				ContentHtml = note.ContentHtml,
+				ContentFormat = ContentFormat.Html,
+				Language = note.Language,
+				Mentions = mentions,
+				Tags = note.Tags.ToList(),
+				Media = _domainBlocks.Find(new Uri(author.ActorURI).Host)?.RejectMedia == true ? new() : note.Attachments.ToList(),
+				InReplyToURI = note.InReplyTo,
+				AnsweringToPostId = parent?.ID,
+				InReplyToAccountId = parent?.AuthorAccountId ?? parent?.GroupUserId,
+				IsFederatedCopy = true,
+				CreationDate = note.Published,
+				UpdateDate = note.Updated ?? note.Published,
+				EditedAt = note.Updated
+			};
+		}
+
+		public async Task<PostEntity> Parent(string inReplyTo, int depth, CancellationToken token)
+		{
+			if (string.IsNullOrEmpty(inReplyTo))
+				return default;
+			var known = await _dbEntities.Posts.Match(p => p.ObjectURI == inReplyTo && !p.DeletedAt.HasValue).ExecuteFirstAsync(token);
+			if (known != default || inReplyTo.StartsWith(_localActors.BaseAddress + "/", StringComparison.OrdinalIgnoreCase))
+				return known;
+			return await StoreContext(inReplyTo, depth, token);
+		}
+
+		public async Task<PostEntity> StoreContext(string objectUri, int depth, CancellationToken token)
+		{
+			var existing = await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri).ExecuteFirstAsync(token);
+			if (existing != default || depth > MaxDepth)
+				return existing;
+
+			using var fetched = await _remoteActors.FetchObject(objectUri, token);
+			var note = fetched == default ? default : NoteParser.Parse(JsonNode.Parse(fetched.Root.GetRawText()));
+			if (note == default || !Origin.Same(note.Id, note.AttributedTo))
+				return default;
+			var visibility = Addressing.Classify(note.To, note.Cc, default);
+			if (visibility is not (PostVisibility.Public or PostVisibility.Unlisted))
+				return default;
+			var author = await _remoteActors.GetActor(note.AttributedTo, refresh: false, token);
+			if (author == default)
+				return default;
+
+			var grandparent = string.IsNullOrEmpty(note.InReplyTo)
+				? default
+				: await _dbEntities.Posts.Match(p => p.ObjectURI == note.InReplyTo && !p.DeletedAt.HasValue).ExecuteFirstAsync(token);
+			var post = await Build(note, author, visibility, note.To, note.Cc, grandparent, token);
+			try
+			{
+				await DB.Default.SaveAsync(post, token);
+			}
+			catch (MongoWriteException ex) when (ex.WriteError?.Category == ServerErrorCategory.DuplicateKey)
+			{
+				return await _dbEntities.Posts.Match(p => p.ObjectURI == objectUri).ExecuteFirstAsync(token);
+			}
+
+			if (grandparent == default && !string.IsNullOrEmpty(note.InReplyTo) && depth < MaxDepth)
+				await _queue.Enqueue(JobKind.FetchAncestors, JsonSerializer.Serialize(new AncestorsPayload(post.ID, depth + 1)), new Uri(note.InReplyTo).Host,
+					"ancestors|" + post.ID, token);
+			return post;
+		}
+	}
+
+	public class AncestorsJobHandler : IJobHandler
+	{
+		readonly DbEntities _dbEntities;
+		readonly IRemotePosts _remotePosts;
+
+		public AncestorsJobHandler(DbEntities dbEntities, IRemotePosts remotePosts)
+		{
+			_dbEntities = dbEntities;
+			_remotePosts = remotePosts;
+		}
+
+		public JobKind Kind => JobKind.FetchAncestors;
+		public int Concurrency => 1;
+		public int MaxAttempts => 3;
+		public int PerHostLimit => 1;
+
+		public async Task<JobOutcome> Handle(Job job, CancellationToken token)
+		{
+			var payload = JsonSerializer.Deserialize<AncestorsPayload>(job.Payload);
+			var child = await _dbEntities.Posts.MatchID(payload.PostId).ExecuteFirstAsync(token);
+			if (child == default || string.IsNullOrEmpty(child.InReplyToURI) || !string.IsNullOrEmpty(child.AnsweringToPostId))
+				return JobOutcome.Done;
+
+			var parent = await _remotePosts.Parent(child.InReplyToURI, payload.Depth, token);
+			if (parent == default)
+				return JobOutcome.Done;
+			await DB.Default.Update<PostEntity>().MatchID(child.ID)
+				.Modify(p => p.AnsweringToPostId, parent.ID)
+				.Modify(p => p.InReplyToAccountId, parent.AuthorAccountId ?? parent.GroupUserId)
+				.ExecuteAsync(token);
+			return JobOutcome.Done;
+		}
+	}
+}

PrivaPub/Federation/Outbox/OutboxPublisher.cs

@@ -0,0 +1,95 @@
+using PrivaPub.Federation.Actors;
+using PrivaPub.Federation.Rendering;
+using PrivaPub.Models.Federation;
+using PrivaPub.Models.Post;
+using PrivaPub.StaticServices;
+
+using System.Text.Json.Nodes;
+
+using PostEntity = PrivaPub.Models.Post.Post;
+
+namespace PrivaPub.Federation.Outbox
+{
+	public interface IOutboxPublisher
+	{
+		Task<IReadOnlyList<string>> Audience(LocalActor author, PostEntity post, CancellationToken token);
+		Task Publish(LocalActor author, PostEntity post, JsonObject activity, CancellationToken token);
+		Task PublishProfile(LocalActor actor, CancellationToken token);
+	}
+
+	public class OutboxPublisher : IOutboxPublisher
+	{
+		readonly DbEntities _dbEntities;
+		readonly ILocalActorService _localActors;
+		readonly IDeliveryService _delivery;
+
+		public OutboxPublisher(DbEntities dbEntities, ILocalActorService localActors, IDeliveryService delivery)
+		{
+			_dbEntities = dbEntities;
+			_localActors = localActors;
+			_delivery = delivery;
+		}
+
+		public async Task<IReadOnlyList<string>> Audience(LocalActor author, PostEntity post, CancellationToken token)
+		{
+			if (post.Visibility is PostVisibility.Circle or PostVisibility.LocalGeo || post.IsLocalOnly)
+				return Array.Empty<string>();
+
+			var inboxes = new List<string>();
+			if (post.Visibility is PostVisibility.Public or PostVisibility.Unlisted or PostVisibility.FollowersOnly)
+				inboxes.AddRange(await _delivery.FollowerInboxes(author, token));
+
+			var addressed = post.Mentions.Where(m => !m.IsLocal).Select(m => m.ActorURI)
+				.Concat(post.Visibility == PostVisibility.Direct ? post.To.Concat(post.Cc) : Enumerable.Empty<string>())
+				.Where(uri => !uri.StartsWith(author.BaseAddress + "/", StringComparison.OrdinalIgnoreCase))
+				.Distinct(StringComparer.Ordinal)
+				.ToList();
+			foreach (var uri in addressed)
+			{
+				var actor = await _dbEntities.ForeignAvatars.Match(a => a.ActorURI == uri).ExecuteFirstAsync(token);
+				if (actor != default && !string.IsNullOrEmpty(actor.InboxURL))
+					inboxes.Add(actor.InboxURL);
+			}
+
+			if (post.Visibility != PostVisibility.Direct && !string.IsNullOrEmpty(post.InReplyToAccountId))
+			{
+				var parentAuthor = await _dbEntities.ForeignAvatars.MatchID(post.InReplyToAccountId).ExecuteFirstAsync(token);
+				if (parentAuthor != default && !string.IsNullOrEmpty(parentAuthor.InboxURL))
+					inboxes.Add(parentAuthor.InboxURL);
+			}
+
+			if (!string.IsNullOrEmpty(post.GroupId) && post.Visibility is PostVisibility.Public or PostVisibility.Unlisted)
+			{
+				var group = await _localActors.FindById(LocalActorKind.Group, post.GroupId, token);
+				if (group is { IsFederated: true })
+					inboxes.AddRange(await _delivery.FollowerInboxes(group, token));
+			}
+
+			return inboxes.Where(i => !string.IsNullOrEmpty(i)).Distinct(StringComparer.Ordinal).ToList();
+		}
+
+		public async Task Publish(LocalActor author, PostEntity post, JsonObject activity, CancellationToken token)
+		{
+			var inboxes = await Audience(author, post, token);
+			if (inboxes.Count > 0)
+				await _delivery.Enqueue(author, inboxes, activity, token);
+		}
+
+		public async Task PublishProfile(LocalActor actor, CancellationToken token)
+		{
+			var document = ActivityPubRenderer.Actor(actor);
+			document.Remove("@context");
+			var update = new JsonObject
+			{
+				["@context"] = ActivityPubRenderer.Context(),
+				["id"] = actor.ActivityUri($"update-profile-{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}"),
+				["type"] = "Update",
+				["actor"] = actor.Uri,
+				["to"] = new JsonArray(ActivityPubRenderer.Public),
+				["cc"] = new JsonArray(actor.Followers),
+				["object"] = document
+			};
+			await _delivery.EnqueueToFollowers(actor, update, token);
+		}
+	}
+}

PrivaPub/Infrastructure/Data/Indexes.cs

@@ -6,6 +6,7 @@ using PrivaPub.Models.Federation;
 using PrivaPub.Models.Group;
 using PrivaPub.Models.Jobs;
 using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
 using PrivaPub.Models.User;
 
 namespace PrivaPub.Infrastructure.Data
@@ -59,6 +60,28 @@ namespace PrivaPub.Infrastructure.Data
 				.Key(j => j.FinishedAt, KeyType.Ascending)
 				.Option(o => o.ExpireAfter = TimeSpan.FromDays(7))
 				.CreateAsync(token);
+			await DB.Default.Index<Following>()
+				.Key(f => f.AvatarId, KeyType.Ascending)
+				.Key(f => f.TargetActorURI, KeyType.Ascending)
+				.Option(o => o.Unique = true)
+				.CreateAsync(token);
+			await Plain<Following>(token, f => f.TargetActorURI, f => f.State);
+			await Plain<Following>(token, f => f.TargetAccountId, f => f.State);
+			await Plain<Following>(token, f => f.FollowActivityURI);
+			await DB.Default.Index<TimelineEntry>()
+				.Key(e => e.AvatarId, KeyType.Ascending)
+				.Key(e => e.PostId, KeyType.Ascending)
+				.Option(o => o.Unique = true)
+				.CreateAsync(token);
+			await Plain<TimelineEntry>(token, e => e.PostId);
+			await Unique<Notification>(n => n.DedupeKey, Builders<Notification>.Filter.Type(n => n.DedupeKey, BsonType.String), token);
+			await Plain<Notification>(token, n => n.AvatarId, n => n.ID);
+			await DB.Default.Index<Favourite>()
+				.Key(f => f.AccountId, KeyType.Ascending)
+				.Key(f => f.PostId, KeyType.Ascending)
+				.Option(o => o.Unique = true)
+				.CreateAsync(token);
+			await Plain<Favourite>(token, f => f.ActivityURI);
 			await Unique<DomainBlock>(b => b.Domain, Builders<DomainBlock>.Filter.Type(b => b.Domain, BsonType.String), token);
 			await Unique<RemoteInstance>(i => i.Host, Builders<RemoteInstance>.Filter.Type(i => i.Host, BsonType.String), token);
 		}

PrivaPub/Middleware/SocialPubConfigurations.cs

@@ -17,6 +17,8 @@ using PrivaPub.Federation.Inbox;
 using PrivaPub.Federation.Moderation;
 using PrivaPub.Federation.Inbox.Handlers;
 using PrivaPub.Domain.Content;
+using PrivaPub.Domain.Social;
+using PrivaPub.Domain.Timelines;
 using PrivaPub.Infrastructure.Http;
 using PrivaPub.Infrastructure.Jobs;
 using Microsoft.Extensions.Options;
@@ -56,13 +58,21 @@ namespace PrivaPub.Middleware
 				.AddSingleton<ILocalActorService, LocalActorService>()
 				.AddSingleton<IRemoteActorService, RemoteActorService>()
 				.AddSingleton<IDeliveryService, DeliveryService>()
+				.AddSingleton<IOutboxPublisher, OutboxPublisher>()
+				.AddSingleton<IFanout, Fanout>()
 				.AddSingleton<IInboxReceiver, InboxReceiver>()
 				.AddSingleton<IActivityHandler, FollowHandler>()
+				.AddSingleton<IActivityHandler, AcceptHandler>()
+				.AddSingleton<IActivityHandler, RejectHandler>()
 				.AddSingleton<IActivityHandler, UndoHandler>()
+				.AddSingleton<IActivityHandler, LikeHandler>()
+				.AddSingleton<IActivityHandler, AnnounceHandler>()
 				.AddSingleton<IActivityHandler, CreateHandler>()
 				.AddSingleton<IActivityHandler, DeleteHandler>()
 				.AddSingleton<IActivityHandler, UpdateHandler>()
 				.AddSingleton<IJobHandler, InboxProcessor>()
+				.AddSingleton<IRemotePosts, RemotePosts>()
+				.AddSingleton<IJobHandler, AncestorsJobHandler>()
 				.AddSingleton<IJobQueue, JobQueue>()
 				.AddSingleton<IHostCircuitBreaker, HostCircuitBreaker>()
 				.AddSingleton<IJobHandler, DeliveryJobHandler>()
@@ -118,6 +128,8 @@ namespace PrivaPub.Middleware
 				.AddTransient<IPrivateAvatarUsersService, PrivateAvatarUsersService>()
 				.AddTransient<IGroupUsersService, GroupUsersService>()
 				.AddTransient<IPostsService, PostsService>()
+				.AddTransient<IFollowService, FollowService>()
+				.AddTransient<ITimelineService, TimelineService>()
 				.AddSingleton<AppConfigurationService>()
 				.AddHttpContextAccessor()
 				.AddMemoryCache()

PrivaPub/Models/Jobs/Job.cs

@@ -21,7 +21,8 @@ namespace PrivaPub.Models.Jobs
 	public enum JobKind
 	{
 		Deliver,
-		ProcessInbox
+		ProcessInbox,
+		FetchAncestors
 	}
 
 	public enum JobState

PrivaPub/Models/Social/Favourite.cs

@@ -0,0 +1,13 @@
+using MongoDB.Entities;
+
+namespace PrivaPub.Models.Social
+{
+	public class Favourite : Entity
+	{
+		public string AccountId { get; set; }//Avatar.ID or ForeignAvatar.ID
+		public string ActorURI { get; set; }
+		public string PostId { get; set; }
+		public string ActivityURI { get; set; }
+		public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+	}
+}

PrivaPub/Models/Social/Following.cs

@@ -0,0 +1,23 @@
+using MongoDB.Entities;
+
+namespace PrivaPub.Models.Social
+{
+	public class Following : Entity
+	{
+		public string AvatarId { get; set; }//the local follower
+		public string TargetActorURI { get; set; }
+		public string TargetAccountId { get; set; }//Avatar.ID, Group.ID or ForeignAvatar.ID
+		public bool TargetIsLocal { get; set; }
+		public string TargetInboxURL { get; set; }
+		public FollowState State { get; set; }
+		public string FollowActivityURI { get; set; }
+		public bool ShowReblogs { get; set; } = true;
+		public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+	}
+
+	public enum FollowState
+	{
+		Requested,
+		Accepted
+	}
+}

PrivaPub/Models/Social/Notification.cs

@@ -0,0 +1,26 @@
+using MongoDB.Entities;
+
+namespace PrivaPub.Models.Social
+{
+	public class Notification : Entity
+	{
+		public string AvatarId { get; set; }
+		public NotificationType Type { get; set; }
+		public string FromAccountId { get; set; }
+		public string FromActorURI { get; set; }
+		public string PostId { get; set; }
+		public string DedupeKey { get; set; }
+		public bool IsRead { get; set; }
+		public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+	}
+
+	public enum NotificationType
+	{
+		Mention,
+		Follow,
+		FollowRequest,
+		Favourite,
+		Reblog,
+		Update
+	}
+}

PrivaPub/Models/Social/TimelineEntry.cs

@@ -0,0 +1,12 @@
+using MongoDB.Entities;
+
+namespace PrivaPub.Models.Social
+{
+	public class TimelineEntry : Entity
+	{
+		public string AvatarId { get; set; }
+		public string PostId { get; set; }//the post shown: a reblog row's id for a reblog
+		public string AuthorAccountId { get; set; }
+		public string ReblogOfPostId { get; set; }
+	}
+}

PrivaPub/Services/ClientToServer/Private/IPrivateAvatarUsersService.cs

@@ -10,6 +10,7 @@ using PrivaPub.Models.User;
 using PrivaPub.Resources;
 using PrivaPub.StaticServices;
 using PrivaPub.Federation.Actors;
+using PrivaPub.Federation.Outbox;
 
 namespace PrivaPub.Services.ClientToServer.Private
 {
@@ -23,16 +24,19 @@ namespace PrivaPub.Services.ClientToServer.Private
 	public class PrivateAvatarUsersService : IPrivateAvatarUsersService
 	{
 		readonly ILocalActorService _localActors;
+		readonly IOutboxPublisher _outbox;
 		readonly DbEntities _dbEntities;
 		readonly IStringLocalizer<GenericRes> _localizer;
 		readonly ILogger<PrivateAvatarUsersService> _logger;
 
 		public PrivateAvatarUsersService(ILocalActorService localActors,
+			IOutboxPublisher outbox,
 			DbEntities dbEntities,
 			IStringLocalizer<GenericRes> localizer,
 			ILogger<PrivateAvatarUsersService> logger)
 		{
 			_localActors = localActors;
+			_outbox = outbox;
 			_dbEntities = dbEntities;
 			_localizer = localizer;
 			_logger = logger;
@@ -115,6 +119,7 @@ namespace PrivaPub.Services.ClientToServer.Private
 					avatar.Settings = ToSettings(form.Settings);
 				avatar.UpdatedAt = DateTime.UtcNow;
 				await DB.Default.SaveAsync(avatar);
+				await _outbox.PublishProfile(_localActors.FromAvatar(avatar), default);
 
 				result.Data = ToView(avatar);
 				return result;

PrivaPub/Services/PostsService.cs

@@ -7,6 +7,7 @@ using PrivaPub.ClientModels.Post;
 using PrivaPub.Models.Federation;
 using PrivaPub.Models.Group;
 using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
 using PrivaPub.Resources;
 using PrivaPub.StaticServices;
 
@@ -14,6 +15,7 @@ using System.Text.Json.Nodes;
 
 using PostEntity = PrivaPub.Models.Post.Post;
 using PrivaPub.Domain.Content;
+using PrivaPub.Domain.Timelines;
 using PrivaPub.Federation.Actors;
 using PrivaPub.Federation.Rendering;
 using PrivaPub.Federation.Outbox;
@@ -24,6 +26,7 @@ namespace PrivaPub.Services
 	{
 		Task<WebResult> InsertPost(string rootUserId, InsertPostForm form, CancellationToken token);
 		Task<WebResult> DeletePost(string rootUserId, DeletePostForm form, CancellationToken token);
+		Task<WebResult> UpdatePost(string rootUserId, UpdatePostForm form, CancellationToken token);
 		Task<WebResult> GetPosts(string rootUserId, string avatarId, string groupId, CancellationToken token);
 		Task<WebResult> InsertDm(string rootUserId, InsertDmForm form, CancellationToken token);
 		Task<WebResult> GetDms(string rootUserId, string avatarId, string dmGroupId, CancellationToken token);
@@ -38,6 +41,8 @@ namespace PrivaPub.Services
 		readonly IRemoteActorService _remoteActors;
 		readonly IDeliveryService _delivery;
 		readonly IContentRenderer _content;
+		readonly IOutboxPublisher _outbox;
+		readonly IFanout _fanout;
 		readonly IStringLocalizer<GenericRes> _localizer;
 		readonly ILogger<PostsService> _logger;
 
@@ -46,6 +51,8 @@ namespace PrivaPub.Services
 			IRemoteActorService remoteActors,
 			IDeliveryService delivery,
 			IContentRenderer content,
+			IOutboxPublisher outbox,
+			IFanout fanout,
 			IStringLocalizer<GenericRes> localizer,
 			ILogger<PostsService> logger)
 		{
@@ -54,6 +61,8 @@ namespace PrivaPub.Services
 			_remoteActors = remoteActors;
 			_delivery = delivery;
 			_content = content;
+			_outbox = outbox;
+			_fanout = fanout;
 			_localizer = localizer;
 			_logger = logger;
 		}
@@ -86,14 +95,15 @@ namespace PrivaPub.Services
 					GroupUserId = author.Id,
 					AuthorAccountId = author.Id,
 					GroupId = group?.Id,
-					Visibility = isLocalOnly ? PostVisibility.Circle : PostVisibility.Public,
+					Visibility = isLocalOnly ? PostVisibility.Circle : LocalVisibility(form.Visibility),
 					Title = form.Title,
+					SpoilerText = string.IsNullOrWhiteSpace(form.SpoilerText) ? default : form.SpoilerText.Trim(),
 					Text = form.Text,
 					ContentHtml = rendered.Html,
 					ContentFormat = ContentFormat.Markdown,
 					Mentions = rendered.Mentions.Select(ToMention).ToList(),
 					Tags = rendered.Tags.ToList(),
-					HasContentWarning = form.HasContentWarning,
+					HasContentWarning = form.HasContentWarning || !string.IsNullOrWhiteSpace(form.SpoilerText),
 					AnsweringToPostId = parent?.ID,
 					InReplyToURI = parent?.ObjectURI ?? RemoteUri(form.AnsweringToPostId),
 					InReplyToAccountId = parent?.AuthorAccountId ?? parent?.GroupUserId,
@@ -107,6 +117,7 @@ namespace PrivaPub.Services
 				if (isLocalOnly)
 				{
 					await DB.Default.SaveAsync(post, token);
+					await _fanout.Distribute(post, token);
 					result.Data = ToView(post);
 					return result;
 				}
@@ -120,11 +131,9 @@ namespace PrivaPub.Services
 				if (parent != default)
 					await DB.Default.Update<PostEntity>().MatchID(parent.ID).Modify(b => b.Inc(p => p.RepliesCount, 1)).ExecuteAsync(token);
 
-				var addressedInboxes = rendered.Mentions.Where(m => !m.IsLocal).Select(m => m.Inbox).ToList();
+				await _fanout.Distribute(post, token);
-				if (parent is { IsFederatedCopy: true } && !string.IsNullOrEmpty(parent.AuthorAccountId))
+				await _outbox.Publish(author, post, create, token);
-					addressedInboxes.Add((await _dbEntities.ForeignAvatars.MatchID(parent.AuthorAccountId).ExecuteFirstAsync(token))?.InboxURL);
+				if (group is { IsFederated: true } && post.Visibility is PostVisibility.Public or PostVisibility.Unlisted)
-				await _delivery.EnqueueToFollowers(author, create, token, addressedInboxes);
-				if (group != default)
 					await _delivery.EnqueueToFollowers(group, ActivityPubRenderer.Announce(group, post.ObjectURI, $"announce-{post.ID}"), token);
 
 				result.Data = ToView(post);
@@ -152,35 +161,28 @@ namespace PrivaPub.Services
 				if (post == default)
 					return result.Invalidate(_localizer["Post not found."], StatusCodes.Status404NotFound);
 
-				await DB.Default.DeleteAsync<PostEntity>(post.ID);
+				if (post.DeletedAt.HasValue)
-				if (post.IsLocalOnly)
 					return result;
+				var audience = await _outbox.Audience(author, post, token);
+				await DB.Default.Update<PostEntity>().MatchID(post.ID)
+					.Modify(p => p.DeletedAt, DateTime.UtcNow)
+					.Modify(p => p.Text, null)
+					.Modify(p => p.ContentHtml, null)
+					.Modify(p => p.Title, null)
+					.Modify(p => p.SpoilerText, null)
+					.Modify(p => p.Media, new List<PostMedia>())
+					.Modify(p => p.Revisions, new List<PostRevision>())
+					.ExecuteAsync(token);
+				await DB.Default.DeleteAsync<TimelineEntry>(e => e.PostId == post.ID);
+				if (!string.IsNullOrEmpty(post.AnsweringToPostId))
+					await DB.Default.Update<PostEntity>().MatchID(post.AnsweringToPostId).Modify(b => b.Inc(p => p.RepliesCount, -1)).ExecuteAsync(token);
 
-				if (post.Visibility == PostVisibility.Direct)
+				if (audience.Count > 0)
 				{
-					var recipients = new List<string>();
+					var delete = ActivityPubRenderer.Delete(author, post.ObjectURI, $"delete-{post.ID}",
-					foreach (var uri in post.To.Concat(post.Cc).Distinct())
+						new JsonArray(post.To.Select(t => (JsonNode)t).ToArray()), new JsonArray(post.Cc.Select(c => (JsonNode)c).ToArray()));
-					{
+					await _delivery.Enqueue(author, audience, delete, token);
-						var foreign = await _dbEntities.ForeignAvatars.Match(a => a.ActorURI == uri).ExecuteFirstAsync(token);
-						if (foreign != default)
-							recipients.Add(foreign.InboxURL);
-					}
-					var directDelete = ActivityPubRenderer.Delete(author, post.ObjectURI, $"delete-{post.ID}",
-						new JsonArray(post.To.Select(t => (JsonNode)t).ToArray()), new JsonArray());
-					await _delivery.Enqueue(author, recipients, directDelete, token);
-					return result;
 				}
-
-				var delete = ActivityPubRenderer.Delete(author, post.ObjectURI, $"delete-{post.ID}",
-					new JsonArray(ActivityPubRenderer.Public), new JsonArray(author.Followers));
-				var extraInboxes = Enumerable.Empty<string>();
-				if (!string.IsNullOrEmpty(post.GroupId))
-				{
-					var group = await _localActors.FindById(LocalActorKind.Group, post.GroupId, token);
-					if (group != default)
-						extraInboxes = await _delivery.FollowerInboxes(group, token);
-				}
-				await _delivery.EnqueueToFollowers(author, delete, token, extraInboxes);
 				return result;
 			}
 			catch (Exception ex)
@@ -190,6 +192,73 @@ namespace PrivaPub.Services
 			}
 		}
 
+		public async Task<WebResult> UpdatePost(string rootUserId, UpdatePostForm form, CancellationToken token)
+		{
+			var result = new WebResult();
+			try
+			{
+				var author = await OwnedAvatar(rootUserId, form.AvatarId, token);
+				if (author == default)
+					return result.Invalidate(_localizer["Avatar not found."], StatusCodes.Status404NotFound);
+				var post = await _dbEntities.Posts
+					.Match(p => p.ID == form.PostId && p.GroupUserId == author.Id && !p.IsFederatedCopy && !p.DeletedAt.HasValue)
+					.ExecuteFirstAsync(token);
+				if (post == default)
+					return result.Invalidate(_localizer["Post not found."], StatusCodes.Status404NotFound);
+
+				post.Revisions.Add(new PostRevision
+				{
+					Title = post.Title,
+					SpoilerText = post.SpoilerText,
+					ContentHtml = post.ContentHtml,
+					HasContentWarning = post.HasContentWarning,
+					EditedAt = post.EditedAt ?? post.CreationDate
+				});
+				var rendered = await _content.Markdown(form.Text, token);
+				post.Title = form.Title;
+				post.SpoilerText = string.IsNullOrWhiteSpace(form.SpoilerText) ? default : form.SpoilerText.Trim();
+				post.HasContentWarning = form.HasContentWarning || post.SpoilerText != default;
+				post.Text = form.Text;
+				post.ContentHtml = rendered.Html;
+				post.Mentions = post.Visibility == PostVisibility.Direct
+					? post.Mentions.Concat(rendered.Mentions.Select(ToMention)).DistinctBy(m => m.ActorURI).ToList()
+					: rendered.Mentions.Select(ToMention).ToList();
+				post.Tags = rendered.Tags.ToList();
+				post.EditedAt = DateTime.UtcNow;
+				post.UpdateDate = post.EditedAt;
+				await DB.Default.SaveAsync(post, token);
+
+				if (!post.IsLocalOnly)
+				{
+					var group = string.IsNullOrEmpty(post.GroupId) ? default : await _localActors.FindById(LocalActorKind.Group, post.GroupId, token);
+					var note = post.Visibility == PostVisibility.Direct
+						? ActivityPubRenderer.DirectNote(post, author, Array.Empty<(string, string)>(), post.ContextURI)
+						: ActivityPubRenderer.Note(post, author, group, post.InReplyToURI);
+					note["to"] = new JsonArray(post.To.Select(t => (JsonNode)t).ToArray());
+					note["cc"] = new JsonArray(post.Cc.Select(c => (JsonNode)c).ToArray());
+					var update = new JsonObject
+					{
+						["@context"] = ActivityPubRenderer.Context(),
+						["id"] = author.ActivityUri($"update-{post.ID}-{new DateTimeOffset(post.EditedAt.Value).ToUnixTimeSeconds()}"),
+						["type"] = "Update",
+						["actor"] = author.Uri,
+						["to"] = note["to"]!.DeepClone(),
+						["cc"] = note["cc"]!.DeepClone(),
+						["object"] = note
+					};
+					await _outbox.Publish(author, post, update, token);
+				}
+
+				result.Data = ToView(post);
+				return result;
+			}
+			catch (Exception ex)
+			{
+				_logger.LogError(ex, $"{nameof(PostsService)}.{nameof(UpdatePost)}");
+				return result.Invalidate(_localizer["Something went wrong."], exception: ex);
+			}
+		}
+
 		public async Task<WebResult> GetPosts(string rootUserId, string avatarId, string groupId, CancellationToken token)
 		{
 			var result = new WebResult();
@@ -304,6 +373,7 @@ namespace PrivaPub.Services
 				dm.Mentions = remote.Select(r => new PostMention { ActorURI = r.Uri, Handle = "@" + r.Handle, IsLocal = r.Uri.StartsWith(author.BaseAddress + "/") }).ToList();
 				await DB.Default.SaveAsync(dm, token);
 				await DB.Default.Update<DmGroup>().MatchID(dmGroup.ID).Modify(g => g.UpdatedAt, DateTime.UtcNow).ExecuteAsync(token);
+				await _fanout.Distribute(dm, token);
 				if (inboxes.Count > 0)
 					await _delivery.Enqueue(author, inboxes, directCreate, token);
 
@@ -387,6 +457,13 @@ namespace PrivaPub.Services
 				: await _dbEntities.Posts.MatchID(answeringTo).ExecuteFirstAsync(token);
 		}
 
+		static PostVisibility LocalVisibility(string requested) => requested?.ToLowerInvariant() switch
+		{
+			"unlisted" => PostVisibility.Unlisted,
+			"followersonly" or "private" => PostVisibility.FollowersOnly,
+			_ => PostVisibility.Public
+		};
+
 		static PostMention ToMention(ResolvedMention mention) => new()
 		{
 			ActorURI = mention.ActorUri,

PrivaPub/StaticServices/DbEntities.cs

@@ -5,6 +5,7 @@ using PrivaPub.Models.Data;
 using PrivaPub.Models.Federation;
 using PrivaPub.Models.Group;
 using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
 using PrivaPub.Models.User;
 
 namespace PrivaPub.StaticServices
@@ -32,5 +33,10 @@ namespace PrivaPub.StaticServices
 		public Find<Follower> Followers { get { return DB.Default.Find<Follower>(); } }
 		public Find<Delivery> Deliveries { get { return DB.Default.Find<Delivery>(); } }
 		public Find<InstanceActor> InstanceActors { get { return DB.Default.Find<InstanceActor>(); } }
+
+		public Find<Following> Followings { get { return DB.Default.Find<Following>(); } }
+		public Find<TimelineEntry> TimelineEntries { get { return DB.Default.Find<TimelineEntry>(); } }
+		public Find<Notification> Notifications { get { return DB.Default.Find<Notification>(); } }
+		public Find<Favourite> Favourites { get { return DB.Default.Find<Favourite>(); } }
 	}
 }

docs/ROADMAP.md

@@ -5,7 +5,7 @@ Written 2026-10-01 from the original 2023 code, the decePubClient UI, a federati
 ## Status
 
 - [x] P0 Security baseline: v1.1.0, deployed and verified 2026-10-01
-- [ ] P1.1 Infrastructure and content model
+- [x] P1.1 Infrastructure and content model: v1.2.0, deployed and verified 2026-10-01
 - [ ] P1.2 Social graph and timelines
 - [ ] P2 Mastodon client API
 - [ ] P3 Social features