matrix-nodejs-homeserver 0.3.2 → 0.3.4

package/dist/api/sync.js

@@ -2,26 +2,29 @@ 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 { readOnlyRules } 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 { trackedReads } from "../core/changes.js";
+import { matchesFilter, roomAllowed, validateSyncFilter } from "./filters.js";
+import { longPoll } from "./longpoll.js";
 import { Semaphore } from "../core/semaphore.js";
 import { fullProfile } from "../core/profile.js";
 //#region src/api/sync.ts
 function parseSyncToken(raw) {
 	if (!raw) return null;
-	const m = /^s(\d+)(?:_(\d+))?$/.exec(raw);
+	const m = /^s(\d+)(?:_(\d+))?(_a)?$/.exec(raw);
 	if (!m) throw errors.invalidParam("Invalid since token");
 	return {
 		pos: Number(m[1]),
-		toDevice: Number(m[2] ?? m[1])
+		toDevice: Number(m[2] ?? m[1]),
+		ack: !!m[3]
 	};
 }
-const formatToken = (t) => `s${t.pos}_${t.toDevice}`;
+const formatToken = (t) => `s${t.pos}_${t.toDevice}${t.ack ? "_a" : ""}`;
 async function loadFilter(hs, userId, raw) {
 	if (!raw) return {};
 	if (raw.trim().startsWith("{")) {
@@ -88,6 +91,8 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		operator: "gt",
 		value: since
 	});
+	const sinceIdsRead = since !== null ? snapshotAt(hs, roomId, since).then((id) => hs.rooms.snapshotIds(id)) : Promise.resolve({});
+	const scanned = [];
 	const events = [];
 	let limited = false;
 	let cursor = upTo;
@@ -106,6 +111,7 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 			limit: batchSize
 		});
 		if (rows.length === 0) break;
+		scanned.push(...rows);
 		const stored = rows.map((r) => hs.rooms.rowToStored(r));
 		const visible = await hs.rooms.filterVisible(p.session.userId, roomId, stored);
 		const ok = new Map(visible.map((v) => [v.pdu.event_id, v]));
@@ -143,25 +149,50 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		events.splice(0, lastGap);
 		limited = true;
 	}
-	if (!limited && events.length) limited = (await hs.db.findMany("events", {
-		where: [...where.filter((c) => c.operator !== "lte"), {
-			field: "stream",
-			operator: "lt",
-			value: events[0].stream
-		}],
-		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));
+	const newestAtOrBefore = async (pos) => {
+		const row = scanned.find((r) => r.stream <= pos);
+		if (row) return row;
+		return (await hs.db.findMany("events", {
+			where: [{
+				field: "room_id",
+				value: roomId
+			}, {
+				field: "stream",
+				operator: "lte",
+				value: pos
+			}],
+			sortBy: {
+				field: "stream",
+				direction: "desc"
+			},
+			limit: 1,
+			fields: ["stream", "state_snapshot"]
+		}))[0] ?? null;
+	};
+	const [atStart, atEnd] = await Promise.all([newestAtOrBefore(startPos), startPos === upTo ? null : newestAtOrBefore(upTo)]);
+	const startSnapshot = atStart?.state_snapshot ?? 0;
+	const endSnapshot = startPos === upTo ? startSnapshot : atEnd?.state_snapshot ?? 0;
+	if (!limited && events.length) {
+		if (events[0].stream === startPos + 1) limited = atStart !== null && (since === null || atStart.stream > since);
+		else limited = (await hs.db.findMany("events", {
+			where: [...where.filter((c) => c.operator !== "lte"), {
+				field: "stream",
+				operator: "lt",
+				value: events[0].stream
+			}],
+			limit: 1,
+			fields: ["stream"]
+		})).length > 0;
+	}
+	const [startState, endState] = await Promise.all([hs.rooms.stateAtSnapshot(startSnapshot), hs.rooms.stateAtSnapshot(endSnapshot)]);
 	const timelineIds = new Set(events.map((e) => e.pdu.event_id));
-	const endState = await hs.rooms.stateAtSnapshot(await snapshotAt(hs, roomId, upTo));
 	for (const [key, ev] of endState) {
 		if (timelineIds.has(ev.event_id) || startState.get(key)?.event_id === ev.event_id) continue;
 		if (events.some((e) => e.pdu.state_key !== void 0 && stateKey(e.pdu.type, e.pdu.state_key) === key)) continue;
 		startState.set(key, ev);
 	}
-	const sinceIds = since !== null ? await hs.rooms.snapshotIds(await snapshotAt(hs, roomId, since)) : {};
+	const sinceIds = await sinceIdsRead;
 	const sf = p.filter.room?.state;
 	const lazy = !!sf?.lazy_load_members;
 	const senders = new Set(events.map((e) => e.pdu.sender));
@@ -181,15 +212,12 @@ async function roomTimeline(hs, p, roomId, since, upTo) {
 		if (member && matchesFilter(sf, member)) state.push(member);
 	}
 	const stateAfter = [];
-	if (p.useStateAfter) {
-		const endState = await hs.rooms.stateAtSnapshot(await snapshotAt(hs, roomId, upTo));
-		for (const [key, ev] of endState) {
-			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;
-			stateAfter.push(ev);
-		}
+	if (p.useStateAfter) for (const [key, ev] of endState) {
+		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;
+		stateAfter.push(ev);
 	}
 	return {
 		stateAfter,
@@ -304,6 +332,8 @@ async function changesSince(hs, p, memberships, since, accountRows) {
 		operator: "lte",
 		value: p.to
 	}];
+	const logs = hs.changes?.logs;
+	const mayHaveChanged = (log, rooms) => logs ? logs[log].filterChanged(rooms, since) : rooms;
 	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",
@@ -311,31 +341,34 @@ async function changesSince(hs, p, memberships, since, accountRows) {
 		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({
+	const kinds = [];
+	const add = (kind, query) => {
+		kinds.push(kind);
+		queries.push(query);
+	};
+	for (const chunk of chunks(mayHaveChanged("roomEvents", joined))) add("events", {
+		model: "events",
+		opts: {
+			where: [inRooms(chunk), ...range],
+			fields: ["room_id"]
+		}
+	});
+	for (const chunk of chunks(mayHaveChanged("roomReceipts", joined))) add("receipts", {
+		model: "receipts",
+		opts: { where: [inRooms(chunk), ...range] }
+	});
+	for (const chunk of chunks(mayHaveChanged("roomPartialState", joined))) add("completed", {
+		model: "partial_state_rooms",
+		opts: {
+			where: [inRooms(chunk), {
+				field: "completed_stream",
+				operator: "gt",
+				value: since
+			}],
+			fields: ["room_id"]
+		}
+	});
+	for (const chunk of chunks(mayHaveChanged("roomMembers", anyMembership))) add("members", {
 		model: "memberships",
 		opts: { where: [inRooms(chunk), {
 			field: "stream",
@@ -343,20 +376,18 @@ async function changesSince(hs, p, memberships, since, accountRows) {
 			value: since
 		}] }
 	});
-	const results = await readBatch(hs.db, queries);
+	const results = queries.length ? 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]);
+	const memberChanges = [];
+	results.forEach((rows, i) => {
+		const kind = kinds[i];
+		for (const r of rows) {
+			if (kind === "members") memberChanges.push(r);
+			else touched.add(r.room_id);
+			if (kind === "receipts") 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);
@@ -369,6 +400,23 @@ async function changesSince(hs, p, memberships, since, accountRows) {
 		memberChanges
 	};
 }
+/** Presence or device-list changes after a token read without a user filter, at most (#44). */
+const RECENT_CHANGES = 500;
+/** How many of a sync's joined rooms are built at once (#38). */
+const JOINED_ROOMS_AT_ONCE = 8;
+/** `fn` over `items` with at most `limit` running at once; results in input order. */
+async function mapConcurrently(items, limit, fn) {
+	const out = [];
+	let next = 0;
+	const worker = async () => {
+		while (next < items.length) {
+			const i = next++;
+			out[i] = await fn(items[i]);
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+	return out;
+}
 async function buildSync(hs, p) {
 	const userId = p.session.userId;
 	const since = p.since?.pos ?? null;
@@ -380,81 +428,120 @@ async function buildSync(hs, p) {
 		field: "device_id",
 		value: p.session.deviceId
 	}];
-	const acknowledged = p.since ? hs.db.delete("to_device", [...deviceWhere, {
+	const acknowledged = p.since?.ack ? 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, [
+	const device = `${userId}|${p.session.deviceId}`;
+	const [memberships, ignoredRows, toDeviceRows, oneTimeKeyRows, fallbackRows, accountRows = []] = await trackedReads(hs.db, hs.changes, [
 		{
-			model: "memberships",
-			opts: { where: [{
-				field: "user_id",
-				value: userId
-			}] }
-		},
-		{
-			model: "account_data",
-			opts: { where: [
-				{
+			query: {
+				model: "memberships",
+				opts: { where: [{
 					field: "user_id",
 					value: userId
-				},
-				{
-					field: "room_id",
-					value: ""
-				},
-				{
-					field: "type",
-					value: M.IGNORED_USER_LIST
-				}
-			] }
+				}] }
+			},
+			cached: {
+				name: "userMemberships",
+				key: userId
+			}
 		},
 		{
-			model: "to_device",
-			opts: {
-				where: [...deviceWhere, {
-					field: "stream",
-					operator: "gt",
-					value: p.since?.toDevice ?? 0
-				}],
-				sortBy: {
-					field: "stream",
-					direction: "asc"
-				},
-				limit: 100
+			query: {
+				model: "account_data",
+				opts: { where: [
+					{
+						field: "user_id",
+						value: userId
+					},
+					{
+						field: "room_id",
+						value: ""
+					},
+					{
+						field: "type",
+						value: M.IGNORED_USER_LIST
+					}
+				] }
+			},
+			cached: {
+				name: "ignoredUsers",
+				key: userId
 			}
 		},
 		{
-			model: "one_time_keys",
-			opts: {
-				where: [...deviceWhere, {
-					field: "fallback",
-					value: false
-				}],
-				fields: ["algorithm"]
+			query: {
+				model: "to_device",
+				opts: {
+					where: [...deviceWhere, {
+						field: "stream",
+						operator: "gt",
+						value: p.since?.toDevice ?? 0
+					}],
+					sortBy: {
+						field: "stream",
+						direction: "asc"
+					},
+					limit: 100
+				}
+			},
+			unlessChanged: {
+				log: "toDevice",
+				key: device,
+				after: p.since?.toDevice ?? 0
+			}
+		},
+		{
+			query: {
+				model: "one_time_keys",
+				opts: {
+					where: [...deviceWhere, {
+						field: "fallback",
+						value: false
+					}],
+					fields: ["algorithm"]
+				}
+			},
+			cached: {
+				name: "oneTimeKeys",
+				key: device
 			}
 		},
 		{
-			model: "fallback_keys",
-			opts: {
-				where: [...deviceWhere, {
-					field: "used",
-					value: false
-				}],
-				fields: ["algorithm"]
+			query: {
+				model: "fallback_keys",
+				opts: {
+					where: [...deviceWhere, {
+						field: "used",
+						value: false
+					}],
+					fields: ["algorithm"]
+				}
+			},
+			cached: {
+				name: "fallbackKeys",
+				key: device
 			}
 		},
 		...incremental ? [{
-			model: "account_data",
-			opts: { where: [{
-				field: "user_id",
-				value: userId
-			}, {
-				field: "stream",
-				operator: "gt",
-				value: since
-			}] }
+			query: {
+				model: "account_data",
+				opts: { where: [{
+					field: "user_id",
+					value: userId
+				}, {
+					field: "stream",
+					operator: "gt",
+					value: since
+				}] }
+			},
+			unlessChanged: {
+				log: "accountData",
+				key: userId,
+				after: since
+			}
 		}] : []
 	]);
 	p = {
@@ -469,39 +556,14 @@ async function buildSync(hs, p) {
 	const leave = {};
 	const knock = {};
 	let empty = true;
+	const joinedBuilds = [];
 	for (const m of memberships) {
 		if (m.stream > p.to || !roomAllowed(p.filter, m.room_id)) continue;
 		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, 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,
-				...p.useStateAfter ? { [p.stateAfterKey ?? "state_after"]: { events: stateAfter.map((e) => toClientEvent(e, { includeRoomId: false })) } } : { state: { events: state.map((e) => toClientEvent(e, { includeRoomId: false })) } },
-				ephemeral: { events: ephemeral },
-				account_data: { events: roomAccountData },
-				summary: await roomSummary(hs, roomId, userId)
-			};
-			const counts = await hs.push.unreadCounts(userId, roomId);
-			if (p.filter.room?.timeline?.unread_thread_notifications) {
-				join[roomId].unread_notifications = counts.room;
-				if (Object.keys(counts.threads).length) join[roomId].unread_thread_notifications = counts.threads;
-			} else {
-				const total = { ...counts.room };
-				for (const t of Object.values(counts.threads)) {
-					total.notification_count += t.notification_count;
-					total.highlight_count += t.highlight_count;
-				}
-				join[roomId].unread_notifications = total;
-			}
-			empty = false;
+			joinedBuilds.push(m);
 		} else if (m.membership === "invite") {
 			if (!changed && !p.fullState) continue;
 			const pdu = await hs.rooms.getPdu(m.event_id);
@@ -533,10 +595,49 @@ async function buildSync(hs, p) {
 			empty = false;
 		}
 	}
+	const joinedRoom = async (m) => {
+		const roomId = m.room_id;
+		if (!p.filter.room?.state?.lazy_load_members && await hs.partialState.isPartial(roomId)) return null;
+		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 }, ephemeral, roomAccountData, summary, counts] = await Promise.all([
+			roomTimeline(hs, p, roomId, initial ? null : since, p.to),
+			roomEphemeral(hs, p, roomId, changes ? changes.receipts.get(roomId) ?? [] : void 0),
+			accountData(hs, p, roomId, changes ? changes.accountData.get(roomId) ?? [] : void 0),
+			roomSummary(hs, roomId, userId),
+			hs.push.unreadCounts(userId, roomId)
+		]);
+		if (!initial && timelineEvents.length === 0 && state.length === 0 && stateAfter.length === 0 && ephemeral.length === 0 && roomAccountData.length === 0) return null;
+		const room = {
+			timeline,
+			...p.useStateAfter ? { [p.stateAfterKey ?? "state_after"]: { events: stateAfter.map((e) => toClientEvent(e, { includeRoomId: false })) } } : { state: { events: state.map((e) => toClientEvent(e, { includeRoomId: false })) } },
+			ephemeral: { events: ephemeral },
+			account_data: { events: roomAccountData },
+			summary
+		};
+		if (p.filter.room?.timeline?.unread_thread_notifications) {
+			room.unread_notifications = counts.room;
+			if (Object.keys(counts.threads).length) room.unread_thread_notifications = counts.threads;
+		} else {
+			const total = { ...counts.room };
+			for (const t of Object.values(counts.threads)) {
+				total.notification_count += t.notification_count;
+				total.highlight_count += t.highlight_count;
+			}
+			room.unread_notifications = total;
+		}
+		return room;
+	};
+	const built = await mapConcurrently(joinedBuilds, JOINED_ROOMS_AT_ONCE, joinedRoom);
+	joinedBuilds.forEach((m, i) => {
+		if (!built[i]) return;
+		join[m.room_id] = built[i];
+		empty = false;
+	});
 	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) }
+		content: { global: await readOnlyRules(hs, userId) }
 	});
 	if (globalAccountData.length) empty = false;
 	await acknowledged;
@@ -557,32 +658,75 @@ async function buildSync(hs, p) {
 		}
 	}
 	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 ? [{
+	const recent = (model) => ({
+		model,
+		opts: {
+			where: [{
 				field: "stream",
 				operator: "gt",
 				value: since
-			}] : []] }
+			}],
+			sortBy: {
+				field: "stream",
+				direction: "asc"
+			},
+			limit: 501
+		}
+	});
+	const presenceQuery = since === null ? {
+		model: "presence",
+		opts: { where: [{
+			field: "user_id",
+			operator: "in",
+			value: wantPresence ? sharingList : []
+		}] }
+	} : wantPresence ? recent("presence") : {
+		model: "presence",
+		opts: { where: [{
+			field: "user_id",
+			operator: "in",
+			value: []
+		}] }
+	};
+	let [presenceRows = [], newlySharedPresence = [], deviceRows] = await trackedReads(hs.db, hs.changes, [
+		since === null ? { query: presenceQuery } : {
+			query: presenceQuery,
+			unlessChanged: {
+				log: "presence",
+				key: "*",
+				after: since
+			}
 		},
-		{
+		{ query: {
 			model: "presence",
 			opts: { where: [{
 				field: "user_id",
 				operator: "in",
 				value: [...newlyShared]
 			}] }
-		},
+		} },
 		...since !== null ? [{
-			model: "device_list_changes",
-			opts: deviceListChangesQuery(sharing, since)
+			query: recent("device_list_changes"),
+			unlessChanged: {
+				log: "deviceLists",
+				key: "*",
+				after: since
+			}
 		}] : []
 	]);
+	if (since !== null) {
+		if (presenceRows.length > RECENT_CHANGES) presenceRows = await hs.db.findMany("presence", { where: [{
+			field: "user_id",
+			operator: "in",
+			value: sharingList
+		}, {
+			field: "stream",
+			operator: "gt",
+			value: since
+		}] });
+		else presenceRows = presenceRows.filter((r) => sharing.has(r.user_id));
+		if (deviceRows.length > RECENT_CHANGES) deviceRows = await hs.db.findMany("device_list_changes", deviceListChangesQuery(sharing, since));
+	}
 	if (wantPresence) {
 		const seen = /* @__PURE__ */ new Set();
 		for (const row of [...presenceRows, ...newlySharedPresence]) {
@@ -609,7 +753,8 @@ async function buildSync(hs, p) {
 	const body = {
 		next_batch: formatToken({
 			pos: p.to,
-			toDevice: nextToDevice
+			toDevice: nextToDevice,
+			ack: toDevice.length > 0
 		}),
 		rooms: Object.fromEntries(Object.entries({
 			join,
@@ -658,14 +803,12 @@ async function sync(ctx) {
 	const timeout = Math.min(Math.max(Number.parseInt(ctx.query.get("timeout") ?? "0", 10) || 0, 0), hs.config.maxSyncTimeoutMs);
 	const setPresence = ctx.query.get("set_presence") ?? "online";
 	if (setPresence !== "offline") await touchPresence(hs, session.userId, setPresence);
-	const deadline = Date.now() + timeout;
-	for (;;) {
-		const to = await hs.streams.position();
-		const ignored = /* @__PURE__ */ new Set();
-		const stable = ctx.query.get("use_state_after") === "true";
-		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 ignored = /* @__PURE__ */ new Set();
+	const stable = ctx.query.get("use_state_after") === "true";
+	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 { value } = await longPoll(hs, session.userId, timeout, ctx.request.signal, async (to) => {
 		const { body, empty } = await syncSlots(hs).run(() => buildSync(hs, {
 			session,
 			ignored,
@@ -676,20 +819,21 @@ async function sync(ctx) {
 			useStateAfter,
 			stateAfterKey
 		}));
-		const remaining = deadline - Date.now();
-		if (!since || !empty || remaining <= 0 || fullState) return body;
-		if (await hs.streams.position() > to) continue;
-		await hs.notifier.wait(session.userId, remaining, ctx.request.signal);
-		if (ctx.request.signal?.aborted) return body;
-	}
+		return {
+			value: body,
+			done: !since || !empty || fullState
+		};
+	});
+	return value;
 }
 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", [{
+	const read = () => hs.db.findOne("presence", [{
 		field: "user_id",
 		value: userId
 	}]);
+	const row = hs.changes ? await hs.changes.values.presenceRow.get(userId, read) : await read();
 	if (row && row.presence === state) {
 		if (Date.now() - row.last_active_ts >= LAST_ACTIVE_GRANULARITY_MS) await hs.db.update("presence", [{
 			field: "user_id",
@@ -697,13 +841,17 @@ async function touchPresence(hs, userId, presence) {
 		}], { last_active_ts: Date.now() });
 		return;
 	}
-	await hs.streams.write((stream) => hs.db.upsert("presence", {
-		user_id: userId,
-		presence: state,
-		status_msg: row?.status_msg ?? null,
-		last_active_ts: Date.now(),
-		stream
-	}));
+	const stream = await hs.streams.write(async (stream) => {
+		await hs.db.upsert("presence", {
+			user_id: userId,
+			presence: state,
+			status_msg: row?.status_msg ?? null,
+			last_active_ts: Date.now(),
+			stream
+		});
+		return stream;
+	});
+	hs.notifier.notify([userId, ...await hs.rooms.usersSharingRooms(userId)], stream);
 	await hs.federation.onPresence(userId, state, row?.status_msg ?? null).catch(() => {});
 }
 function registerSyncRoutes(r) {