matrix-nodejs-homeserver 0.2.0 → 0.3.1

package/dist/core/authrules.js

@@ -1,5 +1,6 @@
 import { isObject } from "./json.js";
 import { publicKeyFromBase64, verifyJsonSignature } from "./crypto.js";
+import { M } from "./m.js";
 import { roomVersionFeatures, stateKey, versionNum } from "./events.js";
 import { errors } from "./errors.js";
 import { isValidUserId } from "./ids.js";
@@ -20,10 +21,10 @@ function getState(state, type, key = "") {
 	return state.get(stateKey(type, key));
 }
 function membershipOf(state, userId) {
-	return getState(state, "m.room.member", userId)?.content?.membership ?? "leave";
+	return getState(state, M.ROOM.MEMBER, userId)?.content?.membership ?? "leave";
 }
 function roomCreator(state, roomVersion) {
-	const create = getState(state, "m.room.create");
+	const create = getState(state, M.ROOM.CREATE);
 	if (!create) return void 0;
 	return roomVersionFeatures(roomVersion).v11 ? create.sender : create.content.creator ?? create.sender;
 }
@@ -35,13 +36,13 @@ const toInt = (v, fallback) => {
 /** v12+: the create event's sender plus `additional_creators`. Empty for older versions. */
 function roomCreators(state, roomVersion) {
 	if (!roomVersionFeatures(roomVersion).v12) return /* @__PURE__ */ new Set();
-	const create = getState(state, "m.room.create");
+	const create = getState(state, M.ROOM.CREATE);
 	if (!create) return /* @__PURE__ */ new Set();
 	const extra = Array.isArray(create.content?.additional_creators) ? create.content.additional_creators : [];
 	return /* @__PURE__ */ new Set([create.sender, ...extra.filter((u) => typeof u === "string")]);
 }
 function powerLevels(state, roomVersion) {
-	const pl = getState(state, "m.room.power_levels")?.content;
+	const pl = getState(state, M.ROOM.POWER_LEVELS)?.content;
 	const creators = roomCreators(state, roomVersion);
 	if (!pl) {
 		const creator = roomCreator(state, roomVersion);
@@ -90,21 +91,21 @@ const sameDomain = (a, b) => a.slice(a.indexOf(":") + 1) === b.slice(b.indexOf("
 const domainOf = (id) => id.slice(id.indexOf(":") + 1);
 /** The (type, state_key) pairs an event's auth_events may reference (spec "auth events selection"). */
 function authEventKeys(event, roomVersion) {
-	if (event.type === "m.room.create") return [];
-	const keys = [stateKey("m.room.power_levels", ""), stateKey("m.room.member", event.sender)];
-	if (!roomVersionFeatures(roomVersion).v12) keys.unshift(stateKey("m.room.create", ""));
-	if (event.type === "m.room.member" && typeof event.state_key === "string") {
-		keys.push(stateKey("m.room.member", event.state_key));
+	if (event.type === M.ROOM.CREATE) return [];
+	const keys = [stateKey(M.ROOM.POWER_LEVELS, ""), stateKey(M.ROOM.MEMBER, event.sender)];
+	if (!roomVersionFeatures(roomVersion).v12) keys.unshift(stateKey(M.ROOM.CREATE, ""));
+	if (event.type === M.ROOM.MEMBER && typeof event.state_key === "string") {
+		keys.push(stateKey(M.ROOM.MEMBER, event.state_key));
 		const membership = event.content?.membership;
 		if ([
 			"join",
 			"invite",
 			"knock"
-		].includes(membership)) keys.push(stateKey("m.room.join_rules", ""));
+		].includes(membership)) keys.push(stateKey(M.ROOM.JOIN_RULES, ""));
 		const token = event.content?.third_party_invite?.signed?.token;
-		if (membership === "invite" && typeof token === "string") keys.push(stateKey("m.room.third_party_invite", token));
+		if (membership === "invite" && typeof token === "string") keys.push(stateKey(M.ROOM.THIRD_PARTY_INVITE, token));
 		const via = event.content?.join_authorised_via_users_server;
-		if (membership === "join" && typeof via === "string" && roomVersionFeatures(roomVersion).restricted) keys.push(stateKey("m.room.member", via));
+		if (membership === "join" && typeof via === "string" && roomVersionFeatures(roomVersion).restricted) keys.push(stateKey(M.ROOM.MEMBER, via));
 	}
 	return [...new Set(keys)];
 }
@@ -121,10 +122,10 @@ function authStateFromAuthEvents(event, authEvents, roomVersion, createEvent) {
 		const key = stateKey(ev.type, ev.state_key);
 		if (state.has(key)) throw errors.forbidden("Duplicate auth event");
 		if (!allowed.has(key)) throw errors.forbidden(`Unexpected auth event ${ev.type}`);
-		if (roomVersionFeatures(roomVersion).v12 && ev.type === "m.room.create") throw errors.forbidden("Create event must not be in auth_events");
+		if (roomVersionFeatures(roomVersion).v12 && ev.type === M.ROOM.CREATE) throw errors.forbidden("Create event must not be in auth_events");
 		state.set(key, ev);
 	}
-	if (createEvent) state.set(stateKey("m.room.create", ""), createEvent);
+	if (createEvent) state.set(stateKey(M.ROOM.CREATE, ""), createEvent);
 	return state;
 }
 /**
@@ -137,7 +138,7 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 	const deny = (msg) => {
 		throw errors.forbidden(msg);
 	};
-	if (event.type === "m.room.create") {
+	if (event.type === M.ROOM.CREATE) {
 		if (state.size > 0 || Array.isArray(event.prev_events) && event.prev_events.length > 0) deny("Create event must be the first event");
 		if (!features.v12 && event.room_id && !sameDomain(event.room_id, event.sender)) deny("Room ID domain must match the creator");
 		const rv = event.content?.room_version;
@@ -149,10 +150,10 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 		}
 		return;
 	}
-	const create = getState(state, "m.room.create");
+	const create = getState(state, M.ROOM.CREATE);
 	if (!create) deny("No create event in room");
-	if (create.content?.["m.federate"] === false && !sameDomain(event.sender, create.sender)) deny("Room is not federated");
-	if (n <= 5 && event.type === "m.room.aliases") {
+	if (create.content?.[M.FEDERATE] === false && !sameDomain(event.sender, create.sender)) deny("Room is not federated");
+	if (n <= 5 && event.type === M.ROOM.ALIASES) {
 		if (event.state_key === void 0) deny("Aliases event lacks a state key");
 		if (event.state_key !== domainOf(event.sender)) deny("Aliases state key must be the sender's domain");
 		return;
@@ -160,12 +161,12 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 	const pl = powerLevels(state, roomVersion);
 	const senderMembership = membershipOf(state, event.sender);
 	const senderLevel = userLevel(pl, event.sender);
-	if (event.type === "m.room.member") {
+	if (event.type === M.ROOM.MEMBER) {
 		const target = event.state_key;
 		const membership = event.content?.membership;
 		if (typeof target !== "string" || typeof membership !== "string") deny("Member event lacks state_key or membership");
 		const targetMembership = membershipOf(state, target);
-		const joinRule = getState(state, "m.room.join_rules")?.content?.join_rule ?? "invite";
+		const joinRule = getState(state, M.ROOM.JOIN_RULES)?.content?.join_rule ?? "invite";
 		const via = event.content?.join_authorised_via_users_server;
 		switch (membership) {
 			case "join": {
@@ -226,7 +227,7 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 		return;
 	}
 	if (senderMembership !== "join") deny("You are not joined to this room");
-	if (event.type === "m.room.third_party_invite") {
+	if (event.type === M.ROOM.THIRD_PARTY_INVITE) {
 		if (senderLevel >= pl.invite) return;
 		deny("Insufficient power level to invite");
 	}
@@ -238,16 +239,16 @@ function checkAuth(event, state, roomVersion, opts = {}) {
 		if (!owner) deny("Malformed user-owned state key");
 		if (owner !== event.sender && senderLevel <= userLevel(pl, owner)) deny("This state key belongs to another user");
 	}
-	if (event.type === "m.room.power_levels" && isState) {
+	if (event.type === M.ROOM.POWER_LEVELS && isState) {
 		if (isObject(event.content?.users)) for (const u of Object.keys(event.content.users)) {
 			if (!isValidUserId(u)) deny("Power level users must be valid user IDs");
 			if (pl.creators.has(u)) deny("Room creators cannot be given a power level");
 		}
-		if (getState(state, "m.room.power_levels")) checkPowerLevelChange(event, pl, senderLevel, features.integerPowerLevels, n >= 6, deny);
+		if (getState(state, M.ROOM.POWER_LEVELS)) checkPowerLevelChange(event, pl, senderLevel, features.integerPowerLevels, n >= 6, deny);
 		else checkPowerLevelShape(event, features.integerPowerLevels, deny);
 		return;
 	}
-	if (n <= 2 && event.type === "m.room.redaction") {
+	if (n <= 2 && event.type === M.ROOM.REDACTION) {
 		if (senderLevel >= pl.redact) return;
 		const redacts = event.redacts;
 		if (typeof redacts === "string" && redacts.includes(":") && domainOf(redacts) === domainOf(event.sender)) return;
@@ -258,7 +259,7 @@ function checkThirdPartyInvite(event, state) {
 	const signed = event.content?.third_party_invite?.signed;
 	if (!isObject(signed) || typeof signed.mxid !== "string" || typeof signed.token !== "string") return false;
 	if (signed.mxid !== event.state_key) return false;
-	const invite = getState(state, "m.room.third_party_invite", signed.token);
+	const invite = getState(state, M.ROOM.THIRD_PARTY_INVITE, signed.token);
 	if (!invite || invite.sender !== event.sender) return false;
 	const keys = [];
 	if (typeof invite.content?.public_key === "string") keys.push(invite.content.public_key);

package/dist/core/delayed.js

@@ -1,4 +1,5 @@
 import { randomString } from "./crypto.js";
+import { UNSTABLE } from "./m.js";
 import { MatrixError, errors } from "./errors.js";
 //#region src/core/delayed.ts
 /**
@@ -27,7 +28,7 @@ var DelayedEventService = class {
 	}
 	async schedule(opts) {
 		if (!Number.isInteger(opts.delayMs) || opts.delayMs < 0) throw errors.invalidParam("Invalid delay");
-		if (opts.delayMs > this.maxDelayMs) throw new MatrixError(400, "M_MAX_DELAY_EXCEEDED", "Delay is too long", { "org.matrix.msc4140.max_delay": this.maxDelayMs });
+		if (opts.delayMs > this.maxDelayMs) throw new MatrixError(400, "M_MAX_DELAY_EXCEEDED", "Delay is too long", { [UNSTABLE.ORG.MATRIX.MSC4140.MAX_DELAY]: this.maxDelayMs });
 		const txnKey = opts.txnId ? `${opts.userId}|${opts.deviceId}|${opts.roomId}|${opts.txnId}` : null;
 		if (txnKey) {
 			const existing = await this.hs.db.findOne("delayed_events", [{

package/dist/core/events.js

@@ -1,5 +1,6 @@
 import { canonicalJson, isObject } from "./json.js";
 import { randomString, sha256, signJson, unpaddedBase64, urlSafeBase64 } from "./crypto.js";
+import { M } from "./m.js";
 //#region src/core/events.ts
 const STABLE_ROOM_VERSIONS = [
 	"1",
@@ -76,7 +77,7 @@ function redact(event, roomVersion) {
 	const keep = n >= 11 ? KEEP_TOP_LEVEL : [...KEEP_TOP_LEVEL, ...KEEP_TOP_LEVEL_LEGACY];
 	const out = {};
 	for (const k of keep) if (k in event) out[k] = event[k];
-	const keepRelation = roomVersion.startsWith("org.matrix.msc3389.") && isObject(event.content?.["m.relates_to"]) ? event.content["m.relates_to"] : void 0;
+	const keepRelation = roomVersion.startsWith("org.matrix.msc3389.") && isObject(event.content?.[M.RELATES_TO]) ? event.content[M.RELATES_TO] : void 0;
 	const content = isObject(event.content) ? event.content : {};
 	const pick = (...keys) => {
 		const c = {};
@@ -84,28 +85,28 @@ function redact(event, roomVersion) {
 		return c;
 	};
 	switch (event.type) {
-		case "m.room.member": {
+		case M.ROOM.MEMBER: {
 			const c = pick("membership", ...n >= 9 ? ["join_authorised_via_users_server"] : []);
 			if (n >= 11 && isObject(content.third_party_invite) && "signed" in content.third_party_invite) c.third_party_invite = { signed: content.third_party_invite.signed };
 			out.content = c;
 			break;
 		}
-		case "m.room.create":
+		case M.ROOM.CREATE:
 			out.content = n >= 11 ? { ...content } : pick("creator");
 			break;
-		case "m.room.join_rules":
+		case M.ROOM.JOIN_RULES:
 			out.content = pick("join_rule", ...n >= 8 ? ["allow"] : []);
 			break;
-		case "m.room.power_levels":
+		case M.ROOM.POWER_LEVELS:
 			out.content = pick("ban", "events", "events_default", "kick", "redact", "state_default", "users", "users_default", ...n >= 11 ? ["invite"] : []);
 			break;
-		case "m.room.history_visibility":
+		case M.ROOM.HISTORY_VISIBILITY:
 			out.content = pick("history_visibility");
 			break;
-		case "m.room.aliases":
+		case M.ROOM.ALIASES:
 			out.content = n <= 5 ? pick("aliases") : {};
 			break;
-		case "m.room.redaction":
+		case M.ROOM.REDACTION:
 			out.content = n >= 11 ? pick("redacts") : {};
 			break;
 		default: out.content = {};
@@ -116,7 +117,7 @@ function redact(event, roomVersion) {
 		if ("event_id" in keepRelation) rel.event_id = keepRelation.event_id;
 		out.content = {
 			...out.content,
-			"m.relates_to": rel
+			[M.RELATES_TO]: rel
 		};
 	}
 	return out;
@@ -161,7 +162,7 @@ function toClientEvent(pdu, opts = {}) {
 	if (opts.includeRoomId !== false) ev.room_id = pdu.room_id;
 	if (pdu.state_key !== void 0) ev.state_key = pdu.state_key;
 	if (pdu.redacts !== void 0) ev.redacts = pdu.redacts;
-	else if (pdu.type === "m.room.redaction" && typeof pdu.content?.redacts === "string") ev.redacts = pdu.content.redacts;
+	else if (pdu.type === M.ROOM.REDACTION && typeof pdu.content?.redacts === "string") ev.redacts = pdu.content.redacts;
 	ev.unsigned = {
 		...pdu.unsigned,
 		age: Math.max(0, Date.now() - pdu.origin_server_ts)

package/dist/core/invitefilter.js

@@ -1,7 +1,8 @@
 import { isObject } from "./json.js";
+import { UNSTABLE } from "./m.js";
 import { globMatch } from "./glob.js";
 //#region src/core/invitefilter.ts
-const INVITE_CONFIG_TYPE = "org.matrix.msc4155.invite_permission_config";
+const INVITE_CONFIG_TYPE = UNSTABLE.ORG.MATRIX.MSC4155.INVITE_PERMISSION_CONFIG;
 /**
 * MSC4155 invite filtering: "allow", "ignore" (accept but hide) or "block" (refuse).
 * User rules take precedence over server rules; within each, allow > ignore > block.

package/dist/core/keys.js

@@ -1,4 +1,5 @@
 import { isObject } from "./json.js";
+import { UNSTABLE } from "./m.js";
 import { errors } from "./errors.js";
 //#region src/core/keys.ts
 /** End-to-end encryption key storage (device keys, one-time keys, cross-signing). */
@@ -78,7 +79,7 @@ var KeyService = class {
 				seq
 			}));
 		}
-		const fallbackKeys = body.fallback_keys ?? body["org.matrix.msc2732.fallback_keys"];
+		const fallbackKeys = body.fallback_keys ?? body[UNSTABLE.ORG.MATRIX.MSC2732.FALLBACK_KEYS];
 		if (isObject(fallbackKeys)) for (const [fullId, key] of Object.entries(fallbackKeys)) {
 			const [algorithm] = fullId.split(":");
 			const existing = await this.hs.db.findOne("fallback_keys", [...device, {

package/dist/core/m.d.ts

@@ -0,0 +1,209 @@
+//#region src/core/m.d.ts
+export declare const M: {
+  readonly BEACON_INFO: "m.beacon_info";
+  readonly CALL: {
+    readonly INVITE: "m.call.invite";
+  };
+  readonly CHANGE_PASSWORD: "m.change_password";
+  readonly DEVICE_LIST_UPDATE: "m.device_list_update";
+  readonly DIRECT: "m.direct";
+  readonly DIRECT_TO_DEVICE: "m.direct_to_device";
+  readonly FEDERATE: "m.federate";
+  readonly FULLY_READ: "m.fully_read";
+  readonly GET_LOGIN_TOKEN: "m.get_login_token";
+  readonly HEROES: "m.heroes";
+  readonly HOMESERVER: "m.homeserver";
+  readonly ID: {
+    readonly PHONE: "m.id.phone";
+    readonly THIRDPARTY: "m.id.thirdparty";
+    readonly USER: "m.id.user";
+  };
+  readonly IGNORED_USER_LIST: "m.ignored_user_list";
+  readonly IN_REPLY_TO: "m.in_reply_to";
+  readonly INVITED_MEMBER_COUNT: "m.invited_member_count";
+  readonly JOINED_MEMBER_COUNT: "m.joined_member_count";
+  readonly LOGIN: {
+    readonly APPLICATION_SERVICE: "m.login.application_service";
+    readonly DUMMY: "m.login.dummy";
+    readonly EMAIL: {
+      readonly IDENTITY: "m.login.email.identity";
+    };
+    readonly MSISDN: "m.login.msisdn";
+    readonly PASSWORD: "m.login.password";
+    readonly REGISTRATION_TOKEN: "m.login.registration_token";
+    readonly SSO: "m.login.sso";
+    readonly TOKEN: "m.login.token";
+  };
+  readonly NOTICE: "m.notice";
+  readonly OAUTH: "m.oauth";
+  readonly POLL: {
+    readonly START: "m.poll.start";
+  };
+  readonly PRESENCE: "m.presence";
+  readonly PROFILE_FIELDS: "m.profile_fields";
+  readonly PUSH_RULES: "m.push_rules";
+  readonly REACTION: "m.reaction";
+  readonly READ: {
+    readonly _: "m.read";
+    readonly PRIVATE: "m.read.private";
+  };
+  readonly RECEIPT: "m.receipt";
+  readonly RELATES_TO: "m.relates_to";
+  readonly RELATIONS: "m.relations";
+  readonly RELATIONSHIP: "m.relationship";
+  readonly REPLACE: "m.replace";
+  readonly ROLE: {
+    readonly ADMIN: "m.role.admin";
+    readonly SECURITY: "m.role.security";
+  };
+  readonly ROOM: {
+    readonly ALIASES: "m.room.aliases";
+    readonly AVATAR: "m.room.avatar";
+    readonly CANONICAL_ALIAS: "m.room.canonical_alias";
+    readonly CREATE: "m.room.create";
+    readonly ENCRYPTED: "m.room.encrypted";
+    readonly ENCRYPTION: "m.room.encryption";
+    readonly GUEST_ACCESS: "m.room.guest_access";
+    readonly HISTORY_VISIBILITY: "m.room.history_visibility";
+    readonly JOIN_RULES: "m.room.join_rules";
+    readonly MEMBER: "m.room.member";
+    readonly MESSAGE: "m.room.message";
+    readonly NAME: "m.room.name";
+    readonly POLICY: "m.room.policy";
+    readonly POWER_LEVELS: "m.room.power_levels";
+    readonly REDACTION: "m.room.redaction";
+    readonly SERVER_ACL: "m.room.server_acl";
+    readonly THIRD_PARTY_INVITE: "m.room.third_party_invite";
+    readonly TOMBSTONE: "m.room.tombstone";
+    readonly TOPIC: "m.room.topic";
+  };
+  readonly ROOM_MEMBERSHIP: "m.room_membership";
+  readonly ROOM_VERSIONS: "m.room_versions";
+  readonly RULE: {
+    readonly CALL: ".m.rule.call";
+    readonly CONTAINS_DISPLAY_NAME: ".m.rule.contains_display_name";
+    readonly CONTAINS_USER_NAME: ".m.rule.contains_user_name";
+    readonly ENCRYPTED: ".m.rule.encrypted";
+    readonly ENCRYPTED_ROOM_ONE_TO_ONE: ".m.rule.encrypted_room_one_to_one";
+    readonly INVITE_FOR_ME: ".m.rule.invite_for_me";
+    readonly IS_ROOM_MENTION: ".m.rule.is_room_mention";
+    readonly IS_USER_MENTION: ".m.rule.is_user_mention";
+    readonly MASTER: ".m.rule.master";
+    readonly MEMBER_EVENT: ".m.rule.member_event";
+    readonly MESSAGE: ".m.rule.message";
+    readonly REACTION: ".m.rule.reaction";
+    readonly ROOM: {
+      readonly SERVER_ACL: ".m.rule.room.server_acl";
+    };
+    readonly ROOM_ONE_TO_ONE: ".m.rule.room_one_to_one";
+    readonly ROOMNOTIF: ".m.rule.roomnotif";
+    readonly SUPPRESS_EDITS: ".m.rule.suppress_edits";
+    readonly SUPPRESS_NOTICES: ".m.rule.suppress_notices";
+    readonly TOMBSTONE: ".m.rule.tombstone";
+  };
+  readonly SERVER: "m.server";
+  readonly SERVER_NOTICE: "m.server_notice";
+  readonly SET_AVATAR_URL: "m.set_avatar_url";
+  readonly SET_DISPLAYNAME: "m.set_displayname";
+  readonly SIGNING_KEY_UPDATE: "m.signing_key_update";
+  readonly SPACE: {
+    readonly _: "m.space";
+    readonly CHILD: "m.space.child";
+  };
+  readonly STICKER: "m.sticker";
+  readonly TAG: "m.tag";
+  readonly TEXT: "m.text";
+  readonly THREAD: "m.thread";
+  readonly THREEPID_CHANGES: "m.3pid_changes";
+  readonly TOPIC: "m.topic";
+  readonly TYPING: "m.typing";
+  readonly UPLOAD: {
+    readonly SIZE: "m.upload.size";
+  };
+};
+export declare const UNSTABLE: {
+  readonly DE: {
+    readonly SORUNOME: {
+      readonly MSC2409: {
+        readonly EPHEMERAL: "de.sorunome.msc2409.ephemeral";
+        readonly PUSH_EPHEMERAL: "de.sorunome.msc2409.push_ephemeral";
+      };
+    };
+  };
+  readonly IO: {
+    readonly ELEMENT: {
+      readonly MSC4306: {
+        readonly RULE: {
+          readonly SUBSCRIBED_THREAD: ".io.element.msc4306.rule.subscribed_thread";
+          readonly UNSUBSCRIBED_THREAD: ".io.element.msc4306.rule.unsubscribed_thread";
+        };
+        readonly THREAD_SUBSCRIPTION: "io.element.msc4306.thread_subscription";
+      };
+      readonly MSC4308: {
+        readonly THREAD_SUBSCRIPTIONS: "io.element.msc4308.thread_subscriptions";
+      };
+    };
+  };
+  readonly ORG: {
+    readonly MATRIX: {
+      readonly CROSS_SIGNING_RESET: "org.matrix.cross_signing_reset";
+      readonly CUSTOM: {
+        readonly HTML: "org.matrix.custom.html";
+      };
+      readonly MSC2732: {
+        readonly FALLBACK_KEYS: "org.matrix.msc2732.fallback_keys";
+      };
+      readonly MSC3202: {
+        readonly DEVICE_ID: "org.matrix.msc3202.device_id";
+      };
+      readonly MSC3381: {
+        readonly POLL: {
+          readonly END: "org.matrix.msc3381.poll.end";
+          readonly RESPONSE: "org.matrix.msc3381.poll.response";
+          readonly START: "org.matrix.msc3381.poll.start";
+        };
+      };
+      readonly MSC3874: {
+        readonly NOT_REL_TYPES: "org.matrix.msc3874.not_rel_types";
+        readonly REL_TYPES: "org.matrix.msc3874.rel_types";
+      };
+      readonly MSC3916: {
+        readonly STABLE: "org.matrix.msc3916.stable";
+      };
+      readonly MSC3930: {
+        readonly RULE: {
+          readonly POLL_END: ".org.matrix.msc3930.rule.poll_end";
+          readonly POLL_END_ONE_TO_ONE: ".org.matrix.msc3930.rule.poll_end_one_to_one";
+          readonly POLL_RESPONSE: ".org.matrix.msc3930.rule.poll_response";
+          readonly POLL_START: ".org.matrix.msc3930.rule.poll_start";
+          readonly POLL_START_ONE_TO_ONE: ".org.matrix.msc3930.rule.poll_start_one_to_one";
+        };
+      };
+      readonly MSC4140: {
+        readonly _: "org.matrix.msc4140";
+        readonly DELAY: "org.matrix.msc4140.delay";
+        readonly MAX_DELAY: "org.matrix.msc4140.max_delay";
+      };
+      readonly MSC4143: {
+        readonly _: "org.matrix.msc4143";
+        readonly RTC_FOCI: "org.matrix.msc4143.rtc_foci";
+      };
+      readonly MSC4155: {
+        readonly ERRCODE: "org.matrix.msc4155.errcode";
+        readonly INVITE_PERMISSION_CONFIG: "org.matrix.msc4155.invite_permission_config";
+      };
+      readonly MSC4222: {
+        readonly _: "org.matrix.msc4222";
+        readonly STATE_AFTER: "org.matrix.msc4222.state_after";
+        readonly USE_STATE_AFTER: "org.matrix.msc4222.use_state_after";
+      };
+      readonly MSC4306: "org.matrix.msc4306";
+      readonly MSC4429: {
+        readonly PROFILE_FIELDS: "org.matrix.msc4429.profile_fields";
+        readonly USERS: "org.matrix.msc4429.users";
+      };
+      readonly SIMPLIFIED_MSC3575: "org.matrix.simplified_msc3575";
+    };
+  };
+};
+//#endregion

package/dist/core/m.js

@@ -0,0 +1,182 @@
+//#region src/core/m.ts
+function deepFreeze(o) {
+	for (const v of Object.values(o)) if (typeof v === "object" && v !== null) deepFreeze(v);
+	return Object.freeze(o);
+}
+const M = deepFreeze({
+	BEACON_INFO: "m.beacon_info",
+	CALL: { INVITE: "m.call.invite" },
+	CHANGE_PASSWORD: "m.change_password",
+	DEVICE_LIST_UPDATE: "m.device_list_update",
+	DIRECT: "m.direct",
+	DIRECT_TO_DEVICE: "m.direct_to_device",
+	FEDERATE: "m.federate",
+	FULLY_READ: "m.fully_read",
+	GET_LOGIN_TOKEN: "m.get_login_token",
+	HEROES: "m.heroes",
+	HOMESERVER: "m.homeserver",
+	ID: {
+		PHONE: "m.id.phone",
+		THIRDPARTY: "m.id.thirdparty",
+		USER: "m.id.user"
+	},
+	IGNORED_USER_LIST: "m.ignored_user_list",
+	IN_REPLY_TO: "m.in_reply_to",
+	INVITED_MEMBER_COUNT: "m.invited_member_count",
+	JOINED_MEMBER_COUNT: "m.joined_member_count",
+	LOGIN: {
+		APPLICATION_SERVICE: "m.login.application_service",
+		DUMMY: "m.login.dummy",
+		EMAIL: { IDENTITY: "m.login.email.identity" },
+		MSISDN: "m.login.msisdn",
+		PASSWORD: "m.login.password",
+		REGISTRATION_TOKEN: "m.login.registration_token",
+		SSO: "m.login.sso",
+		TOKEN: "m.login.token"
+	},
+	NOTICE: "m.notice",
+	OAUTH: "m.oauth",
+	POLL: { START: "m.poll.start" },
+	PRESENCE: "m.presence",
+	PROFILE_FIELDS: "m.profile_fields",
+	PUSH_RULES: "m.push_rules",
+	REACTION: "m.reaction",
+	READ: {
+		_: "m.read",
+		PRIVATE: "m.read.private"
+	},
+	RECEIPT: "m.receipt",
+	RELATES_TO: "m.relates_to",
+	RELATIONS: "m.relations",
+	RELATIONSHIP: "m.relationship",
+	REPLACE: "m.replace",
+	ROLE: {
+		ADMIN: "m.role.admin",
+		SECURITY: "m.role.security"
+	},
+	ROOM: {
+		ALIASES: "m.room.aliases",
+		AVATAR: "m.room.avatar",
+		CANONICAL_ALIAS: "m.room.canonical_alias",
+		CREATE: "m.room.create",
+		ENCRYPTED: "m.room.encrypted",
+		ENCRYPTION: "m.room.encryption",
+		GUEST_ACCESS: "m.room.guest_access",
+		HISTORY_VISIBILITY: "m.room.history_visibility",
+		JOIN_RULES: "m.room.join_rules",
+		MEMBER: "m.room.member",
+		MESSAGE: "m.room.message",
+		NAME: "m.room.name",
+		POLICY: "m.room.policy",
+		POWER_LEVELS: "m.room.power_levels",
+		REDACTION: "m.room.redaction",
+		SERVER_ACL: "m.room.server_acl",
+		THIRD_PARTY_INVITE: "m.room.third_party_invite",
+		TOMBSTONE: "m.room.tombstone",
+		TOPIC: "m.room.topic"
+	},
+	ROOM_MEMBERSHIP: "m.room_membership",
+	ROOM_VERSIONS: "m.room_versions",
+	RULE: {
+		CALL: ".m.rule.call",
+		CONTAINS_DISPLAY_NAME: ".m.rule.contains_display_name",
+		CONTAINS_USER_NAME: ".m.rule.contains_user_name",
+		ENCRYPTED: ".m.rule.encrypted",
+		ENCRYPTED_ROOM_ONE_TO_ONE: ".m.rule.encrypted_room_one_to_one",
+		INVITE_FOR_ME: ".m.rule.invite_for_me",
+		IS_ROOM_MENTION: ".m.rule.is_room_mention",
+		IS_USER_MENTION: ".m.rule.is_user_mention",
+		MASTER: ".m.rule.master",
+		MEMBER_EVENT: ".m.rule.member_event",
+		MESSAGE: ".m.rule.message",
+		REACTION: ".m.rule.reaction",
+		ROOM: { SERVER_ACL: ".m.rule.room.server_acl" },
+		ROOM_ONE_TO_ONE: ".m.rule.room_one_to_one",
+		ROOMNOTIF: ".m.rule.roomnotif",
+		SUPPRESS_EDITS: ".m.rule.suppress_edits",
+		SUPPRESS_NOTICES: ".m.rule.suppress_notices",
+		TOMBSTONE: ".m.rule.tombstone"
+	},
+	SERVER: "m.server",
+	SERVER_NOTICE: "m.server_notice",
+	SET_AVATAR_URL: "m.set_avatar_url",
+	SET_DISPLAYNAME: "m.set_displayname",
+	SIGNING_KEY_UPDATE: "m.signing_key_update",
+	SPACE: {
+		_: "m.space",
+		CHILD: "m.space.child"
+	},
+	STICKER: "m.sticker",
+	TAG: "m.tag",
+	TEXT: "m.text",
+	THREAD: "m.thread",
+	THREEPID_CHANGES: "m.3pid_changes",
+	TOPIC: "m.topic",
+	TYPING: "m.typing",
+	UPLOAD: { SIZE: "m.upload.size" }
+});
+const UNSTABLE = deepFreeze({
+	DE: { SORUNOME: { MSC2409: {
+		EPHEMERAL: "de.sorunome.msc2409.ephemeral",
+		PUSH_EPHEMERAL: "de.sorunome.msc2409.push_ephemeral"
+	} } },
+	IO: { ELEMENT: {
+		MSC4306: {
+			RULE: {
+				SUBSCRIBED_THREAD: ".io.element.msc4306.rule.subscribed_thread",
+				UNSUBSCRIBED_THREAD: ".io.element.msc4306.rule.unsubscribed_thread"
+			},
+			THREAD_SUBSCRIPTION: "io.element.msc4306.thread_subscription"
+		},
+		MSC4308: { THREAD_SUBSCRIPTIONS: "io.element.msc4308.thread_subscriptions" }
+	} },
+	ORG: { MATRIX: {
+		CROSS_SIGNING_RESET: "org.matrix.cross_signing_reset",
+		CUSTOM: { HTML: "org.matrix.custom.html" },
+		MSC2732: { FALLBACK_KEYS: "org.matrix.msc2732.fallback_keys" },
+		MSC3202: { DEVICE_ID: "org.matrix.msc3202.device_id" },
+		MSC3381: { POLL: {
+			END: "org.matrix.msc3381.poll.end",
+			RESPONSE: "org.matrix.msc3381.poll.response",
+			START: "org.matrix.msc3381.poll.start"
+		} },
+		MSC3874: {
+			NOT_REL_TYPES: "org.matrix.msc3874.not_rel_types",
+			REL_TYPES: "org.matrix.msc3874.rel_types"
+		},
+		MSC3916: { STABLE: "org.matrix.msc3916.stable" },
+		MSC3930: { RULE: {
+			POLL_END: ".org.matrix.msc3930.rule.poll_end",
+			POLL_END_ONE_TO_ONE: ".org.matrix.msc3930.rule.poll_end_one_to_one",
+			POLL_RESPONSE: ".org.matrix.msc3930.rule.poll_response",
+			POLL_START: ".org.matrix.msc3930.rule.poll_start",
+			POLL_START_ONE_TO_ONE: ".org.matrix.msc3930.rule.poll_start_one_to_one"
+		} },
+		MSC4140: {
+			_: "org.matrix.msc4140",
+			DELAY: "org.matrix.msc4140.delay",
+			MAX_DELAY: "org.matrix.msc4140.max_delay"
+		},
+		MSC4143: {
+			_: "org.matrix.msc4143",
+			RTC_FOCI: "org.matrix.msc4143.rtc_foci"
+		},
+		MSC4155: {
+			ERRCODE: "org.matrix.msc4155.errcode",
+			INVITE_PERMISSION_CONFIG: "org.matrix.msc4155.invite_permission_config"
+		},
+		MSC4222: {
+			_: "org.matrix.msc4222",
+			STATE_AFTER: "org.matrix.msc4222.state_after",
+			USE_STATE_AFTER: "org.matrix.msc4222.use_state_after"
+		},
+		MSC4306: "org.matrix.msc4306",
+		MSC4429: {
+			PROFILE_FIELDS: "org.matrix.msc4429.profile_fields",
+			USERS: "org.matrix.msc4429.users"
+		},
+		SIMPLIFIED_MSC3575: "org.matrix.simplified_msc3575"
+	} }
+});
+//#endregion
+export { M, UNSTABLE };

package/dist/core/partialstate.js

@@ -1,3 +1,4 @@
+import { M } from "./m.js";
 import { eventIdOf, roomVersionFeatures, stateKey } from "./events.js";
 import { EventEmitter } from "node:events";
 //#region src/core/partialstate.ts
@@ -162,7 +163,7 @@ var PartialStateService = class {
 			try {
 				const fullBefore = await this.hs.federation.stateFromPrevs(server, roomId, version, prevIds, { remote: true });
 				if (this.stopped || this.hs.isClosed) return true;
-				if (!fullBefore[stateKey("m.room.create", "")] && !roomVersionFeatures(version).v12) throw new Error("Resynced state lacks the create event");
+				if (!fullBefore[stateKey(M.ROOM.CREATE, "")] && !roomVersionFeatures(version).v12) throw new Error("Resynced state lacks the create event");
 				const notified = /* @__PURE__ */ new Set([...row.servers ?? [], ...this.hs.federation.serversInRoom(await this.hs.rooms.currentState(roomId), false)]);
 				const missed = await this.hs.rooms.withLock(roomId, () => this.hs.rooms.completePartialState(roomId, version, row.join_event_id, fullBefore, notified));
 				await this.finish(roomId);