@fedify/relay 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/README.md

@@ -40,33 +40,38 @@ subscribed instances, creating a shared pool of federated content.
 Relay protocols
 ---------------
 
-This package supports two popular relay protocols used in the fediverse:
+This package implements the relay-server side of the two relay protocols
+described by [FEP-ae0c].  It does not subscribe an existing ActivityPub
+application to remote relays.
+
+[FEP-ae0c]: https://w3id.org/fep/ae0c
 
 ### Mastodon-style relay
 
-The Mastodon-style relay protocol uses LD signatures for activity
-verification and follows the Public collection. This protocol is widely
-supported by Mastodon and many other ActivityPub implementations.
+Mastodon-style clients subscribe by sending a `Follow` whose object is the
+ActivityStreams Public collection to the relay's shared inbox.  The relay
+accepts or rejects the subscription and forwards signed activities directly to
+accepted subscribers.
 
-Key features:
+#### Key features
 
- -  Direct activity relaying with proper content types (`Create`, `Update`,
-    `Delete`, `Move`)
- -  LD signature verification and generation
- -  Follows the ActivityPub Public collection
- -  Simple subscription mechanism via `Follow` activities
+ -  Direct forwarding of `Create`, `Update`, `Delete`, `Move`, and `Announce`
+    activities
+ -  Immediate subscription state after approval
+ -  Subscription through the shared inbox URI
 
 ### LitePub-style relay
 
-The LitePub-style relay protocol uses bidirectional following relationships
-and wraps activities in `Announce` activities for distribution.
+LitePub-style clients subscribe by following the relay actor.  After approving
+the request, the relay follows the client actor back and waits for an `Accept`.
+It wraps forwarded objects in `Announce` activities.
 
-Key features:
+#### Key features
 
  -  Reciprocal following between relay and subscribers
- -  Activities wrapped in `Announce` for distribution
+ -  Activities distributed through `Announce`
  -  Two-phase subscription (pending → accepted)
- -  Enhanced federation capabilities
+ -  Subscription through the relay actor URI
 
 
 Installation
@@ -102,7 +107,7 @@ Usage
 
 ### Creating a relay
 
-Here's a simple example of creating a relay server using the factory function:
+Here's a simple example of creating a relay server using the factory function.
 
 ~~~~ typescript
 import { createRelay } from "@fedify/relay";
@@ -128,7 +133,7 @@ const relay = createRelay("mastodon", {
 Deno.serve((request) => relay.fetch(request));
 ~~~~
 
-You can also create a LitePub-style relay by changing the type:
+You can also create a LitePub-style relay by changing the type.
 
 ~~~~ typescript
 const relay = createRelay("litepub", {
@@ -138,10 +143,25 @@ const relay = createRelay("litepub", {
 });
 ~~~~
 
+The relay actor and shared inbox use fixed internal routes.  Retrieve their
+public URIs from the relay instead of constructing paths yourself.
+
+~~~~ typescript
+const actorUri = await relay.getActorUri();
+// https://relay.example.com/users/relay
+
+const inboxUri = await relay.getSharedInboxUri();
+// https://relay.example.com/inbox
+~~~~
+
+Give Mastodon-style clients the shared inbox URI and LitePub-style clients the
+actor URI.
+
 ### Subscription handling
 
 The `subscriptionHandler` is required and determines whether to approve or
-reject subscription requests.  For an open relay that accepts all subscriptions:
+reject subscription requests.  The following example creates an open relay that
+accepts all subscriptions.
 
 ~~~~ typescript
 const relay = createRelay("mastodon", {
@@ -151,7 +171,7 @@ const relay = createRelay("mastodon", {
 });
 ~~~~
 
-You can also implement custom approval logic:
+You can also implement custom approval logic.
 
 ~~~~ typescript
 const relay = createRelay("mastodon", {
@@ -199,7 +219,7 @@ if (follower) {
 
 The relay's `fetch()` method returns a standard `Response` object, making it
 compatible with any web framework that supports the Fetch API.  Here's an
-example with Hono:
+example with Hono.
 
 ~~~~ typescript
 import { Hono } from "hono";
@@ -224,31 +244,44 @@ export default app;
 How it works
 ------------
 
-The relay operates by:
+1.  Actor registration—the relay presents itself as an `Application` actor at
+    `/users/relay`.
+2.  Subscription—Mastodon-style clients follow the Public collection;
+    LitePub-style clients follow the relay actor.
+3.  Approval—the relay's subscription handler determines whether to approve
+    the subscription and responds with `Accept` or `Reject`.
+4.  Forwarding—the relay handles `Create`, `Update`, `Delete`, `Move`, and
+    `Announce` activities delivered to its inbox.  Mastodon-style relays forward
+    them directly; LitePub-style relays wrap their objects in `Announce`.
+5.  Unsubscription—instances can unsubscribe by sending an `Undo` activity
+    wrapping their original `Follow` activity.
+
+
+Application responsibilities
+----------------------------
+
+`createRelay()` provides the relay-specific ActivityPub routes and behavior.
+The surrounding application remains responsible for HTTPS, persistent storage,
+a durable production queue, subscription policy, rate limiting, monitoring,
+and moderation.  WebFinger and NodeInfo discovery endpoints are not configured
+by this package.
 
-1.  **Actor registration**: The relay presents itself as a Service actor at
-    `/users/relay`
-2.  **Subscription**: Instances subscribe to the relay by sending a `Follow`
-    activity
-3.  **Approval**: The relay's subscription handler determines whether to
-    approve the subscription (responds with `Accept` or `Reject`)
-4.  **Forwarding**: When a subscribed instance sends activities (`Create`,
-    `Update`, `Delete`, `Move`) to the relay's inbox, the relay forwards them
-    to all other subscribed instances
-5.  **Unsubscription**: Instances can unsubscribe by sending an `Undo` activity
-    wrapping their original `Follow` activity
+The `subscriptionHandler` controls which actors become delivery recipients; it
+does not authorize publishing to the relay.  The relay does not require an
+activity sender to be a stored follower or inspect its audience for the Public
+collection, so deployments need to account for that behavior in their access
+and moderation policies.
 
 
 Storage requirements
 --------------------
 
-The relay requires a key–value store to persist:
+The relay requires a key–value store to persist the following data.
 
- -  Subscriber list and their Follow activity IDs
- -  Subscriber actor information
- -  Relay's cryptographic key pairs (RSA and Ed25519)
+ -  Subscriber actor information and subscription state
+ -  The relay's cryptographic key pairs (RSA and Ed25519)
 
-Any `KvStore` implementation from Fedify can be used, including:
+Any `KvStore` implementation from Fedify can be used, including the following.
 
  -  `MemoryKvStore` (for development/testing)
  -  `DenoKvStore` (Deno KV)
@@ -301,7 +334,7 @@ Public interface for ActivityPub relay implementations.
 
 #### Relay types
 
-The relay type is specified when calling `createRelay()`:
+The relay type is specified when calling `createRelay()`.
 
  -  `"mastodon"`: Mastodon-compatible relay using direct activity forwarding,
     immediate subscription approval, and LD signatures
@@ -310,7 +343,7 @@ The relay type is specified when calling `createRelay()`:
 
 ### `RelayOptions`
 
-Configuration options for the relay:
+Configuration options for the relay.
 
  -  `kv: KvStore` (required): Key–value store for persisting relay data
  -  `origin: string` (required): Relay's origin URL (e.g.,
@@ -326,7 +359,7 @@ Configuration options for the relay:
 
 ### `SubscriptionRequestHandler`
 
-A function that determines whether to approve a subscription request:
+A function that determines whether to approve a subscription request.
 
 ~~~~ typescript
 type SubscriptionRequestHandler = (
@@ -347,7 +380,7 @@ type SubscriptionRequestHandler = (
 
 ### `RelayFollower`
 
-A follower of the relay with validated Actor instance:
+A follower of the relay with validated Actor instance.
 
 ~~~~ typescript
 interface RelayFollower {

package/dist/factory.test.d.ts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/factory.test.js

@@ -0,0 +1,21 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { MemoryKvStore } from "@fedify/fedify";
+import { createRelay } from "@fedify/relay";
+import { strictEqual } from "node:assert";
+import test, { describe } from "node:test";
+//#region src/factory.test.ts
+describe("createRelay", () => {
+	for (const type of ["mastodon", "litepub"]) test(`${type} exposes the canonical relay URIs`, async () => {
+		const relay = createRelay(type, {
+			kv: new MemoryKvStore(),
+			origin: "https://relay.example.com",
+			subscriptionHandler: () => Promise.resolve(true)
+		});
+		strictEqual((await relay.getActorUri()).href, "https://relay.example.com/users/relay");
+		strictEqual((await relay.getSharedInboxUri()).href, "https://relay.example.com/inbox");
+	});
+});
+//#endregion
+export {};

package/dist/litepub.test.js

@@ -1,12 +1,12 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as exportSpki, r as getDocumentLoader, t as isRelayFollowerData } from "./types-B1cI0tFL.js";
+import { n as exportSpki, r as getDocumentLoader, t as isRelayFollowerData } from "./types-D-OFsRKO.js";
 import { MemoryKvStore, signRequest } from "@fedify/fedify";
 import { createRelay } from "@fedify/relay";
-import { Accept, Announce, Create, Delete, Follow, Move, Note, Person, Undo, Update } from "@fedify/vocab";
-import { ok, strictEqual } from "node:assert";
+import { deepStrictEqual, ok, strictEqual } from "node:assert";
 import test, { describe } from "node:test";
+import { Accept, Announce, Create, Delete, Follow, Move, Note, Person, Undo, Update } from "@fedify/vocab";
 //#region src/litepub.test.ts
 const mockDocumentLoader = async (url) => {
 	if (url === "https://remote.example.com/users/alice" || url === "https://remote.example.com/users/alice#main-key") return {
@@ -17,7 +17,7 @@ const mockDocumentLoader = async (url) => {
 			id: url,
 			type: "Person",
 			preferredUsername: "alice",
-			inbox: "https://remote.example.com/users/alice/inbox",
+			inbox: aliceInbox,
 			publicKey: {
 				id: "https://remote.example.com/users/alice#main-key",
 				owner: url.replace(/#main-key$/, ""),
@@ -25,6 +25,22 @@ const mockDocumentLoader = async (url) => {
 			}
 		}
 	};
+	else if (url === "https://remote.example.com/users/dave" || url === "https://remote.example.com/users/dave#main-key") return {
+		contextUrl: null,
+		documentUrl: url.replace(/#main-key$/, ""),
+		document: {
+			"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+			id: url,
+			type: "Person",
+			preferredUsername: "dave",
+			inbox: daveInbox,
+			publicKey: {
+				id: "https://remote.example.com/users/dave#main-key",
+				owner: url.replace(/#main-key$/, ""),
+				publicKeyPem: await exportSpki(rsaKeyPair.publicKey)
+			}
+		}
+	};
 	else if (url === "https://remote.example.com/notes/1") return {
 		contextUrl: null,
 		documentUrl: url,
@@ -52,6 +68,41 @@ const rsaPublicKey = {
 	id: new URL("https://remote.example.com/users/alice#main-key"),
 	...rsaKeyPair.publicKey
 };
+const davePublicKey = {
+	id: new URL("https://remote.example.com/users/dave#main-key"),
+	...rsaKeyPair.publicKey
+};
+const INBOX_PREFIX = "https://[2001:db8:1::";
+const aliceInbox = `${INBOX_PREFIX}4]/users/alice/inbox`;
+const daveInbox = `${INBOX_PREFIX}1]/users/dave/inbox`;
+const pendingInbox = `${INBOX_PREFIX}2]/users/bob/inbox`;
+const acceptedInbox = `${INBOX_PREFIX}3]/users/carol/inbox`;
+const recorders = /* @__PURE__ */ new Map();
+function recordInbox(inbox) {
+	const recorded = [];
+	recorders.set(inbox, recorded);
+	return recorded;
+}
+const aliceDeliveries = recordInbox(aliceInbox);
+function assertAcceptDelivered(follow, deliveries = aliceDeliveries) {
+	const accepts = deliveries.filter(({ body }) => body.type === "Accept" && body.object?.id === follow.id?.href);
+	strictEqual(accepts.length, 1, "Expected exactly one Accept for this Follow");
+	strictEqual(accepts[0].method, "POST");
+	strictEqual(accepts[0].body.actor, "https://relay.example.com/users/relay");
+	strictEqual(accepts[0].body.object.type, "Follow");
+	strictEqual(accepts[0].body.object.actor.id, follow.actorId?.href);
+}
+const nextFetch = globalThis.fetch;
+globalThis.fetch = (async (input, init) => {
+	const request = input instanceof Request ? input : new Request(input, init);
+	if (!request.url.startsWith(INBOX_PREFIX)) return await nextFetch(input, init);
+	const recorded = recorders.get(request.url);
+	if (recorded != null) recorded.push({
+		method: request.method,
+		body: await request.json()
+	});
+	return new Response(null, { status: 202 });
+});
 describe("LitePubRelay", () => {
 	test("constructor with required options", () => {
 		ok(createRelay("litepub", {
@@ -183,12 +234,12 @@ describe("LitePubRelay", () => {
 			}
 		});
 		const follower = new Person({
-			id: new URL("https://remote.example.com/users/alice"),
-			preferredUsername: "alice",
-			inbox: new URL("https://remote.example.com/users/alice/inbox")
+			id: new URL("https://remote.example.com/users/dave"),
+			preferredUsername: "dave",
+			inbox: new URL(daveInbox)
 		});
 		const followActivity = new Follow({
-			id: new URL("https://remote.example.com/activities/follow/1"),
+			id: new URL(`https://remote.example.com/activities/follow/${crypto.randomUUID()}`),
 			actor: follower.id,
 			object: new URL("https://relay.example.com/users/relay")
 		});
@@ -197,13 +248,20 @@ describe("LitePubRelay", () => {
 			headers: { "Content-Type": "application/activity+json" },
 			body: JSON.stringify(await followActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
 		});
-		request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
-		await relay.fetch(request);
+		request = await signRequest(request, rsaKeyPair.privateKey, davePublicKey.id);
+		const deliveredActivities = recordInbox(daveInbox);
+		strictEqual((await relay.fetch(request)).status, 202);
+		assertAcceptDelivered(followActivity, deliveredActivities);
 		strictEqual(handlerCalled, true);
 		ok(handlerActor);
-		const followerData = await kv.get(["follower", "https://remote.example.com/users/alice"]);
+		const followerData = await kv.get(["follower", "https://remote.example.com/users/dave"]);
 		ok(isRelayFollowerData(followerData));
 		strictEqual(followerData.state, "pending");
+		const reciprocalFollow = deliveredActivities.map(({ body }) => body).find((activity) => activity.type === "Follow");
+		ok(reciprocalFollow, "Expected a reciprocal Follow activity");
+		strictEqual(reciprocalFollow.actor, "https://relay.example.com/users/relay");
+		strictEqual(reciprocalFollow.object, "https://remote.example.com/users/dave");
+		strictEqual(reciprocalFollow.to, "https://remote.example.com/users/dave");
 	});
 	test("handles Follow activity with subscription rejection", async () => {
 		const kv = new MemoryKvStore();
@@ -219,7 +277,7 @@ describe("LitePubRelay", () => {
 		const follower = new Person({
 			id: new URL("https://remote.example.com/users/alice"),
 			preferredUsername: "alice",
-			inbox: new URL("https://remote.example.com/users/alice/inbox")
+			inbox: new URL(aliceInbox)
 		});
 		const followActivity = new Follow({
 			id: new URL("https://remote.example.com/activities/follow/1"),
@@ -232,7 +290,7 @@ describe("LitePubRelay", () => {
 			body: JSON.stringify(await followActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
 		});
 		request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
-		await relay.fetch(request);
+		strictEqual((await relay.fetch(request)).status, 202);
 		strictEqual(await kv.get(["follower", "https://remote.example.com/users/alice"]), void 0);
 	});
 	test("handles public Follow activity", async () => {
@@ -247,10 +305,10 @@ describe("LitePubRelay", () => {
 		const follower = new Person({
 			id: new URL("https://remote.example.com/users/alice"),
 			preferredUsername: "alice",
-			inbox: new URL("https://remote.example.com/users/alice/inbox")
+			inbox: new URL(aliceInbox)
 		});
 		const followActivity = new Follow({
-			id: new URL("https://remote.example.com/activities/follow/1"),
+			id: new URL(`https://remote.example.com/activities/follow/${crypto.randomUUID()}`),
 			actor: follower.id,
 			object: new URL("https://www.w3.org/ns/activitystreams#Public")
 		});
@@ -260,7 +318,8 @@ describe("LitePubRelay", () => {
 			body: JSON.stringify(await followActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
 		});
 		request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
-		await relay.fetch(request);
+		strictEqual((await relay.fetch(request)).status, 202);
+		assertAcceptDelivered(followActivity);
 		const followerData = await kv.get(["follower", "https://remote.example.com/users/alice"]);
 		ok(isRelayFollowerData(followerData));
 		strictEqual(followerData.state, "pending");
@@ -284,10 +343,62 @@ describe("LitePubRelay", () => {
 			body: JSON.stringify(await followActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
 		});
 		request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
-		await relay.fetch(request);
+		strictEqual((await relay.fetch(request)).status, 202);
 		strictEqual(await kv.get(["follower", "https://remote.example.com/users/alice"]), void 0);
 	});
-	test("ignores duplicate Follow activity from pending follower", async () => {
+	test("replaces malformed follower data on Follow", async () => {
+		const followerId = "https://remote.example.com/users/alice";
+		const malformedRows = [
+			{ state: "pending" },
+			{
+				actor: null,
+				state: "pending"
+			},
+			{
+				actor: {},
+				state: "pending"
+			},
+			{
+				actor: await new Person({ id: new URL("https://remote.example.com/users/bob") }).toJsonLd(),
+				state: "pending"
+			}
+		];
+		for (const malformedRow of malformedRows) {
+			const kv = new MemoryKvStore();
+			await kv.set(["follower", followerId], malformedRow);
+			let handlerCallCount = 0;
+			const relay = createRelay("litepub", {
+				kv,
+				origin: "https://relay.example.com",
+				documentLoaderFactory: () => mockDocumentLoader,
+				authenticatedDocumentLoaderFactory: () => mockDocumentLoader,
+				subscriptionHandler: () => {
+					handlerCallCount++;
+					return Promise.resolve(true);
+				}
+			});
+			strictEqual(await relay.getFollower(followerId), null);
+			const followActivity = new Follow({
+				id: new URL(`https://remote.example.com/activities/follow/${crypto.randomUUID()}`),
+				actor: new URL(followerId),
+				object: new URL("https://relay.example.com/users/relay")
+			});
+			let request = new Request("https://relay.example.com/inbox", {
+				method: "POST",
+				headers: { "Content-Type": "application/activity+json" },
+				body: JSON.stringify(await followActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
+			});
+			request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
+			strictEqual((await relay.fetch(request)).status, 202);
+			assertAcceptDelivered(followActivity);
+			strictEqual(handlerCallCount, 1);
+			const follower = await relay.getFollower(followerId);
+			ok(follower);
+			strictEqual(follower.state, "pending");
+			strictEqual(follower.actor.id?.href, followerId);
+		}
+	});
+	for (const state of ["pending", "accepted"]) test(`ignores duplicate Follow activity from ${state} follower`, async () => {
 		const kv = new MemoryKvStore();
 		let handlerCallCount = 0;
 		const relay = createRelay("litepub", {
@@ -303,11 +414,11 @@ describe("LitePubRelay", () => {
 		const follower = new Person({
 			id: new URL("https://remote.example.com/users/alice"),
 			preferredUsername: "alice",
-			inbox: new URL("https://remote.example.com/users/alice/inbox")
+			inbox: new URL(aliceInbox)
 		});
 		await kv.set(["follower", "https://remote.example.com/users/alice"], {
 			actor: await follower.toJsonLd(),
-			state: "pending"
+			state
 		});
 		const followActivity = new Follow({
 			id: new URL("https://remote.example.com/activities/follow/1"),
@@ -320,15 +431,18 @@ describe("LitePubRelay", () => {
 			body: JSON.stringify(await followActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
 		});
 		request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
-		await relay.fetch(request);
+		strictEqual((await relay.fetch(request)).status, 202);
 		strictEqual(handlerCallCount, 0);
+		const followerData = await kv.get(["follower", "https://remote.example.com/users/alice"]);
+		ok(isRelayFollowerData(followerData));
+		strictEqual(followerData.state, state);
 	});
 	test("handles Accept activity completing reciprocal follow", async () => {
 		const kv = new MemoryKvStore();
 		const follower = new Person({
 			id: new URL("https://remote.example.com/users/alice"),
 			preferredUsername: "alice",
-			inbox: new URL("https://remote.example.com/users/alice/inbox")
+			inbox: new URL(aliceInbox)
 		});
 		await kv.set(["follower", "https://remote.example.com/users/alice"], {
 			actor: await follower.toJsonLd(),
@@ -357,22 +471,69 @@ describe("LitePubRelay", () => {
 			body: JSON.stringify(await acceptActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
 		});
 		request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
-		await relay.fetch(request);
+		strictEqual((await relay.fetch(request)).status, 202);
 		const followerData = await kv.get(["follower", "https://remote.example.com/users/alice"]);
 		ok(isRelayFollowerData(followerData));
 		strictEqual(followerData.state, "accepted");
 	});
-	test("handles Undo Follow activity", async () => {
+	test("ignores Accept activity for invalid follower data", async () => {
+		const followerId = "https://remote.example.com/users/alice";
+		const invalidRows = [
+			{ state: "pending" },
+			{
+				actor: null,
+				state: "pending"
+			},
+			{
+				actor: {},
+				state: "pending"
+			},
+			{
+				actor: await new Person({ id: new URL("https://remote.example.com/users/bob") }).toJsonLd(),
+				state: "pending"
+			}
+		];
+		for (const invalidRow of invalidRows) {
+			const kv = new MemoryKvStore();
+			await kv.set(["follower", followerId], invalidRow);
+			const relay = createRelay("litepub", {
+				kv,
+				origin: "https://relay.example.com",
+				documentLoaderFactory: () => mockDocumentLoader,
+				authenticatedDocumentLoaderFactory: () => mockDocumentLoader,
+				subscriptionHandler: () => Promise.resolve(true)
+			});
+			const relayFollow = new Follow({
+				id: new URL("https://relay.example.com/activities/follow/1"),
+				actor: new URL("https://relay.example.com/users/relay"),
+				object: new URL(followerId)
+			});
+			const acceptActivity = new Accept({
+				id: new URL("https://remote.example.com/activities/accept/1"),
+				actor: new URL(followerId),
+				object: relayFollow
+			});
+			let request = new Request("https://relay.example.com/inbox", {
+				method: "POST",
+				headers: { "Content-Type": "application/activity+json" },
+				body: JSON.stringify(await acceptActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
+			});
+			request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
+			strictEqual((await relay.fetch(request)).status, 202);
+			deepStrictEqual(await kv.get(["follower", followerId]), invalidRow);
+		}
+	});
+	for (const state of ["pending", "accepted"]) test(`handles Undo Follow activity for ${state} follower`, async () => {
 		const kv = new MemoryKvStore();
 		const followerId = "https://remote.example.com/users/alice";
 		const follower = new Person({
 			id: new URL(followerId),
 			preferredUsername: "alice",
-			inbox: new URL("https://remote.example.com/users/alice/inbox")
+			inbox: new URL(aliceInbox)
 		});
 		await kv.set(["follower", followerId], {
 			actor: await follower.toJsonLd(),
-			state: "accepted"
+			state
 		});
 		const relay = createRelay("litepub", {
 			kv,
@@ -397,7 +558,7 @@ describe("LitePubRelay", () => {
 			body: JSON.stringify(await undoActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
 		});
 		request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
-		await relay.fetch(request);
+		strictEqual((await relay.fetch(request)).status, 202);
 		strictEqual(await kv.get(["follower", followerId]), void 0);
 	});
 	test("handles Create activity with Announce forwarding", async () => {
@@ -406,7 +567,7 @@ describe("LitePubRelay", () => {
 		const follower = new Person({
 			id: new URL(followerId),
 			preferredUsername: "alice",
-			inbox: new URL("https://remote.example.com/users/alice/inbox")
+			inbox: new URL(aliceInbox)
 		});
 		await kv.set(["follower", followerId], {
 			actor: await follower.toJsonLd(),
@@ -437,6 +598,54 @@ describe("LitePubRelay", () => {
 		const response = await relay.fetch(request);
 		ok(response.status === 200 || response.status === 202);
 	});
+	test("forwards activities only to accepted followers", async () => {
+		const kv = new MemoryKvStore();
+		const pendingFollower = new Person({
+			id: new URL("https://pending.example.com/users/bob"),
+			preferredUsername: "bob",
+			inbox: new URL(pendingInbox)
+		});
+		const acceptedFollower = new Person({
+			id: new URL("https://accepted.example.com/users/carol"),
+			preferredUsername: "carol",
+			inbox: new URL(acceptedInbox)
+		});
+		await kv.set(["follower", pendingFollower.id.href], {
+			actor: await pendingFollower.toJsonLd(),
+			state: "pending"
+		});
+		await kv.set(["follower", acceptedFollower.id.href], {
+			actor: await acceptedFollower.toJsonLd(),
+			state: "accepted"
+		});
+		const relay = createRelay("litepub", {
+			kv,
+			origin: "https://relay.example.com",
+			documentLoaderFactory: () => mockDocumentLoader,
+			authenticatedDocumentLoaderFactory: () => mockDocumentLoader,
+			subscriptionHandler: () => Promise.resolve(true)
+		});
+		const createActivity = new Create({
+			id: new URL("https://remote.example.com/activities/create/1"),
+			actor: new URL("https://remote.example.com/users/alice"),
+			object: new Note({
+				id: new URL("https://remote.example.com/notes/1"),
+				content: "Hello world"
+			})
+		});
+		let request = new Request("https://relay.example.com/inbox", {
+			method: "POST",
+			headers: { "Content-Type": "application/activity+json" },
+			body: JSON.stringify(await createActivity.toJsonLd({ contextLoader: mockDocumentLoader }))
+		});
+		request = await signRequest(request, rsaKeyPair.privateKey, rsaPublicKey.id);
+		const deliveredToPending = recordInbox(pendingInbox);
+		const deliveredToAccepted = recordInbox(acceptedInbox);
+		const response = await relay.fetch(request);
+		ok(response.status === 200 || response.status === 202, `Unexpected inbox response status: ${response.status}`);
+		strictEqual(deliveredToAccepted.length, 1);
+		deepStrictEqual(deliveredToPending, []);
+	});
 	test("handles Update activity with Announce forwarding", async () => {
 		const relay = createRelay("litepub", {
 			kv: new MemoryKvStore(),
@@ -661,7 +870,7 @@ describe("LitePubRelay", () => {
 			id: new URL(followerId),
 			preferredUsername: "alice",
 			name: "Alice Wonderland",
-			inbox: new URL("https://remote.example.com/users/alice/inbox")
+			inbox: new URL(aliceInbox)
 		});
 		await kv.set(["follower", followerId], {
 			actor: await follower.toJsonLd(),