@fedify/relay 2.0.0-dev.12 → 2.0.0-dev.158

package/dist/mod.cjs

@@ -1,3 +1,6 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
 //#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -22,181 +25,295 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 const __fedify_fedify = __toESM(require("@fedify/fedify"));
-const __fedify_fedify_vocab = __toESM(require("@fedify/fedify/vocab"));
+const __fedify_vocab = __toESM(require("@fedify/vocab"));
+const __logtape_logtape = __toESM(require("@logtape/logtape"));
 
-//#region src/relay.ts
+//#region src/types.ts
 const RELAY_SERVER_ACTOR = "relay";
 /**
-* A Mastodon-compatible ActivityPub relay implementation.
-* This relay follows Mastodon's relay protocol for maximum compatibility
-* with Mastodon instances.
+* Type predicate to check if a value is valid RelayFollowerData from KV store.
+* Validates the storage format (JSON-LD), not the deserialized Actor instance.
 *
-* @since 2.0.0
+* @param value The value to check
+* @returns true if the value is a RelayFollowerData
+* @internal
 */
-var MastodonRelay = class {
-	#federation;
-	#options;
-	#subscriptionHandler;
-	constructor(options) {
-		this.#options = options;
-		this.#federation = options.federation ?? (0, __fedify_fedify.createFederation)({
-			kv: options.kv,
-			queue: options.queue,
-			documentLoaderFactory: options.documentLoaderFactory,
-			authenticatedDocumentLoaderFactory: options.authenticatedDocumentLoaderFactory
-		});
-		this.#federation.setActorDispatcher("/users/{identifier}", async (ctx, identifier) => {
-			if (identifier !== RELAY_SERVER_ACTOR) return null;
-			const keys = await ctx.getActorKeyPairs(identifier);
-			return new __fedify_fedify_vocab.Service({
-				id: ctx.getActorUri(identifier),
-				preferredUsername: identifier,
-				name: "ActivityPub Relay",
-				summary: "Mastodon-compatible ActivityPub relay server",
-				inbox: ctx.getInboxUri(),
-				followers: ctx.getFollowersUri(identifier),
-				url: ctx.getActorUri(identifier),
-				publicKey: keys[0].cryptographicKey,
-				assertionMethods: keys.map((k) => k.multikey)
-			});
-		}).setKeyPairsDispatcher(async (_ctx, identifier) => {
-			if (identifier !== RELAY_SERVER_ACTOR) return [];
-			const rsaPairJson = await options.kv.get([
-				"keypair",
-				"rsa",
-				identifier
-			]);
-			const ed25519PairJson = await options.kv.get([
-				"keypair",
-				"ed25519",
-				identifier
-			]);
-			if (rsaPairJson == null || ed25519PairJson == null) {
-				const rsaPair$1 = await (0, __fedify_fedify.generateCryptoKeyPair)("RSASSA-PKCS1-v1_5");
-				const ed25519Pair$1 = await (0, __fedify_fedify.generateCryptoKeyPair)("Ed25519");
-				await options.kv.set([
-					"keypair",
-					"rsa",
-					identifier
-				], {
-					privateKey: await (0, __fedify_fedify.exportJwk)(rsaPair$1.privateKey),
-					publicKey: await (0, __fedify_fedify.exportJwk)(rsaPair$1.publicKey)
-				});
-				await options.kv.set([
-					"keypair",
-					"ed25519",
-					identifier
-				], {
-					privateKey: await (0, __fedify_fedify.exportJwk)(ed25519Pair$1.privateKey),
-					publicKey: await (0, __fedify_fedify.exportJwk)(ed25519Pair$1.publicKey)
-				});
-				return [rsaPair$1, ed25519Pair$1];
-			}
-			const rsaPair = {
-				privateKey: await (0, __fedify_fedify.importJwk)(rsaPairJson.privateKey, "private"),
-				publicKey: await (0, __fedify_fedify.importJwk)(rsaPairJson.publicKey, "public")
-			};
-			const ed25519Pair = {
-				privateKey: await (0, __fedify_fedify.importJwk)(ed25519PairJson.privateKey, "private"),
-				publicKey: await (0, __fedify_fedify.importJwk)(ed25519PairJson.publicKey, "public")
-			};
-			return [rsaPair, ed25519Pair];
-		});
-		this.#federation.setFollowersDispatcher("/users/{identifier}/followers", async (_ctx, identifier) => {
-			if (identifier !== RELAY_SERVER_ACTOR) return null;
-			const activityIds = await options.kv.get(["followers"]) ?? [];
-			const actors = [];
-			for (const activityId of activityIds) {
-				const actorJson = await options.kv.get(["follower", activityId]);
-				const actor = await __fedify_fedify_vocab.Object.fromJsonLd(actorJson);
-				if (!(0, __fedify_fedify_vocab.isActor)(actor)) continue;
-				actors.push(actor);
-			}
-			return { items: actors };
+function isRelayFollowerData(value) {
+	if (!value || typeof value !== "object") return false;
+	const obj = value;
+	return "actor" in obj && "state" in obj && typeof obj.state === "string" && (obj.state === "pending" || obj.state === "accepted");
+}
+
+//#endregion
+//#region src/builder.ts
+const relayBuilder = (0, __fedify_fedify.createFederationBuilder)();
+relayBuilder.setActorDispatcher("/users/{identifier}", async (ctx, identifier) => {
+	if (identifier !== RELAY_SERVER_ACTOR) return null;
+	const keys = await ctx.getActorKeyPairs(identifier);
+	return new __fedify_vocab.Application({
+		id: ctx.getActorUri(identifier),
+		preferredUsername: identifier,
+		name: ctx.data.name ?? "ActivityPub Relay",
+		inbox: ctx.getInboxUri(),
+		followers: ctx.getFollowersUri(identifier),
+		following: ctx.getFollowingUri(identifier),
+		url: ctx.getActorUri(identifier),
+		publicKey: keys[0].cryptographicKey,
+		assertionMethods: keys.map((k) => k.multikey)
+	});
+}).setKeyPairsDispatcher(async (ctx, identifier) => {
+	if (identifier !== RELAY_SERVER_ACTOR) return [];
+	const rsaPairJson = await ctx.data.kv.get([
+		"keypair",
+		"rsa",
+		identifier
+	]);
+	const ed25519PairJson = await ctx.data.kv.get([
+		"keypair",
+		"ed25519",
+		identifier
+	]);
+	if (rsaPairJson == null || ed25519PairJson == null) {
+		const rsaPair$1 = await (0, __fedify_fedify.generateCryptoKeyPair)("RSASSA-PKCS1-v1_5");
+		const ed25519Pair$1 = await (0, __fedify_fedify.generateCryptoKeyPair)("Ed25519");
+		await ctx.data.kv.set([
+			"keypair",
+			"rsa",
+			identifier
+		], {
+			privateKey: await (0, __fedify_fedify.exportJwk)(rsaPair$1.privateKey),
+			publicKey: await (0, __fedify_fedify.exportJwk)(rsaPair$1.publicKey)
 		});
-		this.#federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(__fedify_fedify_vocab.Follow, async (ctx, follow) => {
-			if (follow.id == null || follow.objectId == null) return;
-			const parsed = ctx.parseUri(follow.objectId);
-			const isPublicFollow = follow.objectId.href === "https://www.w3.org/ns/activitystreams#Public";
-			if (!isPublicFollow && parsed?.type !== "actor") return;
-			const relayActorUri = ctx.getActorUri(RELAY_SERVER_ACTOR);
-			const follower = await follow.getActor(ctx);
-			if (follower == null || follower.id == null || follower.preferredUsername == null || follower.inboxId == null) return;
-			let approved = false;
-			if (this.#subscriptionHandler) approved = await this.#subscriptionHandler(ctx, follower);
-			if (approved) {
-				const followers = await options.kv.get(["followers"]) ?? [];
-				followers.push(follow.id.href);
-				await options.kv.set(["followers"], followers);
-				await options.kv.set(["follower", follow.id.href], await follower.toJsonLd());
-				await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, follower, new __fedify_fedify_vocab.Accept({
-					id: new URL(`#accepts`, relayActorUri),
-					actor: relayActorUri,
-					object: follow
-				}));
-			} else await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, follower, new __fedify_fedify_vocab.Reject({
-				id: new URL(`#rejects`, relayActorUri),
-				actor: relayActorUri,
-				object: follow
-			}));
-		}).on(__fedify_fedify_vocab.Undo, async (ctx, undo) => {
-			const activity = await undo.getObject(ctx);
-			if (activity instanceof __fedify_fedify_vocab.Follow) {
-				if (activity.id == null || activity.actorId == null) return;
-				const activityId = activity.id.href;
-				const followers = await options.kv.get(["followers"]) ?? [];
-				const updatedFollowers = followers.filter((id) => id !== activityId);
-				await options.kv.set(["followers"], updatedFollowers);
-				options.kv.delete(["follower", activityId]);
-			} else console.warn("Unsupported object type ({type}) for Undo activity: {object}", {
-				type: activity?.constructor.name,
-				object: activity
-			});
-		}).on(__fedify_fedify_vocab.Create, async (ctx, create) => {
-			const sender = await create.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			await ctx.forwardActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", {
-				skipIfUnsigned: true,
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
-		}).on(__fedify_fedify_vocab.Delete, async (ctx, deleteActivity) => {
-			const sender = await deleteActivity.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			await ctx.forwardActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", {
-				skipIfUnsigned: true,
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
-		}).on(__fedify_fedify_vocab.Move, async (ctx, deleteActivity) => {
-			const sender = await deleteActivity.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			await ctx.forwardActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", {
-				skipIfUnsigned: true,
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
-		}).on(__fedify_fedify_vocab.Update, async (ctx, deleteActivity) => {
-			const sender = await deleteActivity.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			await ctx.forwardActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", {
-				skipIfUnsigned: true,
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
+		await ctx.data.kv.set([
+			"keypair",
+			"ed25519",
+			identifier
+		], {
+			privateKey: await (0, __fedify_fedify.exportJwk)(ed25519Pair$1.privateKey),
+			publicKey: await (0, __fedify_fedify.exportJwk)(ed25519Pair$1.publicKey)
 		});
+		return [rsaPair$1, ed25519Pair$1];
+	}
+	const rsaPair = {
+		privateKey: await (0, __fedify_fedify.importJwk)(rsaPairJson.privateKey, "private"),
+		publicKey: await (0, __fedify_fedify.importJwk)(rsaPairJson.publicKey, "public")
+	};
+	const ed25519Pair = {
+		privateKey: await (0, __fedify_fedify.importJwk)(ed25519PairJson.privateKey, "private"),
+		publicKey: await (0, __fedify_fedify.importJwk)(ed25519PairJson.publicKey, "public")
+	};
+	return [rsaPair, ed25519Pair];
+});
+async function getFollowerActors(ctx) {
+	const actors = [];
+	for await (const { value } of ctx.data.kv.list(["follower"])) {
+		if (!isRelayFollowerData(value)) continue;
+		if (value.state !== "accepted") continue;
+		const actor = await __fedify_vocab.Object.fromJsonLd(value.actor);
+		if (!(0, __fedify_vocab.isActor)(actor)) continue;
+		actors.push(actor);
+	}
+	return actors;
+}
+async function dispatchRelayActors(ctx, identifier) {
+	if (identifier !== RELAY_SERVER_ACTOR) return null;
+	const actors = await getFollowerActors(ctx);
+	return { items: actors };
+}
+relayBuilder.setFollowersDispatcher("/users/{identifier}/followers", dispatchRelayActors);
+relayBuilder.setFollowingDispatcher("/users/{identifier}/following", dispatchRelayActors);
+
+//#endregion
+//#region src/base.ts
+/**
+* Abstract base class for relay implementations.
+* Provides common infrastructure for both Mastodon and LitePub relays.
+*
+* @internal
+*/
+var BaseRelay = class {
+	federationBuilder;
+	options;
+	federation;
+	constructor(options, relayBuilder$1) {
+		this.options = options;
+		this.federationBuilder = relayBuilder$1;
+	}
+	async fetch(request) {
+		return await (await this.#getFederation()).fetch(request, { contextData: this.options });
+	}
+	/**
+	* Helper method to parse and validate follower data from storage.
+	* Deserializes JSON-LD actor data and validates it.
+	*
+	* @param actorId The actor ID of the follower
+	* @param data Raw data from KV store
+	* @returns RelayFollower object if valid, null otherwise
+	* @internal
+	*/
+	async parseFollowerData(actorId, data) {
+		if (!isRelayFollowerData(data)) return null;
+		const actor = await __fedify_vocab.Object.fromJsonLd(data.actor);
+		if (!(0, __fedify_vocab.isActor)(actor)) return null;
+		return {
+			actorId,
+			actor,
+			state: data.state
+		};
 	}
-	get domain() {
-		return this.#options.domain || "localhost";
+	/**
+	* Lists all followers of the relay.
+	*
+	* @returns An async iterator of follower entries
+	*
+	* @example
+	* ```ts
+	* import { createRelay } from "@fedify/relay";
+	* import { MemoryKvStore } from "@fedify/fedify";
+	*
+	* const relay = createRelay("mastodon", {
+	*   kv: new MemoryKvStore(),
+	*   origin: "https://relay.example.com",
+	*   subscriptionHandler: async (ctx, actor) => true,
+	* });
+	*
+	* for await (const follower of relay.listFollowers()) {
+	*   console.log(`Follower: ${follower.actorId}`);
+	*   console.log(`State: ${follower.state}`);
+	*   console.log(`Actor: ${follower.actor.name}`);
+	* }
+	* ```
+	*
+	* @since 2.0.0
+	*/
+	async *listFollowers() {
+		for await (const entry of this.options.kv.list(["follower"])) {
+			const actorId = entry.key[1];
+			if (typeof actorId !== "string") continue;
+			const follower = await this.parseFollowerData(actorId, entry.value);
+			if (follower) yield follower;
+		}
 	}
-	fetch(request) {
-		return this.#federation.fetch(request, { contextData: void 0 });
+	/**
+	* Gets a specific follower by actor ID.
+	*
+	* @param actorId The actor ID (URL) of the follower to retrieve
+	* @returns The follower entry if found, null otherwise
+	*
+	* @example
+	* ```ts
+	* import { createRelay } from "@fedify/relay";
+	* import { MemoryKvStore } from "@fedify/fedify";
+	*
+	* const relay = createRelay("mastodon", {
+	*   kv: new MemoryKvStore(),
+	*   origin: "https://relay.example.com",
+	*   subscriptionHandler: async (ctx, actor) => true,
+	* });
+	*
+	* const follower = await relay.getFollower(
+	*   "https://mastodon.example.com/users/alice"
+	* );
+	* if (follower) {
+	*   console.log(`State: ${follower.state}`);
+	*   console.log(`Actor: ${follower.actor.preferredUsername}`);
+	* }
+	* ```
+	*
+	* @since 2.0.0
+	*/
+	async getFollower(actorId) {
+		const followerData = await this.options.kv.get(["follower", actorId]);
+		return await this.parseFollowerData(actorId, followerData);
 	}
-	setSubscriptionHandler(handler) {
-		this.#subscriptionHandler = handler;
-		return this;
+	async #getFederation() {
+		if (this.federation == null) {
+			this.federation = await this.federationBuilder.build(this.options);
+			this.setupInboxListeners();
+		}
+		return this.federation;
+	}
+	async #createContext() {
+		const context = (await this.#getFederation()).createContext(new URL(this.options.origin), this.options);
+		return context;
+	}
+	async getActorUri() {
+		const context = await this.#createContext();
+		return context.getActorUri(RELAY_SERVER_ACTOR);
+	}
+	async getSharedInboxUri() {
+		const context = await this.#createContext();
+		return context.getInboxUri();
 	}
 };
+
+//#endregion
+//#region src/follow.ts
+/**
+* Validate Follow activity and return follower actor if valid.
+* This validation is common to both Mastodon and LitePub relay protocols.
+*
+* @param ctx The federation context
+* @param follow The Follow activity to validate
+* @returns The follower Actor if valid, null otherwise
+*/
+async function validateFollowActivity(ctx, follow) {
+	if (follow.id == null || follow.objectId == null) return null;
+	const parsed = ctx.parseUri(follow.objectId);
+	const isPublicFollow = follow.objectId.href === "https://www.w3.org/ns/activitystreams#Public";
+	if (!isPublicFollow && parsed?.type !== "actor") return null;
+	const follower = await follow.getActor(ctx);
+	if (follower == null || follower.id == null || follower.preferredUsername == null || follower.inboxId == null) return null;
+	return follower;
+}
+/**
+* Send Accept or Reject response for a Follow activity.
+* This is common to both Mastodon and LitePub relay protocols.
+*
+* @param ctx The federation context
+* @param follow The Follow activity being responded to
+* @param follower The actor who sent the Follow
+* @param approved Whether the follow was approved
+*/
+async function sendFollowResponse(ctx, follow, follower, approved) {
+	const relayActorUri = ctx.getActorUri(RELAY_SERVER_ACTOR);
+	const Activity = approved ? __fedify_vocab.Accept : __fedify_vocab.Reject;
+	const action = approved ? "accepts" : "rejects";
+	await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, follower, new Activity({
+		id: new URL(`#${action}`, relayActorUri),
+		actor: relayActorUri,
+		object: follow
+	}));
+}
+/**
+* Handle Undo activity for Follow.
+* This logic is identical for both Mastodon and LitePub relay protocols.
+*
+* @param ctx The federation context
+* @param undo The Undo activity to handle
+* @param logger The logger instance to use for warnings
+*/
+async function handleUndoFollow(ctx, undo, logger$2) {
+	const activity = await undo.getObject({
+		crossOrigin: "trust",
+		...ctx
+	});
+	if (activity instanceof __fedify_vocab.Follow) {
+		if (activity.id == null || activity.actorId == null) return;
+		await ctx.data.kv.delete(["follower", activity.actorId.href]);
+	} else logger$2.warn("Unsupported object type ({type}) for Undo activity: {object}", {
+		type: activity?.constructor.name,
+		object: activity
+	});
+}
+
+//#endregion
+//#region src/litepub.ts
+const logger$1 = (0, __logtape_logtape.getLogger)([
+	"fedify",
+	"relay",
+	"litepub"
+]);
 /**
 * A LitePub-compatible ActivityPub relay implementation.
 * This relay follows LitePub's relay protocol and extensions for
@@ -204,251 +321,133 @@ var MastodonRelay = class {
 *
 * @since 2.0.0
 */
-var LitePubRelay = class {
-	#federation;
-	#options;
-	#subscriptionHandler;
-	constructor(options) {
-		this.#options = options;
-		this.#federation = options.federation ?? (0, __fedify_fedify.createFederation)({
-			kv: options.kv,
-			queue: options.queue,
-			documentLoaderFactory: options.documentLoaderFactory,
-			authenticatedDocumentLoaderFactory: options.authenticatedDocumentLoaderFactory
+var LitePubRelay = class extends BaseRelay {
+	async #announceToFollowers(ctx, activity) {
+		const sender = await activity.getActor(ctx);
+		const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
+		const announce = new __fedify_vocab.Announce({
+			id: new URL(`/announce#${crypto.randomUUID()}`, ctx.origin),
+			actor: ctx.getActorUri(RELAY_SERVER_ACTOR),
+			object: activity.objectId,
+			to: __fedify_vocab.PUBLIC_COLLECTION,
+			published: Temporal.Now.instant()
 		});
-		this.#federation.setActorDispatcher("/users/{identifier}", async (ctx, identifier) => {
-			if (identifier !== RELAY_SERVER_ACTOR) return null;
-			const keys = await ctx.getActorKeyPairs(identifier);
-			return new __fedify_fedify_vocab.Application({
-				id: ctx.getActorUri(identifier),
-				preferredUsername: identifier,
-				name: "ActivityPub Relay",
-				summary: "LitePub-compatible ActivityPub relay server",
-				inbox: ctx.getInboxUri(),
-				followers: ctx.getFollowersUri(identifier),
-				following: ctx.getFollowingUri(identifier),
-				url: ctx.getActorUri(identifier),
-				publicKey: keys[0].cryptographicKey,
-				assertionMethods: keys.map((k) => k.multikey)
-			});
-		}).setKeyPairsDispatcher(async (_ctx, identifier) => {
-			if (identifier !== RELAY_SERVER_ACTOR) return [];
-			const rsaPairJson = await options.kv.get([
-				"keypair",
-				"rsa",
-				identifier
-			]);
-			const ed25519PairJson = await options.kv.get([
-				"keypair",
-				"ed25519",
-				identifier
-			]);
-			if (rsaPairJson == null || ed25519PairJson == null) {
-				const rsaPair$1 = await (0, __fedify_fedify.generateCryptoKeyPair)("RSASSA-PKCS1-v1_5");
-				const ed25519Pair$1 = await (0, __fedify_fedify.generateCryptoKeyPair)("Ed25519");
-				await options.kv.set([
-					"keypair",
-					"rsa",
-					identifier
-				], {
-					privateKey: await (0, __fedify_fedify.exportJwk)(rsaPair$1.privateKey),
-					publicKey: await (0, __fedify_fedify.exportJwk)(rsaPair$1.publicKey)
-				});
-				await options.kv.set([
-					"keypair",
-					"ed25519",
-					identifier
-				], {
-					privateKey: await (0, __fedify_fedify.exportJwk)(ed25519Pair$1.privateKey),
-					publicKey: await (0, __fedify_fedify.exportJwk)(ed25519Pair$1.publicKey)
-				});
-				return [rsaPair$1, ed25519Pair$1];
-			}
-			const rsaPair = {
-				privateKey: await (0, __fedify_fedify.importJwk)(rsaPairJson.privateKey, "private"),
-				publicKey: await (0, __fedify_fedify.importJwk)(rsaPairJson.publicKey, "public")
-			};
-			const ed25519Pair = {
-				privateKey: await (0, __fedify_fedify.importJwk)(ed25519PairJson.privateKey, "private"),
-				publicKey: await (0, __fedify_fedify.importJwk)(ed25519PairJson.publicKey, "public")
-			};
-			return [rsaPair, ed25519Pair];
+		await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", announce, {
+			excludeBaseUris,
+			preferSharedInbox: true
 		});
-		this.#federation.setFollowingDispatcher("/users/{identifier}/following", async (_ctx, identifier) => {
-			if (identifier !== RELAY_SERVER_ACTOR) return null;
-			const followers = await options.kv.get(["followers"]) ?? [];
-			const actors = [];
-			for (const followerId of followers) {
-				const follower = await options.kv.get(["follower", followerId]);
-				if (!follower) continue;
-				const actor = await __fedify_fedify_vocab.Object.fromJsonLd(follower.actor);
-				if (!(0, __fedify_fedify_vocab.isActor)(actor)) continue;
-				actors.push(actor);
-			}
-			return { items: actors };
-		});
-		this.#federation.setFollowersDispatcher("/users/{identifier}/followers", async (_ctx, identifier) => {
-			if (identifier !== RELAY_SERVER_ACTOR) return null;
-			const followers = await options.kv.get(["followers"]) ?? [];
-			const actors = [];
-			for (const followerId of followers) {
-				const follower = await options.kv.get(["follower", followerId]);
-				if (!follower) continue;
-				const actor = await __fedify_fedify_vocab.Object.fromJsonLd(follower.actor);
-				if (!(0, __fedify_fedify_vocab.isActor)(actor)) continue;
-				actors.push(actor);
-			}
-			return { items: actors };
-		});
-		this.#federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(__fedify_fedify_vocab.Follow, async (ctx, follow) => {
-			if (follow.id == null || follow.objectId == null) return;
-			const parsed = ctx.parseUri(follow.objectId);
-			const isPublicFollow = follow.objectId.href === "https://www.w3.org/ns/activitystreams#Public";
-			if (!isPublicFollow && parsed?.type !== "actor") return;
-			const relayActorUri = ctx.getActorUri(RELAY_SERVER_ACTOR);
-			const follower = await follow.getActor(ctx);
-			if (follower == null || follower.id == null || follower.preferredUsername == null || follower.inboxId == null) return;
-			const existingFollow = await options.kv.get(["follower", follower.id.href]);
+	}
+	setupInboxListeners() {
+		if (this.federation != null) this.federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(__fedify_vocab.Follow, async (ctx, follow) => {
+			const follower = await validateFollowActivity(ctx, follow);
+			if (!follower || !follower.id) return;
+			const existingFollow = await ctx.data.kv.get(["follower", follower.id.href]);
 			if (existingFollow?.state === "pending") return;
-			let subscriptionApproved = false;
-			if (this.#subscriptionHandler) subscriptionApproved = await this.#subscriptionHandler(ctx, follower);
-			if (subscriptionApproved) {
-				await options.kv.set(["follower", follower.id.href], {
-					"actor": await follower.toJsonLd(),
-					"state": "pending"
+			const approved = await this.options.subscriptionHandler(ctx, follower);
+			if (approved) {
+				await ctx.data.kv.set(["follower", follower.id.href], {
+					actor: await follower.toJsonLd(),
+					state: "pending"
 				});
-				await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, follower, new __fedify_fedify_vocab.Accept({
-					id: new URL(`#accepts`, relayActorUri),
-					actor: relayActorUri,
-					object: follow
-				}));
-				await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, follower, new __fedify_fedify_vocab.Follow({
+				await sendFollowResponse(ctx, follow, follower, approved);
+				const relayActorUri = ctx.getActorUri(RELAY_SERVER_ACTOR);
+				await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, follower, new __fedify_vocab.Follow({
 					actor: relayActorUri,
 					object: follower.id,
 					to: follower.id
 				}));
-			} else await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, follower, new __fedify_fedify_vocab.Reject({
-				id: new URL(`#rejects`, relayActorUri),
-				actor: relayActorUri,
-				object: follow
-			}));
-		}).on(__fedify_fedify_vocab.Accept, async (ctx, accept) => {
+			} else await sendFollowResponse(ctx, follow, follower, approved);
+		}).on(__fedify_vocab.Accept, async (ctx, accept) => {
 			const follow = await accept.getObject({
 				crossOrigin: "trust",
 				...ctx
 			});
-			if (!(follow instanceof __fedify_fedify_vocab.Follow)) return;
-			const follower = follow.actorId;
-			if (follower == null) return;
-			const following = await accept.getActor();
-			if (!(0, __fedify_fedify_vocab.isActor)(following) || !following.id) return;
-			const parsed = ctx.parseUri(follower);
+			if (!(follow instanceof __fedify_vocab.Follow)) return;
+			const relayActorId = follow.actorId;
+			if (relayActorId == null) return;
+			const followerActor = await accept.getActor();
+			if (!(0, __fedify_vocab.isActor)(followerActor) || !followerActor.id) return;
+			const parsed = ctx.parseUri(relayActorId);
 			if (parsed == null || parsed.type !== "actor") return;
-			const followerData = await options.kv.get(["follower", following.id.href]);
+			const followerData = await ctx.data.kv.get(["follower", followerActor.id.href]);
 			if (followerData == null) return;
 			const updatedFollowerData = {
 				...followerData,
 				state: "accepted"
 			};
-			await options.kv.set(["follower", following.id.href], updatedFollowerData);
-			const followers = await options.kv.get(["followers"]) ?? [];
-			followers.push(following.id.href);
-			await options.kv.set(["followers"], followers);
-		}).on(__fedify_fedify_vocab.Undo, async (ctx, undo) => {
-			const activity = await undo.getObject({
-				crossOrigin: "trust",
-				...ctx
-			});
-			if (activity instanceof __fedify_fedify_vocab.Follow) {
-				if (activity.id == null || activity.actorId == null) return;
-				const followers = await options.kv.get(["followers"]) ?? [];
-				const updatedFollowers = followers.filter((id) => id !== activity.actorId?.href);
-				await options.kv.set(["followers"], updatedFollowers);
-				options.kv.delete(["follower", activity.actorId?.href]);
-			} else console.warn("Unsupported object type ({type}) for Undo activity: {object}", {
-				type: activity?.constructor.name,
-				object: activity
-			});
-		}).on(__fedify_fedify_vocab.Create, async (ctx, create) => {
-			const sender = await create.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			const announce = new __fedify_fedify_vocab.Announce({
-				id: new URL(`/announce#${crypto.randomUUID()}`, ctx.origin),
-				actor: ctx.getActorUri(RELAY_SERVER_ACTOR),
-				object: create.objectId,
-				to: __fedify_fedify_vocab.PUBLIC_COLLECTION,
-				published: Temporal.Now.instant()
-			});
-			await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", announce, {
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
-		}).on(__fedify_fedify_vocab.Update, async (ctx, update) => {
-			const sender = await update.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			const announce = new __fedify_fedify_vocab.Announce({
-				id: new URL(`/announce#${crypto.randomUUID()}`, ctx.origin),
-				actor: ctx.getActorUri(RELAY_SERVER_ACTOR),
-				object: update.objectId,
-				to: __fedify_fedify_vocab.PUBLIC_COLLECTION
-			});
-			await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", announce, {
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
-		}).on(__fedify_fedify_vocab.Move, async (ctx, move) => {
-			const sender = await move.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			const announce = new __fedify_fedify_vocab.Announce({
-				id: new URL(`/announce#${crypto.randomUUID()}`, ctx.origin),
-				actor: ctx.getActorUri(RELAY_SERVER_ACTOR),
-				object: move.objectId,
-				to: __fedify_fedify_vocab.PUBLIC_COLLECTION
-			});
-			await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", announce, {
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
-		}).on(__fedify_fedify_vocab.Delete, async (ctx, deleteActivity) => {
-			const sender = await deleteActivity.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			const announce = new __fedify_fedify_vocab.Announce({
-				id: new URL(`/announce#${crypto.randomUUID()}`, ctx.origin),
-				actor: ctx.getActorUri(RELAY_SERVER_ACTOR),
-				object: deleteActivity.objectId,
-				to: __fedify_fedify_vocab.PUBLIC_COLLECTION
-			});
-			await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", announce, {
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
-		}).on(__fedify_fedify_vocab.Announce, async (ctx, announceActivity) => {
-			const sender = await announceActivity.getActor(ctx);
-			const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
-			const announce = new __fedify_fedify_vocab.Announce({
-				id: new URL(`/announce#${crypto.randomUUID()}`, ctx.origin),
-				actor: ctx.getActorUri(RELAY_SERVER_ACTOR),
-				object: announceActivity.objectId,
-				to: __fedify_fedify_vocab.PUBLIC_COLLECTION
-			});
-			await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", announce, {
-				excludeBaseUris,
-				preferSharedInbox: true
-			});
-		});
+			await ctx.data.kv.set(["follower", followerActor.id.href], updatedFollowerData);
+		}).on(__fedify_vocab.Undo, async (ctx, undo) => await handleUndoFollow(ctx, undo, logger$1)).on(__fedify_vocab.Create, async (ctx, create) => await this.#announceToFollowers(ctx, create)).on(__fedify_vocab.Update, async (ctx, update) => await this.#announceToFollowers(ctx, update)).on(__fedify_vocab.Move, async (ctx, move) => await this.#announceToFollowers(ctx, move)).on(__fedify_vocab.Delete, async (ctx, deleteActivity) => await this.#announceToFollowers(ctx, deleteActivity)).on(__fedify_vocab.Announce, async (ctx, announce) => await this.#announceToFollowers(ctx, announce));
 	}
-	get domain() {
-		return this.#options.domain || "localhost";
-	}
-	fetch(request) {
-		return this.#federation.fetch(request, { contextData: void 0 });
+};
+
+//#endregion
+//#region src/mastodon.ts
+const logger = (0, __logtape_logtape.getLogger)([
+	"fedify",
+	"relay",
+	"mastodon"
+]);
+/**
+* A Mastodon-compatible ActivityPub relay implementation.
+* This relay follows Mastodon's relay protocol for compatibility
+* with Mastodon instances.
+*
+* @since 2.0.0
+*/
+var MastodonRelay = class extends BaseRelay {
+	async #forwardToFollowers(ctx, activity) {
+		const sender = await activity.getActor(ctx);
+		const excludeBaseUris = sender?.id ? [new URL(sender.id)] : [];
+		await ctx.forwardActivity({ identifier: RELAY_SERVER_ACTOR }, "followers", {
+			skipIfUnsigned: true,
+			excludeBaseUris,
+			preferSharedInbox: true
+		});
 	}
-	setSubscriptionHandler(handler) {
-		this.#subscriptionHandler = handler;
-		return this;
+	setupInboxListeners() {
+		if (this.federation != null) this.federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(__fedify_vocab.Follow, async (ctx, follow) => {
+			const follower = await validateFollowActivity(ctx, follow);
+			if (!follower || !follower.id) return;
+			const approved = await this.options.subscriptionHandler(ctx, follower);
+			if (approved) await ctx.data.kv.set(["follower", follower.id.href], {
+				actor: await follower.toJsonLd(),
+				state: "accepted"
+			});
+			await sendFollowResponse(ctx, follow, follower, approved);
+		}).on(__fedify_vocab.Undo, async (ctx, undo) => await handleUndoFollow(ctx, undo, logger)).on(__fedify_vocab.Create, async (ctx, create) => await this.#forwardToFollowers(ctx, create)).on(__fedify_vocab.Delete, async (ctx, deleteActivity) => await this.#forwardToFollowers(ctx, deleteActivity)).on(__fedify_vocab.Move, async (ctx, move) => await this.#forwardToFollowers(ctx, move)).on(__fedify_vocab.Update, async (ctx, update) => await this.#forwardToFollowers(ctx, update)).on(__fedify_vocab.Announce, async (ctx, announce) => await this.#forwardToFollowers(ctx, announce));
 	}
 };
 
 //#endregion
-exports.LitePubRelay = LitePubRelay;
-exports.MastodonRelay = MastodonRelay;
+//#region src/factory.ts
+/**
+* Factory function to create a relay instance.
+*
+* @param type The type of relay to create ("mastodon" or "litepub")
+* @param options Configuration options for the relay
+* @returns A relay instance
+*
+* @example
+* ```ts
+* import { createRelay } from "@fedify/relay";
+* import { MemoryKvStore } from "@fedify/fedify";
+*
+* const relay = createRelay("mastodon", {
+*   kv: new MemoryKvStore(),
+*   origin: "https://relay.example.com",
+*   subscriptionHandler: async (ctx, actor) => true,
+* });
+* ```
+*
+* @since 2.0.0
+*/
+function createRelay(type, options) {
+	switch (type) {
+		case "mastodon": return new MastodonRelay(options, relayBuilder);
+		case "litepub": return new LitePubRelay(options, relayBuilder);
+	}
+}
+
+//#endregion
+exports.RELAY_SERVER_ACTOR = RELAY_SERVER_ACTOR;
+exports.createRelay = createRelay;