matrix-nodejs-homeserver 0.2.0 → 0.3.2

package/dist/api/user.js

@@ -1,16 +1,18 @@
 import { canonicalJson, isObject } from "../core/json.js";
+import { M } from "../core/m.js";
 import { errors } from "../core/errors.js";
-import { requireUia } from "./uia.js";
+import { array, record, string, unknown } from "../vendor/zod/v4/classic/schemas.js";
 import { body, fail } from "../http/input.js";
-import { z } from "zod";
+import { procedure } from "../http/procedure.js";
+import { requireUia } from "./uia.js";
 //#region src/api/user.ts
-const deleteDevicesBody = body({ devices: z.array(z.unknown(), fail("M_BAD_JSON", "devices must be a list")) });
+const deleteDevicesBody = body({ devices: array(unknown(), fail("M_BAD_JSON", "devices must be a list")) });
 const keysQueryBody = body({
-	device_keys: z.record(z.string(), z.array(z.string(), fail("M_BAD_JSON", "device_keys values must be lists of device IDs")), fail("M_BAD_JSON", "device_keys must be an object")),
-	timeout: z.unknown().optional()
+	device_keys: record(string(), array(string(), fail("M_BAD_JSON", "device_keys values must be lists of device IDs")), fail("M_BAD_JSON", "device_keys must be an object")),
+	timeout: unknown().optional()
 });
-const keysClaimBody = body({ one_time_keys: z.record(z.string(), z.unknown(), fail("M_BAD_JSON", "one_time_keys must be an object")) });
-const SERVER_MANAGED_TYPES = ["m.fully_read", "m.push_rules"];
+const keysClaimBody = body({ one_time_keys: record(string(), unknown(), fail("M_BAD_JSON", "one_time_keys must be an object")) });
+const SERVER_MANAGED_TYPES = [M.FULLY_READ, M.PUSH_RULES];
 async function setAccountData(hs, userId, roomId, type, content) {
 	await hs.streams.write((stream) => hs.db.upsert("account_data", {
 		user_id: userId,
@@ -48,39 +50,39 @@ async function checkRoom(ctx) {
 	if (!ctx.params.roomId.startsWith("!")) throw errors.invalidParam("Invalid room ID");
 }
 function registerUserRoutes(r) {
-	r.client("PUT", "/user/:userId/account_data/:type", async (ctx) => {
+	r.client("PUT", "/user/:userId/account_data/:type", procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		if (SERVER_MANAGED_TYPES.includes(ctx.params.type)) throw errors.badJson("This type is managed by the server");
 		await setAccountData(ctx.hs, s.userId, "", ctx.params.type, await ctx.json());
 		return {};
-	});
-	r.client("GET", "/user/:userId/account_data/:type", async (ctx) => {
+	} }));
+	r.client("GET", "/user/:userId/account_data/:type", procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		return getAccountData(ctx.hs, s.userId, "", ctx.params.type);
-	});
-	r.client("PUT", "/user/:userId/rooms/:roomId/account_data/:type", async (ctx) => {
+	} }));
+	r.client("PUT", "/user/:userId/rooms/:roomId/account_data/:type", procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		await checkRoom(ctx);
 		if (SERVER_MANAGED_TYPES.includes(ctx.params.type)) throw errors.badJson("This type is managed by the server");
 		await setAccountData(ctx.hs, s.userId, ctx.params.roomId, ctx.params.type, await ctx.json());
 		return {};
-	});
-	r.client("GET", "/user/:userId/rooms/:roomId/account_data/:type", async (ctx) => {
+	} }));
+	r.client("GET", "/user/:userId/rooms/:roomId/account_data/:type", procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		await checkRoom(ctx);
 		return getAccountData(ctx.hs, s.userId, ctx.params.roomId, ctx.params.type);
-	});
+	} }));
 	const del = "/_matrix/client/unstable/org.matrix.msc3391";
-	r.delete(`${del}/user/:userId/account_data/:type`, async (ctx) => {
+	r.delete(`${del}/user/:userId/account_data/:type`, procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		await setAccountData(ctx.hs, s.userId, "", ctx.params.type, {});
 		return {};
-	});
-	r.delete(`${del}/user/:userId/rooms/:roomId/account_data/:type`, async (ctx) => {
+	} }));
+	r.delete(`${del}/user/:userId/rooms/:roomId/account_data/:type`, procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		await setAccountData(ctx.hs, s.userId, ctx.params.roomId, ctx.params.type, {});
 		return {};
-	});
+	} }));
 	const readTags = async (hs, userId, roomId) => {
 		const row = await hs.db.findOne("account_data", [
 			{
@@ -93,194 +95,235 @@ function registerUserRoutes(r) {
 			},
 			{
 				field: "type",
-				value: "m.tag"
+				value: M.TAG
 			}
 		]);
 		return isObject(row?.content?.tags) ? row.content.tags : {};
 	};
-	r.client("GET", "/user/:userId/rooms/:roomId/tags", async (ctx) => {
+	r.client("GET", "/user/:userId/rooms/:roomId/tags", procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		return { tags: await readTags(ctx.hs, s.userId, ctx.params.roomId) };
-	});
-	r.client("PUT", "/user/:userId/rooms/:roomId/tags/:tag", async (ctx) => {
+	} }));
+	r.client("PUT", "/user/:userId/rooms/:roomId/tags/:tag", procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		const body = await ctx.json();
 		if (body.order !== void 0 && typeof body.order !== "number") throw errors.badJson("order must be a number");
 		const tags = await readTags(ctx.hs, s.userId, ctx.params.roomId);
 		tags[ctx.params.tag] = body;
-		await setAccountData(ctx.hs, s.userId, ctx.params.roomId, "m.tag", { tags });
+		await setAccountData(ctx.hs, s.userId, ctx.params.roomId, M.TAG, { tags });
 		return {};
-	});
-	r.client("DELETE", "/user/:userId/rooms/:roomId/tags/:tag", async (ctx) => {
+	} }));
+	r.client("DELETE", "/user/:userId/rooms/:roomId/tags/:tag", procedure({ handler: async (ctx) => {
 		const s = await checkUser(ctx);
 		const tags = await readTags(ctx.hs, s.userId, ctx.params.roomId);
 		delete tags[ctx.params.tag];
-		await setAccountData(ctx.hs, s.userId, ctx.params.roomId, "m.tag", { tags });
+		await setAccountData(ctx.hs, s.userId, ctx.params.roomId, M.TAG, { tags });
 		return {};
-	});
+	} }));
 	const formatDevice = (d) => ({
 		device_id: d.device_id,
 		display_name: d.display_name ?? void 0,
 		last_seen_ip: d.last_seen_ip ?? void 0,
 		last_seen_ts: d.last_seen_ts ?? void 0
 	});
-	r.client("GET", "/devices", async (ctx) => {
-		const s = await ctx.auth();
-		return { devices: (await ctx.hs.db.findMany("devices", { where: [{
-			field: "user_id",
-			value: s.userId
-		}] })).map(formatDevice) };
-	});
-	r.client("GET", "/devices/:deviceId", async (ctx) => {
-		const s = await ctx.auth();
-		const row = await ctx.hs.db.findOne("devices", [{
-			field: "user_id",
-			value: s.userId
-		}, {
-			field: "device_id",
-			value: ctx.params.deviceId
-		}]);
-		if (!row) throw errors.notFound("Device not found");
-		return formatDevice(row);
-	});
-	r.client("PUT", "/devices/:deviceId", async (ctx) => {
-		const s = await ctx.auth();
-		const body = await ctx.json();
-		const where = [{
-			field: "user_id",
-			value: s.userId
-		}, {
-			field: "device_id",
-			value: ctx.params.deviceId
-		}];
-		if (!await ctx.hs.db.findOne("devices", where)) throw errors.notFound("Device not found");
-		if (body.display_name !== void 0) {
-			if (typeof body.display_name !== "string") throw errors.badJson("display_name must be a string");
-			await ctx.hs.db.update("devices", where, { display_name: body.display_name });
-			await ctx.hs.keys.deviceChanged(s.userId);
+	r.client("GET", "/devices", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			return { devices: (await ctx.hs.db.findMany("devices", { where: [{
+				field: "user_id",
+				value: s.userId
+			}] })).map(formatDevice) };
 		}
-		return {};
-	});
-	r.client("DELETE", "/devices/:deviceId", async (ctx) => {
-		const s = await ctx.auth();
-		const body = await ctx.json();
-		const where = [{
-			field: "user_id",
-			value: s.userId
-		}, {
-			field: "device_id",
-			value: ctx.params.deviceId
-		}];
-		if (!await ctx.hs.db.findOne("devices", where)) throw errors.notFound("Device not found");
-		await requireUia(ctx.hs, body, [["m.login.password"]], s.userId);
-		await ctx.hs.auth.deleteDevice(s.userId, ctx.params.deviceId);
-		return {};
-	});
-	r.client("POST", "/delete_devices", { input: deleteDevicesBody }, async (ctx) => {
-		const s = await ctx.auth();
-		const body = ctx.input;
-		await requireUia(ctx.hs, body, [["m.login.password"]], s.userId);
-		for (const d of body.devices) if (typeof d === "string") await ctx.hs.auth.deleteDevice(s.userId, d);
-		return {};
-	});
-	r.client("POST", "/keys/upload", { input: body({}) }, async (ctx) => {
-		const s = await ctx.auth();
-		return { one_time_key_counts: await ctx.hs.keys.upload(s.userId, s.deviceId, ctx.input) };
-	});
-	r.client("POST", "/keys/query", { input: keysQueryBody }, async (ctx) => {
-		const s = await ctx.auth();
-		await ctx.rateLimit("keyQuery");
-		const body = ctx.input;
-		return ctx.hs.keys.query(s.userId, body.device_keys, Math.min(Number(body.timeout ?? 1e4) || 1e4, 3e4));
-	});
-	r.client("POST", "/keys/claim", { input: keysClaimBody }, async (ctx) => {
-		await ctx.auth();
-		const body = ctx.input;
-		const local = {};
-		const remote = {};
-		for (const [userId, devices] of Object.entries(body.one_time_keys)) (ctx.hs.isLocalUser(userId) ? local : remote)[userId] = devices;
-		const claimed = await ctx.hs.keys.claim(local);
-		const fed = Object.keys(remote).length ? await ctx.hs.federation.claimKeys(remote) : {
-			results: {},
-			failures: {}
-		};
-		return {
-			one_time_keys: {
-				...claimed,
-				...fed.results
-			},
-			failures: fed.failures
-		};
-	});
-	r.client("GET", "/keys/changes", async (ctx) => {
-		const s = await ctx.auth();
-		const parse = (v) => {
-			const m = /^s?(\d+)/.exec(v ?? "");
-			if (!m) throw errors.invalidParam("Invalid token");
-			return Number(m[1]);
-		};
-		return ctx.hs.keys.changesSince(s.userId, parse(ctx.query.get("from")), parse(ctx.query.get("to")));
-	});
-	r.client("POST", "/keys/device_signing/upload", { input: body({}) }, async (ctx) => {
-		const s = await ctx.auth();
-		const body = ctx.input;
-		if (await ctx.hs.db.findOne("cross_signing_keys", [{
-			field: "user_id",
-			value: s.userId
-		}, {
-			field: "key_type",
-			value: "master"
-		}])) {
-			const stored = new Map((await ctx.hs.db.findMany("cross_signing_keys", { where: [{
+	}));
+	r.client("GET", "/devices/:deviceId", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const row = await ctx.hs.db.findOne("devices", [{
 				field: "user_id",
 				value: s.userId
-			}] })).map((row) => [row.key_type, canonicalJson(row.key)]));
-			if ([
-				"master",
-				"self_signing",
-				"user_signing"
-			].filter((type) => body[`${type}_key`] !== void 0).every((type) => stored.get(type) === canonicalJson(body[`${type}_key`]))) return {};
-			await requireUia(ctx.hs, body, [["m.login.password"]], s.userId);
+			}, {
+				field: "device_id",
+				value: ctx.params.deviceId
+			}]);
+			if (!row) throw errors.notFound("Device not found");
+			return formatDevice(row);
 		}
-		await ctx.hs.keys.uploadCrossSigning(s.userId, body);
-		return {};
-	});
-	r.client("POST", "/keys/signatures/upload", { input: body({}) }, async (ctx) => {
-		const s = await ctx.auth();
-		return ctx.hs.keys.uploadSignatures(s.userId, ctx.input);
-	});
-	r.client("PUT", "/sendToDevice/:eventType/:txnId", async (ctx) => {
-		const s = await ctx.auth();
-		const hs = ctx.hs;
-		const body = await ctx.json();
-		if (!isObject(body.messages)) throw errors.badJson("messages must be an object");
-		const txnKey = `${s.userId}|${s.deviceId}|${ctx.params.txnId}`;
-		if (!await hs.cluster.setIfAbsent(`todevice-txn:${txnKey}`, true, 864e5)) return {};
-		const recipients = /* @__PURE__ */ new Set();
-		for (const [userId, devices] of Object.entries(body.messages)) {
-			if (!isObject(devices) || !hs.isLocalUser(userId)) continue;
-			let targets = Object.keys(devices);
-			if (targets.includes("*")) targets = (await hs.db.findMany("devices", { where: [{
+	}));
+	r.client("PUT", "/devices/:deviceId", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const body = await ctx.json();
+			const where = [{
 				field: "user_id",
-				value: userId
-			}] })).map((d) => d.device_id);
-			for (const deviceId of targets) {
-				const content = devices[deviceId] ?? devices["*"];
-				await hs.streams.write((stream) => hs.db.create("to_device", {
-					stream,
-					user_id: userId,
-					device_id: deviceId,
-					sender: s.userId,
-					type: ctx.params.eventType,
-					content
-				}));
+				value: s.userId
+			}, {
+				field: "device_id",
+				value: ctx.params.deviceId
+			}];
+			if (!await ctx.hs.db.findOne("devices", where)) throw errors.notFound("Device not found");
+			if (body.display_name !== void 0) {
+				if (typeof body.display_name !== "string") throw errors.badJson("display_name must be a string");
+				await ctx.hs.db.update("devices", where, { display_name: body.display_name });
+				await ctx.hs.keys.deviceChanged(s.userId);
 			}
-			recipients.add(userId);
+			return {};
 		}
-		hs.notifier.notify(recipients);
-		await hs.federation.sendToDevice(s.userId, ctx.params.eventType, body.messages, `${s.deviceId}-${ctx.params.txnId}`);
-		return {};
-	});
+	}));
+	r.client("DELETE", "/devices/:deviceId", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const body = await ctx.json();
+			const where = [{
+				field: "user_id",
+				value: s.userId
+			}, {
+				field: "device_id",
+				value: ctx.params.deviceId
+			}];
+			if (!await ctx.hs.db.findOne("devices", where)) throw errors.notFound("Device not found");
+			await requireUia(ctx.hs, body, [[M.LOGIN.PASSWORD]], s.userId);
+			await ctx.hs.auth.deleteDevice(s.userId, ctx.params.deviceId);
+			return {};
+		}
+	}));
+	r.client("POST", "/delete_devices", procedure({
+		auth: "user",
+		input: deleteDevicesBody,
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const body = ctx.input;
+			await requireUia(ctx.hs, body, [[M.LOGIN.PASSWORD]], s.userId);
+			for (const d of body.devices) if (typeof d === "string") await ctx.hs.auth.deleteDevice(s.userId, d);
+			return {};
+		}
+	}));
+	r.client("POST", "/keys/upload", procedure({
+		auth: "user",
+		input: body({}),
+		handler: async (ctx) => {
+			const s = ctx.session;
+			return { one_time_key_counts: await ctx.hs.keys.upload(s.userId, s.deviceId, ctx.input) };
+		}
+	}));
+	r.client("POST", "/keys/query", procedure({
+		auth: "user",
+		rateLimit: "keyQuery",
+		input: keysQueryBody,
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const body = ctx.input;
+			return ctx.hs.keys.query(s.userId, body.device_keys, Math.min(Number(body.timeout ?? 1e4) || 1e4, 3e4));
+		}
+	}));
+	r.client("POST", "/keys/claim", procedure({
+		auth: "user",
+		input: keysClaimBody,
+		handler: async (ctx) => {
+			const body = ctx.input;
+			const local = {};
+			const remote = {};
+			for (const [userId, devices] of Object.entries(body.one_time_keys)) (ctx.hs.isLocalUser(userId) ? local : remote)[userId] = devices;
+			const claimed = await ctx.hs.keys.claim(local);
+			const fed = Object.keys(remote).length ? await ctx.hs.federation.claimKeys(remote) : {
+				results: {},
+				failures: {}
+			};
+			return {
+				one_time_keys: {
+					...claimed,
+					...fed.results
+				},
+				failures: fed.failures
+			};
+		}
+	}));
+	r.client("GET", "/keys/changes", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const parse = (v) => {
+				const m = /^s?(\d+)/.exec(v ?? "");
+				if (!m) throw errors.invalidParam("Invalid token");
+				return Number(m[1]);
+			};
+			return ctx.hs.keys.changesSince(s.userId, parse(ctx.query.get("from")), parse(ctx.query.get("to")));
+		}
+	}));
+	r.client("POST", "/keys/device_signing/upload", procedure({
+		auth: "user",
+		input: body({}),
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const body = ctx.input;
+			if (await ctx.hs.db.findOne("cross_signing_keys", [{
+				field: "user_id",
+				value: s.userId
+			}, {
+				field: "key_type",
+				value: "master"
+			}])) {
+				const stored = new Map((await ctx.hs.db.findMany("cross_signing_keys", { where: [{
+					field: "user_id",
+					value: s.userId
+				}] })).map((row) => [row.key_type, canonicalJson(row.key)]));
+				if ([
+					"master",
+					"self_signing",
+					"user_signing"
+				].filter((type) => body[`${type}_key`] !== void 0).every((type) => stored.get(type) === canonicalJson(body[`${type}_key`]))) return {};
+				await requireUia(ctx.hs, body, [[M.LOGIN.PASSWORD]], s.userId);
+			}
+			await ctx.hs.keys.uploadCrossSigning(s.userId, body);
+			return {};
+		}
+	}));
+	r.client("POST", "/keys/signatures/upload", procedure({
+		auth: "user",
+		input: body({}),
+		handler: async (ctx) => {
+			const s = ctx.session;
+			return ctx.hs.keys.uploadSignatures(s.userId, ctx.input);
+		}
+	}));
+	r.client("PUT", "/sendToDevice/:eventType/:txnId", procedure({
+		auth: "user",
+		handler: async (ctx) => {
+			const s = ctx.session;
+			const hs = ctx.hs;
+			const body = await ctx.json();
+			if (!isObject(body.messages)) throw errors.badJson("messages must be an object");
+			const txnKey = `${s.userId}|${s.deviceId}|${ctx.params.txnId}`;
+			if (!await hs.cluster.setIfAbsent(`todevice-txn:${txnKey}`, true, 864e5)) return {};
+			const recipients = /* @__PURE__ */ new Set();
+			for (const [userId, devices] of Object.entries(body.messages)) {
+				if (!isObject(devices) || !hs.isLocalUser(userId)) continue;
+				let targets = Object.keys(devices);
+				if (targets.includes("*")) targets = (await hs.db.findMany("devices", { where: [{
+					field: "user_id",
+					value: userId
+				}] })).map((d) => d.device_id);
+				for (const deviceId of targets) {
+					const content = devices[deviceId] ?? devices["*"];
+					await hs.streams.write((stream) => hs.db.create("to_device", {
+						stream,
+						user_id: userId,
+						device_id: deviceId,
+						sender: s.userId,
+						type: ctx.params.eventType,
+						content
+					}));
+				}
+				recipients.add(userId);
+			}
+			hs.notifier.notify(recipients);
+			await hs.federation.sendToDevice(s.userId, ctx.params.eventType, body.messages, `${s.deviceId}-${ctx.params.txnId}`);
+			return {};
+		}
+	}));
 }
 //#endregion
 export { registerUserRoutes };

package/dist/core/admin.d.ts

@@ -1,6 +1,5 @@
 import { Row } from "../storage/types.js";
 import { Homeserver } from "../homeserver.js";
-import "../index.js";
 //#region src/core/admin.d.ts
 export interface ServerNoticesOptions {
   /** Localpart of the user that sends server notices. Default: "server". */

package/dist/core/admin.js

@@ -1,4 +1,5 @@
 import { randomString } from "./crypto.js";
+import { M } from "./m.js";
 import { errors } from "./errors.js";
 import { LOCALPART_RE, isValidUserId } from "./ids.js";
 import { createUser } from "../api/account.js";
@@ -259,7 +260,7 @@ var AdminService = class {
 		const membership = await this.hs.rooms.membership(roomId, userId);
 		if (membership !== "join" && membership !== "invite") await this.hs.rooms.invite(roomId, noticeUser, userId);
 		const eventId = await this.hs.rooms.sendEvent(roomId, noticeUser, {
-			type: opts.type ?? "m.room.message",
+			type: opts.type ?? M.ROOM.MESSAGE,
 			content
 		});
 		if (txnKey) await this.hs.cluster.set(txnKey, eventId, 864e5);
@@ -282,9 +283,9 @@ var AdminService = class {
 			},
 			{
 				field: "type",
-				value: "m.tag"
+				value: M.TAG
 			}
-		]))?.content?.tags?.["m.server_notice"]) return room.room_id;
+		]))?.content?.tags?.[M.SERVER_NOTICE]) return room.room_id;
 		const { room_id } = await this.hs.rooms.createRoom(noticeUser, {
 			preset: "private_chat",
 			name: this.hs.config.serverNotices.roomName,
@@ -296,8 +297,8 @@ var AdminService = class {
 		await this.hs.streams.write((stream) => this.hs.db.upsert("account_data", {
 			user_id: userId,
 			room_id,
-			type: "m.tag",
-			content: { tags: { "m.server_notice": { order: .5 } } },
+			type: M.TAG,
+			content: { tags: { [M.SERVER_NOTICE]: { order: .5 } } },
 			stream
 		}));
 		return room_id;

package/dist/core/adminroom.js

@@ -1,4 +1,5 @@
 import { randomString } from "./crypto.js";
+import { M, UNSTABLE } from "./m.js";
 import { MatrixError } from "./errors.js";
 import { isValidRoomId, isValidUserId } from "./ids.js";
 import { createUser } from "../api/account.js";
@@ -93,7 +94,7 @@ var AdminRoomService = class {
 					ban: 100
 				},
 				initial_state: [{
-					type: "m.room.history_visibility",
+					type: M.ROOM.HISTORY_VISIBILITY,
 					state_key: "",
 					content: { history_visibility: "joined" }
 				}]
@@ -144,23 +145,23 @@ var AdminRoomService = class {
 		if (!roomId) return;
 		const escaped = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 		const content = {
-			msgtype: "m.notice",
+			msgtype: M.NOTICE,
 			body: text,
-			format: "org.matrix.custom.html",
+			format: UNSTABLE.ORG.MATRIX.CUSTOM.HTML,
 			formatted_body: text.includes("\n") ? `<pre><code>${escaped}</code></pre>` : escaped.replace(/`([^`]+)`/g, "<code>$1</code>")
 		};
-		if (replyTo) content["m.relates_to"] = { "m.in_reply_to": { event_id: replyTo } };
+		if (replyTo) content[M.RELATES_TO] = { [M.IN_REPLY_TO]: { event_id: replyTo } };
 		await this.hs.rooms.sendEvent(roomId, this.botUserId, {
-			type: "m.room.message",
+			type: M.ROOM.MESSAGE,
 			content
 		});
 	}
 	/** Called for every new event; handles commands posted in the admin room. */
 	async onEvent(event) {
-		if (!this.options.enabled || event.type !== "m.room.message" || event.sender === this.botUserId) return;
+		if (!this.options.enabled || event.type !== M.ROOM.MESSAGE || event.sender === this.botUserId) return;
 		if (event.room_id !== await this.roomId()) return;
 		const body = typeof event.content?.body === "string" ? event.content.body.trim() : "";
-		if (!body || event.content?.msgtype === "m.notice") return;
+		if (!body || event.content?.msgtype === M.NOTICE) return;
 		if (!(await this.hs.db.findOne("users", [{
 			field: "user_id",
 			value: event.sender
@@ -418,7 +419,7 @@ var AdminRoomService = class {
 				const message = pos.slice(2).join(" ");
 				if (!message) return "Usage: notice <user> <message>";
 				await hs.admin.sendServerNotice(target, {
-					msgtype: "m.text",
+					msgtype: M.TEXT,
 					body: message
 				});
 				await hs.audit.record({

package/dist/core/appservices.d.ts

@@ -1,5 +1,6 @@
 import { PDU } from "./events.js";
 import { StateMap } from "./authrules.js";
+import { UNSTABLE } from "./m.js";
 import { Homeserver } from "../homeserver.js";
 //#region src/core/appservices.d.ts
 export interface AppServiceNamespace {
@@ -22,7 +23,7 @@ export interface AppServiceRegistration {
   rate_limited?: boolean;
   protocols?: string[];
   /** MSC2409: also push ephemeral events (typing, receipts, presence). */
-  "de.sorunome.msc2409.push_ephemeral"?: boolean;
+  [UNSTABLE.DE.SORUNOME.MSC2409.PUSH_EPHEMERAL]?: boolean;
   receive_ephemeral?: boolean;
 }
 /**

package/dist/core/appservices.js

@@ -1,3 +1,4 @@
+import { M, UNSTABLE } from "./m.js";
 import { splitStateKey, toClientEvent } from "./events.js";
 import { MatrixError, errors } from "./errors.js";
 import { readFile, readdir } from "node:fs/promises";
@@ -159,7 +160,7 @@ var AppServiceService = class {
 	async interestedInEvent(svc, pdu, state) {
 		const reg = svc.reg;
 		if (this.isInterestedUser(reg, pdu.sender)) return true;
-		if (pdu.type === "m.room.member" && typeof pdu.state_key === "string" && this.isInterestedUser(reg, pdu.state_key)) return true;
+		if (pdu.type === M.ROOM.MEMBER && typeof pdu.state_key === "string" && this.isInterestedUser(reg, pdu.state_key)) return true;
 		if (svc.rooms.some((n) => n.re.test(pdu.room_id))) return true;
 		if (svc.aliases.length) {
 			if ((await this.hs.db.findMany("room_aliases", { where: [{
@@ -169,7 +170,7 @@ var AppServiceService = class {
 		}
 		for (const [key, ev] of state) {
 			const [type, userId] = splitStateKey(key);
-			if (type === "m.room.member" && ev.content?.membership === "join" && this.isInterestedUser(reg, userId)) return true;
+			if (type === M.ROOM.MEMBER && ev.content?.membership === "join" && this.isInterestedUser(reg, userId)) return true;
 		}
 		return false;
 	}
@@ -184,7 +185,7 @@ var AppServiceService = class {
 	async onEphemeral(roomId, event, users) {
 		for (const svc of this.services) {
 			const reg = svc.reg;
-			if (!reg.url || !(reg.receive_ephemeral || reg["de.sorunome.msc2409.push_ephemeral"])) continue;
+			if (!reg.url || !(reg.receive_ephemeral || reg[UNSTABLE.DE.SORUNOME.MSC2409.PUSH_EPHEMERAL])) continue;
 			let interested = users.some((u) => this.isInterestedUser(reg, u)) || roomId !== null && svc.rooms.some((n) => n.re.test(roomId));
 			if (!interested && roomId) {
 				for (const u of await this.hs.rooms.joinedMembers(roomId)) if (this.isInterestedUser(reg, u)) {
@@ -242,7 +243,7 @@ var AppServiceService = class {
 				const ephemeral = rows.filter((r) => r.kind === "ephemeral").map((r) => r.payload);
 				if (ephemeral.length) {
 					body.ephemeral = ephemeral;
-					body["de.sorunome.msc2409.ephemeral"] = ephemeral;
+					body[UNSTABLE.DE.SORUNOME.MSC2409.EPHEMERAL] = ephemeral;
 				}
 				const txnId = String(rows[rows.length - 1].id);
 				try {

package/dist/core/audit.d.ts

@@ -1,6 +1,5 @@
 import { Row } from "../storage/types.js";
 import { Homeserver } from "../homeserver.js";
-import "../index.js";
 //#region src/core/audit.d.ts
 /** Security-relevant actions recorded in the audit log. */
 export type AuditAction = "login" | "login_failed" | "logout" | "register" | "password_change" | "deactivate" | "device_create" | "device_delete" | "token_refresh" | "room_create" | "room_delete" | "member_kick" | "member_ban" | "member_unban" | "admin_action" | "admin_command" | "registration_token_create" | "registration_token_delete" | "registration_setting" | "event_report" | "user_report" | "sso_login" | "oauth_login" | "user_lock" | "user_unlock" | "user_suspend" | "user_unsuspend";