matrix-nodejs-homeserver 0.0.0-stage → 0.2.0

package/dist/api/rtc.d.ts

@@ -0,0 +1,24 @@
+import "../http/router.js";
+//#region src/api/rtc.d.ts
+export interface TurnOptions {
+  uris: string[];
+  /** coturn `static-auth-secret`: time-limited credentials are derived from it. */
+  sharedSecret?: string;
+  /** Static credentials, when not using a shared secret. */
+  username?: string;
+  password?: string;
+  /** Credential lifetime in seconds. Default: 86400. */
+  ttlSeconds?: number;
+  /** Whether guests may obtain credentials. Default: false. */
+  allowGuests?: boolean;
+}
+export interface RtcOptions {
+  /** VoIP TURN servers. */
+  turn?: TurnOptions;
+  /**
+   * MatrixRTC transports (MSC4143), e.g. `[{ type: "livekit", livekit_service_url: "https://lk-jwt.example.com" }]`.
+   * Advertised at /rtc/transports and in /.well-known/matrix/client.
+   */
+  transports?: Record<string, unknown>[];
+}
+//#endregion

package/dist/api/rtc.js

@@ -0,0 +1,52 @@
+import { errors } from "../core/errors.js";
+import { body, fail } from "../http/input.js";
+import { createHmac } from "node:crypto";
+import { z } from "zod";
+//#region src/api/rtc.ts
+function registerRtcRoutes(r) {
+	r.client("GET", "/voip/turnServer", async (ctx) => {
+		const s = await ctx.auth();
+		const turn = ctx.hs.config.rtc.turn;
+		if (!turn || !turn.uris.length) return {};
+		if (s.isGuest && !turn.allowGuests) throw errors.forbidden("Guests may not use TURN");
+		const ttl = turn.ttlSeconds ?? 86400;
+		if (turn.sharedSecret) {
+			const username = `${Math.floor(Date.now() / 1e3) + ttl}:${s.userId}`;
+			return {
+				username,
+				password: createHmac("sha1", turn.sharedSecret).update(username).digest("base64"),
+				uris: turn.uris,
+				ttl
+			};
+		}
+		return {
+			username: turn.username ?? "",
+			password: turn.password ?? "",
+			uris: turn.uris,
+			ttl
+		};
+	});
+	const transports = async (ctx) => {
+		await ctx.auth();
+		return { rtc_transports: ctx.hs.config.rtc.transports ?? [] };
+	};
+	r.client("GET", "/rtc/transports", transports, ["v1"]);
+	r.get("/_matrix/client/unstable/org.matrix.msc4143/rtc/transports", transports);
+	const base = "/_matrix/client/unstable/org.matrix.msc4140/delayed_events";
+	r.get(base, async (ctx) => {
+		const s = await ctx.auth();
+		return { delayed_events: await ctx.hs.delayedEvents.list(s.userId) };
+	});
+	r.post(`${base}/:delayId`, { input: body({ action: z.string(fail("M_MISSING_PARAM", "Missing action")) }) }, async (ctx) => {
+		const s = await ctx.auth();
+		await ctx.hs.delayedEvents.update(s.userId, ctx.params.delayId, ctx.input.action);
+		return {};
+	});
+	r.post(`${base}/:delayId/:action`, async (ctx) => {
+		const s = await ctx.auth();
+		await ctx.hs.delayedEvents.update(s.userId, ctx.params.delayId, ctx.params.action);
+		return {};
+	});
+}
+//#endregion
+export { registerRtcRoutes };

package/dist/api/search.js

@@ -0,0 +1,155 @@
+import { isObject } from "../core/json.js";
+import { getState } from "../core/authrules.js";
+import { body, fail } from "../http/input.js";
+import { matchesFilter } from "./filters.js";
+import { paginate, topoToken } from "./rooms.js";
+import { z } from "zod";
+//#region src/api/search.ts
+const DEFAULT_KEYS = [
+	"content.body",
+	"content.name",
+	"content.topic"
+];
+function valueAt(obj, path) {
+	return path.split(".").reduce((o, k) => isObject(o) ? o[k] : void 0, obj);
+}
+function registerSearchRoutes(r) {
+	const missingTerm = fail("M_BAD_JSON", "Missing search_categories.room_events.search_term");
+	const searchBody = body({ search_categories: z.looseObject({ room_events: z.looseObject({
+		search_term: z.string(missingTerm),
+		keys: z.unknown().optional(),
+		filter: z.unknown().optional(),
+		order_by: z.unknown().optional()
+	}, missingTerm) }, missingTerm) });
+	r.client("POST", "/search", { input: searchBody }, async (ctx) => {
+		const s = await ctx.auth();
+		const hs = ctx.hs;
+		const criteria = ctx.input.search_categories.room_events;
+		const terms = criteria.search_term.toLowerCase().split(/\s+/).filter(Boolean);
+		const keys = Array.isArray(criteria.keys) && criteria.keys.length ? criteria.keys : DEFAULT_KEYS;
+		const filter = isObject(criteria.filter) ? criteria.filter : {};
+		const limit = Math.min(filter.limit ?? 10, 100);
+		const orderBy = criteria.order_by === "recent" ? "recent" : "rank";
+		const offset = Number.parseInt(ctx.query.get("next_batch") ?? "0", 10) || 0;
+		let rooms = await hs.rooms.roomsForUser(s.userId);
+		if (filter.rooms) rooms = rooms.filter((r) => filter.rooms.includes(r));
+		if (filter.not_rooms) rooms = rooms.filter((r) => !filter.not_rooms.includes(r));
+		const hits = [];
+		for (const roomId of rooms) {
+			const rows = await hs.db.findMany("events", {
+				where: [{
+					field: "room_id",
+					value: roomId
+				}],
+				sortBy: {
+					field: "stream",
+					direction: "desc"
+				}
+			});
+			const candidates = [];
+			for (const row of rows) {
+				if (row.state_key !== null || !matchesFilter(filter, row.json)) continue;
+				let rank = 0;
+				const words = [];
+				for (const key of keys) {
+					const v = valueAt(row.json, key);
+					if (typeof v === "string") words.push(...v.toLowerCase().split(/[^\p{L}\p{N}]+/u));
+				}
+				if (terms.every((t) => words.includes(t))) for (const t of terms) rank += words.filter((w) => w === t).length;
+				if (rank > 0) candidates.push({
+					ev: hs.rooms.rowToStored(row),
+					rank
+				});
+			}
+			const visible = new Set((await hs.rooms.filterVisible(s.userId, roomId, candidates.map((c) => c.ev))).map((v) => v.pdu.event_id));
+			hits.push(...candidates.filter((c) => visible.has(c.ev.pdu.event_id)));
+		}
+		hits.sort((a, b) => orderBy === "rank" && b.rank !== a.rank ? b.rank - a.rank : b.ev.stream - a.ev.stream);
+		const page = hits.slice(offset, offset + limit);
+		const viewer = {
+			userId: s.userId,
+			deviceId: s.deviceId
+		};
+		const ec = isObject(criteria.event_context) ? criteria.event_context : null;
+		const results = [];
+		for (const hit of page) {
+			const result = {
+				rank: hit.rank,
+				result: hs.rooms.formatEvent(hit.ev, viewer)
+			};
+			if (ec) {
+				const roomId = hit.ev.pdu.room_id;
+				const here = {
+					depth: hit.ev.pdu.depth,
+					stream: hit.ev.stream
+				};
+				const before = await paginate(hs, s.userId, roomId, {
+					from: here,
+					to: null,
+					dir: "b",
+					limit: ec.before_limit ?? 5
+				});
+				const after = await paginate(hs, s.userId, roomId, {
+					from: here,
+					to: null,
+					dir: "f",
+					limit: ec.after_limit ?? 5
+				});
+				const context = {
+					events_before: before.events.map((e) => hs.rooms.formatEvent(e, viewer)),
+					events_after: after.events.map((e) => hs.rooms.formatEvent(e, viewer)),
+					start: before.end ?? topoToken(before.events.at(-1) ?? hit.ev),
+					end: topoToken(after.events.at(-1) ?? hit.ev)
+				};
+				if (ec.include_profile) {
+					const state = await hs.rooms.currentState(roomId);
+					const profile_info = {};
+					for (const e of [
+						...before.events,
+						hit.ev,
+						...after.events
+					]) {
+						const m = getState(state, "m.room.member", e.pdu.sender)?.content;
+						profile_info[e.pdu.sender] = {
+							displayname: m?.displayname,
+							avatar_url: m?.avatar_url
+						};
+					}
+					context.profile_info = profile_info;
+				}
+				result.context = context;
+			}
+			results.push(result);
+		}
+		const out = {
+			results,
+			count: hits.length,
+			highlights: terms
+		};
+		if (page.length === limit && offset + limit <= hits.length) out.next_batch = String(offset + limit);
+		if (criteria.include_state) {
+			out.state = {};
+			for (const roomId of new Set(page.map((h) => h.ev.pdu.room_id))) out.state[roomId] = [...(await hs.rooms.currentState(roomId)).values()].map((e) => hs.rooms.formatEvent({
+				pdu: e,
+				stream: 0,
+				snapshot: 0,
+				txnId: null,
+				txnToken: null
+			}));
+		}
+		if (criteria.groupings?.group_by?.some?.((g) => g?.key === "room_id")) {
+			const groups = {};
+			hits.forEach((h, i) => {
+				(groups[h.ev.pdu.room_id] ??= {
+					results: [],
+					order: i,
+					next_batch: null
+				}).results.push(h.ev.pdu.event_id);
+			});
+			out.groups = { room_id: groups };
+		}
+		return { search_categories: { room_events: out } };
+	});
+}
+//#endregion
+export { registerSearchRoutes };

package/dist/api/slidingsync.js

@@ -0,0 +1,464 @@
+import { isObject } from "../core/json.js";
+import { splitStateKey, toClientEvent } from "../core/events.js";
+import { MatrixError } from "../core/errors.js";
+import { getState } from "../core/authrules.js";
+import { body, lenient } from "../http/input.js";
+import { roomEphemeral, roomTimeline, toStripped } from "./sync.js";
+import { z } from "zod";
+//#region src/api/slidingsync.ts
+const slidingSyncBody = body({
+	conn_id: lenient(z.string()),
+	lists: lenient(z.record(z.string(), z.unknown())),
+	room_subscriptions: lenient(z.record(z.string(), z.unknown())),
+	extensions: lenient(z.record(z.string(), z.unknown()))
+});
+const BUMP_TYPES = /* @__PURE__ */ new Set([
+	"m.room.create",
+	"m.room.message",
+	"m.room.encrypted",
+	"m.sticker",
+	"m.call.invite",
+	"m.poll.start",
+	"m.beacon_info"
+]);
+async function loadConnection(hs, s, connId) {
+	return hs.db.findOne("sliding_sync_connections", [
+		{
+			field: "user_id",
+			value: s.userId
+		},
+		{
+			field: "device_id",
+			value: s.deviceId
+		},
+		{
+			field: "conn_id",
+			value: connId
+		}
+	]);
+}
+/** Stream position of the latest "interesting" event in a room. */
+async function bumpStamp(hs, roomId, upTo) {
+	const rows = await hs.db.findMany("events", {
+		where: [{
+			field: "room_id",
+			value: roomId
+		}, {
+			field: "stream",
+			operator: "lte",
+			value: upTo
+		}],
+		sortBy: {
+			field: "stream",
+			direction: "desc"
+		},
+		limit: 50
+	});
+	for (const r of rows) if (BUMP_TYPES.has(r.type)) return r.stream;
+	return rows[rows.length - 1]?.stream ?? 0;
+}
+function matchesRequiredState(required, type, key, userId, lazyMembers) {
+	for (const [t, k] of required) {
+		if (t !== "*" && t !== type) continue;
+		if (k === "*" || k === key) return true;
+		if (k === "$ME" && key === userId) return true;
+		if (k === "$LAZY" && type === "m.room.member" && lazyMembers.has(key)) return true;
+	}
+	return false;
+}
+function registerSlidingSyncRoutes(r) {
+	r.post("/_matrix/client/unstable/org.matrix.simplified_msc3575/sync", { input: slidingSyncBody }, slidingSync);
+	r.post("/_matrix/client/v5/sync", { input: slidingSyncBody }, slidingSync);
+}
+async function slidingSync(ctx) {
+	const hs = ctx.hs;
+	const s = await ctx.auth();
+	const body = ctx.input;
+	const connId = body.conn_id ?? "";
+	const posParam = ctx.query.get("pos");
+	const timeout = Math.min(Math.max(Number.parseInt(ctx.query.get("timeout") ?? "0", 10) || 0, 0), hs.config.maxSyncTimeoutMs);
+	let conn = {
+		rooms: {},
+		prevPos: null,
+		toDeviceSince: 0
+	};
+	let since = null;
+	if (posParam !== null) {
+		const row = await loadConnection(hs, s, connId);
+		const pos = Number(posParam);
+		if (!row || !Number.isInteger(pos) || pos !== row.pos && pos !== row.state.prevPos) throw new MatrixError(400, "M_UNKNOWN_POS", "Unknown position; start a new connection");
+		conn = row.state;
+		since = pos;
+		if (pos === row.state.prevPos && pos !== row.pos) conn = {
+			...conn,
+			rooms: {}
+		};
+	}
+	const deadline = Date.now() + timeout;
+	for (;;) {
+		const to = await hs.streams.position();
+		const { response, empty, next } = await buildResponse(hs, s, body, conn, since, to);
+		const remaining = deadline - Date.now();
+		if (since === null || !empty || remaining <= 0) {
+			await hs.db.upsert("sliding_sync_connections", {
+				user_id: s.userId,
+				device_id: s.deviceId,
+				conn_id: connId,
+				pos: to,
+				state: {
+					...next,
+					prevPos: since
+				},
+				updated_ts: Date.now()
+			});
+			return {
+				pos: String(to),
+				...response
+			};
+		}
+		if (await hs.streams.position() > to) continue;
+		await hs.notifier.wait(s.userId, remaining, ctx.request.signal);
+		if (ctx.request.signal?.aborted) return {
+			pos: String(since),
+			lists: {},
+			rooms: {},
+			extensions: {}
+		};
+	}
+}
+async function buildResponse(hs, s, body, conn, since, to) {
+	const userId = s.userId;
+	const memberships = await hs.db.findMany("memberships", { where: [{
+		field: "user_id",
+		value: userId
+	}] });
+	const direct = await hs.db.findOne("account_data", [
+		{
+			field: "user_id",
+			value: userId
+		},
+		{
+			field: "room_id",
+			value: ""
+		},
+		{
+			field: "type",
+			value: "m.direct"
+		}
+	]);
+	const dmRooms = new Set(Object.values(direct?.content ?? {}).flat().filter((x) => typeof x === "string"));
+	const candidates = memberships.filter((m) => m.stream <= to && ([
+		"join",
+		"invite",
+		"knock"
+	].includes(m.membership) || since !== null && m.stream > since && !m.forgotten));
+	const infos = [];
+	for (const m of candidates) {
+		const state = await hs.rooms.currentState(m.room_id);
+		const bump = m.membership === "join" ? await bumpStamp(hs, m.room_id, to) : m.stream;
+		infos.push({
+			roomId: m.room_id,
+			membership: m.membership,
+			bump,
+			state
+		});
+		const invite = getState(state, "m.room.member", userId);
+		if (m.membership === "invite" && invite?.content?.is_direct) dmRooms.add(m.room_id);
+	}
+	infos.sort((a, b) => b.bump - a.bump);
+	const wanted = /* @__PURE__ */ new Map();
+	const lists = {};
+	for (const [name, raw] of Object.entries(isObject(body.lists) ? body.lists : {})) {
+		const list = raw;
+		const f = list.filters ?? {};
+		let rooms = infos;
+		if (f.is_dm !== void 0) rooms = rooms.filter((r) => dmRooms.has(r.roomId) === f.is_dm);
+		if (f.is_invite !== void 0) rooms = rooms.filter((r) => r.membership === "invite" === f.is_invite);
+		if (f.is_encrypted !== void 0) rooms = rooms.filter((r) => !!getState(r.state, "m.room.encryption") === f.is_encrypted);
+		const roomType = (r) => getState(r.state, "m.room.create")?.content?.type ?? null;
+		if (f.room_types) rooms = rooms.filter((r) => f.room_types.includes(roomType(r)));
+		if (f.not_room_types) rooms = rooms.filter((r) => !f.not_room_types.includes(roomType(r)));
+		if (f.spaces) {
+			const children = /* @__PURE__ */ new Set();
+			for (const space of f.spaces) {
+				if (!await hs.rooms.exists(space)) continue;
+				for (const key of (await hs.rooms.currentState(space)).keys()) {
+					const [t, k] = splitStateKey(key);
+					if (t === "m.space.child") children.add(k);
+				}
+			}
+			rooms = rooms.filter((r) => children.has(r.roomId));
+		}
+		lists[name] = { count: rooms.length };
+		for (const [start, end] of list.ranges ?? [[0, rooms.length - 1]]) for (const room of rooms.slice(Math.max(0, start), Math.max(0, end) + 1)) {
+			const prev = wanted.get(room.roomId);
+			wanted.set(room.roomId, mergeConfig(prev, list));
+		}
+	}
+	for (const [roomId, raw] of Object.entries(isObject(body.room_subscriptions) ? body.room_subscriptions : {})) {
+		if (!infos.find((i) => i.roomId === roomId)) {
+			if (!await hs.rooms.exists(roomId) || !(await hs.rooms.canPeek(roomId, userId)).worldReadable) continue;
+			infos.push({
+				roomId,
+				membership: "leave",
+				bump: 0,
+				state: await hs.rooms.currentState(roomId)
+			});
+		}
+		wanted.set(roomId, mergeConfig(wanted.get(roomId), raw));
+	}
+	const next = {
+		rooms: { ...conn.rooms },
+		prevPos: conn.prevPos,
+		toDeviceSince: conn.toDeviceSince
+	};
+	const rooms = {};
+	for (const [roomId, config] of wanted) {
+		const info = infos.find((i) => i.roomId === roomId);
+		const configKey = JSON.stringify(config);
+		const known = since !== null ? conn.rooms[roomId] : void 0;
+		const initial = !known || known.config !== configKey;
+		const room = await buildRoom(hs, s, info, config, initial ? null : since, to, dmRooms.has(roomId));
+		const counts = JSON.stringify([
+			room.notification_count,
+			room.highlight_count,
+			room.joined_count,
+			room.invited_count
+		]);
+		if (!initial && room.timeline.length === 0 && room.required_state.length === 0 && known.counts === counts) continue;
+		if (initial) room.initial = true;
+		if (since !== null && !initial) room.num_live = room.timeline.filter((e) => e.__stream > since).length;
+		for (const e of room.timeline) delete e.__stream;
+		rooms[roomId] = room;
+		next.rooms[roomId] = {
+			config: configKey,
+			counts
+		};
+	}
+	const extensions = await buildExtensions(hs, s, body.extensions ?? {}, since, to, Object.keys(rooms), next);
+	const empty = Object.keys(rooms).length === 0 && Object.values(extensions).every((e) => isEmptyExtension(e));
+	return {
+		response: {
+			lists,
+			rooms,
+			extensions
+		},
+		empty,
+		next
+	};
+}
+function mergeConfig(a, b) {
+	if (!a) return {
+		required_state: b.required_state ?? [],
+		timeline_limit: b.timeline_limit ?? 0
+	};
+	return {
+		required_state: [...a.required_state ?? [], ...b.required_state ?? []],
+		timeline_limit: Math.max(a.timeline_limit ?? 0, b.timeline_limit ?? 0)
+	};
+}
+async function buildRoom(hs, s, info, config, since, to, isDm) {
+	const { roomId, state } = info;
+	const userId = s.userId;
+	const room = {
+		bump_stamp: info.bump,
+		timeline: [],
+		required_state: []
+	};
+	const name = getState(state, "m.room.name")?.content?.name;
+	if (typeof name === "string") room.name = name;
+	const avatar = getState(state, "m.room.avatar")?.content?.url;
+	if (typeof avatar === "string") room.avatar = avatar;
+	if (isDm) room.is_dm = true;
+	if (info.membership === "invite" || info.membership === "knock") {
+		const own = getState(state, "m.room.member", userId);
+		const ev = own?.event_id ? await hs.rooms.getEvent(own.event_id) : null;
+		if (ev) {
+			const key = info.membership === "invite" ? "invite_room_state" : "knock_room_state";
+			room[info.membership === "invite" ? "invite_state" : "knock_state"] = [...ev.pdu.unsigned?.[key] ?? [], ev.pdu].map(toStripped);
+		}
+		return room;
+	}
+	const p = {
+		session: s,
+		ignored: /* @__PURE__ */ new Set(),
+		since: since === null ? null : {
+			pos: since,
+			toDevice: 0
+		},
+		to,
+		filter: { room: { timeline: { limit: config.timeline_limit ?? 0 } } },
+		fullState: false
+	};
+	const upTo = info.membership === "join" ? to : Math.min(to, (await hs.db.findOne("memberships", [{
+		field: "room_id",
+		value: roomId
+	}, {
+		field: "user_id",
+		value: userId
+	}]))?.stream ?? to);
+	if ((config.timeline_limit ?? 0) > 0) {
+		const { timeline, timelineEvents } = await roomTimeline(hs, p, roomId, since, upTo);
+		room.timeline = timeline.events.map((e, i) => ({
+			...e,
+			room_id: void 0,
+			__stream: timelineEvents[i].stream
+		}));
+		room.limited = timeline.limited;
+		room.prev_batch = timeline.prev_batch;
+	}
+	const lazy = /* @__PURE__ */ new Set([userId, ...room.timeline.map((e) => e.sender)]);
+	const required = config.required_state ?? [];
+	for (const [key, ev] of state) {
+		const [type, sk] = splitStateKey(key);
+		if (!matchesRequiredState(required, type, sk, userId, lazy)) continue;
+		if (since !== null) {
+			const stored = ev.event_id ? await hs.rooms.getEvent(ev.event_id) : null;
+			if (!stored || stored.stream <= since) continue;
+		}
+		room.required_state.push(toClientEvent(ev, { includeRoomId: false }));
+	}
+	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({
+			user_id: sk,
+			displayname: ev.content?.displayname,
+			avatar_url: ev.content?.avatar_url
+		});
+	}
+	room.joined_count = joined;
+	room.invited_count = invited;
+	if (!room.name) room.heroes = heroes;
+	const counts = await hs.push.unreadCounts(userId, roomId);
+	room.notification_count = counts.room.notification_count + Object.values(counts.threads).reduce((n, t) => n + t.notification_count, 0);
+	room.highlight_count = counts.room.highlight_count + Object.values(counts.threads).reduce((n, t) => n + t.highlight_count, 0);
+	return room;
+}
+async function buildExtensions(hs, s, ext, since, to, roomIds, next) {
+	const out = {};
+	const userId = s.userId;
+	if (ext.to_device?.enabled) {
+		const where = [{
+			field: "user_id",
+			value: userId
+		}, {
+			field: "device_id",
+			value: s.deviceId
+		}];
+		const ackUpTo = Number(ext.to_device.since ?? next.toDeviceSince) || 0;
+		if (ackUpTo) await hs.db.delete("to_device", [...where, {
+			field: "stream",
+			operator: "lte",
+			value: ackUpTo
+		}]);
+		const rows = (await hs.db.findMany("to_device", {
+			where: [...where, {
+				field: "stream",
+				operator: "gt",
+				value: ackUpTo
+			}],
+			sortBy: {
+				field: "stream",
+				direction: "asc"
+			},
+			limit: Math.min(Number(ext.to_device.limit ?? 100) || 100, 1e3)
+		})).filter((r) => r.stream <= to);
+		const nextBatch = rows.length ? rows[rows.length - 1].stream : ackUpTo;
+		next.toDeviceSince = nextBatch;
+		out.to_device = {
+			next_batch: String(nextBatch),
+			events: rows.map((r) => ({
+				sender: r.sender,
+				type: r.type,
+				content: r.content
+			}))
+		};
+	}
+	if (ext.e2ee?.enabled) {
+		const e2ee = {
+			device_one_time_keys_count: await hs.keys.oneTimeKeyCounts(userId, s.deviceId),
+			device_unused_fallback_key_types: await hs.keys.unusedFallbackKeyTypes(userId, s.deviceId)
+		};
+		if (since !== null) e2ee.device_lists = await hs.keys.changesSince(userId, since, to);
+		out.e2ee = e2ee;
+	}
+	if (ext.account_data?.enabled) {
+		const where = [{
+			field: "user_id",
+			value: userId
+		}];
+		if (since !== null) where.push({
+			field: "stream",
+			operator: "gt",
+			value: since
+		});
+		const rows = (await hs.db.findMany("account_data", { where })).filter((r) => r.stream <= to);
+		const rooms = {};
+		const global = [];
+		for (const r of rows) {
+			const ev = {
+				type: r.type,
+				content: r.content
+			};
+			if (r.room_id === "") global.push(ev);
+			else if (roomIds.includes(r.room_id) || since !== null) (rooms[r.room_id] ??= []).push(ev);
+		}
+		if (since === null && !global.some((e) => e.type === "m.push_rules")) {
+			const { loadRules } = await import("../core/pushrules.js");
+			global.push({
+				type: "m.push_rules",
+				content: { global: await loadRules(hs, userId) }
+			});
+		}
+		out.account_data = {
+			global,
+			rooms
+		};
+	}
+	if (ext["io.element.msc4308.thread_subscriptions"]?.enabled) {
+		const { threadSubscriptionsExtension } = await import("./threadsubs.js");
+		out["io.element.msc4308.thread_subscriptions"] = await threadSubscriptionsExtension(hs, userId, ext["io.element.msc4308.thread_subscriptions"], since, to);
+	}
+	if (ext.receipts?.enabled || ext.typing?.enabled) {
+		const p = {
+			session: s,
+			ignored: /* @__PURE__ */ new Set(),
+			since: since === null ? null : {
+				pos: since,
+				toDevice: 0
+			},
+			to,
+			filter: {},
+			fullState: false
+		};
+		const receipts = {};
+		const typing = {};
+		const joined = new Set(await hs.rooms.roomsForUser(userId));
+		for (const roomId of since === null ? roomIds : [...joined]) {
+			if (!joined.has(roomId)) continue;
+			for (const e of await roomEphemeral(hs, p, roomId)) {
+				if (e.type === "m.receipt" && ext.receipts?.enabled) receipts[roomId] = e;
+				if (e.type === "m.typing" && ext.typing?.enabled && (since !== null || e.content.user_ids.length)) typing[roomId] = e;
+			}
+		}
+		if (ext.receipts?.enabled) out.receipts = { rooms: receipts };
+		if (ext.typing?.enabled) out.typing = { rooms: typing };
+	}
+	return out;
+}
+function isEmptyExtension(e) {
+	if (Array.isArray(e.events)) return e.events.length === 0;
+	if (e.rooms && Object.keys(e.rooms).length) return false;
+	if (e.global && e.global.length) return false;
+	if (e.device_lists && (e.device_lists.changed.length || e.device_lists.left.length)) return false;
+	return true;
+}
+//#endregion
+export { registerSlidingSyncRoutes };