matrix-nodejs-homeserver 0.2.0 → 0.3.2

package/dist/core/authrules.js

@@ -1,5 +1,6 @@
 import { isObject } from "./json.js";
 import { publicKeyFromBase64, verifyJsonSignature } from "./crypto.js";
+import { M } from "./m.js";
 import { roomVersionFeatures, stateKey, versionNum } from "./events.js";
 import { errors } from "./errors.js";
 import { isValidUserId } from "./ids.js";
@@ -20,10 +21,10 @@ function getState(state, type, key = "") {
 	return state.get(stateKey(type, key));
 }
 function membershipOf(state, userId) {
-	return getState(state, "m.room.member", userId)?.content?.membership ?? "leave";
+	return getState(state, M.ROOM.MEMBER, userId)?.content?.membership ?? "leave";
 }
 function roomCreator(state, roomVersion) {
-	const create = getState(state, "m.room.create");
+	const create = getState(state, M.ROOM.CREATE);
 	if (!create) return void 0;
 	return roomVersionFeatures(roomVersion).v11 ? create.sender : create.content.creator ?? create.sender;
 }
@@ -35,13 +36,13 @@ const toInt = (v, fallback) => {
 /** v12+: the create event's sender plus `additional_creators`. Empty for older versions. */
 function roomCreators(state, roomVersion) {
 	if (!roomVersionFeatures(roomVersion).v12) return /* @__PURE__ */ new Set();
-	const create = getState(state, "m.room.create");
+	const create = getState(state, M.ROOM.CREATE);
 	if (!create) return /* @__PURE__ */ new Set();
 	const extra = Array.isArray(create.content?.additional_creators) ? create.content.additional_creators : [];
 	return /* @__PURE__ */ new Set([create.sender, ...extra.filter((u) => typeof u === "string")]);
 }
 function powerLevels(state, roomVersion) {
-	const pl = getState(state, "m.room.power_levels")?.content;
+	const pl = getState(state, M.ROOM.POWER_LEVELS)?.content;
 	const creators = roomCreators(state, roomVersion);
 	if (!pl) {
 		const creator = roomCreator(state, roomVersion);
@@ -90,21 +91,21 @@ const sameDomain = (a, b) => a.slice(a.indexOf(":") + 1) === b.slice(b.indexOf("
 const domainOf = (id) => id.slice(id.indexOf(":") + 1);
 /** The (type, state_key) pairs an event's auth_events may reference (spec "auth events selection"). */
 function authEventKeys(event, roomVersion) {
-	if (event.type === "m.room.create") return [];
-	const keys = [stateKey("m.room.power_levels", ""), stateKey("m.room.member", event.sender)];
-	if (!roomVersionFeatures(roomVersion).v12) keys.unshift(stateKey("m.room.create", ""));
-	if (event.type === "m.room.member" && typeof event.state_key === "string") {
-		keys.push(stateKey("m.room.member", event.state_key));
+	if (event.type === M.ROOM.CREATE) return [];
+	const keys = [stateKey(M.ROOM.POWER_LEVELS, ""), stateKey(M.ROOM.MEMBER, event.sender)];
+	if (!roomVersionFeatures(roomVersion).v12) keys.unshift(stateKey(M.ROOM.CREATE, ""));
+	if (event.type === M.ROOM.MEMBER && typeof event.state_key === "string") {
+		keys.push(stateKey(M.ROOM.MEMBER, event.state_key));
 		const membership = event.content?.membership;
 		if ([
 			"join",
 			"invite",
 			"knock"
-		].includes(membership)) keys.push(stateKey("m.room.join_rules", ""));
+		].includes(membership)) keys.push(stateKey(M.ROOM.JOIN_RULES, ""));
 		const token = event.content?.third_party_invite?.signed?.token;
-		if (membership === "invite" && typeof token === "string") keys.push(stateKey("m.room.third_party_invite", token));
+		if (membership === "invite" && typeof token === "string") keys.push(stateKey(M.ROOM.THIRD_PARTY_INVITE, token));
 		const via = event.content?.join_authorised_via_users_server;
-		if (membership === "join" && typeof via === "string" && roomVersionFeatures(roomVersion).restricted) keys.push(stateKey("m.room.member", via));
+		if (membership === "join" && typeof via === "string" && roomVersionFeatures(roomVersion).restricted) keys.push(stateKey(M.ROOM.MEMBER, via));
 	}
 	return [...new Set(keys)];
 }
@@ -121,10 +122,10 @@ function authStateFromAuthEvents(event, authEvents, roomVersion, createEvent) {
 		const key = stateKey(ev.type, ev.state_key);
 		if (state.has(key)) throw errors.forbidden("Duplicate auth event");
 		if (!allowed.has(key)) throw errors.forbidden(`Unexpected auth event ${ev.type}`);
-		if (roomVersionFeatures(roomVersion).v12 && ev.type === "m.room.create") throw errors.forbidden("Create event must not be in auth_events");
+		if (roomVersionFeatures(roomVersion).v12 && ev.type === M.ROOM.CREATE) throw errors.forbidden("Create event must not be in auth_events");
 		state.set(key, ev);
 	}
-	if (createEvent) state.set(stateKey("m.room.create", ""), createEvent);
+	if (createEvent) state.set(stateKey(M.ROOM.CREATE, ""), createEvent);
 	return state;
 }
 /**
@@ -137,7 +138,7 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 	const deny = (msg) => {
 		throw errors.forbidden(msg);
 	};
-	if (event.type === "m.room.create") {
+	if (event.type === M.ROOM.CREATE) {
 		if (state.size > 0 || Array.isArray(event.prev_events) && event.prev_events.length > 0) deny("Create event must be the first event");
 		if (!features.v12 && event.room_id && !sameDomain(event.room_id, event.sender)) deny("Room ID domain must match the creator");
 		const rv = event.content?.room_version;
@@ -149,10 +150,10 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 		}
 		return;
 	}
-	const create = getState(state, "m.room.create");
+	const create = getState(state, M.ROOM.CREATE);
 	if (!create) deny("No create event in room");
-	if (create.content?.["m.federate"] === false && !sameDomain(event.sender, create.sender)) deny("Room is not federated");
-	if (n <= 5 && event.type === "m.room.aliases") {
+	if (create.content?.[M.FEDERATE] === false && !sameDomain(event.sender, create.sender)) deny("Room is not federated");
+	if (n <= 5 && event.type === M.ROOM.ALIASES) {
 		if (event.state_key === void 0) deny("Aliases event lacks a state key");
 		if (event.state_key !== domainOf(event.sender)) deny("Aliases state key must be the sender's domain");
 		return;
@@ -160,12 +161,12 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 	const pl = powerLevels(state, roomVersion);
 	const senderMembership = membershipOf(state, event.sender);
 	const senderLevel = userLevel(pl, event.sender);
-	if (event.type === "m.room.member") {
+	if (event.type === M.ROOM.MEMBER) {
 		const target = event.state_key;
 		const membership = event.content?.membership;
 		if (typeof target !== "string" || typeof membership !== "string") deny("Member event lacks state_key or membership");
 		const targetMembership = membershipOf(state, target);
-		const joinRule = getState(state, "m.room.join_rules")?.content?.join_rule ?? "invite";
+		const joinRule = getState(state, M.ROOM.JOIN_RULES)?.content?.join_rule ?? "invite";
 		const via = event.content?.join_authorised_via_users_server;
 		switch (membership) {
 			case "join": {
@@ -226,7 +227,7 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 		return;
 	}
 	if (senderMembership !== "join") deny("You are not joined to this room");
-	if (event.type === "m.room.third_party_invite") {
+	if (event.type === M.ROOM.THIRD_PARTY_INVITE) {
 		if (senderLevel >= pl.invite) return;
 		deny("Insufficient power level to invite");
 	}
@@ -238,16 +239,16 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 		if (!owner) deny("Malformed user-owned state key");
 		if (owner !== event.sender && senderLevel <= userLevel(pl, owner)) deny("This state key belongs to another user");
 	}
-	if (event.type === "m.room.power_levels" && isState) {
+	if (event.type === M.ROOM.POWER_LEVELS && isState) {
 		if (isObject(event.content?.users)) for (const u of Object.keys(event.content.users)) {
 			if (!isValidUserId(u)) deny("Power level users must be valid user IDs");
 			if (pl.creators.has(u)) deny("Room creators cannot be given a power level");
 		}
-		if (getState(state, "m.room.power_levels")) checkPowerLevelChange(event, pl, senderLevel, features.integerPowerLevels, n >= 6, deny);
+		if (getState(state, M.ROOM.POWER_LEVELS)) checkPowerLevelChange(event, pl, senderLevel, features.integerPowerLevels, n >= 6, deny);
 		else checkPowerLevelShape(event, features.integerPowerLevels, deny);
 		return;
 	}
-	if (n <= 2 && event.type === "m.room.redaction") {
+	if (n <= 2 && event.type === M.ROOM.REDACTION) {
 		if (senderLevel >= pl.redact) return;
 		const redacts = event.redacts;
 		if (typeof redacts === "string" && redacts.includes(":") && domainOf(redacts) === domainOf(event.sender)) return;
@@ -258,7 +259,7 @@ function checkThirdPartyInvite(event, state) {
 	const signed = event.content?.third_party_invite?.signed;
 	if (!isObject(signed) || typeof signed.mxid !== "string" || typeof signed.token !== "string") return false;
 	if (signed.mxid !== event.state_key) return false;
-	const invite = getState(state, "m.room.third_party_invite", signed.token);
+	const invite = getState(state, M.ROOM.THIRD_PARTY_INVITE, signed.token);
 	if (!invite || invite.sender !== event.sender) return false;
 	const keys = [];
 	if (typeof invite.content?.public_key === "string") keys.push(invite.content.public_key);

package/dist/core/cluster.d.ts

@@ -1,8 +1,8 @@
 //#region src/core/cluster.d.ts
 /**
  * Coordination between homeserver instances sharing one database. The default
- * (`localCluster()`) keeps everything in process; use `postgresCluster()` or
- * `redisCluster()` to run several instances behind a load balancer.
+ * (`localCluster()`) keeps everything in process; use `postgresCluster()` to run several
+ * instances behind a load balancer.
  */
 export interface ClusterAdapter {
   /** Allocate the next value of a cluster-wide, strictly increasing sequence. */
@@ -44,13 +44,20 @@ export declare class StreamManager {
   private cluster;
   private instanceId;
   private inflight;
-  private published;
-  private transition;
+  /** Allocations waiting for a publish that covers them. */
+  private reserving;
+  /** Allocations whose publish is done, asking the sequence for their position now. */
+  private allocating;
+  /** The position of the last published busy state: below every position still being allocated. */
+  private lastPos;
   private heartbeat;
   private positionCache;
+  private publishing;
+  private nextPublish;
   constructor(cluster: ClusterAdapter, instanceId: string);
   private key;
-  private publishState;
+  /** Publish this writer's state as it is when the publish starts; concurrent callers share it. */
+  private flush;
   /** Allocate a position. The caller must call `done()` once its writes are committed. */
   allocate(): Promise<StreamLease>;
   /** Allocate a position, run `fn` with it, then complete it. */

package/dist/core/cluster.js

@@ -91,38 +91,64 @@ var StreamManager = class {
 	cluster;
 	instanceId;
 	inflight = /* @__PURE__ */ new Set();
-	published = {
-		busy: false,
-		pos: 0
-	};
-	transition = Promise.resolve();
+	/** Allocations waiting for a publish that covers them. */
+	reserving = 0;
+	/** Allocations whose publish is done, asking the sequence for their position now. */
+	allocating = 0;
+	/** The position of the last published busy state: below every position still being allocated. */
+	lastPos = 0;
 	heartbeat;
 	positionCache = null;
+	publishing = Promise.resolve();
+	nextPublish = null;
 	constructor(cluster, instanceId) {
 		this.cluster = cluster;
 		this.instanceId = instanceId;
-		this.heartbeat = setInterval(() => void this.publishState().catch(() => {}), WRITER_TTL_MS / 3);
+		this.heartbeat = setInterval(() => void this.flush().catch(() => {}), WRITER_TTL_MS / 3);
 		this.heartbeat.unref?.();
 	}
 	key() {
 		return `writer:${this.instanceId}`;
 	}
-	async publishState() {
-		await this.cluster.set(this.key(), this.published, WRITER_TTL_MS);
+	/** Publish this writer's state as it is when the publish starts; concurrent callers share it. */
+	flush() {
+		if (this.nextPublish) return this.nextPublish;
+		const run = async () => {
+			this.nextPublish = null;
+			const covered = this.reserving;
+			const earlier = this.allocating;
+			this.reserving = 0;
+			this.allocating += covered;
+			const bounds = [];
+			if (this.inflight.size) bounds.push(Math.min(...this.inflight) - 1);
+			if (earlier) bounds.push(this.lastPos);
+			if (covered) bounds.push(await this.cluster.currentId("stream"));
+			const state = bounds.length ? {
+				busy: true,
+				pos: Math.min(...bounds)
+			} : {
+				busy: false,
+				pos: 0
+			};
+			if (state.busy) this.lastPos = state.pos;
+			await this.cluster.set(this.key(), state, WRITER_TTL_MS);
+		};
+		const p = this.publishing.then(run, run);
+		this.nextPublish = p;
+		this.publishing = p.catch(() => {});
+		return p;
 	}
 	/** Allocate a position. The caller must call `done()` once its writes are committed. */
 	async allocate() {
-		await (this.transition = this.transition.then(async () => {
-			if (!this.published.busy) {
-				this.published = {
-					busy: true,
-					pos: await this.cluster.currentId("stream")
-				};
-				await this.publishState();
-			}
-		}));
-		const id = await this.cluster.nextId("stream");
-		this.inflight.add(id);
+		this.reserving++;
+		let id;
+		try {
+			await this.flush();
+			id = await this.cluster.nextId("stream");
+			this.inflight.add(id);
+		} finally {
+			this.allocating--;
+		}
 		let finished = false;
 		const timer = setTimeout(() => void lease.done(), 6e4);
 		timer.unref?.();
@@ -133,16 +159,7 @@ var StreamManager = class {
 				finished = true;
 				clearTimeout(timer);
 				this.inflight.delete(id);
-				await (this.transition = this.transition.then(async () => {
-					this.published = this.inflight.size ? {
-						busy: true,
-						pos: Math.min(...this.inflight) - 1
-					} : {
-						busy: false,
-						pos: await this.cluster.currentId("stream")
-					};
-					await this.publishState();
-				}));
+				await this.flush();
 				this.positionCache = null;
 			}
 		};

package/dist/core/delayed.js

@@ -1,4 +1,5 @@
 import { randomString } from "./crypto.js";
+import { UNSTABLE } from "./m.js";
 import { MatrixError, errors } from "./errors.js";
 //#region src/core/delayed.ts
 /**
@@ -27,7 +28,7 @@ var DelayedEventService = class {
 	}
 	async schedule(opts) {
 		if (!Number.isInteger(opts.delayMs) || opts.delayMs < 0) throw errors.invalidParam("Invalid delay");
-		if (opts.delayMs > this.maxDelayMs) throw new MatrixError(400, "M_MAX_DELAY_EXCEEDED", "Delay is too long", { "org.matrix.msc4140.max_delay": this.maxDelayMs });
+		if (opts.delayMs > this.maxDelayMs) throw new MatrixError(400, "M_MAX_DELAY_EXCEEDED", "Delay is too long", { [UNSTABLE.ORG.MATRIX.MSC4140.MAX_DELAY]: this.maxDelayMs });
 		const txnKey = opts.txnId ? `${opts.userId}|${opts.deviceId}|${opts.roomId}|${opts.txnId}` : null;
 		if (txnKey) {
 			const existing = await this.hs.db.findOne("delayed_events", [{

package/dist/core/events.js

@@ -1,5 +1,6 @@
 import { canonicalJson, isObject } from "./json.js";
 import { randomString, sha256, signJson, unpaddedBase64, urlSafeBase64 } from "./crypto.js";
+import { M } from "./m.js";
 //#region src/core/events.ts
 const STABLE_ROOM_VERSIONS = [
 	"1",
@@ -76,7 +77,7 @@ function redact(event, roomVersion) {
 	const keep = n >= 11 ? KEEP_TOP_LEVEL : [...KEEP_TOP_LEVEL, ...KEEP_TOP_LEVEL_LEGACY];
 	const out = {};
 	for (const k of keep) if (k in event) out[k] = event[k];
-	const keepRelation = roomVersion.startsWith("org.matrix.msc3389.") && isObject(event.content?.["m.relates_to"]) ? event.content["m.relates_to"] : void 0;
+	const keepRelation = roomVersion.startsWith("org.matrix.msc3389.") && isObject(event.content?.[M.RELATES_TO]) ? event.content[M.RELATES_TO] : void 0;
 	const content = isObject(event.content) ? event.content : {};
 	const pick = (...keys) => {
 		const c = {};
@@ -84,28 +85,28 @@ function redact(event, roomVersion) {
 		return c;
 	};
 	switch (event.type) {
-		case "m.room.member": {
+		case M.ROOM.MEMBER: {
 			const c = pick("membership", ...n >= 9 ? ["join_authorised_via_users_server"] : []);
 			if (n >= 11 && isObject(content.third_party_invite) && "signed" in content.third_party_invite) c.third_party_invite = { signed: content.third_party_invite.signed };
 			out.content = c;
 			break;
 		}
-		case "m.room.create":
+		case M.ROOM.CREATE:
 			out.content = n >= 11 ? { ...content } : pick("creator");
 			break;
-		case "m.room.join_rules":
+		case M.ROOM.JOIN_RULES:
 			out.content = pick("join_rule", ...n >= 8 ? ["allow"] : []);
 			break;
-		case "m.room.power_levels":
+		case M.ROOM.POWER_LEVELS:
 			out.content = pick("ban", "events", "events_default", "kick", "redact", "state_default", "users", "users_default", ...n >= 11 ? ["invite"] : []);
 			break;
-		case "m.room.history_visibility":
+		case M.ROOM.HISTORY_VISIBILITY:
 			out.content = pick("history_visibility");
 			break;
-		case "m.room.aliases":
+		case M.ROOM.ALIASES:
 			out.content = n <= 5 ? pick("aliases") : {};
 			break;
-		case "m.room.redaction":
+		case M.ROOM.REDACTION:
 			out.content = n >= 11 ? pick("redacts") : {};
 			break;
 		default: out.content = {};
@@ -116,7 +117,7 @@ function redact(event, roomVersion) {
 		if ("event_id" in keepRelation) rel.event_id = keepRelation.event_id;
 		out.content = {
 			...out.content,
-			"m.relates_to": rel
+			[M.RELATES_TO]: rel
 		};
 	}
 	return out;
@@ -161,7 +162,7 @@ function toClientEvent(pdu, opts = {}) {
 	if (opts.includeRoomId !== false) ev.room_id = pdu.room_id;
 	if (pdu.state_key !== void 0) ev.state_key = pdu.state_key;
 	if (pdu.redacts !== void 0) ev.redacts = pdu.redacts;
-	else if (pdu.type === "m.room.redaction" && typeof pdu.content?.redacts === "string") ev.redacts = pdu.content.redacts;
+	else if (pdu.type === M.ROOM.REDACTION && typeof pdu.content?.redacts === "string") ev.redacts = pdu.content.redacts;
 	ev.unsigned = {
 		...pdu.unsigned,
 		age: Math.max(0, Date.now() - pdu.origin_server_ts)

package/dist/core/html.js

@@ -0,0 +1,13 @@
+//#region src/core/html.ts
+/** Escape text for use in HTML content and quoted attributes. */
+function escapeHtml(s) {
+	return s.replace(/[&<>"']/g, (c) => ({
+		"&": "&amp;",
+		"<": "&lt;",
+		">": "&gt;",
+		"\"": "&quot;",
+		"'": "&#39;"
+	})[c]);
+}
+//#endregion
+export { escapeHtml };

package/dist/core/identity.js

@@ -18,7 +18,7 @@ var IdentityServers = class {
 		if (opts.signed) headers.authorization = this.hs.federation.client.authHeader(idServer, method, path, opts.body);
 		let res;
 		try {
-			res = await this.hs.fetch(`${this.base(idServer)}${path}`, {
+			res = await this.hs.publicFetch(`${this.base(idServer)}${path}`, {
 				method,
 				headers,
 				body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body),

package/dist/core/invitefilter.js

@@ -1,7 +1,8 @@
 import { isObject } from "./json.js";
+import { UNSTABLE } from "./m.js";
 import { globMatch } from "./glob.js";
 //#region src/core/invitefilter.ts
-const INVITE_CONFIG_TYPE = "org.matrix.msc4155.invite_permission_config";
+const INVITE_CONFIG_TYPE = UNSTABLE.ORG.MATRIX.MSC4155.INVITE_PERMISSION_CONFIG;
 /**
 * MSC4155 invite filtering: "allow", "ignore" (accept but hide) or "block" (refuse).
 * User rules take precedence over server rules; within each, allow > ignore > block.

package/dist/core/json.js

@@ -1,4 +1,13 @@
 //#region src/core/json.ts
+function byCodePoint(a, b) {
+	for (let i = 0; i < a.length && i < b.length;) {
+		const ca = a.codePointAt(i);
+		const cb = b.codePointAt(i);
+		if (ca !== cb) return ca - cb;
+		i += ca > 65535 ? 2 : 1;
+	}
+	return a.length - b.length;
+}
 /** Matrix canonical JSON: sorted keys, no whitespace, UTF-8, integers only. */
 function canonicalJson(value) {
 	if (value === null || typeof value !== "object") {
@@ -7,7 +16,7 @@ function canonicalJson(value) {
 	}
 	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
 	const obj = value;
-	return `{${Object.keys(obj).filter((k) => obj[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(",")}}`;
+	return `{${Object.keys(obj).filter((k) => obj[k] !== void 0).sort(byCodePoint).map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(",")}}`;
 }
 function isObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/core/keys.d.ts

@@ -1,3 +1,4 @@
+import { Row } from "../storage/types.js";
 import { Homeserver } from "../homeserver.js";
 //#region src/core/keys.d.ts
 /** End-to-end encryption key storage (device keys, one-time keys, cross-signing). */
@@ -28,7 +29,15 @@ export declare class KeyService {
   uploadCrossSigning(userId: string, body: Record<string, any>): Promise<void>;
   uploadSignatures(signer: string, body: Record<string, any>): Promise<Record<string, any>>;
   /** Users (sharing a room with `userId`) whose device lists changed after `since`. */
-  changesSince(userId: string, since: number, upTo: number): Promise<{
+  /**
+   * Device-list changes for /sync and /keys/changes. /sync passes what it has already read (the
+   * membership changes, the device-list rows, the user's joined rooms) to save the queries.
+   */
+  changesSince(userId: string, since: number, upTo: number, known?: {
+    memberChanges?: Row[];
+    deviceRows?: Row[];
+    joinedRooms?: string[];
+  }): Promise<{
     changed: string[];
     left: string[];
   }>;

package/dist/core/keys.js

@@ -1,4 +1,5 @@
 import { isObject } from "./json.js";
+import { UNSTABLE } from "./m.js";
 import { errors } from "./errors.js";
 //#region src/core/keys.ts
 /** End-to-end encryption key storage (device keys, one-time keys, cross-signing). */
@@ -78,7 +79,7 @@ var KeyService = class {
 				seq
 			}));
 		}
-		const fallbackKeys = body.fallback_keys ?? body["org.matrix.msc2732.fallback_keys"];
+		const fallbackKeys = body.fallback_keys ?? body[UNSTABLE.ORG.MATRIX.MSC2732.FALLBACK_KEYS];
 		if (isObject(fallbackKeys)) for (const [fullId, key] of Object.entries(fallbackKeys)) {
 			const [algorithm] = fullId.split(":");
 			const existing = await this.hs.db.findOne("fallback_keys", [...device, {
@@ -98,39 +99,45 @@ var KeyService = class {
 		return this.oneTimeKeyCounts(userId, deviceId);
 	}
 	async oneTimeKeyCounts(userId, deviceId) {
-		const rows = await this.hs.db.findMany("one_time_keys", { where: [
-			{
-				field: "user_id",
-				value: userId
-			},
-			{
-				field: "device_id",
-				value: deviceId
-			},
-			{
-				field: "fallback",
-				value: false
-			}
-		] });
+		const rows = await this.hs.db.findMany("one_time_keys", {
+			where: [
+				{
+					field: "user_id",
+					value: userId
+				},
+				{
+					field: "device_id",
+					value: deviceId
+				},
+				{
+					field: "fallback",
+					value: false
+				}
+			],
+			fields: ["algorithm"]
+		});
 		const counts = { signed_curve25519: 0 };
 		for (const r of rows) counts[r.algorithm] = (counts[r.algorithm] ?? 0) + 1;
 		return counts;
 	}
 	async unusedFallbackKeyTypes(userId, deviceId) {
-		const rows = await this.hs.db.findMany("fallback_keys", { where: [
-			{
-				field: "user_id",
-				value: userId
-			},
-			{
-				field: "device_id",
-				value: deviceId
-			},
-			{
-				field: "used",
-				value: false
-			}
-		] });
+		const rows = await this.hs.db.findMany("fallback_keys", {
+			where: [
+				{
+					field: "user_id",
+					value: userId
+				},
+				{
+					field: "device_id",
+					value: deviceId
+				},
+				{
+					field: "used",
+					value: false
+				}
+			],
+			fields: ["algorithm"]
+		});
 		return [...new Set(rows.map((r) => r.algorithm))];
 	}
 	async query(requester, deviceKeys, timeoutMs = 1e4) {
@@ -412,22 +419,18 @@ var KeyService = class {
 		return { failures };
 	}
 	/** Users (sharing a room with `userId`) whose device lists changed after `since`. */
-	async changesSince(userId, since, upTo) {
+	/**
+	* Device-list changes for /sync and /keys/changes. /sync passes what it has already read (the
+	* membership changes, the device-list rows, the user's joined rooms) to save the queries.
+	*/
+	async changesSince(userId, since, upTo, known = {}) {
 		const sharing = await this.hs.rooms.usersSharingRooms(userId);
-		const rows = await this.hs.db.findMany("device_list_changes", { where: [{
-			field: "stream",
-			operator: "gt",
-			value: since
-		}] });
+		const rows = known.deviceRows ?? await this.hs.db.findMany("device_list_changes", deviceListChangesQuery(sharing, since));
 		const changed = /* @__PURE__ */ new Set();
 		for (const r of rows) if (r.stream <= upTo && sharing.has(r.user_id)) changed.add(r.user_id);
 		const left = /* @__PURE__ */ new Set();
-		const memberRows = await this.hs.db.findMany("memberships", { where: [{
-			field: "stream",
-			operator: "gt",
-			value: since
-		}] });
-		const myRooms = /* @__PURE__ */ new Set([...await this.hs.rooms.roomsForUser(userId), ...memberRows.filter((m) => m.user_id === userId).map((m) => m.room_id)]);
+		const memberRows = known.memberChanges ?? await this.hs.rooms.membershipChangesSince(userId, since);
+		const myRooms = /* @__PURE__ */ new Set([...known.joinedRooms ?? await this.hs.rooms.roomsForUser(userId), ...memberRows.filter((m) => m.user_id === userId).map((m) => m.room_id)]);
 		for (const m of memberRows) {
 			if (m.stream > upTo || !myRooms.has(m.room_id)) continue;
 			if (m.user_id === userId) {
@@ -445,5 +448,22 @@ var KeyService = class {
 		};
 	}
 };
+/**
+* The device-list changes after `since` of the users sharing a room with someone.
+* https://github.com/k18k/matrix-nodejs-homeserver/issues/31: this read every device-list change
+* on the server since `since`; it asks for the users sharing a room only (up to a size where an IN
+* list stays reasonable for the database).
+*/
+function deviceListChangesQuery(sharing, since) {
+	return { where: [{
+		field: "stream",
+		operator: "gt",
+		value: since
+	}, ...sharing.size <= 5e3 ? [{
+		field: "user_id",
+		operator: "in",
+		value: [...sharing]
+	}] : []] };
+}
 //#endregion
-export { KeyService };
+export { KeyService, deviceListChangesQuery };