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

package/dist/repository.js

@@ -9,31 +9,326 @@ import { exportJwk, importJwk } from "@fedify/fedify/sig";
 //#region src/repository.ts
 const logger = getLogger(["botkit", "repository"]);
 /**
+* A view of a {@link Repository} which is scoped to a single bot actor
+* identifier.  It exposes the same operations as {@link Repository} without
+* the `identifier` parameter, which is bound at construction time.
+* @since 0.5.0
+*/
+var ActorScopedRepository = class {
+	/**
+	* The underlying repository.
+	*/
+	repository;
+	/**
+	* The identifier of the bot actor this view is scoped to.
+	*/
+	identifier;
+	/**
+	* Creates a new scoped repository view.
+	* @param repository The underlying repository.
+	* @param identifier The identifier of the bot actor to scope the view to.
+	*/
+	constructor(repository, identifier) {
+		this.repository = repository;
+		this.identifier = identifier;
+	}
+	/**
+	* Sets the key pairs of the bot actor.
+	* @param keyPairs The key pairs to set.
+	*/
+	setKeyPairs(keyPairs) {
+		return this.repository.setKeyPairs(this.identifier, keyPairs);
+	}
+	/**
+	* Gets the key pairs of the bot actor.
+	* @returns The key pairs of the bot actor. If the key pairs do not exist,
+	*          `undefined` will be returned.
+	*/
+	getKeyPairs() {
+		return this.repository.getKeyPairs(this.identifier);
+	}
+	/**
+	* Adds a message to the repository.
+	* @param id The UUID of the message.
+	* @param activity The activity to add.
+	*/
+	addMessage(id, activity) {
+		return this.repository.addMessage(this.identifier, id, activity);
+	}
+	/**
+	* Updates a message in the repository.
+	* @param id The UUID of the message.
+	* @param updater The function to update the message.  See also
+	*                {@link Repository.updateMessage}.
+	* @returns `true` if the message was updated, `false` if the message does not
+	*          exist.
+	*/
+	updateMessage(id, updater) {
+		return this.repository.updateMessage(this.identifier, id, updater);
+	}
+	/**
+	* Removes a message from the repository.
+	* @param id The UUID of the message to remove.
+	* @returns The removed activity.  If the message does not exist, `undefined`
+	*          will be returned.
+	*/
+	removeMessage(id) {
+		return this.repository.removeMessage(this.identifier, id);
+	}
+	/**
+	* Gets messages from the repository.
+	* @param options The options for getting messages.
+	* @returns An async iterable of message activities.
+	*/
+	getMessages(options) {
+		return this.repository.getMessages(this.identifier, options);
+	}
+	/**
+	* Gets a message from the repository.
+	* @param id The UUID of the message to get.
+	* @returns The message activity, or `undefined` if the message does not
+	*          exist.
+	*/
+	getMessage(id) {
+		return this.repository.getMessage(this.identifier, id);
+	}
+	/**
+	* Counts the number of messages in the repository.
+	* @returns The number of messages in the repository.
+	*/
+	countMessages() {
+		return this.repository.countMessages(this.identifier);
+	}
+	/**
+	* Adds a follower to the repository.
+	* @param followId The URL of the follow request.
+	* @param follower The actor who follows the bot.
+	*/
+	addFollower(followId, follower) {
+		return this.repository.addFollower(this.identifier, followId, follower);
+	}
+	/**
+	* Removes a follower from the repository.
+	* @param followId The URL of the follow request.
+	* @param followerId The ID of the actor to remove.
+	* @returns The removed actor.  If the follower does not exist or the follow
+	*          request is not about the follower, `undefined` will be returned.
+	*/
+	removeFollower(followId, followerId) {
+		return this.repository.removeFollower(this.identifier, followId, followerId);
+	}
+	/**
+	* Checks if the repository has a follower.
+	* @param followerId The ID of the follower to check.
+	* @returns `true` if the repository has the follower, `false` otherwise.
+	*/
+	hasFollower(followerId) {
+		return this.repository.hasFollower(this.identifier, followerId);
+	}
+	/**
+	* Gets followers from the repository.
+	* @param options The options for getting followers.
+	* @returns An async iterable of actors who follow the bot.
+	*/
+	getFollowers(options) {
+		return this.repository.getFollowers(this.identifier, options);
+	}
+	/**
+	* Counts the number of followers in the repository.
+	* @returns The number of followers in the repository.
+	*/
+	countFollowers() {
+		return this.repository.countFollowers(this.identifier);
+	}
+	/**
+	* Adds a sent follow request to the repository.
+	* @param id The UUID of the follow request.
+	* @param follow The follow activity to add.
+	*/
+	addSentFollow(id, follow) {
+		return this.repository.addSentFollow(this.identifier, id, follow);
+	}
+	/**
+	* Removes a sent follow request from the repository.
+	* @param id The UUID of the follow request to remove.
+	* @returns The removed follow activity.  If the follow request does not
+	*          exist, `undefined` will be returned.
+	*/
+	removeSentFollow(id) {
+		return this.repository.removeSentFollow(this.identifier, id);
+	}
+	/**
+	* Gets a sent follow request from the repository.
+	* @param id The UUID of the follow request to get.
+	* @returns The `Follow` activity, or `undefined` if the follow request does
+	*          not exist.
+	*/
+	getSentFollow(id) {
+		return this.repository.getSentFollow(this.identifier, id);
+	}
+	/**
+	* Adds a followee to the repository.
+	* @param followeeId The ID of the followee to add.
+	* @param follow The follow activity to add.
+	*/
+	addFollowee(followeeId, follow) {
+		return this.repository.addFollowee(this.identifier, followeeId, follow);
+	}
+	/**
+	* Removes a followee from the repository.
+	* @param followeeId The ID of the followee to remove.
+	* @returns The `Follow` activity that was removed.  If the followee does not
+	*          exist, `undefined` will be returned.
+	*/
+	removeFollowee(followeeId) {
+		return this.repository.removeFollowee(this.identifier, followeeId);
+	}
+	/**
+	* Gets a followee from the repository.
+	* @param followeeId The ID of the followee to get.
+	* @returns The `Follow` activity, or `undefined` if the followee does not
+	*          exist.
+	*/
+	getFollowee(followeeId) {
+		return this.repository.getFollowee(this.identifier, followeeId);
+	}
+	/**
+	* Records a vote in a poll.  If the same voter had already voted for the
+	* same option in a poll, the vote will be silently ignored.
+	* @param messageId The UUID of the poll message to vote on.
+	* @param voterId The ID of the voter.
+	* @param option The option that the voter is voting for.
+	*/
+	vote(messageId, voterId, option) {
+		return this.repository.vote(this.identifier, messageId, voterId, option);
+	}
+	/**
+	* Counts the number of voters in a poll.  Even if the poll allows multiple
+	* selections, each voter is counted only once.
+	* @param messageId The UUID of the poll message to count voters for.
+	* @returns The number of voters in the poll.  If the poll does not exist,
+	*          0 will be returned.
+	*/
+	countVoters(messageId) {
+		return this.repository.countVoters(this.identifier, messageId);
+	}
+	/**
+	* Counts the votes for each option in a poll.
+	* @param messageId The UUID of the poll message to count votes for.
+	* @returns A record where the keys are the options and the values are
+	*          the number of votes for each option.  See also
+	*          {@link Repository.countVotes}.
+	*/
+	countVotes(messageId) {
+		return this.repository.countVotes(this.identifier, messageId);
+	}
+};
+/**
 * A repository for storing bot data using a key-value store.
 */
 var KvRepository = class {
 	kv;
-	prefixes;
+	/**
+	* The key prefix under which all BotKit data is stored.
+	* @since 0.5.0
+	*/
+	prefix;
 	/**
 	* Creates a new key-value store repository.
 	* @param kv The key-value store to use.
-	* @param prefixes The prefixes for key-value store keys.
+	* @param options The options for the repository.
 	*/
-	constructor(kv, prefixes) {
+	constructor(kv, options = {}) {
 		if (kv.cas == null) logger.warn("The given KvStore {kv} does not support CAS operations. This may cause issues with concurrent updates.", { kv });
 		this.kv = kv;
-		this.prefixes = {
-			keyPairs: ["_botkit", "keyPairs"],
-			messages: ["_botkit", "messages"],
-			followers: ["_botkit", "followers"],
-			followRequests: ["_botkit", "followRequests"],
-			followees: ["_botkit", "followees"],
-			follows: ["_botkit", "follows"],
-			polls: ["_botkit", "polls"],
-			...prefixes ?? {}
-		};
-	}
-	async setKeyPairs(keyPairs) {
+		this.prefix = options.prefix ?? ["_botkit"];
+	}
+	#key(identifier, ...rest) {
+		return [
+			...this.prefix,
+			"bots",
+			identifier,
+			...rest
+		];
+	}
+	#followeeIndexKey(followeeId) {
+		return [
+			...this.prefix,
+			"index",
+			"followees",
+			followeeId.href
+		];
+	}
+	/**
+	* Migrates data stored by BotKit 0.4 or earlier, which was not scoped by
+	* bot actor identifiers, so that it belongs to the given identifier.
+	*
+	* The legacy data can be adopted by exactly one identifier.  The adopter
+	* is claimed atomically (through a compare-and-set operation when the
+	* underlying store supports one) before anything is copied, so that
+	* reusing the repository for another bot, even concurrently, does not
+	* adopt the same rows again.  Legacy keys are copied, not moved, and
+	* the completion is recorded last, so a partially failed run is simply
+	* retried by the adopter on the next call without data loss.  Followees
+	* are also entered into the reverse lookup index used by
+	* {@link KvRepository.findFollowedBots}.
+	*
+	* Calling this method again after a successful migration is a no-op.
+	* @param identifier The identifier of the bot actor that adopts the legacy
+	*                   data.
+	* @since 0.5.0
+	*/
+	async migrate(identifier) {
+		const markerKey = [...this.prefix, "migrated"];
+		let marker = await this.kv.get(markerKey);
+		if (marker == null) {
+			const claim = { adopter: identifier };
+			if (this.kv.cas == null) {
+				await this.kv.set(markerKey, claim);
+				marker = claim;
+			} else if (await this.kv.cas(markerKey, void 0, claim)) marker = claim;
+			else marker = await this.kv.get(markerKey);
+		}
+		if (marker == null || marker.adopter !== identifier || marker.done) return;
+		logger.info("Migrating legacy repository data to bot {identifier}...", { identifier });
+		const categories = [
+			"keyPairs",
+			"messages",
+			"followers",
+			"followRequests",
+			"followees",
+			"follows",
+			"polls"
+		];
+		for (const category of categories) {
+			const legacyPrefix = [...this.prefix, category];
+			for await (const entry of this.kv.list(legacyPrefix)) {
+				const rest = entry.key.slice(this.prefix.length + 1);
+				if ((category === "messages" || category === "followers") && rest.length === 1 && rest[0] === "lock") continue;
+				const scopedKey = this.#key(identifier, category, ...rest);
+				if (await this.kv.get(scopedKey) == null) await this.kv.set(scopedKey, entry.value);
+				if (category === "followees" && rest.length === 1) {
+					let followeeId;
+					try {
+						followeeId = new URL(rest[0]);
+					} catch (error) {
+						logger.warn("Skipping the malformed legacy followee key {followeeId}.", {
+							followeeId: rest[0],
+							error
+						});
+						continue;
+					}
+					await this.#addToFolloweeIndex(identifier, followeeId);
+				}
+			}
+		}
+		await this.kv.set(markerKey, {
+			adopter: identifier,
+			done: true
+		});
+		logger.info("Finished migrating legacy repository data to bot {identifier}.", { identifier });
+	}
+	async setKeyPairs(identifier, keyPairs) {
 		const pairs = [];
 		for (const keyPair of keyPairs) {
 			const pair = {
@@ -42,10 +337,10 @@ var KvRepository = class {
 			};
 			pairs.push(pair);
 		}
-		await this.kv.set(this.prefixes.keyPairs, pairs);
+		await this.kv.set(this.#key(identifier, "keyPairs"), pairs);
 	}
-	async getKeyPairs() {
-		const keyPairs = await this.kv.get(this.prefixes.keyPairs);
+	async getKeyPairs(identifier) {
+		const keyPairs = await this.kv.get(this.#key(identifier, "keyPairs"));
 		if (keyPairs == null) return void 0;
 		const promises = keyPairs.map(async (pair) => ({
 			privateKey: await importJwk(pair.private, "private"),
@@ -53,11 +348,11 @@ var KvRepository = class {
 		}));
 		return await Promise.all(promises);
 	}
-	async addMessage(id, activity) {
-		const messageKey = [...this.prefixes.messages, id];
+	async addMessage(identifier, id, activity) {
+		const messageKey = this.#key(identifier, "messages", id);
 		await this.kv.set(messageKey, await activity.toJsonLd({ format: "compact" }));
-		const lockKey = [...this.prefixes.messages, "lock"];
-		const listKey = this.prefixes.messages;
+		const lockKey = this.#key(identifier, "messages", "lock");
+		const listKey = this.#key(identifier, "messages");
 		do {
 			await this.kv.set(lockKey, id);
 			const set = new Set(await this.kv.get(listKey) ?? []);
@@ -67,8 +362,8 @@ var KvRepository = class {
 			await this.kv.set(listKey, list);
 		} while (await this.kv.get(lockKey) !== id);
 	}
-	async updateMessage(id, updater) {
-		const kvKey = [...this.prefixes.messages, id];
+	async updateMessage(identifier, id, updater) {
+		const kvKey = this.#key(identifier, "messages", id);
 		const createJson = await this.kv.get(kvKey);
 		if (createJson == null) return false;
 		const activity = await Activity.fromJsonLd(createJson);
@@ -78,9 +373,9 @@ var KvRepository = class {
 		await this.kv.set(kvKey, await newActivity.toJsonLd({ format: "compact" }));
 		return true;
 	}
-	async removeMessage(id) {
-		const listKey = this.prefixes.messages;
-		const lockKey = [...listKey, "lock"];
+	async removeMessage(identifier, id) {
+		const listKey = this.#key(identifier, "messages");
+		const lockKey = this.#key(identifier, "messages", "lock");
 		const lockId = `${id}:delete`;
 		do {
 			await this.kv.set(lockKey, lockId);
@@ -90,7 +385,7 @@ var KvRepository = class {
 			list.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
 			await this.kv.set(listKey, list);
 		} while (await this.kv.get(lockKey) !== lockId);
-		const messageKey = [...listKey, id];
+		const messageKey = this.#key(identifier, "messages", id);
 		const activityJson = await this.kv.get(messageKey);
 		if (activityJson == null) return;
 		await this.kv.delete(messageKey);
@@ -98,11 +393,11 @@ var KvRepository = class {
 		if (activity instanceof Create$1 || activity instanceof Announce$1) return activity;
 		return void 0;
 	}
-	async *getMessages(options = {}) {
+	async *getMessages(identifier, options = {}) {
 		const { order, until, since, limit } = options;
 		const untilTs = until == null ? null : until.epochMilliseconds;
 		const sinceTs = since == null ? null : since.epochMilliseconds;
-		let messageIds = await this.kv.get(this.prefixes.messages) ?? [];
+		let messageIds = await this.kv.get(this.#key(identifier, "messages")) ?? [];
 		if (sinceTs != null) {
 			const offset = messageIds.findIndex((id) => extractTimestamp(id) >= sinceTs);
 			messageIds = messageIds.slice(offset);
@@ -114,7 +409,7 @@ var KvRepository = class {
 		if (order == null || order === "newest") messageIds = messageIds.toReversed();
 		if (limit != null) messageIds = messageIds.slice(0, limit);
 		for (const id of messageIds) {
-			const messageJson = await this.kv.get([...this.prefixes.messages, id]);
+			const messageJson = await this.kv.get(this.#key(identifier, "messages", id));
 			if (messageJson == null) continue;
 			try {
 				const activity = await Activity.fromJsonLd(messageJson);
@@ -124,8 +419,8 @@ var KvRepository = class {
 			}
 		}
 	}
-	async getMessage(id) {
-		const json = await this.kv.get([...this.prefixes.messages, id]);
+	async getMessage(identifier, id) {
+		const json = await this.kv.get(this.#key(identifier, "messages", id));
 		if (json == null) return void 0;
 		let activity;
 		try {
@@ -137,30 +432,30 @@ var KvRepository = class {
 		if (activity instanceof Create$1 || activity instanceof Announce$1) return activity;
 		return void 0;
 	}
-	async countMessages() {
-		const messageIds = await this.kv.get(this.prefixes.messages) ?? [];
+	async countMessages(identifier) {
+		const messageIds = await this.kv.get(this.#key(identifier, "messages")) ?? [];
 		return messageIds.length;
 	}
-	async addFollower(followRequestId, follower) {
+	async addFollower(identifier, followRequestId, follower) {
 		if (follower.id == null) throw new TypeError("The follower ID is missing.");
-		const followerKey = [...this.prefixes.followers, follower.id.href];
+		const followerKey = this.#key(identifier, "followers", follower.id.href);
 		await this.kv.set(followerKey, await follower.toJsonLd({ format: "compact" }));
-		const lockKey = [...this.prefixes.followers, "lock"];
-		const listKey = this.prefixes.followers;
+		const lockKey = this.#key(identifier, "followers", "lock");
+		const listKey = this.#key(identifier, "followers");
 		do {
 			await this.kv.set(lockKey, follower.id.href);
 			const list = await this.kv.get(listKey) ?? [];
 			if (!list.includes(follower.id.href)) list.push(follower.id.href);
 			await this.kv.set(listKey, list);
 		} while (await this.kv.get(lockKey) !== follower.id.href);
-		const followRequestKey = [...this.prefixes.followRequests, followRequestId.href];
+		const followRequestKey = this.#key(identifier, "followRequests", followRequestId.href);
 		await this.kv.set(followRequestKey, follower.id.href);
 	}
-	async removeFollower(followRequestId, actorId) {
-		const followRequestKey = [...this.prefixes.followRequests, followRequestId.href];
+	async removeFollower(identifier, followRequestId, actorId) {
+		const followRequestKey = this.#key(identifier, "followRequests", followRequestId.href);
 		const followerId = await this.kv.get(followRequestKey);
 		if (followerId == null) return void 0;
-		const followerKey = [...this.prefixes.followers, followerId];
+		const followerKey = this.#key(identifier, "followers", followerId);
 		if (followerId !== actorId.href) return void 0;
 		const followerJson = await this.kv.get(followerKey);
 		if (followerJson == null) return void 0;
@@ -171,8 +466,8 @@ var KvRepository = class {
 			return void 0;
 		}
 		if (!isActor(follower)) return void 0;
-		const lockKey = [...this.prefixes.followers, "lock"];
-		const listKey = this.prefixes.followers;
+		const lockKey = this.#key(identifier, "followers", "lock");
+		const listKey = this.#key(identifier, "followers");
 		do {
 			await this.kv.set(lockKey, followerId);
 			let list = await this.kv.get(listKey) ?? [];
@@ -183,16 +478,16 @@ var KvRepository = class {
 		await this.kv.delete(followRequestKey);
 		return follower;
 	}
-	async hasFollower(followerId) {
-		return await this.kv.get([...this.prefixes.followers, followerId.href]) != null;
+	async hasFollower(identifier, followerId) {
+		return await this.kv.get(this.#key(identifier, "followers", followerId.href)) != null;
 	}
-	async *getFollowers(options = {}) {
+	async *getFollowers(identifier, options = {}) {
 		const { offset = 0, limit } = options;
-		let followerIds = await this.kv.get(this.prefixes.followers) ?? [];
+		let followerIds = await this.kv.get(this.#key(identifier, "followers")) ?? [];
 		followerIds = followerIds.slice(offset);
 		if (limit != null) followerIds = followerIds.slice(0, limit);
 		for (const id of followerIds) {
-			const json = await this.kv.get([...this.prefixes.followers, id]);
+			const json = await this.kv.get(this.#key(identifier, "followers", id));
 			let actor;
 			try {
 				actor = await Object$1.fromJsonLd(json);
@@ -203,21 +498,21 @@ var KvRepository = class {
 			if (isActor(actor)) yield actor;
 		}
 	}
-	async countFollowers() {
-		const followerIds = await this.kv.get(this.prefixes.followers) ?? [];
+	async countFollowers(identifier) {
+		const followerIds = await this.kv.get(this.#key(identifier, "followers")) ?? [];
 		return followerIds.length;
 	}
-	async addSentFollow(id, follow) {
-		await this.kv.set([...this.prefixes.follows, id], await follow.toJsonLd({ format: "compact" }));
+	async addSentFollow(identifier, id, follow) {
+		await this.kv.set(this.#key(identifier, "follows", id), await follow.toJsonLd({ format: "compact" }));
 	}
-	async removeSentFollow(id) {
-		const follow = await this.getSentFollow(id);
+	async removeSentFollow(identifier, id) {
+		const follow = await this.getSentFollow(identifier, id);
 		if (follow == null) return void 0;
-		await this.kv.delete([...this.prefixes.follows, id]);
+		await this.kv.delete(this.#key(identifier, "follows", id));
 		return follow;
 	}
-	async getSentFollow(id) {
-		const followJson = await this.kv.get([...this.prefixes.follows, id]);
+	async getSentFollow(identifier, id) {
+		const followJson = await this.kv.get(this.#key(identifier, "follows", id));
 		if (followJson == null) return void 0;
 		try {
 			return await Follow.fromJsonLd(followJson);
@@ -225,17 +520,22 @@ var KvRepository = class {
 			return void 0;
 		}
 	}
-	async addFollowee(followeeId, follow) {
-		await this.kv.set([...this.prefixes.followees, followeeId.href], await follow.toJsonLd({ format: "compact" }));
+	async addFollowee(identifier, followeeId, follow) {
+		await this.kv.set(this.#key(identifier, "followees", followeeId.href), await follow.toJsonLd({ format: "compact" }));
+		await this.#addToFolloweeIndex(identifier, followeeId);
 	}
-	async removeFollowee(followeeId) {
-		const follow = await this.getFollowee(followeeId);
-		if (follow == null) return void 0;
-		await this.kv.delete([...this.prefixes.followees, followeeId.href]);
+	async removeFollowee(identifier, followeeId) {
+		const follow = await this.getFollowee(identifier, followeeId);
+		if (follow == null) {
+			await this.#removeFromFolloweeIndex(identifier, followeeId);
+			return void 0;
+		}
+		await this.kv.delete(this.#key(identifier, "followees", followeeId.href));
+		await this.#removeFromFolloweeIndex(identifier, followeeId);
 		return follow;
 	}
-	async getFollowee(followeeId) {
-		const json = await this.kv.get([...this.prefixes.followees, followeeId.href]);
+	async getFollowee(identifier, followeeId) {
+		const json = await this.kv.get(this.#key(identifier, "followees", followeeId.href));
 		if (json == null) return void 0;
 		try {
 			return await Follow.fromJsonLd(json);
@@ -243,18 +543,52 @@ var KvRepository = class {
 			return void 0;
 		}
 	}
-	async vote(messageId, voterId, option) {
-		const key = [
-			...this.prefixes.polls,
-			messageId,
-			option
-		];
+	async *findFollowedBots(followeeId) {
+		const identifiers = await this.kv.get(this.#followeeIndexKey(followeeId)) ?? [];
+		for (const identifier of identifiers) yield identifier;
+	}
+	async #addToFolloweeIndex(identifier, followeeId) {
+		const key = this.#followeeIndexKey(followeeId);
+		while (true) {
+			const prev = await this.kv.get(key);
+			if (prev != null && prev.includes(identifier)) return;
+			const next = prev == null ? [identifier] : [...prev, identifier];
+			if (this.kv.cas == null) {
+				await this.kv.set(key, next);
+				return;
+			}
+			if (await this.kv.cas(key, prev, next)) return;
+			logger.trace("CAS operation failed, retrying to index followee {followeeId} for bot {identifier}.", {
+				followeeId: followeeId.href,
+				identifier
+			});
+		}
+	}
+	async #removeFromFolloweeIndex(identifier, followeeId) {
+		const key = this.#followeeIndexKey(followeeId);
+		while (true) {
+			const prev = await this.kv.get(key);
+			if (prev == null || !prev.includes(identifier)) return;
+			const next = prev.filter((id) => id !== identifier);
+			if (this.kv.cas == null) {
+				await this.kv.set(key, next);
+				return;
+			}
+			if (await this.kv.cas(key, prev, next)) return;
+			logger.trace("CAS operation failed, retrying to unindex followee {followeeId} for bot {identifier}.", {
+				followeeId: followeeId.href,
+				identifier
+			});
+		}
+	}
+	async vote(identifier, messageId, voterId, option) {
+		const key = this.#key(identifier, "polls", messageId, option);
 		while (true) {
 			const prev = await this.kv.get(key);
 			if (prev != null && prev.includes(voterId.href)) return;
 			const next = prev == null ? [voterId.href] : [...prev, voterId.href];
 			if (this.kv.cas == null) {
-				this.kv.set(key, next);
+				await this.kv.set(key, next);
 				break;
 			} else {
 				const success = await this.kv.cas(key, prev, next);
@@ -266,13 +600,13 @@ var KvRepository = class {
 				});
 			}
 		}
-		const optionsKey = [...this.prefixes.polls, messageId];
+		const optionsKey = this.#key(identifier, "polls", messageId);
 		while (true) {
 			const prevOptions = await this.kv.get(optionsKey);
 			if (prevOptions != null && prevOptions.includes(option)) return;
 			const nextOptions = prevOptions == null ? [option] : [...prevOptions, option];
 			if (this.kv.cas == null) {
-				this.kv.set(optionsKey, nextOptions);
+				await this.kv.set(optionsKey, nextOptions);
 				break;
 			} else {
 				const success = await this.kv.cas(optionsKey, prevOptions, nextOptions);
@@ -284,32 +618,27 @@ var KvRepository = class {
 			}
 		}
 	}
-	async countVoters(messageId) {
-		const options = await this.kv.get([...this.prefixes.polls, messageId]) ?? [];
+	async countVoters(identifier, messageId) {
+		const options = await this.kv.get(this.#key(identifier, "polls", messageId)) ?? [];
 		const result = /* @__PURE__ */ new Set();
 		for (const option of options) {
-			const voters = await this.kv.get([
-				...this.prefixes.polls,
-				messageId,
-				option
-			]);
+			const voters = await this.kv.get(this.#key(identifier, "polls", messageId, option));
 			if (voters != null) for (const voter of voters) result.add(voter);
 		}
 		return result.size;
 	}
-	async countVotes(messageId) {
-		const options = await this.kv.get([...this.prefixes.polls, messageId]) ?? [];
+	async countVotes(identifier, messageId) {
+		const options = await this.kv.get(this.#key(identifier, "polls", messageId)) ?? [];
 		const result = {};
 		for (const option of options) {
-			const voters = await this.kv.get([
-				...this.prefixes.polls,
-				messageId,
-				option
-			]);
+			const voters = await this.kv.get(this.#key(identifier, "polls", messageId, option));
 			result[option] = voters == null ? 0 : voters.length;
 		}
 		return result;
 	}
+	forIdentifier(identifier) {
+		return new ActorScopedRepository(this, identifier);
+	}
 };
 /**
 * Extracts the timestamp from a UUIDv7.
@@ -327,125 +656,149 @@ function extractTimestamp(uuid) {
 * persistent and is only suitable for testing or development.
 */
 var MemoryRepository = class {
-	keyPairs;
-	messages = /* @__PURE__ */ new Map();
-	followers = /* @__PURE__ */ new Map();
-	followRequests = {};
-	sentFollows = {};
-	followees = {};
-	polls = {};
-	setKeyPairs(keyPairs) {
-		this.keyPairs = keyPairs;
+	#data = /* @__PURE__ */ new Map();
+	#bucket(identifier) {
+		let data = this.#data.get(identifier);
+		if (data == null) {
+			data = {
+				messages: /* @__PURE__ */ new Map(),
+				followers: /* @__PURE__ */ new Map(),
+				followRequests: {},
+				sentFollows: {},
+				followees: {},
+				polls: {}
+			};
+			this.#data.set(identifier, data);
+		}
+		return data;
+	}
+	setKeyPairs(identifier, keyPairs) {
+		this.#bucket(identifier).keyPairs = keyPairs;
 		return Promise.resolve();
 	}
-	getKeyPairs() {
-		return Promise.resolve(this.keyPairs);
+	getKeyPairs(identifier) {
+		return Promise.resolve(this.#data.get(identifier)?.keyPairs);
 	}
-	addMessage(id, activity) {
-		this.messages.set(id, activity);
+	addMessage(identifier, id, activity) {
+		this.#bucket(identifier).messages.set(id, activity);
 		return Promise.resolve();
 	}
-	async updateMessage(id, updater) {
-		const existing = this.messages.get(id);
-		if (existing == null) return false;
+	async updateMessage(identifier, id, updater) {
+		const messages = this.#data.get(identifier)?.messages;
+		const existing = messages?.get(id);
+		if (messages == null || existing == null) return false;
 		const newActivity = await updater(existing);
 		if (newActivity == null) return false;
-		this.messages.set(id, newActivity);
+		messages.set(id, newActivity);
 		return true;
 	}
-	removeMessage(id) {
-		const activity = this.messages.get(id);
-		this.messages.delete(id);
+	removeMessage(identifier, id) {
+		const messages = this.#data.get(identifier)?.messages;
+		const activity = messages?.get(id);
+		messages?.delete(id);
 		return Promise.resolve(activity);
 	}
-	async *getMessages(options = {}) {
+	async *getMessages(identifier, options = {}) {
 		const { order, until, since, limit } = options;
-		let messages = [...this.messages.values()];
+		let messages = [...this.#data.get(identifier)?.messages.values() ?? []];
 		if (since != null) messages = messages.filter((message) => message.published != null && Temporal.Instant.compare(message.published, since) >= 0);
 		if (until != null) messages = messages.filter((message) => message.published != null && Temporal.Instant.compare(message.published, until) <= 0);
 		if (order === "oldest") messages.sort((a, b) => (a.published?.epochMilliseconds ?? 0) - (b.published?.epochMilliseconds ?? 0));
 		else messages.sort((a, b) => (b.published?.epochMilliseconds ?? 0) - (a.published?.epochMilliseconds ?? 0));
-		if (limit != null) messages.slice(0, limit);
+		if (limit != null) messages = messages.slice(0, limit);
 		for (const message of messages) yield message;
 	}
-	getMessage(id) {
-		return Promise.resolve(this.messages.get(id));
+	getMessage(identifier, id) {
+		return Promise.resolve(this.#data.get(identifier)?.messages.get(id));
 	}
-	countMessages() {
-		return Promise.resolve(this.messages.size);
+	countMessages(identifier) {
+		return Promise.resolve(this.#data.get(identifier)?.messages.size ?? 0);
 	}
-	addFollower(followId, follower) {
+	addFollower(identifier, followId, follower) {
 		if (follower.id == null) throw new TypeError("The follower ID is missing.");
-		this.followers.set(follower.id.href, follower);
-		this.followRequests[followId.href] = follower.id.href;
+		const data = this.#bucket(identifier);
+		data.followers.set(follower.id.href, follower);
+		data.followRequests[followId.href] = follower.id.href;
 		return Promise.resolve();
 	}
-	removeFollower(followId, followerId) {
-		const existing = this.followRequests[followId.href];
+	removeFollower(identifier, followId, followerId) {
+		const data = this.#data.get(identifier);
+		if (data == null) return Promise.resolve(void 0);
+		const existing = data.followRequests[followId.href];
 		if (existing == null || existing !== followerId.href) return Promise.resolve(void 0);
-		delete this.followRequests[followId.href];
-		const follower = this.followers.get(followerId.href);
-		this.followers.delete(followerId.href);
+		delete data.followRequests[followId.href];
+		const follower = data.followers.get(followerId.href);
+		data.followers.delete(followerId.href);
 		return Promise.resolve(follower);
 	}
-	hasFollower(followerId) {
-		return Promise.resolve(this.followers.has(followerId.href));
+	hasFollower(identifier, followerId) {
+		return Promise.resolve(this.#data.get(identifier)?.followers.has(followerId.href) ?? false);
 	}
-	async *getFollowers(options = {}) {
+	async *getFollowers(identifier, options = {}) {
 		const { offset = 0, limit } = options;
-		let followers = [...this.followers.values()];
+		let followers = [...this.#data.get(identifier)?.followers.values() ?? []];
 		followers.sort((a, b) => b.id.href.localeCompare(a.id.href) ?? 0);
 		if (offset > 0) followers = followers.slice(offset);
 		if (limit != null) followers = followers.slice(0, limit);
 		for (const follower of followers) yield follower;
 	}
-	countFollowers() {
-		return Promise.resolve(this.followers.size);
+	countFollowers(identifier) {
+		return Promise.resolve(this.#data.get(identifier)?.followers.size ?? 0);
 	}
-	addSentFollow(id, follow) {
-		this.sentFollows[id] = follow;
+	addSentFollow(identifier, id, follow) {
+		this.#bucket(identifier).sentFollows[id] = follow;
 		return Promise.resolve();
 	}
-	removeSentFollow(id) {
-		const follow = this.sentFollows[id];
-		delete this.sentFollows[id];
+	removeSentFollow(identifier, id) {
+		const sentFollows = this.#data.get(identifier)?.sentFollows;
+		if (sentFollows == null) return Promise.resolve(void 0);
+		const follow = sentFollows[id];
+		delete sentFollows[id];
 		return Promise.resolve(follow);
 	}
-	getSentFollow(id) {
-		return Promise.resolve(this.sentFollows[id]);
+	getSentFollow(identifier, id) {
+		return Promise.resolve(this.#data.get(identifier)?.sentFollows[id]);
 	}
-	addFollowee(followeeId, follow) {
-		this.followees[followeeId.href] = follow;
+	addFollowee(identifier, followeeId, follow) {
+		this.#bucket(identifier).followees[followeeId.href] = follow;
 		return Promise.resolve();
 	}
-	removeFollowee(followeeId) {
-		const follow = this.followees[followeeId.href];
-		delete this.followees[followeeId.href];
+	removeFollowee(identifier, followeeId) {
+		const followees = this.#data.get(identifier)?.followees;
+		if (followees == null) return Promise.resolve(void 0);
+		const follow = followees[followeeId.href];
+		delete followees[followeeId.href];
 		return Promise.resolve(follow);
 	}
-	getFollowee(followeeId) {
-		return Promise.resolve(this.followees[followeeId.href]);
+	getFollowee(identifier, followeeId) {
+		return Promise.resolve(this.#data.get(identifier)?.followees[followeeId.href]);
 	}
-	vote(messageId, voterId, option) {
-		const poll = this.polls[messageId] ??= {};
+	async *findFollowedBots(followeeId) {
+		for (const [identifier, data] of this.#data) if (followeeId.href in data.followees) yield identifier;
+	}
+	vote(identifier, messageId, voterId, option) {
+		const poll = this.#bucket(identifier).polls[messageId] ??= {};
 		const voters = poll[option] ??= /* @__PURE__ */ new Set();
 		voters.add(voterId.href);
 		return Promise.resolve();
 	}
-	countVoters(messageId) {
-		const poll = this.polls[messageId];
+	countVoters(identifier, messageId) {
+		const poll = this.#data.get(identifier)?.polls[messageId];
 		if (poll == null) return Promise.resolve(0);
 		let voters = /* @__PURE__ */ new Set();
 		for (const votersSet of globalThis.Object.values(poll)) voters = voters.union(votersSet);
 		return Promise.resolve(voters.size);
 	}
-	countVotes(messageId) {
-		const poll = this.polls[messageId];
+	countVotes(identifier, messageId) {
+		const poll = this.#data.get(identifier)?.polls[messageId];
 		if (poll == null) return Promise.resolve({});
 		const counts = {};
 		for (const [option, voters] of globalThis.Object.entries(poll)) counts[option] = voters.size;
 		return Promise.resolve(counts);
 	}
+	forIdentifier(identifier) {
+		return new ActorScopedRepository(this, identifier);
+	}
 };
 /**
 * A repository decorator that adds an in-memory cache layer on top of another
@@ -453,9 +806,10 @@ var MemoryRepository = class {
 * of accesses to the underlying persistent storage, but it increases memory
 * usage. The cache is not persistent and will be lost when the process exits.
 *
-* Note: List operations like `getMessages` and `getFollowers`, and count
-* operations like `countMessages` and `countFollowers` are not cached and
-* always delegate to the underlying repository.
+* Note: List operations like `getMessages` and `getFollowers`, count
+* operations like `countMessages` and `countFollowers`, and reverse lookups
+* like `findFollowedBots` are not cached and always delegate to the
+* underlying repository.
 * @since 0.3.0
 */
 var MemoryCachedRepository = class {
@@ -471,120 +825,138 @@ var MemoryCachedRepository = class {
 		this.underlying = underlying;
 		this.cache = cache ?? new MemoryRepository();
 	}
-	async setKeyPairs(keyPairs) {
-		await this.underlying.setKeyPairs(keyPairs);
-		await this.cache.setKeyPairs(keyPairs);
+	async setKeyPairs(identifier, keyPairs) {
+		await this.underlying.setKeyPairs(identifier, keyPairs);
+		await this.cache.setKeyPairs(identifier, keyPairs);
 	}
-	async getKeyPairs() {
-		let keyPairs = await this.cache.getKeyPairs();
+	async getKeyPairs(identifier) {
+		let keyPairs = await this.cache.getKeyPairs(identifier);
 		if (keyPairs === void 0) {
-			keyPairs = await this.underlying.getKeyPairs();
-			if (keyPairs !== void 0) await this.cache.setKeyPairs(keyPairs);
+			keyPairs = await this.underlying.getKeyPairs(identifier);
+			if (keyPairs !== void 0) await this.cache.setKeyPairs(identifier, keyPairs);
 		}
 		return keyPairs;
 	}
-	async addMessage(id, activity) {
-		await this.underlying.addMessage(id, activity);
-		await this.cache.addMessage(id, activity);
+	async addMessage(identifier, id, activity) {
+		await this.underlying.addMessage(identifier, id, activity);
+		await this.cache.addMessage(identifier, id, activity);
 	}
-	async updateMessage(id, updater) {
-		const updated = await this.underlying.updateMessage(id, updater);
+	async updateMessage(identifier, id, updater) {
+		const updated = await this.underlying.updateMessage(identifier, id, updater);
 		if (updated) {
-			const updatedMessage = await this.underlying.getMessage(id);
-			if (updatedMessage) await this.cache.addMessage(id, updatedMessage);
-			else await this.cache.removeMessage(id);
+			const updatedMessage = await this.underlying.getMessage(identifier, id);
+			if (updatedMessage) await this.cache.addMessage(identifier, id, updatedMessage);
+			else await this.cache.removeMessage(identifier, id);
 		}
 		return updated;
 	}
-	async removeMessage(id) {
-		const removedActivity = await this.underlying.removeMessage(id);
-		if (removedActivity !== void 0) await this.cache.removeMessage(id);
+	async removeMessage(identifier, id) {
+		const removedActivity = await this.underlying.removeMessage(identifier, id);
+		if (removedActivity !== void 0) await this.cache.removeMessage(identifier, id);
 		return removedActivity;
 	}
-	getMessages(options) {
-		return this.underlying.getMessages(options);
+	getMessages(identifier, options) {
+		return this.underlying.getMessages(identifier, options);
 	}
-	async getMessage(id) {
-		let message = await this.cache.getMessage(id);
+	async getMessage(identifier, id) {
+		let message = await this.cache.getMessage(identifier, id);
 		if (message === void 0) {
-			message = await this.underlying.getMessage(id);
-			if (message !== void 0) await this.cache.addMessage(id, message);
+			message = await this.underlying.getMessage(identifier, id);
+			if (message !== void 0) await this.cache.addMessage(identifier, id, message);
 		}
 		return message;
 	}
-	countMessages() {
-		return this.underlying.countMessages();
+	countMessages(identifier) {
+		return this.underlying.countMessages(identifier);
 	}
-	async addFollower(followId, follower) {
-		await this.underlying.addFollower(followId, follower);
-		await this.cache.addFollower(followId, follower);
+	async addFollower(identifier, followId, follower) {
+		await this.underlying.addFollower(identifier, followId, follower);
+		await this.cache.addFollower(identifier, followId, follower);
 	}
-	async removeFollower(followId, followerId) {
-		const removedFollower = await this.underlying.removeFollower(followId, followerId);
-		if (removedFollower !== void 0) await this.cache.removeFollower(followId, followerId);
+	async removeFollower(identifier, followId, followerId) {
+		const removedFollower = await this.underlying.removeFollower(identifier, followId, followerId);
+		if (removedFollower !== void 0) await this.cache.removeFollower(identifier, followId, followerId);
 		return removedFollower;
 	}
-	async hasFollower(followerId) {
-		if (await this.cache.hasFollower(followerId)) return true;
-		const exists = await this.underlying.hasFollower(followerId);
+	async hasFollower(identifier, followerId) {
+		if (await this.cache.hasFollower(identifier, followerId)) return true;
+		const exists = await this.underlying.hasFollower(identifier, followerId);
 		return exists;
 	}
-	getFollowers(options) {
-		return this.underlying.getFollowers(options);
+	getFollowers(identifier, options) {
+		return this.underlying.getFollowers(identifier, options);
 	}
-	countFollowers() {
-		return this.underlying.countFollowers();
+	countFollowers(identifier) {
+		return this.underlying.countFollowers(identifier);
 	}
-	async addSentFollow(id, follow) {
-		await this.underlying.addSentFollow(id, follow);
-		await this.cache.addSentFollow(id, follow);
+	async addSentFollow(identifier, id, follow) {
+		await this.underlying.addSentFollow(identifier, id, follow);
+		await this.cache.addSentFollow(identifier, id, follow);
 	}
-	async removeSentFollow(id) {
-		const removedFollow = await this.underlying.removeSentFollow(id);
-		if (removedFollow !== void 0) await this.cache.removeSentFollow(id);
+	async removeSentFollow(identifier, id) {
+		const removedFollow = await this.underlying.removeSentFollow(identifier, id);
+		if (removedFollow !== void 0) await this.cache.removeSentFollow(identifier, id);
 		return removedFollow;
 	}
-	async getSentFollow(id) {
-		let follow = await this.cache.getSentFollow(id);
+	async getSentFollow(identifier, id) {
+		let follow = await this.cache.getSentFollow(identifier, id);
 		if (follow === void 0) {
-			follow = await this.underlying.getSentFollow(id);
-			if (follow !== void 0) await this.cache.addSentFollow(id, follow);
+			follow = await this.underlying.getSentFollow(identifier, id);
+			if (follow !== void 0) await this.cache.addSentFollow(identifier, id, follow);
 		}
 		return follow;
 	}
-	async addFollowee(followeeId, follow) {
-		await this.underlying.addFollowee(followeeId, follow);
-		await this.cache.addFollowee(followeeId, follow);
+	async addFollowee(identifier, followeeId, follow) {
+		await this.underlying.addFollowee(identifier, followeeId, follow);
+		await this.cache.addFollowee(identifier, followeeId, follow);
 	}
-	async removeFollowee(followeeId) {
-		const removedFollow = await this.underlying.removeFollowee(followeeId);
-		if (removedFollow !== void 0) await this.cache.removeFollowee(followeeId);
+	async removeFollowee(identifier, followeeId) {
+		const removedFollow = await this.underlying.removeFollowee(identifier, followeeId);
+		await this.cache.removeFollowee(identifier, followeeId);
 		return removedFollow;
 	}
-	async getFollowee(followeeId) {
-		let follow = await this.cache.getFollowee(followeeId);
+	async getFollowee(identifier, followeeId) {
+		let follow = await this.cache.getFollowee(identifier, followeeId);
 		if (follow === void 0) {
-			follow = await this.underlying.getFollowee(followeeId);
-			if (follow !== void 0) await this.cache.addFollowee(followeeId, follow);
+			follow = await this.underlying.getFollowee(identifier, followeeId);
+			if (follow !== void 0) await this.cache.addFollowee(identifier, followeeId, follow);
 		}
 		return follow;
 	}
-	async vote(messageId, voterId, option) {
-		await this.cache.vote(messageId, voterId, option);
-		await this.underlying.vote(messageId, voterId, option);
+	findFollowedBots(followeeId) {
+		return this.underlying.findFollowedBots(followeeId);
 	}
-	async countVoters(messageId) {
-		const voters = await this.cache.countVoters(messageId);
+	async vote(identifier, messageId, voterId, option) {
+		await this.cache.vote(identifier, messageId, voterId, option);
+		await this.underlying.vote(identifier, messageId, voterId, option);
+	}
+	async countVoters(identifier, messageId) {
+		const voters = await this.cache.countVoters(identifier, messageId);
 		if (voters > 0) return voters;
-		return this.underlying.countVoters(messageId);
+		return this.underlying.countVoters(identifier, messageId);
 	}
-	async countVotes(messageId) {
-		const votes = await this.cache.countVotes(messageId);
+	async countVotes(identifier, messageId) {
+		const votes = await this.cache.countVotes(identifier, messageId);
 		if (globalThis.Object.keys(votes).length > 0) return votes;
-		return await this.underlying.countVotes(messageId);
+		return await this.underlying.countVotes(identifier, messageId);
+	}
+	forIdentifier(identifier) {
+		return new ActorScopedRepository(this, identifier);
+	}
+	/**
+	* Migrates data stored by BotKit 0.4 or earlier in the underlying
+	* repository, so that it belongs to the given identifier.  The cache is
+	* not involved: it starts empty and only ever holds values read after
+	* the migration.
+	* @param identifier The identifier of the bot actor that adopts the
+	*                   legacy data.
+	* @since 0.5.0
+	*/
+	async migrate(identifier) {
+		await this.underlying.migrate?.(identifier);
 	}
 };
 
 //#endregion
-export { Announce, Create, KvRepository, MemoryCachedRepository, MemoryRepository };
+export { ActorScopedRepository, Announce, Create, KvRepository, MemoryCachedRepository, MemoryRepository };
 //# sourceMappingURL=repository.js.map