matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/core/push.js

@@ -0,0 +1,307 @@
+import { isObject } from "./json.js";
+import { M, UNSTABLE } from "./m.js";
+import { splitStateKey, toClientEvent } from "./events.js";
+import { getState, powerLevels, userLevel } from "./authrules.js";
+import { globMatch, globSearchWords } from "./glob.js";
+import { KINDS, loadRules } from "./pushrules.js";
+import { isSubscribed } from "../api/threadsubs.js";
+//#region src/core/push.ts
+/** Look up a dotted path; `\.` escapes a literal dot in a key (e.g. `content.m\.relates_to`). */
+function valueAtPath(obj, path) {
+	const parts = path.split(/(?<!\\)\./).map((p) => p.replace(/\\\./g, ".").replace(/\\\\/g, "\\"));
+	let cur = obj;
+	for (const p of parts) {
+		if (!isObject(cur) || !(p in cur)) return void 0;
+		cur = cur[p];
+	}
+	return cur;
+}
+function conditionMatches(cond, ctx) {
+	switch (cond.kind) {
+		case "event_match": {
+			if (typeof cond.key !== "string" || typeof cond.pattern !== "string") return false;
+			const value = valueAtPath(ctx.event, cond.key);
+			if (typeof value !== "string") return false;
+			return cond.key === "content.body" ? globSearchWords(cond.pattern, value) : globMatch(cond.pattern, value, { caseInsensitive: true });
+		}
+		case "event_property_is": return typeof cond.key === "string" && valueAtPath(ctx.event, cond.key) === cond.value;
+		case "event_property_contains": {
+			const value = typeof cond.key === "string" ? valueAtPath(ctx.event, cond.key) : void 0;
+			return Array.isArray(value) && value.includes(cond.value);
+		}
+		case "contains_display_name": {
+			const body = ctx.event.content?.body;
+			if (!ctx.displayName || typeof body !== "string") return false;
+			const escaped = ctx.displayName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			return new RegExp(`(^|\\W)${escaped}(\\W|$)`, "i").test(body);
+		}
+		case "room_member_count": {
+			const m = /^(==|<=|>=|<|>)?(\d+)$/.exec(String(cond.is ?? ""));
+			if (!m) return false;
+			const n = Number(m[2]);
+			switch (m[1] ?? "==") {
+				case "==": return ctx.memberCount === n;
+				case "<": return ctx.memberCount < n;
+				case ">": return ctx.memberCount > n;
+				case "<=": return ctx.memberCount <= n;
+				case ">=": return ctx.memberCount >= n;
+			}
+			return false;
+		}
+		case UNSTABLE.IO.ELEMENT.MSC4306.THREAD_SUBSCRIPTION: return ctx.threadSubscribed !== void 0 && ctx.threadSubscribed !== null && ctx.threadSubscribed === cond.subscribed;
+		case "sender_notification_permission": return typeof cond.key === "string" && ctx.senderLevel >= (ctx.notificationLevels[cond.key] ?? 50);
+		default: return false;
+	}
+}
+function ruleMatches(kind, rule, ctx) {
+	if (!rule.enabled) return false;
+	switch (kind) {
+		case "override":
+		case "postcontent":
+		case "underride": return (rule.conditions ?? []).every((c) => conditionMatches(c, ctx));
+		case "content": return typeof rule.pattern === "string" && conditionMatches({
+			kind: "event_match",
+			key: "content.body",
+			pattern: rule.pattern
+		}, ctx);
+		case "room": return ctx.event.room_id === rule.rule_id;
+		case "sender": return ctx.event.sender === rule.rule_id;
+	}
+	return false;
+}
+/** Evaluate a user's push rules against an event; returns the actions of the first matching rule. */
+function evaluateRules(rules, ctx) {
+	for (const kind of KINDS) for (const rule of rules[kind] ?? []) if (ruleMatches(kind, rule, ctx)) return rule.actions ?? [];
+	return null;
+}
+function tweaksOf(actions) {
+	const tweaks = {};
+	for (const a of actions) if (isObject(a) && typeof a.set_tweak === "string") tweaks[a.set_tweak] = "value" in a ? a.value : true;
+	return tweaks;
+}
+/** Thread an event belongs to for notification purposes ("main" for the main timeline). */
+function threadIdOf(event) {
+	const rel = event.content?.[M.RELATES_TO];
+	return isObject(rel) && rel.rel_type === M.THREAD && typeof rel.event_id === "string" ? rel.event_id : "main";
+}
+/**
+* Push rule evaluation and push gateway delivery. Every new event is evaluated for
+* every local member; matches are stored for unread counts and `/notifications`.
+*/
+var PushService = class {
+	hs;
+	constructor(hs) {
+		this.hs = hs;
+	}
+	async onEvent(ev, state, version) {
+		const event = ev.pdu;
+		const members = [];
+		for (const [key, member] of state) {
+			const [type, userId] = splitStateKey(key);
+			if (type !== M.ROOM.MEMBER) continue;
+			const m = member.content?.membership;
+			if (m === "join" || m === "invite" && event.type === M.ROOM.MEMBER && event.state_key === userId) members.push(userId);
+		}
+		const joined = members.filter((u) => getState(state, M.ROOM.MEMBER, u)?.content?.membership === "join");
+		const pl = powerLevels(state, version);
+		const senderLevel = userLevel(pl, event.sender);
+		const thread = threadIdOf(event);
+		for (const userId of members) {
+			if (userId === event.sender || !this.hs.isLocalUser(userId)) continue;
+			const actions = evaluateRules(await loadRules(this.hs, userId), {
+				event,
+				userId,
+				displayName: getState(state, M.ROOM.MEMBER, userId)?.content?.displayname ?? null,
+				memberCount: joined.length,
+				senderLevel: Number.isFinite(senderLevel) ? senderLevel : Number.MAX_SAFE_INTEGER,
+				notificationLevels: pl.notifications,
+				threadSubscribed: thread === "main" ? void 0 : await isSubscribed(this.hs, userId, event.room_id, thread)
+			});
+			if (!actions || !actions.includes("notify")) continue;
+			const tweaks = tweaksOf(actions);
+			await this.hs.db.upsert("notifications", {
+				user_id: userId,
+				room_id: event.room_id,
+				event_id: event.event_id,
+				stream: ev.stream,
+				highlight: tweaks.highlight === true,
+				thread_id: threadIdOf(event),
+				actions,
+				ts: Date.now()
+			});
+			this.deliver(userId, ev, state, tweaks).catch((err) => this.hs.logger.warn("Push delivery failed", err));
+		}
+	}
+	/** Unread notification counts since the user's read receipts. */
+	/** Stream positions up to which the user has read the room (unthreaded) and each thread. */
+	async readPositions(userId, roomId) {
+		const receipts = await this.hs.db.findMany("receipts", { where: [{
+			field: "room_id",
+			value: roomId
+		}, {
+			field: "user_id",
+			value: userId
+		}] });
+		let unthreaded = 0;
+		const threadRead = /* @__PURE__ */ new Map();
+		for (const r of receipts) {
+			if (r.receipt_type !== M.READ._ && r.receipt_type !== M.READ.PRIVATE) continue;
+			const target = await this.hs.rooms.getEvent(r.event_id);
+			if (!target) continue;
+			if (r.thread_id === "") unthreaded = Math.max(unthreaded, target.stream);
+			else threadRead.set(r.thread_id, Math.max(threadRead.get(r.thread_id) ?? 0, target.stream));
+		}
+		return {
+			unthreaded,
+			threads: threadRead
+		};
+	}
+	isRead(row, read) {
+		return row.stream <= read.unthreaded || row.stream <= (read.threads.get(row.thread_id) ?? 0);
+	}
+	async unreadCounts(userId, roomId) {
+		const read = await this.readPositions(userId, roomId);
+		const unthreaded = read.unthreaded;
+		const rows = await this.hs.db.findMany("notifications", { where: [
+			{
+				field: "user_id",
+				value: userId
+			},
+			{
+				field: "room_id",
+				value: roomId
+			},
+			{
+				field: "stream",
+				operator: "gt",
+				value: unthreaded
+			}
+		] });
+		const room = {
+			notification_count: 0,
+			highlight_count: 0
+		};
+		const threads = {};
+		for (const n of rows) {
+			if (this.isRead(n, read)) continue;
+			const bucket = n.thread_id === "main" ? room : threads[n.thread_id] ??= {
+				notification_count: 0,
+				highlight_count: 0
+			};
+			bucket.notification_count++;
+			if (n.highlight) bucket.highlight_count++;
+		}
+		return {
+			room,
+			threads
+		};
+	}
+	async deliver(userId, ev, state, tweaks) {
+		const pushers = await this.hs.db.findMany("pushers", { where: [{
+			field: "user_id",
+			value: userId
+		}] });
+		if (pushers.length === 0) return;
+		const event = ev.pdu;
+		const unread = (await this.unreadCounts(userId, event.room_id)).room.notification_count;
+		for (const row of pushers) {
+			const pusher = row.pusher;
+			if (pusher.kind !== "http" || typeof pusher.data?.url !== "string") continue;
+			const { url, format, ...data } = pusher.data;
+			const notification = {
+				event_id: event.event_id,
+				room_id: event.room_id,
+				counts: { unread },
+				devices: [{
+					app_id: pusher.app_id,
+					pushkey: pusher.pushkey,
+					pushkey_ts: Math.floor(Date.now() / 1e3),
+					data,
+					tweaks
+				}],
+				prio: tweaks.highlight || tweaks.sound ? "high" : "low"
+			};
+			if (format !== "event_id_only") {
+				notification.type = event.type;
+				notification.sender = event.sender;
+				notification.content = event.content;
+				const name = getState(state, M.ROOM.NAME)?.content?.name;
+				if (typeof name === "string") notification.room_name = name;
+				const senderName = getState(state, M.ROOM.MEMBER, event.sender)?.content?.displayname;
+				if (typeof senderName === "string") notification.sender_display_name = senderName;
+				if (event.type === M.ROOM.MEMBER) {
+					notification.membership = event.content?.membership;
+					notification.user_is_target = event.state_key === userId;
+				}
+			}
+			const res = await this.hs.fetch(url, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({ notification }),
+				signal: AbortSignal.timeout(1e4)
+			});
+			if (!res.ok) {
+				this.hs.logger.warn("Push gateway returned", res.status, "for", url);
+				continue;
+			}
+			const body = await res.json().catch(() => ({}));
+			if (Array.isArray(body.rejected) && body.rejected.includes(pusher.pushkey)) await this.hs.db.delete("pushers", [
+				{
+					field: "user_id",
+					value: userId
+				},
+				{
+					field: "app_id",
+					value: pusher.app_id
+				},
+				{
+					field: "pushkey",
+					value: pusher.pushkey
+				}
+			]);
+		}
+	}
+	/** Rows for `GET /notifications`. */
+	async list(userId, opts) {
+		const where = [{
+			field: "user_id",
+			value: userId
+		}];
+		if (opts.from !== null) where.push({
+			field: "stream",
+			operator: "lt",
+			value: opts.from
+		});
+		if (opts.onlyHighlight) where.push({
+			field: "highlight",
+			value: true
+		});
+		const rows = await this.hs.db.findMany("notifications", {
+			where,
+			sortBy: {
+				field: "stream",
+				direction: "desc"
+			},
+			limit: opts.limit
+		});
+		const out = [];
+		const readByRoom = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const ev = await this.hs.rooms.getEvent(row.event_id);
+			if (!ev) continue;
+			let read = readByRoom.get(row.room_id);
+			if (!read) readByRoom.set(row.room_id, read = await this.readPositions(userId, row.room_id));
+			out.push({
+				actions: row.actions,
+				event: toClientEvent(ev.pdu),
+				room_id: row.room_id,
+				ts: row.ts,
+				read: this.isRead(row, read),
+				stream: row.stream
+			});
+		}
+		return out;
+	}
+};
+//#endregion
+export { PushService, evaluateRules, threadIdOf, tweaksOf, valueAtPath };

package/dist/core/pushrules.js

@@ -0,0 +1,229 @@
+import { isObject } from "./json.js";
+import { M, UNSTABLE } from "./m.js";
+//#region src/core/pushrules.ts
+const KINDS = [
+	"override",
+	"content",
+	"postcontent",
+	"room",
+	"sender",
+	"underride"
+];
+function defaultRules(userId) {
+	const localpart = userId.slice(1).split(":")[0];
+	const notify = ["notify"];
+	const sound = (s) => ({
+		set_tweak: "sound",
+		value: s
+	});
+	const highlight = { set_tweak: "highlight" };
+	const r = (rule_id, conditions, actions, extra = {}) => ({
+		rule_id,
+		default: true,
+		enabled: true,
+		actions,
+		...conditions ? { conditions } : {},
+		...extra
+	});
+	const em = (key, pattern) => ({
+		kind: "event_match",
+		key,
+		pattern
+	});
+	const ep = (key, value) => ({
+		kind: "event_property_is",
+		key,
+		value
+	});
+	return {
+		override: [
+			r(M.RULE.MASTER, [], [], { enabled: false }),
+			r(M.RULE.SUPPRESS_NOTICES, [em("content.msgtype", M.NOTICE)], []),
+			r(M.RULE.INVITE_FOR_ME, [
+				em("type", M.ROOM.MEMBER),
+				em("content.membership", "invite"),
+				em("state_key", userId)
+			], [...notify, sound("default")]),
+			r(M.RULE.MEMBER_EVENT, [em("type", M.ROOM.MEMBER)], []),
+			r(M.RULE.IS_USER_MENTION, [{
+				kind: "event_property_contains",
+				key: "content.m\\.mentions.user_ids",
+				value: userId
+			}], [
+				...notify,
+				sound("default"),
+				highlight
+			]),
+			r(M.RULE.CONTAINS_DISPLAY_NAME, [{ kind: "contains_display_name" }], [
+				...notify,
+				sound("default"),
+				highlight
+			]),
+			r(M.RULE.IS_ROOM_MENTION, [ep("content.m\\.mentions.room", true), {
+				kind: "sender_notification_permission",
+				key: "room"
+			}], [...notify, highlight]),
+			r(M.RULE.ROOMNOTIF, [em("content.body", "@room"), {
+				kind: "sender_notification_permission",
+				key: "room"
+			}], [...notify, highlight]),
+			r(M.RULE.TOMBSTONE, [em("type", M.ROOM.TOMBSTONE), em("state_key", "")], [...notify, highlight]),
+			r(M.RULE.REACTION, [em("type", M.REACTION)], []),
+			r(M.RULE.ROOM.SERVER_ACL, [em("type", M.ROOM.SERVER_ACL), em("state_key", "")], []),
+			r(M.RULE.SUPPRESS_EDITS, [ep("content.m\\.relates_to.rel_type", M.REPLACE)], []),
+			r(UNSTABLE.ORG.MATRIX.MSC3930.RULE.POLL_RESPONSE, [em("type", UNSTABLE.ORG.MATRIX.MSC3381.POLL.RESPONSE)], [])
+		],
+		content: [r(M.RULE.CONTAINS_USER_NAME, void 0, [
+			...notify,
+			sound("default"),
+			highlight
+		], { pattern: localpart })],
+		postcontent: [r(UNSTABLE.IO.ELEMENT.MSC4306.RULE.UNSUBSCRIBED_THREAD, [{
+			kind: UNSTABLE.IO.ELEMENT.MSC4306.THREAD_SUBSCRIPTION,
+			subscribed: false
+		}], []), r(UNSTABLE.IO.ELEMENT.MSC4306.RULE.SUBSCRIBED_THREAD, [{
+			kind: UNSTABLE.IO.ELEMENT.MSC4306.THREAD_SUBSCRIPTION,
+			subscribed: true
+		}], [...notify, sound("default")])],
+		room: [],
+		sender: [],
+		underride: [
+			r(M.RULE.CALL, [em("type", M.CALL.INVITE)], [...notify, sound("ring")]),
+			r(M.RULE.ENCRYPTED_ROOM_ONE_TO_ONE, [{
+				kind: "room_member_count",
+				is: "2"
+			}, em("type", M.ROOM.ENCRYPTED)], [...notify, sound("default")]),
+			r(M.RULE.ROOM_ONE_TO_ONE, [{
+				kind: "room_member_count",
+				is: "2"
+			}, em("type", M.ROOM.MESSAGE)], [...notify, sound("default")]),
+			r(M.RULE.MESSAGE, [em("type", M.ROOM.MESSAGE)], notify),
+			r(UNSTABLE.ORG.MATRIX.MSC3930.RULE.POLL_START_ONE_TO_ONE, [{
+				kind: "room_member_count",
+				is: "2"
+			}, em("type", UNSTABLE.ORG.MATRIX.MSC3381.POLL.START)], [...notify, sound("default")]),
+			r(UNSTABLE.ORG.MATRIX.MSC3930.RULE.POLL_END_ONE_TO_ONE, [{
+				kind: "room_member_count",
+				is: "2"
+			}, em("type", UNSTABLE.ORG.MATRIX.MSC3381.POLL.END)], [...notify, sound("default")]),
+			r(UNSTABLE.ORG.MATRIX.MSC3930.RULE.POLL_START, [em("type", UNSTABLE.ORG.MATRIX.MSC3381.POLL.START)], notify),
+			r(UNSTABLE.ORG.MATRIX.MSC3930.RULE.POLL_END, [em("type", UNSTABLE.ORG.MATRIX.MSC3381.POLL.END)], notify),
+			r(M.RULE.ENCRYPTED, [em("type", M.ROOM.ENCRYPTED)], notify)
+		]
+	};
+}
+/** Serialise read-modify-write cycles on a user's push rules (cluster-wide). */
+function withRulesLock(hs, userId, fn) {
+	return hs.cluster.lock(`pushrules:${userId}`, () => {
+		cacheFor(hs).delete(userId);
+		return fn();
+	});
+}
+const rulesCache = /* @__PURE__ */ new WeakMap();
+function cacheFor(hs) {
+	let c = rulesCache.get(hs);
+	if (!c) {
+		const cache = /* @__PURE__ */ new Map();
+		rulesCache.set(hs, c = cache);
+		hs.cluster.subscribe("pushrules", (msg) => {
+			if (msg?.from !== hs.instanceId) cache.delete(msg.userId);
+		});
+	}
+	return c;
+}
+async function loadRules(hs, userId) {
+	const cached = cacheFor(hs).get(userId);
+	if (cached) return structuredClone(cached);
+	const rules = await readRules(hs, userId);
+	const cache = cacheFor(hs);
+	if (cache.size > 5e3) cache.clear();
+	cache.set(userId, rules);
+	return structuredClone(rules);
+}
+async function readRules(hs, userId) {
+	const row = await hs.db.findOne("account_data", [
+		{
+			field: "user_id",
+			value: userId
+		},
+		{
+			field: "room_id",
+			value: ""
+		},
+		{
+			field: "type",
+			value: M.PUSH_RULES
+		}
+	]);
+	if (!isObject(row?.content?.global)) return defaultRules(userId);
+	const rules = row.content.global;
+	const defaults = defaultRules(userId);
+	for (const kind of KINDS) if (!Array.isArray(rules[kind])) rules[kind] = defaults[kind];
+	return rules;
+}
+async function saveRules(hs, userId, rules) {
+	cacheFor(hs).set(userId, structuredClone(rules));
+	hs.cluster.publish("pushrules", {
+		from: hs.instanceId,
+		userId
+	}).catch(() => {});
+	await hs.streams.write((stream) => hs.db.upsert("account_data", {
+		user_id: userId,
+		room_id: "",
+		type: M.PUSH_RULES,
+		content: { global: rules },
+		stream
+	}));
+	hs.notifier.notify([userId]);
+}
+/** Copy room-specific push rules from an upgraded room's predecessor to the new room. */
+function copyRoomPushRules(hs, userId, oldRoomId, newRoomId) {
+	return withRulesLock(hs, userId, () => copyRules(hs, userId, oldRoomId, newRoomId));
+}
+async function copyRules(hs, userId, oldRoomId, newRoomId) {
+	const row = await hs.db.findOne("account_data", [
+		{
+			field: "user_id",
+			value: userId
+		},
+		{
+			field: "room_id",
+			value: ""
+		},
+		{
+			field: "type",
+			value: M.PUSH_RULES
+		}
+	]);
+	if (!isObject(row?.content?.global)) return;
+	const rules = row.content.global;
+	let changed = false;
+	for (const kind of KINDS) {
+		const list = rules[kind] ?? [];
+		const additions = [];
+		for (const rule of list) {
+			if (rule.default) continue;
+			if (kind === "room" && rule.rule_id === oldRoomId) {
+				if (!list.some((r) => r.rule_id === newRoomId)) additions.push({
+					...structuredClone(rule),
+					rule_id: newRoomId
+				});
+			} else if (Array.isArray(rule.conditions) && rule.conditions.some((c) => c?.key === "room_id" && c?.pattern === oldRoomId)) {
+				const copy = structuredClone(rule);
+				copy.rule_id = `${rule.rule_id}-${newRoomId}`;
+				copy.conditions = copy.conditions.map((c) => c?.key === "room_id" && c?.pattern === oldRoomId ? {
+					...c,
+					pattern: newRoomId
+				} : c);
+				if (!list.some((r) => r.rule_id === copy.rule_id)) additions.push(copy);
+			}
+		}
+		if (additions.length) {
+			rules[kind] = [...additions, ...list];
+			changed = true;
+		}
+	}
+	if (changed) await saveRules(hs, userId, rules);
+}
+//#endregion
+export { KINDS, copyRoomPushRules, defaultRules, loadRules, saveRules, withRulesLock };

package/dist/core/ratelimit.d.ts

@@ -0,0 +1,23 @@
+//#region src/core/ratelimit.d.ts
+/** A rate limiter keyed by an arbitrary string. Implement this to share limits across instances (e.g. Redis). */
+export interface RateLimiter {
+  /** Consume one unit for `key` under `rule`; resolve with the delay to wait (0 when allowed). */
+  consume(key: string, rule: RateLimitRule): Promise<number>;
+}
+export interface RateLimitRule {
+  /** Sustained requests per second. */
+  perSecond: number;
+  /** Burst size. */
+  burst: number;
+}
+export type RateLimitAction = "login" | "register" | "message" | "join" | "invite" | "upload" | "createRoom" | "keyQuery";
+/** In-process token bucket limiter. */
+export declare function memoryRateLimiter(): RateLimiter;
+export declare class RateLimits {
+  private limiter;
+  private rules;
+  constructor(limiter: RateLimiter | null, overrides?: Partial<Record<RateLimitAction, RateLimitRule>>);
+  /** Throw M_LIMIT_EXCEEDED when `key` exceeded the limit for `action`. Exempt keys are never limited. */
+  check(action: RateLimitAction, key: string): Promise<void>;
+}
+//#endregion

package/dist/core/ratelimit.js

@@ -0,0 +1,77 @@
+import { MatrixError } from "./errors.js";
+//#region src/core/ratelimit.ts
+const DEFAULT_RATE_LIMITS = {
+	login: {
+		perSecond: .17,
+		burst: 5
+	},
+	register: {
+		perSecond: .17,
+		burst: 3
+	},
+	message: {
+		perSecond: 1,
+		burst: 20
+	},
+	join: {
+		perSecond: .5,
+		burst: 10
+	},
+	invite: {
+		perSecond: .3,
+		burst: 10
+	},
+	upload: {
+		perSecond: 1,
+		burst: 10
+	},
+	createRoom: {
+		perSecond: .1,
+		burst: 5
+	},
+	keyQuery: {
+		perSecond: 5,
+		burst: 50
+	}
+};
+/** In-process token bucket limiter. */
+function memoryRateLimiter() {
+	const buckets = /* @__PURE__ */ new Map();
+	return { async consume(key, rule) {
+		const now = Date.now();
+		let b = buckets.get(key);
+		if (!b) {
+			if (buckets.size > 1e5) buckets.clear();
+			buckets.set(key, b = {
+				tokens: rule.burst,
+				updated: now
+			});
+		}
+		b.tokens = Math.min(rule.burst, b.tokens + (now - b.updated) / 1e3 * rule.perSecond);
+		b.updated = now;
+		if (b.tokens >= 1) {
+			b.tokens -= 1;
+			return 0;
+		}
+		return Math.ceil((1 - b.tokens) / rule.perSecond * 1e3);
+	} };
+}
+var RateLimits = class {
+	limiter;
+	rules;
+	constructor(limiter, overrides = {}) {
+		this.limiter = limiter;
+		this.rules = {
+			...DEFAULT_RATE_LIMITS,
+			...overrides
+		};
+	}
+	/** Throw M_LIMIT_EXCEEDED when `key` exceeded the limit for `action`. Exempt keys are never limited. */
+	async check(action, key) {
+		if (!this.limiter) return;
+		const wait = await this.limiter.consume(`${action}:${key}`, this.rules[action]);
+		if (wait > 0) throw new MatrixError(429, "M_LIMIT_EXCEEDED", "Too many requests", { retry_after_ms: wait });
+	}
+};
+//#endregion
+export { DEFAULT_RATE_LIMITS, RateLimits, memoryRateLimiter };