@fedify/relay 2.0.0-pr.471.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2025 Hong Minhee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,257 @@
+<!-- deno-fmt-ignore-file -->
+
+@fedify/relay: ActivityPub relay for Fedify
+============================================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+[![Follow @fedify@hollo.social][@fedify@hollo.social badge]][@fedify@hollo.social]
+
+*This package is available since Fedify 2.0.0.*
+
+This package provides ActivityPub relay functionality for the [Fedify]
+ecosystem, enabling the creation and management of relay servers that can
+forward activities between federated instances.
+
+
+What is an ActivityPub relay?
+------------------------------
+
+ActivityPub relays are infrastructure components that help small instances
+participate effectively in the federated social network by acting as
+intermediary servers that distribute public content without requiring
+individual actor-following relationships.  When an instance subscribes to
+a relay, all public posts from that instance are forwarded to all other
+subscribed instances, creating a shared pool of federated content.
+
+
+Relay protocols
+---------------
+
+This package supports two popular relay protocols used in the fediverse:
+
+### 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.
+
+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
+
+### LitePub-style relay
+
+*LitePub relay support is planned for a future release.*
+
+The LitePub-style relay protocol uses bidirectional following relationships
+and wraps activities in `Announce` activities for distribution.
+
+
+Installation
+------------
+
+::: code-group
+
+~~~~ sh [Deno]
+deno add jsr:@fedify/relay
+~~~~
+
+~~~~ sh [npm]
+npm add @fedify/relay
+~~~~
+
+~~~~ sh [pnpm]
+pnpm add @fedify/relay
+~~~~
+
+~~~~ sh [Yarn]
+yarn add @fedify/relay
+~~~~
+
+~~~~ sh [Bun]
+bun add @fedify/relay
+~~~~
+
+:::
+
+
+Usage
+-----
+
+### Creating a Mastodon-style relay
+
+Here's a simple example of creating a Mastodon-compatible relay server:
+
+~~~~ typescript
+import { MastodonRelay } from "@fedify/relay";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const relay = new MastodonRelay({
+  kv: new MemoryKvStore(),
+  domain: "relay.example.com",
+});
+
+// Optional: Set a custom subscription handler to approve/reject subscriptions
+relay.setSubscriptionHandler(async (ctx, actor) => {
+  // Implement your approval logic here
+  // Return true to approve, false to reject
+  const domain = new URL(actor.id!).hostname;
+  const blockedDomains = ["spam.example", "blocked.example"];
+  return !blockedDomains.includes(domain);
+});
+
+// Serve the relay
+Deno.serve((request) => relay.fetch(request));
+~~~~
+
+### Subscription handling
+
+By default, the relay automatically rejects all subscription requests.
+You can customize this behavior by setting a subscription handler:
+
+~~~~ typescript
+relay.setSubscriptionHandler(async (ctx, actor) => {
+  // Example: Only allow subscriptions from specific domains
+  const domain = new URL(actor.id!).hostname;
+  const allowedDomains = ["mastodon.social", "fosstodon.org"];
+  return allowedDomains.includes(domain);
+});
+~~~~
+
+### Integration with web frameworks
+
+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:
+
+~~~~ typescript
+import { Hono } from "hono";
+import { MastodonRelay } from "@fedify/relay";
+import { MemoryKvStore } from "@fedify/fedify";
+
+const app = new Hono();
+const relay = new MastodonRelay({
+  kv: new MemoryKvStore(),
+  domain: "relay.example.com",
+});
+
+app.use("*", async (c) => {
+  return await relay.fetch(c.req.raw);
+});
+
+export default app;
+~~~~
+
+
+How it works
+------------
+
+The relay operates by:
+
+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
+
+
+Storage requirements
+--------------------
+
+The relay requires a key–value store to persist:
+
+ -  Subscriber list and their Follow activity IDs
+ -  Subscriber actor information
+ -  Relay's cryptographic key pairs (RSA and Ed25519)
+
+Any `KvStore` implementation from Fedify can be used, including:
+
+ -  `MemoryKvStore` (for development/testing)
+ -  `DenoKvStore` (Deno KV)
+ -  `RedisKvStore` (Redis)
+ -  `PostgresKvStore` (PostgreSQL)
+ -  `SqliteKvStore` (SQLite)
+
+For production use, choose a persistent storage backend like Redis or
+PostgreSQL.  See the [Fedify documentation on key–value stores] for more
+details.
+
+
+API reference
+-------------
+
+### `MastodonRelay`
+
+A Mastodon-compatible ActivityPub relay implementation.
+
+#### Constructor
+
+~~~~ typescript
+new MastodonRelay(options: RelayOptions)
+~~~~
+
+#### Properties
+
+ -  `domain`: The relay's domain name (read-only)
+
+#### Methods
+
+ -  `fetch(request: Request): Promise<Response>`: Handle incoming HTTP requests
+ -  `setSubscriptionHandler(handler: SubscriptionRequestHandler): this`:
+    Set a custom handler for subscription approval/rejection
+
+### `RelayOptions`
+
+Configuration options for the relay:
+
+ -  `kv: KvStore` (required): Key–value store for persisting relay data
+ -  `domain?: string`: Relay's domain name (defaults to `"localhost"`)
+ -  `documentLoaderFactory?: DocumentLoaderFactory`: Custom document loader
+    factory
+ -  `authenticatedDocumentLoaderFactory?: AuthenticatedDocumentLoaderFactory`:
+    Custom authenticated document loader factory
+ -  `federation?: Federation<void>`: Custom Federation instance (for advanced
+    use cases)
+ -  `queue?: MessageQueue`: Message queue for background activity processing
+
+### `SubscriptionRequestHandler`
+
+A function that determines whether to approve a subscription request:
+
+~~~~ typescript
+type SubscriptionRequestHandler = (
+  ctx: Context<void>,
+  clientActor: Actor,
+) => Promise<boolean>
+~~~~
+
+Parameters:
+
+ -  `ctx`: The Fedify context object
+ -  `clientActor`: The actor requesting to subscribe
+
+Returns:
+
+ -  `true` to approve the subscription
+ -  `false` to reject the subscription
+
+
+[JSR]: https://jsr.io/@fedify/relay
+[JSR badge]: https://jsr.io/badges/@fedify/relay
+[npm]: https://www.npmjs.com/package/@fedify/relay
+[npm badge]: https://img.shields.io/npm/v/@fedify/relay?logo=npm
+[@fedify@hollo.social badge]: https://fedi-badge.deno.dev/@fedify@hollo.social/followers.svg
+[@fedify@hollo.social]: https://hollo.social/@fedify
+[Fedify]: https://fedify.dev/
+[Fedify documentation on key–value stores]: https://fedify.dev/manual/kv

package/dist/mod.cjs

@@ -0,0 +1,229 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __fedify_fedify = __toESM(require("@fedify/fedify"));
+const __fedify_fedify_vocab = __toESM(require("@fedify/fedify/vocab"));
+
+//#region src/relay.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.
+*
+* @since 2.0.0
+*/
+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 };
+		});
+		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 recipient = await follow.getActor(ctx);
+			if (recipient == null || recipient.id == null || recipient.preferredUsername == null || recipient.inboxId == null) return;
+			let approved = false;
+			if (this.#subscriptionHandler) approved = await this.#subscriptionHandler(ctx, recipient);
+			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 recipient.toJsonLd());
+				await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, recipient, new __fedify_fedify_vocab.Accept({
+					id: new URL(`#accepts`, relayActorUri),
+					actor: relayActorUri,
+					object: follow
+				}));
+			} else await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, recipient, 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
+			});
+		});
+	}
+	get domain() {
+		return this.#options.domain || "localhost";
+	}
+	fetch(request) {
+		return this.#federation.fetch(request, { contextData: void 0 });
+	}
+	setSubscriptionHandler(handler) {
+		this.#subscriptionHandler = handler;
+		return this;
+	}
+};
+/**
+* A LitePub-compatible ActivityPub relay implementation.
+* This relay follows LitePub's relay protocol and extensions for
+* enhanced federation capabilities.
+*
+* @since 2.0.0
+*/
+var LitePubRelay = class {
+	#federation;
+	#options;
+	#subscriptionHandler;
+	constructor(options) {
+		this.#options = options;
+		this.#federation = (0, __fedify_fedify.createFederation)({ kv: options.kv });
+	}
+	get domain() {
+		return this.#options.domain || "localhost";
+	}
+	fetch(request) {
+		return this.#federation.fetch(request, { contextData: void 0 });
+	}
+	setSubscriptionHandler(handler) {
+		this.#subscriptionHandler = handler;
+		return this;
+	}
+};
+
+//#endregion
+exports.LitePubRelay = LitePubRelay;
+exports.MastodonRelay = MastodonRelay;

package/dist/mod.d.cts

@@ -0,0 +1,59 @@
+import { Context, Federation, KvStore, MessageQueue } from "@fedify/fedify";
+import { Actor } from "@fedify/fedify/vocab";
+import { AuthenticatedDocumentLoaderFactory, DocumentLoaderFactory } from "@fedify/vocab-runtime";
+
+//#region src/relay.d.ts
+
+/**
+ * Handler for subscription requests (Follow/Undo activities).
+ */
+type SubscriptionRequestHandler = (ctx: Context<void>, clientActor: Actor) => Promise<boolean>;
+/**
+ * Configuration options for the ActivityPub relay.
+ */
+interface RelayOptions {
+  kv: KvStore;
+  domain?: string;
+  documentLoaderFactory?: DocumentLoaderFactory;
+  authenticatedDocumentLoaderFactory?: AuthenticatedDocumentLoaderFactory;
+  federation?: Federation<void>;
+  queue?: MessageQueue;
+}
+/**
+ * Base interface for ActivityPub relay implementations.
+ */
+interface Relay {
+  readonly domain: string;
+  fetch(request: Request): Promise<Response>;
+  setSubscriptionHandler(handler: SubscriptionRequestHandler): this;
+}
+/**
+ * A Mastodon-compatible ActivityPub relay implementation.
+ * This relay follows Mastodon's relay protocol for maximum compatibility
+ * with Mastodon instances.
+ *
+ * @since 2.0.0
+ */
+declare class MastodonRelay implements Relay {
+  #private;
+  constructor(options: RelayOptions);
+  get domain(): string;
+  fetch(request: Request): Promise<Response>;
+  setSubscriptionHandler(handler: SubscriptionRequestHandler): this;
+}
+/**
+ * A LitePub-compatible ActivityPub relay implementation.
+ * This relay follows LitePub's relay protocol and extensions for
+ * enhanced federation capabilities.
+ *
+ * @since 2.0.0
+ */
+declare class LitePubRelay implements Relay {
+  #private;
+  constructor(options: RelayOptions);
+  get domain(): string;
+  fetch(request: Request): Promise<Response>;
+  setSubscriptionHandler(handler: SubscriptionRequestHandler): this;
+}
+//#endregion
+export { LitePubRelay, MastodonRelay, Relay, RelayOptions };

package/dist/mod.d.ts

@@ -0,0 +1,59 @@
+import { Context, Federation, KvStore, MessageQueue } from "@fedify/fedify";
+import { Actor } from "@fedify/fedify/vocab";
+import { AuthenticatedDocumentLoaderFactory, DocumentLoaderFactory } from "@fedify/vocab-runtime";
+
+//#region src/relay.d.ts
+
+/**
+ * Handler for subscription requests (Follow/Undo activities).
+ */
+type SubscriptionRequestHandler = (ctx: Context<void>, clientActor: Actor) => Promise<boolean>;
+/**
+ * Configuration options for the ActivityPub relay.
+ */
+interface RelayOptions {
+  kv: KvStore;
+  domain?: string;
+  documentLoaderFactory?: DocumentLoaderFactory;
+  authenticatedDocumentLoaderFactory?: AuthenticatedDocumentLoaderFactory;
+  federation?: Federation<void>;
+  queue?: MessageQueue;
+}
+/**
+ * Base interface for ActivityPub relay implementations.
+ */
+interface Relay {
+  readonly domain: string;
+  fetch(request: Request): Promise<Response>;
+  setSubscriptionHandler(handler: SubscriptionRequestHandler): this;
+}
+/**
+ * A Mastodon-compatible ActivityPub relay implementation.
+ * This relay follows Mastodon's relay protocol for maximum compatibility
+ * with Mastodon instances.
+ *
+ * @since 2.0.0
+ */
+declare class MastodonRelay implements Relay {
+  #private;
+  constructor(options: RelayOptions);
+  get domain(): string;
+  fetch(request: Request): Promise<Response>;
+  setSubscriptionHandler(handler: SubscriptionRequestHandler): this;
+}
+/**
+ * A LitePub-compatible ActivityPub relay implementation.
+ * This relay follows LitePub's relay protocol and extensions for
+ * enhanced federation capabilities.
+ *
+ * @since 2.0.0
+ */
+declare class LitePubRelay implements Relay {
+  #private;
+  constructor(options: RelayOptions);
+  get domain(): string;
+  fetch(request: Request): Promise<Response>;
+  setSubscriptionHandler(handler: SubscriptionRequestHandler): this;
+}
+//#endregion
+export { LitePubRelay, MastodonRelay, Relay, RelayOptions };

package/dist/mod.js

@@ -0,0 +1,205 @@
+import { createFederation, exportJwk, generateCryptoKeyPair, importJwk } from "@fedify/fedify";
+import { Accept, Create, Delete, Follow, Move, Object as Object$1, Reject, Service, Undo, Update, isActor } from "@fedify/fedify/vocab";
+
+//#region src/relay.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.
+*
+* @since 2.0.0
+*/
+var MastodonRelay = class {
+	#federation;
+	#options;
+	#subscriptionHandler;
+	constructor(options) {
+		this.#options = options;
+		this.#federation = options.federation ?? 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 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 generateCryptoKeyPair("RSASSA-PKCS1-v1_5");
+				const ed25519Pair$1 = await generateCryptoKeyPair("Ed25519");
+				await options.kv.set([
+					"keypair",
+					"rsa",
+					identifier
+				], {
+					privateKey: await exportJwk(rsaPair$1.privateKey),
+					publicKey: await exportJwk(rsaPair$1.publicKey)
+				});
+				await options.kv.set([
+					"keypair",
+					"ed25519",
+					identifier
+				], {
+					privateKey: await exportJwk(ed25519Pair$1.privateKey),
+					publicKey: await exportJwk(ed25519Pair$1.publicKey)
+				});
+				return [rsaPair$1, ed25519Pair$1];
+			}
+			const rsaPair = {
+				privateKey: await importJwk(rsaPairJson.privateKey, "private"),
+				publicKey: await importJwk(rsaPairJson.publicKey, "public")
+			};
+			const ed25519Pair = {
+				privateKey: await importJwk(ed25519PairJson.privateKey, "private"),
+				publicKey: await 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 Object$1.fromJsonLd(actorJson);
+				if (!isActor(actor)) continue;
+				actors.push(actor);
+			}
+			return { items: actors };
+		});
+		this.#federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(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 recipient = await follow.getActor(ctx);
+			if (recipient == null || recipient.id == null || recipient.preferredUsername == null || recipient.inboxId == null) return;
+			let approved = false;
+			if (this.#subscriptionHandler) approved = await this.#subscriptionHandler(ctx, recipient);
+			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 recipient.toJsonLd());
+				await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, recipient, new Accept({
+					id: new URL(`#accepts`, relayActorUri),
+					actor: relayActorUri,
+					object: follow
+				}));
+			} else await ctx.sendActivity({ identifier: RELAY_SERVER_ACTOR }, recipient, new Reject({
+				id: new URL(`#rejects`, relayActorUri),
+				actor: relayActorUri,
+				object: follow
+			}));
+		}).on(Undo, async (ctx, undo) => {
+			const activity = await undo.getObject(ctx);
+			if (activity instanceof 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(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(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(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(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
+			});
+		});
+	}
+	get domain() {
+		return this.#options.domain || "localhost";
+	}
+	fetch(request) {
+		return this.#federation.fetch(request, { contextData: void 0 });
+	}
+	setSubscriptionHandler(handler) {
+		this.#subscriptionHandler = handler;
+		return this;
+	}
+};
+/**
+* A LitePub-compatible ActivityPub relay implementation.
+* This relay follows LitePub's relay protocol and extensions for
+* enhanced federation capabilities.
+*
+* @since 2.0.0
+*/
+var LitePubRelay = class {
+	#federation;
+	#options;
+	#subscriptionHandler;
+	constructor(options) {
+		this.#options = options;
+		this.#federation = createFederation({ kv: options.kv });
+	}
+	get domain() {
+		return this.#options.domain || "localhost";
+	}
+	fetch(request) {
+		return this.#federation.fetch(request, { contextData: void 0 });
+	}
+	setSubscriptionHandler(handler) {
+		this.#subscriptionHandler = handler;
+		return this;
+	}
+};
+
+//#endregion
+export { LitePubRelay, MastodonRelay };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@fedify/relay",
+  "version": "2.0.0-pr.471.1",
+  "description": "ActivityPub relay support for Fedify",
+  "keywords": [
+    "Fedify",
+    "ActivityPub",
+    "Fediverse",
+    "Relay"
+  ],
+  "author": {
+    "name": "Jiwon Kwon",
+    "email": "jiwonkwon@duck.com"
+  },
+  "homepage": "https://fedify.dev/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fedify-dev/fedify.git",
+    "directory": "packages/relay"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fedify-dev/fedify/issues"
+  },
+  "funding": [
+    "https://opencollective.com/fedify",
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "main": "./dist/mod.cjs",
+  "module": "./dist/mod.js",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts",
+        "default": "./dist/mod.d.ts"
+      },
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs",
+      "default": "./dist/mod.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "package.json"
+  ],
+  "peerDependencies": {
+    "@fedify/fedify": "^2.0.0-pr.471.1"
+  },
+  "devDependencies": {
+    "tsdown": "^0.12.9",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "deno task codegen && tsdown",
+    "prepublish": "deno task codegen && tsdown",
+    "test": "deno task codegen && tsdown && cd dist/ && node --test",
+    "test:bun": "deno task codegen && deno task pnpm:build-vocab && tsdown && cd dist/ && bun test --timeout 60000",
+    "test:cfworkers": "deno task codegen && wrangler deploy --dry-run --outdir src/cfworkers && node --import=tsx src/cfworkers/client.ts"
+  }
+}