Replies to a persona's posts reach its followers; personas join remote events

Two owner decisions of 2026-10-05, recorded in the roadmap.

Replies passed on ("the fediverse is broken without"): a public or unlisted
reply from another server to a persona's public, unlisted or followers-only
post goes on to the persona's followers as its author's server sent it, as
Mastodon forwards it, never to the replier's own server, never for a
local-only or group post; its edit and deletion follow. Only an activity its
own actor delivered is passed on (Arrival.Raw), so nothing forwarded is
forwarded again. The town checks it as relay.reply cells (specs/relay-five:
882 checks pass); Mastodon takes a passed-on activity only with an LD
signature, which GoToSocial and Akkoma don't add, and the checker knows it.

Events: a persona joins another server's event with a Join and leaves it with
a Leave, both to the organiser only, through
POST /api/privapub/v1/statuses/:id/join|leave; the organiser's Accept or
Reject is routed by our join id and shows as privapub.event.participation.
Events by invitation or taken on another site are refused before anything
is sent. Mobilizon's scenario joins and leaves an event (28 checks) and keeps
one for decePubClient's e2e.

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

PrivaPub.Tests/Federation/ParticipationTests.cs

@@ -0,0 +1,100 @@
+using MongoDB.Entities;
+
+using PrivaPub.Models.Post;
+using PrivaPub.Models.Social;
+using PrivaPub.Tests.Support;
+
+using System.Text.Json.Nodes;
+
+using static PrivaPub.Tests.Support.FederatedSeeds;
+
+namespace PrivaPub.Tests.Federation
+{
+	// a persona joins a remote event (owner decision 2026-10-05): Join, answered Accept or Reject; Leave
+	[Trait("Category", "Integration")]
+	public sealed class ParticipationTests : 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<(PrivaPub.Federation.Actors.LocalActor Alice, RemoteActor Group, Post Event)> Announced(string joinMode = "free")
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (_, alice) = await _harness.Persona("alice");
+			var group = new RemoteActor(_harness.Peer, "group", type: "Group");
+			await Follows(alice.Id, group);
+			var happening = new JsonObject
+			{
+				["id"] = NewId(group, "events"), ["type"] = "Event", ["name"] = "A picnic", ["content"] = "<p>bring bread</p>",
+				["attributedTo"] = group.Id, ["startTime"] = DateTime.UtcNow.AddDays(3).ToString("O"), ["joinMode"] = joinMode,
+				["to"] = new JsonArray(PrivaPub.Federation.Objects.Addressing.Public), ["cc"] = new JsonArray(group.Id + "/followers")
+			};
+			await _harness.Deliver(group, "/human-centipede", Create(group, happening));
+			return (alice, group, await DB.Default.Find<Post>().Match(p => p.ObjectURI == IdOf(happening)).ExecuteSingleAsync(token));
+		}
+
+		Task<Participation> Of(PrivaPub.Federation.Actors.LocalActor alice, Post happening) =>
+			DB.Default.Find<Participation>().Match(p => p.AvatarId == alice.Id && p.PostId == happening.ID).ExecuteFirstAsync(TestContext.Current.CancellationToken);
+
+		[Fact]
+		public async Task A_persona_joins_an_event_its_server_accepts_and_leaves_it()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (alice, group, happening) = await Announced();
+
+			Assert.True((await _harness.Participations.Join(alice, happening.ID, token)).Ok);
+
+			var join = Assert.Single(await _harness.Outgoing(group.Id + "/inbox"), a => a["type"]!.GetValue<string>() == "Join");
+			Assert.Equal((alice.Uri, happening.ObjectURI), (join["actor"]!.GetValue<string>(), join["object"]!.GetValue<string>()));
+			Assert.Equal(ParticipationState.Pending, (await Of(alice, happening)).State);
+
+			await _harness.Deliver(group, "/human-centipede", new JsonObject
+			{
+				["id"] = NewId(group, "accepts"), ["type"] = "Accept", ["actor"] = group.Id, ["object"] = join["id"]!.GetValue<string>()
+			});
+			Assert.Equal(ParticipationState.Accepted, (await Of(alice, happening)).State);
+
+			Assert.True((await _harness.Participations.Leave(alice, happening.ID, token)).Ok);
+			Assert.Null(await Of(alice, happening));
+			var leave = Assert.Single(await _harness.Outgoing(group.Id + "/inbox"), a => a["type"]!.GetValue<string>() == "Leave");
+			Assert.Equal(happening.ObjectURI, leave["object"]!.GetValue<string>());
+		}
+
+		[Fact]
+		public async Task A_refusal_counts_an_answer_from_another_server_does_not_and_an_invitation_only_event_is_not_joined()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (alice, group, happening) = await Announced();
+			await _harness.Participations.Join(alice, happening.ID, token);
+			var join = Assert.Single(await _harness.Outgoing(group.Id + "/inbox"), a => a["type"]!.GetValue<string>() == "Join");
+
+			var stranger = new RemoteActor(_harness.Peer, "stranger", _harness.Peer.B);
+			await _harness.Deliver(stranger, "/human-centipede", new JsonObject
+			{
+				["id"] = NewId(stranger, "accepts"), ["type"] = "Accept", ["actor"] = stranger.Id, ["object"] = join["id"]!.GetValue<string>()
+			});
+			Assert.Equal(ParticipationState.Pending, (await Of(alice, happening)).State);
+
+			await _harness.Deliver(group, "/human-centipede", new JsonObject
+			{
+				["id"] = NewId(group, "rejects"), ["type"] = "Reject", ["actor"] = group.Id,
+				["object"] = new JsonObject { ["id"] = join["id"]!.GetValue<string>(), ["type"] = "Join", ["actor"] = alice.Uri, ["object"] = happening.ObjectURI }
+			});
+			Assert.Equal(ParticipationState.Rejected, (await Of(alice, happening)).State);
+
+			var (carol, _, invitationOnly) = await Announced("invite");
+			Assert.Equal(422, (await _harness.Participations.Join(carol, invitationOnly.ID, token)).Status);
+		}
+	}
+}

PrivaPub.Tests/Federation/ReplyRelayTests.cs

@@ -0,0 +1,114 @@
+using MongoDB.Entities;
+
+using PrivaPub.Domain.Statuses;
+using PrivaPub.Models.Post;
+using PrivaPub.Tests.Support;
+
+using System.Text.Json.Nodes;
+
+using static PrivaPub.Tests.Support.FederatedSeeds;
+
+namespace PrivaPub.Tests.Federation
+{
+	// Inbox forwarding of replies (owner decision 2026-10-05): a reply to a persona's post reaches the persona's followers,
+	// who are not among those its author's server sends it to
+	[Trait("Category", "Integration")]
+	public sealed class ReplyRelayTests : 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();
+		}
+
+		// alice's post; bob replies from his server, fan follows alice from another, pal from bob's
+		async Task<(PrivaPub.Federation.Actors.LocalActor Alice, Post Post, RemoteActor Bob, RemoteActor Fan, RemoteActor Pal)> Thread()
+		{
+			var token = TestContext.Current.CancellationToken;
+			var (_, alice) = await _harness.Persona("alice");
+			var bob = new RemoteActor(_harness.Peer, "bob");
+			var fan = new RemoteActor(_harness.Peer, "fan", _harness.Peer.B);
+			var pal = new RemoteActor(_harness.Peer, "pal");
+			await _harness.FollowedBy(alice, fan);
+			await _harness.FollowedBy(alice, pal);
+			var post = (await _harness.Statuses.Publish(alice, new StatusDraft { Text = "what do you think?" }, token)).Post;
+			return (alice, post, bob, fan, pal);
+		}
+
+		JsonObject Reply(RemoteActor bob, Post post, string visibility = "public")
+		{
+			var reply = PublicNote(bob, "<p>I think so</p>", post.ActorURI);
+			reply["inReplyTo"] = post.ObjectURI;
+			if (visibility == "followers")
+			{
+				reply["to"] = new JsonArray(bob.Id + "/followers");
+				reply["cc"] = new JsonArray(post.ActorURI);
+			}
+			return reply;
+		}
+
+		Task<List<JsonObject>> At(RemoteActor follower) => _harness.Outgoing(follower.SharedInbox);
+
+		[Fact]
+		public async Task A_public_reply_to_a_personas_post_reaches_its_followers_as_it_came_and_not_its_authors_server()
+		{
+			var (_, post, bob, fan, pal) = await Thread();
+			var create = Create(bob, Reply(bob, post));
+			create["signature"] = new JsonObject { ["type"] = "RsaSignature2017", ["signatureValue"] = "kept as it came" };
+
+			await _harness.Deliver(bob, "/human-centipede", create);
+
+			var relayed = Assert.Single(await At(fan), a => a["id"]!.GetValue<string>() == IdOf(create));
+			Assert.Equal(bob.Id, relayed["actor"]!.GetValue<string>());
+			Assert.Equal("kept as it came", relayed["signature"]!["signatureValue"]!.GetValue<string>());
+			Assert.DoesNotContain(await At(pal), a => a["id"]!.GetValue<string>() == IdOf(create));
+		}
+
+		[Fact]
+		public async Task Its_edit_and_deletion_follow_it_and_a_followers_only_reply_stays_where_it_was_sent()
+		{
+			var (_, post, bob, fan, _) = await Thread();
+			var reply = Reply(bob, post);
+			await _harness.Deliver(bob, "/human-centipede", Create(bob, reply));
+			var edited = (JsonObject)reply.DeepClone();
+			edited["content"] = "<p>I think so, on second thought</p>";
+			edited["updated"] = DateTime.UtcNow.AddMinutes(1).ToString("O");
+			var update = Activity(bob, "Update", edited);
+			await _harness.Deliver(bob, "/human-centipede", update);
+			var delete = Activity(bob, "Delete", JsonValue.Create(IdOf(reply))!);
+			await _harness.Deliver(bob, "/human-centipede", delete);
+
+			var relayed = (await At(fan)).Select(a => a["id"]!.GetValue<string>()).ToList();
+			Assert.Contains(IdOf(update), relayed);
+			Assert.Contains(IdOf(delete), relayed);
+
+			var quiet = Create(bob, Reply(bob, post, "followers"));
+			await _harness.Deliver(bob, "/human-centipede", quiet);
+			Assert.DoesNotContain(await At(fan), a => a["id"]!.GetValue<string>() == IdOf(quiet));
+		}
+
+		[Fact]
+		public async Task A_reply_that_reached_us_forwarded_is_not_passed_on_again()
+		{
+			var (_, post, bob, fan, _) = await Thread();
+			var other = new RemoteActor(_harness.Peer, "other", _harness.Peer.B);
+			var reply = Reply(bob, post);
+			_harness.Peer.Serve(new Uri(IdOf(reply)).AbsolutePath, reply.ToJsonString());
+			var create = Create(bob, reply);
+
+			var result = await _harness.Deliver(other, "/human-centipede", create);
+
+			Assert.Equal("forwarded", result.Reason);
+			Assert.True(await DB.Default.Find<Post>().Match(p => p.ObjectURI == IdOf(reply)).ExecuteAnyAsync(TestContext.Current.CancellationToken));
+			Assert.DoesNotContain(await At(fan), a => a["id"]!.GetValue<string>() == IdOf(create));
+		}
+	}
+}

PrivaPub.Tests/Support/Harness.cs

@@ -52,12 +52,13 @@ namespace PrivaPub.Tests.Support
 			Outbox = new OutboxPublisher(Db, Local, Delivery);
 			Quotes = new QuoteService(Db, Remote, RemotePosts, Local, Delivery, Outbox);
 			Approvals = new InteractionApprovals(Db, Remote, Local, Delivery, Outbox);
+			Participations = new Participations(Db, Local, Delivery);
 			Receiver = new InboxReceiver(Local, Remote, Queue, new NoBlocks(), NullLogger<InboxReceiver>.Instance, Ledger);
 			Handlers = new IActivityHandler[]
 			{
 				new FollowHandler(Db, Local, Remote, Delivery),
-				new AcceptHandler(Db, Local, Quotes, Approvals),
-				new RejectHandler(Db, Local, Quotes, Approvals),
+				new AcceptHandler(Db, Local, Quotes, Approvals, Participations),
+				new RejectHandler(Db, Local, Quotes, Approvals, Participations),
 				new UndoHandler(Db, Local, Reactions),
 				new LikeHandler(Db, Reactions),
 				new EmojiReactHandler(Db, Reactions),
@@ -67,7 +68,7 @@ namespace PrivaPub.Tests.Support
 				new AnnounceHandler(Db, Local, RemotePosts, Fanout, Remote, Records, Quotes),
 				new CreateHandler(Db, Local, Remote, Delivery, new NoBlocks(), Fanout, RemotePosts, Groups, Records, Polls, new NoPreviews(), Quotes, Approvals),
 				new DeleteHandler(Db, Local, Remote, Delivery, Groups, Quotes),
-				new UpdateHandler(Db, Local, Remote, Groups, Records, Quotes),
+				new UpdateHandler(Db, Local, Remote, Groups, Records, Quotes, Delivery),
 				new FlagHandler(Db, Local),
 				new BlockHandler(Db, Local)
 			};
@@ -108,6 +109,7 @@ namespace PrivaPub.Tests.Support
 		public Reactions Reactions { get; }
 		public QuoteService Quotes { get; }
 		public InteractionApprovals Approvals { get; }
+		public Participations Participations { get; }
 		public TimelineService Timelines { get; }
 		public RelationshipService Relationships { get; }
 		public ReportService Reports { get; }