@fedify/botkit 0.5.0-dev.209 → 0.5.0-dev.225

package/dist/instance-impl.js

@@ -0,0 +1,603 @@
+
+      import { Temporal, toTemporalInstant } from "@js-temporal/polyfill";
+      Date.prototype.toTemporalInstant = toTemporalInstant;
+    
+import deno_default from "./deno.js";
+import { parseLocalUri, rewriteLegacyObjectPath } from "./uri.js";
+import { isMessageObject, isQuoteLink } from "./message-impl.js";
+import { KvRepository } from "./repository.js";
+import { BotGroupImpl, BotImpl, GroupBotImpl, wrapBotImpl } from "./bot-impl.js";
+import { app, multiApp } from "./pages.js";
+import { Accept, Announce, Application, Article, ChatMessage, Create, Delete, Emoji, Endpoints, Follow, Image, Like, Link, Mention, Note, Question, Reject, Undo } from "@fedify/vocab";
+import { createFederation, generateCryptoKeyPair } from "@fedify/fedify";
+import { getLogger } from "@logtape/logtape";
+import mimeDb from "mime-db";
+import fs from "node:fs/promises";
+import { getXForwardedRequest } from "x-forwarded-fetch";
+
+//#region src/instance-impl.ts
+/**
+* The default identifier of the instance actor: an internal `Application`
+* actor that an {@link Instance} uses for signing shared-inbox related
+* requests on behalf of the whole instance.  It can be overridden through
+* the {@link CreateInstanceOptions.instanceActorIdentifier} option; either
+* way, bots cannot take the effective identifier.
+* @since 0.5.0
+*/
+const DEFAULT_INSTANCE_ACTOR_IDENTIFIER = "__botkit_instance__";
+/**
+* The internal implementation of an {@link Instance}.  It owns the single
+* Fedify {@link Federation} shared by every bot hosted on the instance, and
+* routes federation callbacks to the right bot by its identifier.
+* @internal
+*/
+var InstanceImpl = class {
+	kv;
+	queue;
+	/**
+	* The root repository shared by every bot hosted on the instance.
+	*/
+	repository;
+	software;
+	behindProxy;
+	pages;
+	collectionWindow;
+	federation;
+	customEmojis = {};
+	/**
+	* The identifier of the bot actor that owns local objects whose URIs are
+	* in the legacy (pre-0.5) format, which did not carry the identifier.
+	*/
+	legacyObjectUrisIdentifier;
+	/**
+	* Whether the instance was created through the single-bot
+	* `createBot()` compatibility path.
+	*/
+	compatMode;
+	/**
+	* The reserved identifier of the instance actor.
+	*/
+	instanceActorIdentifier;
+	#bots = /* @__PURE__ */ new Map();
+	#groups = [];
+	/**
+	* Memoizes dynamic bot resolution per Fedify context, which is stable
+	* for the duration of one HTTP dispatch or one queue-delivered inbox
+	* activity, so a dispatcher is invoked at most once per identifier per
+	* request.  Entries die with their context.
+	*/
+	#resolutionCache = /* @__PURE__ */ new WeakMap();
+	constructor(options) {
+		this.kv = options.kv;
+		this.queue = options.queue;
+		this.repository = options.repository ?? new KvRepository(options.kv);
+		this.software = options.software;
+		this.behindProxy = options.behindProxy ?? false;
+		this.pages = {
+			color: "green",
+			css: "",
+			...options.pages ?? {}
+		};
+		this.collectionWindow = options.collectionWindow ?? 50;
+		this.legacyObjectUrisIdentifier = options.legacyObjectUris?.identifier;
+		this.compatMode = options.compatMode ?? false;
+		this.instanceActorIdentifier = options.instanceActorIdentifier ?? DEFAULT_INSTANCE_ACTOR_IDENTIFIER;
+		if (this.instanceActorIdentifier === "") throw new TypeError("The instance actor identifier cannot be empty.");
+		this.federation = createFederation({
+			kv: options.kv,
+			queue: options.queue,
+			userAgent: { software: `BotKit/${deno_default.version}` }
+		});
+		this.#initialize();
+	}
+	#initialize() {
+		this.federation.setActorDispatcher("/ap/actor/{identifier}", async (ctx, identifier) => {
+			if (!this.compatMode && identifier === this.instanceActorIdentifier) return await this.#dispatchInstanceActor(ctx);
+			const bot = await this.resolveBot(ctx, identifier);
+			return await bot?.dispatchActor(ctx, identifier) ?? null;
+		}).mapHandle((ctx, username) => this.mapHandle(ctx, username)).setKeyPairsDispatcher(async (ctx, identifier) => {
+			if (!this.compatMode && identifier === this.instanceActorIdentifier) return await this.#dispatchInstanceActorKeyPairs();
+			const bot = await this.resolveBot(ctx, identifier);
+			return await bot?.dispatchActorKeyPairs(ctx, identifier) ?? [];
+		});
+		this.federation.setFollowersDispatcher("/ap/actor/{identifier}/followers", async (ctx, identifier, cursor) => {
+			const bot = await this.resolveBot(ctx, identifier);
+			return await bot?.dispatchFollowers(ctx, identifier, cursor) ?? null;
+		}).setFirstCursor(async (ctx, identifier) => {
+			const bot = await this.resolveBot(ctx, identifier);
+			return bot?.getFollowersFirstCursor(ctx, identifier) ?? null;
+		}).setCounter(async (ctx, identifier) => {
+			const bot = await this.resolveBot(ctx, identifier);
+			return await bot?.countFollowers(ctx, identifier) ?? null;
+		});
+		this.federation.setOutboxDispatcher("/ap/actor/{identifier}/outbox", async (ctx, identifier, cursor) => {
+			const bot = await this.resolveBot(ctx, identifier);
+			return await bot?.dispatchOutbox(ctx, identifier, cursor) ?? null;
+		}).setFirstCursor(async (ctx, identifier) => {
+			const bot = await this.resolveBot(ctx, identifier);
+			return bot?.getOutboxFirstCursor(ctx, identifier) ?? null;
+		}).setCounter(async (ctx, identifier) => {
+			const bot = await this.resolveBot(ctx, identifier);
+			return await bot?.countOutbox(ctx, identifier) ?? null;
+		});
+		this.federation.setObjectDispatcher(Follow, "/ap/actor/{identifier}/follow/{id}", async (ctx, values) => {
+			const bot = await this.resolveBot(ctx, values.identifier);
+			return await bot?.dispatchFollow(ctx, values) ?? null;
+		}).authorize(async (ctx, values) => {
+			const bot = await this.resolveBot(ctx, values.identifier);
+			return await bot?.authorizeFollow(ctx, values) ?? false;
+		});
+		this.federation.setObjectDispatcher(Create, "/ap/actor/{identifier}/create/{id}", async (ctx, values) => {
+			const bot = await this.resolveBot(ctx, values.identifier);
+			return await bot?.dispatchCreate(ctx, values) ?? null;
+		});
+		this.federation.setObjectDispatcher(Article, "/ap/actor/{identifier}/article/{id}", async (ctx, values) => {
+			const bot = await this.resolveBot(ctx, values.identifier);
+			return await bot?.dispatchMessage(Article, ctx, values.id) ?? null;
+		});
+		this.federation.setObjectDispatcher(ChatMessage, "/ap/actor/{identifier}/chat-message/{id}", async (ctx, values) => {
+			const bot = await this.resolveBot(ctx, values.identifier);
+			return await bot?.dispatchMessage(ChatMessage, ctx, values.id) ?? null;
+		});
+		this.federation.setObjectDispatcher(Note, "/ap/actor/{identifier}/note/{id}", async (ctx, values) => {
+			const bot = await this.resolveBot(ctx, values.identifier);
+			return await bot?.dispatchMessage(Note, ctx, values.id) ?? null;
+		});
+		this.federation.setObjectDispatcher(Question, "/ap/actor/{identifier}/question/{id}", async (ctx, values) => {
+			const bot = await this.resolveBot(ctx, values.identifier);
+			return await bot?.dispatchMessage(Question, ctx, values.id) ?? null;
+		});
+		this.federation.setObjectDispatcher(Announce, "/ap/actor/{identifier}/announce/{id}", async (ctx, values) => {
+			const bot = await this.resolveBot(ctx, values.identifier);
+			return await bot?.dispatchAnnounce(ctx, values) ?? null;
+		});
+		this.federation.setObjectDispatcher(Emoji, "/ap/emoji/{name}", (ctx, values) => this.dispatchEmoji(ctx, values));
+		this.federation.setInboxListeners("/ap/actor/{identifier}/inbox", "/ap/inbox").onUnverifiedActivity((ctx, activity, reason) => this.onUnverifiedActivity(ctx, activity, reason)).on(Follow, (ctx, follow) => this.onFollowed(ctx, follow)).on(Undo, (ctx, undo) => this.onUndone(ctx, undo)).on(Accept, (ctx, accept) => this.onFollowAccepted(ctx, accept)).on(Reject, (ctx, reject) => this.onFollowRejected(ctx, reject)).on(Create, (ctx, create) => this.onCreated(ctx, create)).on(Announce, (ctx, announce) => this.onAnnounced(ctx, announce)).on(Like, (ctx, like) => this.onLiked(ctx, like)).setSharedKeyDispatcher((ctx) => this.dispatchSharedKey(ctx));
+		if (this.software != null) this.federation.setNodeInfoDispatcher("/nodeinfo/2.1", (ctx) => this.dispatchNodeInfo(ctx));
+	}
+	/**
+	* Registers a bot on the instance.  Invoked by the {@link BotImpl}
+	* constructor.
+	* @param bot The bot to register.
+	* @throws {TypeError} If a bot with the same identifier or username
+	*                     already exists on the instance.
+	*/
+	addBot(bot) {
+		if (!this.compatMode && bot.identifier === this.instanceActorIdentifier) throw new TypeError(`The identifier is reserved for the instance actor: ${bot.identifier}`);
+		if (this.#bots.has(bot.identifier)) throw new TypeError(`A bot with the identifier already exists: ${bot.identifier}`);
+		const username = bot.username.toLowerCase();
+		for (const existing of this.#bots.values()) if (existing.username.toLowerCase() === username) throw new TypeError(`A bot with the username already exists: ${bot.username}`);
+		this.#bots.set(bot.identifier, bot);
+	}
+	/**
+	* Resolves a bot hosted on the instance by its identifier.
+	* @param identifier The identifier of the bot to resolve.
+	* @returns The resolved bot, or `undefined` if no bot has the identifier.
+	*/
+	getBot(identifier) {
+		return this.#bots.get(identifier);
+	}
+	/**
+	* Resolves a bot by its identifier: bots registered statically win, then
+	* the dynamic bot groups are probed in their registration order.
+	* Dynamic resolutions are memoized per context.
+	* @param ctx The Fedify context of the resolution.
+	* @param identifier The identifier of the bot to resolve.
+	* @returns The resolved bot, or `null` if no bot has the identifier.
+	*/
+	async resolveBot(ctx, identifier) {
+		if (!this.compatMode && identifier === this.instanceActorIdentifier) return null;
+		const staticBot = this.#bots.get(identifier);
+		if (staticBot != null) return staticBot;
+		if (this.#groups.length < 1) return null;
+		let cache = this.#resolutionCache.get(ctx);
+		if (cache == null) {
+			cache = /* @__PURE__ */ new Map();
+			this.#resolutionCache.set(ctx, cache);
+		}
+		const cached = cache.get(identifier);
+		if (cached !== void 0) return cached;
+		let resolved = null;
+		for (const group of this.#groups) {
+			const profile = await group.dispatcher(ctx, identifier);
+			if (profile != null) {
+				resolved = new GroupBotImpl(group, identifier, profile);
+				break;
+			}
+		}
+		cache.set(identifier, resolved);
+		return resolved;
+	}
+	/**
+	* Every bot hosted on the instance.
+	*/
+	get bots() {
+		return this.#bots.values();
+	}
+	/**
+	* The number of bots hosted on the instance.
+	*/
+	get botCount() {
+		return this.#bots.size;
+	}
+	#firstBot() {
+		return this.#bots.values().next().value;
+	}
+	createBot(identifierOrDispatcher, profileOrOptions) {
+		if (typeof identifierOrDispatcher !== "string") {
+			const group = new BotGroupImpl(this, identifierOrDispatcher, profileOrOptions);
+			this.#groups.push(group);
+			return group;
+		}
+		const profile = profileOrOptions;
+		if (profile == null || profile.username == null) throw new TypeError("The bot profile with a username is required.");
+		const bot = new BotImpl({
+			instance: this,
+			identifier: identifierOrDispatcher,
+			kv: this.kv,
+			class: profile.class,
+			username: profile.username,
+			name: profile.name,
+			summary: profile.summary,
+			icon: profile.icon,
+			image: profile.image,
+			properties: profile.properties,
+			followerPolicy: profile.followerPolicy
+		});
+		return wrapBotImpl(bot);
+	}
+	/**
+	* Resolves a bot hosted on the instance by its username, including
+	* dynamically resolved bots.
+	* @param ctx The Fedify context of the resolution.
+	* @param username The username of the bot to resolve.
+	* @returns The resolved bot, or `null` if no bot has the username.
+	*/
+	async resolveBotByUsername(ctx, username) {
+		const identifier = await this.mapHandle(ctx, username);
+		if (identifier == null) return null;
+		return await this.resolveBot(ctx, identifier);
+	}
+	async mapHandle(ctx, username) {
+		const normalized = username.toLowerCase();
+		for (const bot$1 of this.#bots.values()) if (bot$1.username.toLowerCase() === normalized) return bot$1.identifier;
+		for (const group of this.#groups) {
+			if (group.mapUsername == null) continue;
+			const identifier = await group.mapUsername(ctx, username);
+			if (identifier == null) continue;
+			const bot$1 = await this.resolveBot(ctx, identifier);
+			if (bot$1 instanceof GroupBotImpl && bot$1.group === group) return identifier;
+		}
+		const bot = await this.resolveBot(ctx, username);
+		if (bot instanceof GroupBotImpl && bot.group.mapUsername == null) return username;
+		return null;
+	}
+	onUnverifiedActivity(_ctx, activity, reason) {
+		if (activity instanceof Delete && reason.type === "keyFetchError" && typeof reason.result === "object" && reason.result != null && "status" in reason.result && reason.result.status === 410) return new Response(null, { status: 202 });
+	}
+	/**
+	* Resolves which bots an incoming shared-inbox activity is relevant to.
+	* On a compatible (single-bot) instance every hosted bot is returned,
+	* preserving the pre-0.5 behavior.  A personal-inbox delivery targets
+	* its recipient only.  Otherwise the given resolver computes the
+	* relevant bot identifiers.
+	*/
+	async #resolveTargets(ctx, resolve) {
+		if (this.compatMode) return [...this.#bots.values()];
+		if (ctx.recipient != null) {
+			const bot = await this.resolveBot(ctx, ctx.recipient);
+			return bot == null ? [] : [bot];
+		}
+		const identifiers = new Set(await resolve());
+		const bots = [];
+		for (const identifier of identifiers) {
+			const bot = await this.resolveBot(ctx, identifier);
+			if (bot != null) bots.push(bot);
+		}
+		return bots;
+	}
+	/**
+	* Attributes a local object URI to its owning bot identifier, or logs and
+	* yields nothing when the URI is not a local object.  Activities on
+	* objects the instance does not own cannot be attributed to any bot on
+	* a multi-bot instance, so they are dropped.
+	*/
+	#localObjectTarget(ctx, uri) {
+		const parsed = parseLocalUri(ctx, uri, this.legacyObjectUrisIdentifier);
+		if (parsed?.type === "object" && typeof parsed.values.identifier === "string") return [parsed.values.identifier];
+		const logger = getLogger([
+			"botkit",
+			"instance",
+			"inbox"
+		]);
+		logger.debug("The object {uri} is not owned by any bot on this instance; the activity is not routed.", { uri: uri?.href });
+		return [];
+	}
+	async onFollowed(ctx, follow) {
+		const bots = await this.#resolveTargets(ctx, () => {
+			const parsed = ctx.parseUri(follow.objectId);
+			return parsed?.type === "actor" ? [parsed.identifier] : [];
+		});
+		for (const bot of bots) await bot.onFollowed(ctx, follow);
+	}
+	async onUndone(ctx, undo) {
+		const object = await undo.getObject(ctx);
+		if (object instanceof Follow) {
+			const bots = await this.#resolveTargets(ctx, () => {
+				const parsed = ctx.parseUri(object.objectId);
+				return parsed?.type === "actor" ? [parsed.identifier] : [];
+			});
+			for (const bot of bots) await bot.onUnfollowed(ctx, undo);
+		} else if (object instanceof Like) {
+			const bots = await this.#resolveTargets(ctx, () => this.#localObjectTarget(ctx, object.objectId));
+			for (const bot of bots) await bot.onUnliked(ctx, undo);
+		} else {
+			const logger = getLogger([
+				"botkit",
+				"bot",
+				"inbox"
+			]);
+			logger.warn("The Undo object {undoId} is not about Follow or Like: {object}.", {
+				undoId: undo.id?.href,
+				object
+			});
+		}
+	}
+	async onFollowAccepted(ctx, accept) {
+		const bots = await this.#resolveTargets(ctx, () => this.#localObjectTarget(ctx, accept.objectId));
+		for (const bot of bots) await bot.onFollowAccepted(ctx, accept);
+	}
+	async onFollowRejected(ctx, reject) {
+		const bots = await this.#resolveTargets(ctx, () => this.#localObjectTarget(ctx, reject.objectId));
+		for (const bot of bots) await bot.onFollowRejected(ctx, reject);
+	}
+	async onLiked(ctx, like) {
+		const bots = await this.#resolveTargets(ctx, () => this.#localObjectTarget(ctx, like.objectId));
+		for (const bot of bots) await bot.onLiked(ctx, like);
+	}
+	async onCreated(ctx, create) {
+		const bots = await this.#resolveTargets(ctx, async () => {
+			const targets = /* @__PURE__ */ new Set();
+			if (create.actorId != null) for await (const identifier of this.repository.findFollowedBots(create.actorId)) targets.add(identifier);
+			const addAddressee = (uri) => {
+				const parsed = ctx.parseUri(uri);
+				if (parsed?.type === "actor" || parsed?.type === "followers") {
+					if (parsed.identifier != null) targets.add(parsed.identifier);
+				}
+			};
+			for (const uri of [...create.toIds, ...create.ccIds]) addAddressee(uri);
+			const addLocalObject = (uri) => {
+				const parsed = parseLocalUri(ctx, uri, this.legacyObjectUrisIdentifier);
+				if (parsed?.type === "object" && typeof parsed.values.identifier === "string") targets.add(parsed.values.identifier);
+			};
+			const object = await create.getObject(ctx);
+			if (isMessageObject(object)) {
+				for (const uri of [...object.toIds, ...object.ccIds]) addAddressee(uri);
+				for await (const tag of object.getTags(ctx)) if (tag instanceof Mention && tag.href != null) {
+					const parsed = ctx.parseUri(tag.href);
+					if (parsed?.type === "actor") targets.add(parsed.identifier);
+				} else if (tag instanceof Link && isQuoteLink(tag)) addLocalObject(tag.href);
+				addLocalObject(object.quoteUrl);
+				addLocalObject(object.replyTargetId);
+			}
+			return targets;
+		});
+		for (const bot of bots) await bot.onCreated(ctx, create);
+	}
+	async onAnnounced(ctx, announce) {
+		const bots = await this.#resolveTargets(ctx, async () => {
+			const targets = /* @__PURE__ */ new Set();
+			if (announce.actorId != null) for await (const identifier of this.repository.findFollowedBots(announce.actorId)) targets.add(identifier);
+			for (const uri of [...announce.toIds, ...announce.ccIds]) {
+				const parsed = ctx.parseUri(uri);
+				if (parsed?.type === "actor" || parsed?.type === "followers") {
+					if (parsed.identifier != null) targets.add(parsed.identifier);
+				}
+			}
+			const parsedObject = parseLocalUri(ctx, announce.objectId, this.legacyObjectUrisIdentifier);
+			if (parsedObject?.type === "object" && typeof parsedObject.values.identifier === "string") targets.add(parsedObject.values.identifier);
+			return targets;
+		});
+		for (const bot of bots) await bot.onAnnounced(ctx, announce);
+	}
+	dispatchSharedKey(_ctx) {
+		if (this.compatMode) {
+			const bot = this.#firstBot();
+			if (bot == null) throw new TypeError("The instance has no bots; the shared inbox key cannot be dispatched.");
+			return { identifier: bot.identifier };
+		}
+		return { identifier: this.instanceActorIdentifier };
+	}
+	async #dispatchInstanceActor(ctx) {
+		const keyPairs = await ctx.getActorKeyPairs(this.instanceActorIdentifier);
+		return new Application({
+			id: ctx.getActorUri(this.instanceActorIdentifier),
+			preferredUsername: this.instanceActorIdentifier,
+			name: "Instance actor",
+			summary: "An internal actor the instance uses for signing requests on behalf of the whole instance.",
+			inbox: ctx.getInboxUri(this.instanceActorIdentifier),
+			endpoints: new Endpoints({ sharedInbox: ctx.getInboxUri() }),
+			publicKey: keyPairs[0].cryptographicKey,
+			assertionMethods: keyPairs.map((pair) => pair.multikey),
+			discoverable: false
+		});
+	}
+	#instanceActorKeyPairs;
+	#dispatchInstanceActorKeyPairs() {
+		if (this.#instanceActorKeyPairs != null) return this.#instanceActorKeyPairs;
+		const promise = (async () => {
+			let keyPairs = await this.repository.getKeyPairs(this.instanceActorIdentifier);
+			if (keyPairs == null) {
+				const rsa = await generateCryptoKeyPair("RSASSA-PKCS1-v1_5");
+				const ed25519 = await generateCryptoKeyPair("Ed25519");
+				keyPairs = [rsa, ed25519];
+				await this.repository.setKeyPairs(this.instanceActorIdentifier, keyPairs);
+			}
+			return keyPairs;
+		})();
+		this.#instanceActorKeyPairs = promise;
+		promise.catch(() => {
+			if (this.#instanceActorKeyPairs === promise) this.#instanceActorKeyPairs = void 0;
+		});
+		return promise;
+	}
+	dispatchNodeInfo(_ctx) {
+		return {
+			software: this.software,
+			protocols: ["activitypub"],
+			services: { outbound: ["atom1.0"] },
+			usage: {
+				users: {
+					total: this.botCount,
+					activeMonth: this.botCount,
+					activeHalfyear: this.botCount
+				},
+				localPosts: 0,
+				localComments: 0
+			}
+		};
+	}
+	dispatchEmoji(ctx, values) {
+		const customEmoji = this.customEmojis[values.name];
+		if (customEmoji == null) return null;
+		return this.getEmoji(ctx, values.name, customEmoji);
+	}
+	getEmoji(ctx, name, data) {
+		let url;
+		if ("url" in data) url = new URL(data.url);
+		else {
+			const t = mimeDb[data.type];
+			url = new URL(`/emojis/${name}${t == null || t.extensions == null || t.extensions.length < 1 ? "" : `.${t.extensions[0]}`}`, ctx.origin);
+		}
+		return new Emoji({
+			id: ctx.getObjectUri(Emoji, { name }),
+			name: `:${name}:`,
+			icon: new Image({
+				mediaType: data.type,
+				url
+			})
+		});
+	}
+	addCustomEmoji(name, data) {
+		if (!name.match(/^[a-z0-9-_]+$/i)) throw new TypeError(`Invalid custom emoji name: ${name}. It must match /^[a-z0-9-_]+$/i.`);
+		else if (name in this.customEmojis) throw new TypeError(`Duplicate custom emoji name: ${name}`);
+		else if (!data.type.startsWith("image/")) throw new TypeError(`Unsupported media type: ${data.type}`);
+		this.customEmojis[name] = data;
+		return (session) => this.getEmoji(session.context, name, data);
+	}
+	addCustomEmojis(emojis) {
+		const emojiMap = {};
+		for (const name in emojis) emojiMap[name] = this.addCustomEmoji(name, emojis[name]);
+		return emojiMap;
+	}
+	async addCollectionInverseProperty(request, contextData, response) {
+		if (!response.ok) return response;
+		const ctx = this.federation.createContext(request, contextData);
+		const parsed = ctx.parseUri(new URL(request.url));
+		if (parsed == null || parsed.type !== "outbox" && parsed.type !== "followers" || parsed.identifier == null) return response;
+		const contentType = response.headers.get("Content-Type");
+		if (contentType == null || !contentType.startsWith("application/activity+json") && !contentType.startsWith("application/ld+json")) return response;
+		const body = await response.json();
+		if (typeof body !== "object" || body == null || Array.isArray(body)) return new Response(JSON.stringify(body), {
+			headers: response.headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+		const property = parsed.type === "outbox" ? "outboxOf" : "followersOf";
+		const actorUri = ctx.getActorUri(parsed.identifier).href;
+		if (body[property] === actorUri) return new Response(JSON.stringify(body), {
+			headers: response.headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+		const headers = new Headers(response.headers);
+		headers.delete("Content-Length");
+		return new Response(JSON.stringify({
+			...body,
+			[property]: actorUri
+		}), {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	}
+	async fetch(request, contextData) {
+		if (this.behindProxy) request = await getXForwardedRequest(request);
+		const url = new URL(request.url);
+		if ((request.method === "GET" || request.method === "HEAD") && this.legacyObjectUrisIdentifier != null) {
+			const rewrittenPath = rewriteLegacyObjectPath(url.pathname, this.legacyObjectUrisIdentifier);
+			if (rewrittenPath != null) {
+				const location = new URL(url.href);
+				location.pathname = rewrittenPath;
+				return new Response(null, {
+					status: 301,
+					headers: { Location: location.href }
+				});
+			}
+		}
+		if (url.pathname.startsWith("/.well-known/") || url.pathname.startsWith("/ap/") || url.pathname.startsWith("/nodeinfo/")) {
+			const response = await this.federation.fetch(request, { contextData });
+			return await this.addCollectionInverseProperty(request, contextData, response);
+		}
+		const match = /^\/emojis\/([a-z0-9-_]+)(?:$|\.)/.exec(url.pathname);
+		if (match != null) {
+			const customEmoji = this.customEmojis[match[1]];
+			if (customEmoji == null || !("file" in customEmoji)) return new Response("Not Found", { status: 404 });
+			let fileInfo;
+			let data;
+			try {
+				fileInfo = await fs.stat(customEmoji.file);
+				data = await fs.readFile(customEmoji.file);
+			} catch (error) {
+				if (typeof error === "object" && error != null && "code" in error && error.code === "ENOENT") return new Response("Not Found", { status: 404 });
+				throw error;
+			}
+			const mtime = fileInfo.mtime ?? /* @__PURE__ */ new Date();
+			return new Response(data, { headers: {
+				"Content-Type": customEmoji.type,
+				"Content-Length": fileInfo.size.toString(),
+				"Cache-Control": "public, max-age=31536000, immutable",
+				"Last-Modified": mtime.toUTCString(),
+				"ETag": `"${mtime.getTime().toString(36)}${fileInfo.size.toString(36)}"`
+			} });
+		}
+		if (this.compatMode) {
+			const bot = this.#firstBot();
+			if (bot == null) return new Response("Not Found", { status: 404 });
+			return await app.fetch(request, {
+				bot,
+				contextData
+			});
+		}
+		return await multiApp.fetch(request, {
+			instance: this,
+			contextData
+		});
+	}
+	/**
+	* The web page URL of a bot hosted on the instance.  A compatible
+	* (single-bot) instance serves its bot at the web root; a multi-bot
+	* instance serves each bot under a path derived from its username.
+	* @param bot The bot to get the web page URL of.
+	* @param origin The origin of the URL.
+	* @returns The web page URL of the bot.
+	*/
+	getBotWebUrl(bot, origin) {
+		return new URL(this.compatMode ? "/" : `/@${encodeURIComponent(bot.username)}`, origin);
+	}
+	/**
+	* The web permalink of a message published by a bot hosted on
+	* the instance.
+	* @param bot The bot that published the message.
+	* @param id The UUID of the message.
+	* @param origin The origin of the URL.
+	* @returns The web permalink of the message.
+	*/
+	getMessageWebUrl(bot, id, origin) {
+		return new URL(this.compatMode ? `/message/${id}` : `/@${encodeURIComponent(bot.username)}/${id}`, origin);
+	}
+};
+
+//#endregion
+export { DEFAULT_INSTANCE_ACTOR_IDENTIFIER, InstanceImpl };
+//# sourceMappingURL=instance-impl.js.map