matrix-nodejs-homeserver 0.2.0 → 0.3.2

package/dist/api/sync.js

@@ -1,10 +1,15 @@
+import { M, UNSTABLE } from "../core/m.js";
 import { eventIdOf, splitStateKey, stateKey, toClientEvent } from "../core/events.js";
 import { errors } from "../core/errors.js";
 import { getState } from "../core/authrules.js";
 import { loadRules } from "../core/pushrules.js";
 import { inviteDecision } from "../core/invitefilter.js";
+import { deviceListChangesQuery } from "../core/keys.js";
 import { body } from "../http/input.js";
+import { procedure } from "../http/procedure.js";
 import { matchesFilter, roomAllowed, validateSyncFilter } from "./filters.js";
+import { readBatch } from "../storage/batch.js";
+import { Semaphore } from "../core/semaphore.js";
 import { fullProfile } from "../core/profile.js";
 //#region src/api/sync.ts
 function parseSyncToken(raw) {
@@ -62,7 +67,8 @@ async function snapshotAt(hs, roomId, pos) {
 			field: "stream",
 			direction: "desc"
 		},
-		limit: 1
+		limit: 1,
+		fields: ["state_snapshot"]
 	}))[0]?.state_snapshot ?? 0;
 }
 /** Build the timeline + state section of a room. */
@@ -124,7 +130,8 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 	}
 	if (limit === 0 && events.length === 0) limited = (await hs.db.findMany("events", {
 		where,
-		limit: 1
+		limit: 1,
+		fields: ["stream"]
 	})).length > 0;
 	if (since === null) events.sort((a, b) => (a.pdu.depth ?? 0) - (b.pdu.depth ?? 0) || a.stream - b.stream);
 	else events.reverse();
@@ -142,7 +149,8 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 			operator: "lt",
 			value: events[0].stream
 		}],
-		limit: 1
+		limit: 1,
+		fields: ["stream"]
 	})).length > 0;
 	const startPos = events.length ? Math.min(...events.map((e) => e.stream)) - 1 : upTo;
 	const startState = await hs.rooms.stateAtSnapshot(await snapshotAt(hs, roomId, startPos));
@@ -163,13 +171,13 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		if (sinceIds[key] === ev.event_id) continue;
 		const [type, sk] = splitStateKey(key);
 		if (!matchesFilter(sf, ev)) continue;
-		if (lazy && type === "m.room.member" && !senders.has(sk)) continue;
+		if (lazy && type === M.ROOM.MEMBER && !senders.has(sk)) continue;
 		state.push(ev);
 	}
 	if (lazy) for (const e of events) {
-		const key = stateKey("m.room.member", e.pdu.sender);
-		if (startState.has(key) || state.some((s) => s.type === "m.room.member" && s.state_key === e.pdu.sender)) continue;
-		const member = [...(await hs.rooms.getPdus((e.pdu.auth_events ?? []).map(eventIdOf))).values()].find((a) => a.type === "m.room.member" && a.state_key === e.pdu.sender);
+		const key = stateKey(M.ROOM.MEMBER, e.pdu.sender);
+		if (startState.has(key) || state.some((s) => s.type === M.ROOM.MEMBER && s.state_key === e.pdu.sender)) continue;
+		const member = [...(await hs.rooms.getPdus((e.pdu.auth_events ?? []).map(eventIdOf))).values()].find((a) => a.type === M.ROOM.MEMBER && a.state_key === e.pdu.sender);
 		if (member && matchesFilter(sf, member)) state.push(member);
 	}
 	const stateAfter = [];
@@ -179,7 +187,7 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 			if (sinceIds[key] === ev.event_id) continue;
 			const [type, sk] = splitStateKey(key);
 			if (!matchesFilter(sf, ev)) continue;
-			if (lazy && type === "m.room.member" && !senders.has(sk)) continue;
+			if (lazy && type === M.ROOM.MEMBER && !senders.has(sk)) continue;
 			stateAfter.push(ev);
 		}
 	}
@@ -194,12 +202,12 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		timelineEvents: events
 	};
 }
-async function roomEphemeral(hs, p, roomId) {
+async function roomEphemeral(hs, p, roomId, prefetched) {
 	const since = p.since?.pos ?? null;
 	const out = [];
 	const typing = hs.typing.typingSince(roomId, since);
 	if (typing !== null && (since !== null || typing.length > 0)) out.push({
-		type: "m.typing",
+		type: M.TYPING,
 		content: { user_ids: typing }
 	});
 	const where = [{
@@ -211,10 +219,10 @@ async function roomEphemeral(hs, p, roomId) {
 		operator: "gt",
 		value: since
 	});
-	const receipts = (await hs.db.findMany("receipts", { where })).filter((r) => r.stream <= p.to);
+	const receipts = (prefetched ?? await hs.db.findMany("receipts", { where })).filter((r) => r.stream <= p.to);
 	const content = {};
 	for (const r of receipts) {
-		if (r.receipt_type === "m.read.private" && r.user_id !== p.session.userId) continue;
+		if (r.receipt_type === M.READ.PRIVATE && r.user_id !== p.session.userId) continue;
 		content[r.event_id] ??= {};
 		content[r.event_id][r.receipt_type] ??= {};
 		if (r.thread_id && content[r.event_id][r.receipt_type][r.user_id] && !content[r.event_id][r.receipt_type][r.user_id].thread_id) continue;
@@ -224,12 +232,12 @@ async function roomEphemeral(hs, p, roomId) {
 		};
 	}
 	if (Object.keys(content).length) out.push({
-		type: "m.receipt",
+		type: M.RECEIPT,
 		content
 	});
 	return out.filter((e) => matchesFilter(p.filter.room?.ephemeral, e));
 }
-async function accountData(hs, p, roomId) {
+async function accountData(hs, p, roomId, prefetched) {
 	const where = [{
 		field: "user_id",
 		value: p.session.userId
@@ -242,7 +250,7 @@ async function accountData(hs, p, roomId) {
 		operator: "gt",
 		value: p.since.pos
 	});
-	const rows = await hs.db.findMany("account_data", { where });
+	const rows = prefetched ?? await hs.db.findMany("account_data", { where });
 	const filter = roomId ? p.filter.room?.account_data : p.filter.account_data;
 	return rows.filter((r) => r.stream <= p.to && (p.since || Object.keys(r.content ?? {}).length > 0)).map((r) => ({
 		type: r.type,
@@ -256,26 +264,206 @@ async function roomSummary(hs, roomId, userId) {
 	const heroes = [];
 	for (const [key, ev] of state) {
 		const [type, sk] = splitStateKey(key);
-		if (type !== "m.room.member") continue;
+		if (type !== M.ROOM.MEMBER) continue;
 		const m = ev.content?.membership;
 		if (m === "join") joined++;
 		if (m === "invite") invited++;
 		if ((m === "join" || m === "invite") && sk !== userId && heroes.length < 5) heroes.push(sk);
 	}
 	const summary = {
-		"m.joined_member_count": joined,
-		"m.invited_member_count": invited
+		[M.JOINED_MEMBER_COUNT]: joined,
+		[M.INVITED_MEMBER_COUNT]: invited
 	};
-	if (!getState(state, "m.room.name")?.content?.name && !getState(state, "m.room.canonical_alias")?.content?.alias) summary["m.heroes"] = heroes.sort();
+	if (!getState(state, M.ROOM.NAME)?.content?.name && !getState(state, M.ROOM.CANONICAL_ALIAS)?.content?.alias) summary[M.HEROES] = heroes.sort();
 	return summary;
 }
+/**
+* What changed for the user since the token, for all of their rooms at once: the rooms with new
+* events or newly complete state, and the new receipts and account data by room.
+*
+* https://github.com/k18k/matrix-nodejs-homeserver/issues/33: an incremental sync queried every
+* joined room (timeline, receipts, account data) and only then found that most had nothing new,
+* so a sync cost as many queries as the user had rooms, each time a long-poll woke up. These few
+* queries find the rooms that changed, and only those are built.
+*/
+/** One-time key counts by algorithm, as /sync reports them (signed_curve25519 always present). */
+function countAlgorithms(rows) {
+	const counts = { signed_curve25519: 0 };
+	for (const r of rows) counts[r.algorithm] = (counts[r.algorithm] ?? 0) + 1;
+	return counts;
+}
+async function changesSince(hs, p, memberships, since, accountRows) {
+	const joined = memberships.filter((m) => m.membership === "join").map((m) => m.room_id);
+	const anyMembership = [...new Set(memberships.map((m) => m.room_id))];
+	const range = [{
+		field: "stream",
+		operator: "gt",
+		value: since
+	}, {
+		field: "stream",
+		operator: "lte",
+		value: p.to
+	}];
+	const chunks = (list) => Array.from({ length: Math.ceil(list.length / 500) }, (_, i) => list.slice(i * 500, i * 500 + 500));
+	const inRooms = (chunk) => ({
+		field: "room_id",
+		operator: "in",
+		value: chunk
+	});
+	const queries = [];
+	for (const chunk of chunks(joined)) {
+		queries.push({
+			model: "events",
+			opts: {
+				where: [inRooms(chunk), ...range],
+				fields: ["room_id"]
+			}
+		});
+		queries.push({
+			model: "receipts",
+			opts: { where: [inRooms(chunk), ...range] }
+		});
+		queries.push({
+			model: "partial_state_rooms",
+			opts: {
+				where: [inRooms(chunk), {
+					field: "completed_stream",
+					operator: "gt",
+					value: since
+				}],
+				fields: ["room_id"]
+			}
+		});
+	}
+	for (const chunk of chunks(anyMembership)) queries.push({
+		model: "memberships",
+		opts: { where: [inRooms(chunk), {
+			field: "stream",
+			operator: "gt",
+			value: since
+		}] }
+	});
+	const results = await readBatch(hs.db, queries);
+	const touched = /* @__PURE__ */ new Set();
+	const receipts = /* @__PURE__ */ new Map();
+	const joinedChunks = Math.ceil(joined.length / 500);
+	for (let c = 0; c < joinedChunks; c++) {
+		const [events, receiptRows, completed] = results.slice(c * 3, c * 3 + 3);
+		for (const r of events) touched.add(r.room_id);
+		for (const r of receiptRows) {
+			touched.add(r.room_id);
+			receipts.set(r.room_id, [...receipts.get(r.room_id) ?? [], r]);
+		}
+		for (const r of completed) touched.add(r.room_id);
+	}
+	const memberChanges = results.slice(joinedChunks * 3).flat();
+	const accountData = /* @__PURE__ */ new Map();
+	for (const r of accountRows) {
+		if (r.room_id) touched.add(r.room_id);
+		accountData.set(r.room_id, [...accountData.get(r.room_id) ?? [], r]);
+	}
+	return {
+		touched,
+		receipts,
+		accountData,
+		memberChanges
+	};
+}
 async function buildSync(hs, p) {
 	const userId = p.session.userId;
 	const since = p.since?.pos ?? null;
-	const memberships = await hs.db.findMany("memberships", { where: [{
+	const incremental = since !== null && !p.fullState;
+	const deviceWhere = [{
 		field: "user_id",
 		value: userId
-	}] });
+	}, {
+		field: "device_id",
+		value: p.session.deviceId
+	}];
+	const acknowledged = p.since ? hs.db.delete("to_device", [...deviceWhere, {
+		field: "stream",
+		operator: "lte",
+		value: p.since.toDevice
+	}]) : Promise.resolve(0);
+	const [memberships, ignoredRows, toDeviceRows, oneTimeKeyRows, fallbackRows, accountRows = []] = await readBatch(hs.db, [
+		{
+			model: "memberships",
+			opts: { where: [{
+				field: "user_id",
+				value: userId
+			}] }
+		},
+		{
+			model: "account_data",
+			opts: { where: [
+				{
+					field: "user_id",
+					value: userId
+				},
+				{
+					field: "room_id",
+					value: ""
+				},
+				{
+					field: "type",
+					value: M.IGNORED_USER_LIST
+				}
+			] }
+		},
+		{
+			model: "to_device",
+			opts: {
+				where: [...deviceWhere, {
+					field: "stream",
+					operator: "gt",
+					value: p.since?.toDevice ?? 0
+				}],
+				sortBy: {
+					field: "stream",
+					direction: "asc"
+				},
+				limit: 100
+			}
+		},
+		{
+			model: "one_time_keys",
+			opts: {
+				where: [...deviceWhere, {
+					field: "fallback",
+					value: false
+				}],
+				fields: ["algorithm"]
+			}
+		},
+		{
+			model: "fallback_keys",
+			opts: {
+				where: [...deviceWhere, {
+					field: "used",
+					value: false
+				}],
+				fields: ["algorithm"]
+			}
+		},
+		...incremental ? [{
+			model: "account_data",
+			opts: { where: [{
+				field: "user_id",
+				value: userId
+			}, {
+				field: "stream",
+				operator: "gt",
+				value: since
+			}] }
+		}] : []
+	]);
+	p = {
+		...p,
+		ignored: new Set(Object.keys(ignoredRows[0]?.content?.ignored_users ?? {}))
+	};
+	const changes = incremental ? await changesSince(hs, p, memberships, since, accountRows) : null;
+	let memberChangesRead = changes ? Promise.resolve(changes.memberChanges) : null;
+	const memberChanges = () => memberChangesRead ??= hs.rooms.membershipChangesSince(userId, since ?? 0, memberships);
 	const join = {};
 	const invite = {};
 	const leave = {};
@@ -286,12 +474,13 @@ async function buildSync(hs, p) {
 		const roomId = m.room_id;
 		const changed = since === null || m.stream > since;
 		if (m.membership === "join") {
+			if (changes && !changed && !changes.touched.has(roomId) && hs.typing.typingSince(roomId, since) === null) continue;
 			if (!p.filter.room?.state?.lazy_load_members && await hs.partialState.isPartial(roomId)) continue;
 			const completedAt = await hs.partialState.completedAt(roomId);
 			const initial = since === null || p.fullState || m.stream > since || completedAt !== null && completedAt > since && completedAt <= p.to;
 			const { timeline, state, stateAfter, timelineEvents } = await roomTimeline(hs, p, roomId, initial ? null : since, p.to);
-			const ephemeral = await roomEphemeral(hs, p, roomId);
-			const roomAccountData = await accountData(hs, p, roomId);
+			const ephemeral = await roomEphemeral(hs, p, roomId, changes ? changes.receipts.get(roomId) ?? [] : void 0);
+			const roomAccountData = await accountData(hs, p, roomId, changes ? changes.accountData.get(roomId) ?? [] : void 0);
 			if (!initial && timelineEvents.length === 0 && state.length === 0 && stateAfter.length === 0 && ephemeral.length === 0 && roomAccountData.length === 0) continue;
 			join[roomId] = {
 				timeline,
@@ -339,68 +528,67 @@ async function buildSync(hs, p) {
 			leave[roomId] = {
 				timeline,
 				state: { events: state.map((e) => toClientEvent(e, { includeRoomId: false })) },
-				account_data: { events: await accountData(hs, p, roomId) }
+				account_data: { events: await accountData(hs, p, roomId, changes ? changes.accountData.get(roomId) ?? [] : void 0) }
 			};
 			empty = false;
 		}
 	}
-	const globalAccountData = await accountData(hs, p, "");
-	if (since === null && !globalAccountData.some((e) => e.type === "m.push_rules")) globalAccountData.push({
-		type: "m.push_rules",
+	const globalAccountData = await accountData(hs, p, "", changes ? changes.accountData.get("") ?? [] : void 0);
+	if (since === null && !globalAccountData.some((e) => e.type === M.PUSH_RULES)) globalAccountData.push({
+		type: M.PUSH_RULES,
 		content: { global: await loadRules(hs, userId) }
 	});
 	if (globalAccountData.length) empty = false;
-	const deviceWhere = [{
-		field: "user_id",
-		value: userId
-	}, {
-		field: "device_id",
-		value: p.session.deviceId
-	}];
-	if (p.since) await hs.db.delete("to_device", [...deviceWhere, {
-		field: "stream",
-		operator: "lte",
-		value: p.since.toDevice
-	}]);
-	const toDevice = (await hs.db.findMany("to_device", {
-		where: [...deviceWhere, {
-			field: "stream",
-			operator: "gt",
-			value: p.since?.toDevice ?? 0
-		}],
-		sortBy: {
-			field: "stream",
-			direction: "asc"
-		},
-		limit: 100
-	})).filter((r) => r.stream <= p.to);
+	await acknowledged;
+	const toDevice = toDeviceRows.filter((r) => r.stream <= p.to);
 	const nextToDevice = toDevice.length ? toDevice[toDevice.length - 1].stream : p.since?.toDevice ?? 0;
 	if (toDevice.length) empty = false;
 	const presenceEvents = [];
-	if (!p.filter.presence?.types || p.filter.presence.types.length) {
-		const sharing = await hs.rooms.usersSharingRooms(userId);
-		const newlyShared = /* @__PURE__ */ new Set();
-		if (since !== null) {
-			const changes = await hs.db.findMany("memberships", { where: [{
+	const wantPresence = !p.filter.presence?.types || p.filter.presence.types.length > 0;
+	const sharing = await hs.rooms.usersSharingRooms(userId);
+	const joinedRooms = memberships.filter((m) => m.membership === "join").map((m) => m.room_id);
+	const newlyShared = /* @__PURE__ */ new Set();
+	if (since !== null && wantPresence) {
+		const myRooms = new Set(joinedRooms);
+		for (const c of await memberChanges()) {
+			if (c.membership !== "join" || !myRooms.has(c.room_id)) continue;
+			if (c.user_id === userId) for (const u of await hs.rooms.joinedMembers(c.room_id)) newlyShared.add(u);
+			else newlyShared.add(c.user_id);
+		}
+	}
+	const sharingList = [...sharing];
+	const [presenceRows = [], newlySharedPresence = [], deviceRows] = await readBatch(hs.db, [
+		{
+			model: "presence",
+			opts: { where: [{
+				field: "user_id",
+				operator: "in",
+				value: wantPresence ? sharingList : []
+			}, ...since !== null ? [{
 				field: "stream",
 				operator: "gt",
 				value: since
-			}] });
-			const myRooms = new Set(memberships.filter((m) => m.membership === "join").map((m) => m.room_id));
-			for (const c of changes) {
-				if (c.membership !== "join" || !myRooms.has(c.room_id)) continue;
-				if (c.user_id === userId) for (const u of await hs.rooms.joinedMembers(c.room_id)) newlyShared.add(u);
-				else newlyShared.add(c.user_id);
-			}
-		}
-		const where = [{
-			field: "user_id",
-			operator: "in",
-			value: [...sharing]
-		}];
-		for (const row of await hs.db.findMany("presence", { where })) {
+			}] : []] }
+		},
+		{
+			model: "presence",
+			opts: { where: [{
+				field: "user_id",
+				operator: "in",
+				value: [...newlyShared]
+			}] }
+		},
+		...since !== null ? [{
+			model: "device_list_changes",
+			opts: deviceListChangesQuery(sharing, since)
+		}] : []
+	]);
+	if (wantPresence) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const row of [...presenceRows, ...newlySharedPresence]) {
+			if (seen.has(row.user_id)) continue;
+			seen.add(row.user_id);
 			if (row.stream > p.to) continue;
-			if (since !== null && row.stream <= since && !newlyShared.has(row.user_id)) continue;
 			const content = {
 				presence: row.presence,
 				last_active_ago: Date.now() - row.last_active_ts
@@ -408,7 +596,7 @@ async function buildSync(hs, p) {
 			if (row.status_msg) content.status_msg = row.status_msg;
 			if (row.presence === "online") content.currently_active = true;
 			const ev = {
-				type: "m.presence",
+				type: M.PRESENCE,
 				sender: row.user_id,
 				content
 			};
@@ -416,7 +604,7 @@ async function buildSync(hs, p) {
 		}
 	}
 	if (presenceEvents.length) empty = false;
-	const profileUpdates = await profileUpdatesFor(hs, p, memberships);
+	const profileUpdates = await profileUpdatesFor(hs, p, memberships, memberChanges);
 	if (profileUpdates) empty = false;
 	const body = {
 		next_batch: formatToken({
@@ -436,12 +624,16 @@ async function buildSync(hs, p) {
 			type: r.type,
 			content: r.content
 		})) },
-		device_one_time_keys_count: await hs.keys.oneTimeKeyCounts(userId, p.session.deviceId),
-		device_unused_fallback_key_types: await hs.keys.unusedFallbackKeyTypes(userId, p.session.deviceId)
+		device_one_time_keys_count: countAlgorithms(oneTimeKeyRows),
+		device_unused_fallback_key_types: [...new Set(fallbackRows.map((r) => r.algorithm))]
 	};
-	if (profileUpdates) body["org.matrix.msc4429.users"] = profileUpdates;
+	if (profileUpdates) body[UNSTABLE.ORG.MATRIX.MSC4429.USERS] = profileUpdates;
 	if (since !== null) {
-		const lists = await hs.keys.changesSince(userId, since, p.to);
+		const lists = await hs.keys.changesSince(userId, since, p.to, {
+			memberChanges: await memberChanges(),
+			deviceRows,
+			joinedRooms
+		});
 		body.device_lists = lists;
 		if (lists.changed.length || lists.left.length) empty = false;
 	}
@@ -451,6 +643,12 @@ async function buildSync(hs, p) {
 		nextToDevice
 	};
 }
+const slots = /* @__PURE__ */ new WeakMap();
+function syncSlots(hs) {
+	let s = slots.get(hs);
+	if (!s) slots.set(hs, s = new Semaphore(hs.config.maxConcurrentSyncs));
+	return s;
+}
 async function sync(ctx) {
 	const hs = ctx.hs;
 	const session = await ctx.auth();
@@ -463,33 +661,21 @@ async function sync(ctx) {
 	const deadline = Date.now() + timeout;
 	for (;;) {
 		const to = await hs.streams.position();
-		const ignoredRow = await hs.db.findOne("account_data", [
-			{
-				field: "user_id",
-				value: session.userId
-			},
-			{
-				field: "room_id",
-				value: ""
-			},
-			{
-				field: "type",
-				value: "m.ignored_user_list"
-			}
-		]);
-		const ignored = new Set(Object.keys(ignoredRow?.content?.ignored_users ?? {}));
+		const ignored = /* @__PURE__ */ new Set();
 		const stable = ctx.query.get("use_state_after") === "true";
-		const unstable = ctx.query.get("org.matrix.msc4222.use_state_after") === "true";
-		const { body, empty } = await buildSync(hs, {
+		const unstable = ctx.query.get(UNSTABLE.ORG.MATRIX.MSC4222.USE_STATE_AFTER) === "true";
+		const useStateAfter = stable || unstable;
+		const stateAfterKey = stable ? "state_after" : UNSTABLE.ORG.MATRIX.MSC4222.STATE_AFTER;
+		const { body, empty } = await syncSlots(hs).run(() => buildSync(hs, {
 			session,
 			ignored,
 			since,
 			to,
 			filter,
 			fullState,
-			useStateAfter: stable || unstable,
-			stateAfterKey: stable ? "state_after" : "org.matrix.msc4222.state_after"
-		});
+			useStateAfter,
+			stateAfterKey
+		}));
 		const remaining = deadline - Date.now();
 		if (!since || !empty || remaining <= 0 || fullState) return body;
 		if (await hs.streams.position() > to) continue;
@@ -497,6 +683,7 @@ async function sync(ctx) {
 		if (ctx.request.signal?.aborted) return body;
 	}
 }
+const LAST_ACTIVE_GRANULARITY_MS = 6e4;
 async function touchPresence(hs, userId, presence) {
 	const state = presence === "unavailable" ? "unavailable" : "online";
 	const row = await hs.db.findOne("presence", [{
@@ -504,7 +691,7 @@ async function touchPresence(hs, userId, presence) {
 		value: userId
 	}]);
 	if (row && row.presence === state) {
-		await hs.db.update("presence", [{
+		if (Date.now() - row.last_active_ts >= LAST_ACTIVE_GRANULARITY_MS) await hs.db.update("presence", [{
 			field: "user_id",
 			value: userId
 		}], { last_active_ts: Date.now() });
@@ -520,43 +707,50 @@ async function touchPresence(hs, userId, presence) {
 	await hs.federation.onPresence(userId, state, row?.status_msg ?? null).catch(() => {});
 }
 function registerSyncRoutes(r) {
-	r.client("GET", "/sync", sync);
-	r.client("POST", "/user/:userId/filter", { input: body({}) }, async (ctx) => {
-		const s = await ctx.auth();
-		if (ctx.params.userId !== s.userId) throw errors.forbidden("Cannot create filters for other users");
-		const filter = validateSyncFilter(ctx.input);
-		const existing = await ctx.hs.db.findMany("filters", { where: [{
-			field: "user_id",
-			value: s.userId
-		}] });
-		const filterId = String(existing.reduce((max, f) => Math.max(max, Number(f.filter_id) || 0), 0) + 1);
-		await ctx.hs.db.create("filters", {
-			user_id: s.userId,
-			filter_id: filterId,
-			filter
-		});
-		return { filter_id: filterId };
-	});
-	r.client("GET", "/user/:userId/filter/:filterId", async (ctx) => {
-		const s = await ctx.auth();
-		if (ctx.params.userId !== s.userId) throw errors.forbidden("Cannot read filters of other users");
-		const row = await ctx.hs.db.findOne("filters", [{
-			field: "user_id",
-			value: s.userId
-		}, {
-			field: "filter_id",
-			value: ctx.params.filterId
-		}]);
-		if (!row) throw errors.notFound("Unknown filter");
-		return row.filter;
-	});
+	r.client("GET", "/sync", procedure({ handler: sync }));
+	r.client("POST", "/user/:userId/filter", procedure({
+		auth: "user",
+		input: body({}),
+		handler: async (ctx) => {
+			const s = ctx.session;
+			if (ctx.params.userId !== s.userId) throw errors.forbidden("Cannot create filters for other users");
+			const filter = validateSyncFilter(ctx.input);
+			const existing = await ctx.hs.db.findMany("filters", { where: [{
+				field: "user_id",
+				value: s.userId
+			}] });
+			const filterId = String(existing.reduce((max, f) => Math.max(max, Number(f.filter_id) || 0), 0) + 1);
+			await ctx.hs.db.create("filters", {
+				user_id: s.userId,
+				filter_id: filterId,
+				filter
+			});
+			return { filter_id: filterId };
+		}
+	}));
+	r.client("GET", "/user/:userId/filter/:filterId", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			if (ctx.params.userId !== s.userId) throw errors.forbidden("Cannot read filters of other users");
+			const row = await ctx.hs.db.findOne("filters", [{
+				field: "user_id",
+				value: s.userId
+			}, {
+				field: "filter_id",
+				value: ctx.params.filterId
+			}]);
+			if (!row) throw errors.notFound("Unknown filter");
+			return row.filter;
+		}
+	}));
 }
 /**
 * MSC4429: profile changes of users sharing a room, limited to the fields the filter asks for.
 * The initial sync carries current values; users we no longer share any room with get `null`.
 */
-async function profileUpdatesFor(hs, p, memberships) {
-	const ids = (p.filter.profile_fields ?? p.filter["org.matrix.msc4429.profile_fields"])?.ids;
+async function profileUpdatesFor(hs, p, memberships, memberChanges) {
+	const ids = (p.filter.profile_fields ?? p.filter[UNSTABLE.ORG.MATRIX.MSC4429.PROFILE_FIELDS])?.ids;
 	if (!Array.isArray(ids) || !ids.length) return null;
 	const wanted = new Set(ids.filter((x) => typeof x === "string"));
 	const since = p.since?.pos ?? null;
@@ -568,11 +762,7 @@ async function profileUpdatesFor(hs, p, memberships) {
 	const full = new Set(since === null ? sharing : []);
 	if (since !== null) {
 		const myRooms = new Set(memberships.filter((m) => m.membership === "join").map((m) => m.room_id));
-		const changes = await hs.db.findMany("memberships", { where: [{
-			field: "stream",
-			operator: "gt",
-			value: since
-		}] });
+		const changes = await memberChanges();
 		for (const c of changes) {
 			if (c.stream > p.to || c.user_id === p.session.userId) continue;
 			if (c.membership === "join" && myRooms.has(c.room_id)) {