matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/api/sync.js

@@ -0,0 +1,609 @@
+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 { body } from "../http/input.js";
+import { procedure } from "../http/procedure.js";
+import { matchesFilter, roomAllowed, validateSyncFilter } from "./filters.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);
+	if (!m) throw errors.invalidParam("Invalid since token");
+	return {
+		pos: Number(m[1]),
+		toDevice: Number(m[2] ?? m[1])
+	};
+}
+const formatToken = (t) => `s${t.pos}_${t.toDevice}`;
+async function loadFilter(hs, userId, raw) {
+	if (!raw) return {};
+	if (raw.trim().startsWith("{")) {
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			throw errors.badJson("Invalid filter JSON");
+		}
+		return validateSyncFilter(parsed);
+	}
+	const row = await hs.db.findOne("filters", [{
+		field: "user_id",
+		value: userId
+	}, {
+		field: "filter_id",
+		value: raw
+	}]);
+	if (!row) throw errors.notFound("Unknown filter");
+	return row.filter;
+}
+/** A stripped state event as clients expect it. */
+function toStripped(ev) {
+	return {
+		type: ev.type,
+		state_key: ev.state_key,
+		sender: ev.sender,
+		content: ev.content
+	};
+}
+/** State snapshot ID in effect at stream position `pos` in a room (0 = empty). */
+async function snapshotAt(hs, roomId, pos) {
+	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
+	}))[0]?.state_snapshot ?? 0;
+}
+/** Build the timeline + state section of a room. */
+async function roomTimeline(hs, p, roomId, since, upTo) {
+	const tf = p.filter.room?.timeline;
+	const limit = tf?.limit ?? 10;
+	const where = [{
+		field: "room_id",
+		value: roomId
+	}, {
+		field: "stream",
+		operator: "lte",
+		value: upTo
+	}];
+	if (since !== null) where.push({
+		field: "stream",
+		operator: "gt",
+		value: since
+	});
+	const events = [];
+	let limited = false;
+	let cursor = upTo;
+	const batchSize = Math.max(limit * 2, 20);
+	for (;;) {
+		const w = where.map((c) => c.field === "stream" && c.operator === "lte" ? {
+			...c,
+			value: cursor
+		} : c);
+		const rows = await hs.db.findMany("events", {
+			where: w,
+			sortBy: {
+				field: "stream",
+				direction: "desc"
+			},
+			limit: batchSize
+		});
+		if (rows.length === 0) break;
+		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]));
+		let full = false;
+		for (const raw of stored) {
+			cursor = raw.stream - 1;
+			const ev = ok.get(raw.pdu.event_id);
+			if (!ev || !matchesFilter(tf, ev.pdu) || p.ignored.has(ev.pdu.sender)) continue;
+			if (events.length >= (since === null ? limit * 2 : limit)) {
+				limited = true;
+				full = true;
+				break;
+			}
+			events.push(ev);
+		}
+		if (full || rows.length < batchSize) break;
+	}
+	if (since === null && events.length > limit) {
+		events.sort((a, b) => (b.pdu.depth ?? 0) - (a.pdu.depth ?? 0) || b.stream - a.stream);
+		events.length = limit;
+		limited = true;
+	}
+	if (limit === 0 && events.length === 0) limited = (await hs.db.findMany("events", {
+		where,
+		limit: 1
+	})).length > 0;
+	if (since === null) events.sort((a, b) => (a.pdu.depth ?? 0) - (b.pdu.depth ?? 0) || a.stream - b.stream);
+	else events.reverse();
+	let lastGap = -1;
+	events.forEach((e, i) => {
+		if (e.gap) lastGap = i;
+	});
+	if (lastGap >= 0) {
+		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
+	})).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 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 sf = p.filter.room?.state;
+	const lazy = !!sf?.lazy_load_members;
+	const senders = new Set(events.map((e) => e.pdu.sender));
+	senders.add(p.session.userId);
+	const state = [];
+	for (const [key, ev] of startState) {
+		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;
+		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);
+		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);
+		}
+	}
+	return {
+		stateAfter,
+		timeline: {
+			events: events.map((e) => hs.rooms.formatEvent(e, p.session, { includeRoomId: false })),
+			limited,
+			prev_batch: `s${startPos}`
+		},
+		state,
+		timelineEvents: events
+	};
+}
+async function roomEphemeral(hs, p, roomId) {
+	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,
+		content: { user_ids: typing }
+	});
+	const where = [{
+		field: "room_id",
+		value: roomId
+	}];
+	if (since !== null) where.push({
+		field: "stream",
+		operator: "gt",
+		value: since
+	});
+	const receipts = (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;
+		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;
+		content[r.event_id][r.receipt_type][r.user_id] = {
+			ts: r.ts,
+			...r.thread_id ? { thread_id: r.thread_id } : {}
+		};
+	}
+	if (Object.keys(content).length) out.push({
+		type: M.RECEIPT,
+		content
+	});
+	return out.filter((e) => matchesFilter(p.filter.room?.ephemeral, e));
+}
+async function accountData(hs, p, roomId) {
+	const where = [{
+		field: "user_id",
+		value: p.session.userId
+	}, {
+		field: "room_id",
+		value: roomId
+	}];
+	if (p.since && !p.fullState) where.push({
+		field: "stream",
+		operator: "gt",
+		value: p.since.pos
+	});
+	const rows = 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,
+		content: r.content
+	})).filter((e) => matchesFilter(filter, e));
+}
+async function roomSummary(hs, roomId, userId) {
+	const state = await hs.rooms.currentState(roomId);
+	let joined = 0;
+	let invited = 0;
+	const heroes = [];
+	for (const [key, ev] of state) {
+		const [type, sk] = splitStateKey(key);
+		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
+	};
+	if (!getState(state, M.ROOM.NAME)?.content?.name && !getState(state, M.ROOM.CANONICAL_ALIAS)?.content?.alias) summary[M.HEROES] = heroes.sort();
+	return summary;
+}
+async function buildSync(hs, p) {
+	const userId = p.session.userId;
+	const since = p.since?.pos ?? null;
+	const memberships = await hs.db.findMany("memberships", { where: [{
+		field: "user_id",
+		value: userId
+	}] });
+	const join = {};
+	const invite = {};
+	const leave = {};
+	const knock = {};
+	let empty = true;
+	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 (!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);
+			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;
+		} else if (m.membership === "invite") {
+			if (!changed && !p.fullState) continue;
+			const pdu = await hs.rooms.getPdu(m.event_id);
+			if (!pdu || p.ignored.has(pdu.sender)) continue;
+			if (await inviteDecision(hs, userId, pdu.sender) !== "allow") continue;
+			invite[roomId] = { invite_state: { events: [...pdu.unsigned?.invite_room_state ?? [], pdu].map(toStripped) } };
+			empty = false;
+		} else if (m.membership === "knock") {
+			if (!changed && !p.fullState) continue;
+			const knockPdu = await hs.rooms.getPdu(m.event_id);
+			const ev = knockPdu ? { pdu: knockPdu } : null;
+			if (!ev) continue;
+			knock[roomId] = { knock_state: { events: [...ev.pdu.unsigned?.knock_room_state ?? [], ev.pdu].map(toStripped) } };
+			empty = false;
+		} else {
+			if (m.forgotten && since === null) continue;
+			if (since === null ? !p.filter.room?.include_leave : m.stream <= since) continue;
+			const { timeline, state } = await roomTimeline(hs, p, roomId, since, m.stream);
+			const tf = p.filter.room?.timeline;
+			if (!await hs.rooms.exists(roomId) && (tf?.limit ?? 10) > 0 && !timeline.events.some((e) => e.event_id === m.event_id)) {
+				const leavePdu = await hs.rooms.getPdu(m.event_id);
+				if (leavePdu && matchesFilter(tf, leavePdu)) timeline.events.push(toClientEvent(leavePdu, { includeRoomId: false }));
+			}
+			leave[roomId] = {
+				timeline,
+				state: { events: state.map((e) => toClientEvent(e, { includeRoomId: false })) },
+				account_data: { events: await accountData(hs, p, roomId) }
+			};
+			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,
+		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);
+	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: [{
+				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 })) {
+			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
+			};
+			if (row.status_msg) content.status_msg = row.status_msg;
+			if (row.presence === "online") content.currently_active = true;
+			const ev = {
+				type: M.PRESENCE,
+				sender: row.user_id,
+				content
+			};
+			if (matchesFilter(p.filter.presence, ev)) presenceEvents.push(ev);
+		}
+	}
+	if (presenceEvents.length) empty = false;
+	const profileUpdates = await profileUpdatesFor(hs, p, memberships);
+	if (profileUpdates) empty = false;
+	const body = {
+		next_batch: formatToken({
+			pos: p.to,
+			toDevice: nextToDevice
+		}),
+		rooms: Object.fromEntries(Object.entries({
+			join,
+			invite,
+			leave,
+			knock
+		}).filter(([, v]) => Object.keys(v).length)),
+		presence: { events: presenceEvents },
+		account_data: { events: globalAccountData },
+		to_device: { events: toDevice.map((r) => ({
+			sender: r.sender,
+			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)
+	};
+	if (profileUpdates) body[UNSTABLE.ORG.MATRIX.MSC4429.USERS] = profileUpdates;
+	if (since !== null) {
+		const lists = await hs.keys.changesSince(userId, since, p.to);
+		body.device_lists = lists;
+		if (lists.changed.length || lists.left.length) empty = false;
+	}
+	return {
+		body,
+		empty,
+		nextToDevice
+	};
+}
+async function sync(ctx) {
+	const hs = ctx.hs;
+	const session = await ctx.auth();
+	const filter = await loadFilter(hs, session.userId, ctx.query.get("filter"));
+	const since = parseSyncToken(ctx.query.get("since"));
+	const fullState = ctx.query.get("full_state") === "true";
+	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 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 stable = ctx.query.get("use_state_after") === "true";
+		const unstable = ctx.query.get(UNSTABLE.ORG.MATRIX.MSC4222.USE_STATE_AFTER) === "true";
+		const { body, empty } = await buildSync(hs, {
+			session,
+			ignored,
+			since,
+			to,
+			filter,
+			fullState,
+			useStateAfter: stable || unstable,
+			stateAfterKey: stable ? "state_after" : UNSTABLE.ORG.MATRIX.MSC4222.STATE_AFTER
+		});
+		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;
+	}
+}
+async function touchPresence(hs, userId, presence) {
+	const state = presence === "unavailable" ? "unavailable" : "online";
+	const row = await hs.db.findOne("presence", [{
+		field: "user_id",
+		value: userId
+	}]);
+	if (row && row.presence === state) {
+		await hs.db.update("presence", [{
+			field: "user_id",
+			value: userId
+		}], { 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
+	}));
+	await hs.federation.onPresence(userId, state, row?.status_msg ?? null).catch(() => {});
+}
+function registerSyncRoutes(r) {
+	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[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;
+	const sharing = await hs.rooms.usersSharingRooms(p.session.userId);
+	const out = {};
+	const add = (userId, field, value) => {
+		(out[userId] ??= { profile_updates: {} }).profile_updates[field] = value ?? null;
+	};
+	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
+		}] });
+		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)) {
+				if ((await hs.rooms.getEvent(c.event_id))?.pdu.unsigned?.prev_content?.membership !== "join") full.add(c.user_id);
+			} else if (!sharing.has(c.user_id) && (myRooms.has(c.room_id) || memberships.some((m) => m.room_id === c.room_id))) out[c.user_id] = { profile_updates: null };
+		}
+		const rows = await hs.db.findMany("profile_fields", { where: [{
+			field: "stream",
+			operator: "gt",
+			value: since
+		}] });
+		for (const row of rows) {
+			if (row.stream > p.to || !wanted.has(row.field) || !sharing.has(row.user_id) || full.has(row.user_id)) continue;
+			add(row.user_id, row.field, row.value);
+		}
+	}
+	for (const userId of full) {
+		if (!sharing.has(userId) || !hs.isLocalUser(userId)) continue;
+		const profile = await fullProfile(hs, userId) ?? {};
+		for (const field of wanted) if (profile[field] !== void 0) add(userId, field, profile[field]);
+	}
+	return Object.keys(out).length ? out : null;
+}
+//#endregion
+export { registerSyncRoutes, roomEphemeral, roomSummary, roomTimeline, toStripped };