matrix-nodejs-homeserver 0.2.0 → 0.3.2

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/outbound.d.ts

@@ -0,0 +1,16 @@
+import { LookupAddress, LookupOptions } from "node:dns";
+//#region src/core/outbound.d.ts
+type LookupCallback = (err: NodeJS.ErrnoException | null, address: string | LookupAddress[], family?: number) => void;
+/** Which addresses outbound requests to user- or remote-chosen destinations may connect to. */
+export interface AddressPolicy {
+  allows(address: string): boolean;
+  /**
+   * A `dns.lookup` for http(s) requests that refuses disallowed addresses. It runs when the
+   * connection is made, so the address checked is the one connected to: a name cannot resolve to
+   * a public address for a check and to a private one for the request (DNS rebinding).
+   * Undefined when every address is allowed.
+   */
+  lookup?: (hostname: string, options: LookupOptions, callback: LookupCallback) => void;
+}
+//#endregion
+export {};

package/dist/core/outbound.js

@@ -0,0 +1,172 @@
+import { errors } from "./errors.js";
+import { lookup } from "node:dns/promises";
+import { request } from "node:https";
+import { BlockList, isIP } from "node:net";
+import { lookup as lookup$1 } from "node:dns";
+import { request as request$1 } from "node:http";
+import { Readable } from "node:stream";
+//#region src/core/outbound.ts
+const privateRanges = new BlockList();
+for (const [net, prefix] of [
+	["0.0.0.0", 8],
+	["10.0.0.0", 8],
+	["100.64.0.0", 10],
+	["127.0.0.0", 8],
+	["169.254.0.0", 16],
+	["172.16.0.0", 12],
+	["192.0.0.0", 24],
+	["192.168.0.0", 16],
+	["198.18.0.0", 15],
+	["224.0.0.0", 4],
+	["240.0.0.0", 4]
+]) privateRanges.addSubnet(net, prefix, "ipv4");
+for (const [net, prefix] of [
+	["::", 128],
+	["::1", 128],
+	["fc00::", 7],
+	["fe80::", 10],
+	["ff00::", 8]
+]) privateRanges.addSubnet(net, prefix, "ipv6");
+/** Whether an IP address is loopback, private, link-local, multicast or otherwise not public. */
+function isPrivateAddress(address) {
+	const family = isIP(address);
+	return family !== 0 && privateRanges.check(address, family === 6 ? "ipv6" : "ipv4");
+}
+/** The policy for the `allowPrivateAddresses` option. */
+function addressPolicy(allowPrivate) {
+	if (allowPrivate === true) return { allows: () => true };
+	const allowed = new BlockList();
+	for (const entry of Array.isArray(allowPrivate) ? allowPrivate : []) {
+		const [address, prefix] = entry.split("/");
+		const family = isIP(address);
+		if (family === 0) throw new Error(`allowPrivateAddresses: not an IP address or range: ${entry}`);
+		allowed.addSubnet(address, prefix === void 0 ? family === 6 ? 128 : 32 : Number(prefix), family === 6 ? "ipv6" : "ipv4");
+	}
+	const allows = (address) => !isPrivateAddress(address) || allowed.check(address, isIP(address) === 6 ? "ipv6" : "ipv4");
+	return {
+		allows,
+		lookup: (hostname, options, callback) => {
+			lookup$1(hostname, {
+				...options,
+				all: true
+			}, (err, addresses) => {
+				if (err) return callback(err, []);
+				if (addresses.length === 0 || !addresses.every((a) => allows(a.address))) return callback(privateAddressError(hostname), []);
+				if (options.all) callback(null, addresses);
+				else callback(null, addresses[0].address, addresses[0].family);
+			});
+		}
+	};
+}
+function privateAddressError(host) {
+	return Object.assign(/* @__PURE__ */ new Error(`${host} resolves to a private address`), { code: "EPRIVATE" });
+}
+/** Refuse an IP literal the policy does not allow (literals are connected to without a lookup). */
+function checkLiteral(policy, host) {
+	const literal = host.replace(/^\[|\]$/g, "");
+	if (isIP(literal) && !policy.allows(literal)) throw errors.forbidden("Address is private");
+}
+/**
+* A `fetch` for user- or remote-chosen URLs that connects only to addresses `policy` allows.
+* Redirects are never followed: callers that follow them send the next request through this
+* function again, so each target is checked. Only http(s) URLs are accepted.
+*
+* With a custom `fetch` (the `fetch` option, e.g. for a proxy), the host is resolved and checked
+* before the request instead. That leaves the DNS-rebinding window open; the custom client is the
+* operator's to secure.
+*/
+function policyFetch(policy, custom) {
+	return async (input, init = {}) => {
+		const url = new URL(input instanceof Request ? input.url : String(input));
+		if (url.protocol !== "http:" && url.protocol !== "https:") throw errors.forbidden("Only http and https URLs can be fetched");
+		checkLiteral(policy, url.hostname);
+		if (custom) {
+			if (policy.lookup && !isIP(url.hostname.replace(/^\[|\]$/g, ""))) {
+				if (!(await lookup(url.hostname, { all: true })).every((a) => policy.allows(a.address))) throw errors.forbidden("Address is private");
+			}
+			return custom(input, {
+				...init,
+				redirect: "manual"
+			});
+		}
+		return nodeFetch(url, init, policy);
+	};
+}
+const NULL_BODY = /* @__PURE__ */ new Set([
+	101,
+	103,
+	204,
+	205,
+	304
+]);
+function nodeFetch(url, init, policy) {
+	const method = (init.method ?? "GET").toUpperCase();
+	const headers = new Headers(init.headers);
+	const body = init.body === void 0 || init.body === null ? void 0 : typeof init.body === "string" || init.body instanceof URLSearchParams ? Buffer.from(String(init.body)) : Buffer.from(init.body);
+	if (body && init.body instanceof URLSearchParams && !headers.has("content-type")) headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+	const request$2 = url.protocol === "https:" ? request : request$1;
+	return new Promise((resolve, reject) => {
+		const req = request$2(url, {
+			method,
+			headers: Object.fromEntries(headers),
+			lookup: policy.lookup,
+			signal: init.signal ?? void 0
+		}, (res) => {
+			const out = new Headers();
+			for (let i = 0; i < res.rawHeaders.length; i += 2) out.append(res.rawHeaders[i], res.rawHeaders[i + 1]);
+			const status = res.statusCode ?? 502;
+			const nullBody = NULL_BODY.has(status) || method === "HEAD";
+			if (nullBody) res.resume();
+			resolve(new Response(nullBody ? null : Readable.toWeb(res), {
+				status,
+				statusText: res.statusMessage,
+				headers: out
+			}));
+		});
+		req.on("error", (err) => reject(err.code === "EPRIVATE" ? errors.forbidden("Address is private") : err));
+		req.end(body);
+	});
+}
+/** GET a URL through a `policyFetch`, following redirects (each one checked again) and capping the body. */
+async function publicGet(fetchFn, rawUrl, options) {
+	let url = new URL(rawUrl);
+	const signal = AbortSignal.timeout(options.timeoutMs ?? 3e4);
+	for (let redirects = 0;; redirects++) {
+		const res = await fetchFn(url, {
+			redirect: "manual",
+			signal,
+			headers: options.headers
+		});
+		const location = res.headers.get("location");
+		if (res.status >= 300 && res.status < 400 && location) {
+			await res.body?.cancel();
+			if (redirects >= (options.maxRedirects ?? 5)) throw errors.notFound("Too many redirects");
+			url = new URL(location, url);
+			continue;
+		}
+		if (Number(res.headers.get("content-length")) > options.maxBytes && !options.truncate) {
+			await res.body?.cancel();
+			throw errors.tooLarge("Remote response is too large");
+		}
+		const chunks = [];
+		let size = 0;
+		for await (const chunk of res.body ?? []) {
+			size += chunk.length;
+			if (size > options.maxBytes) {
+				await res.body?.cancel().catch(() => {});
+				if (!options.truncate) throw errors.tooLarge("Remote response is too large");
+				chunks.push(chunk.subarray(0, chunk.length - (size - options.maxBytes)));
+				break;
+			}
+			chunks.push(chunk);
+		}
+		return {
+			status: res.status,
+			headers: res.headers,
+			body: Buffer.concat(chunks),
+			url
+		};
+	}
+}
+//#endregion
+export { addressPolicy, checkLiteral, isPrivateAddress, policyFetch, publicGet };

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);

package/dist/core/policy.js

@@ -1,4 +1,5 @@
 import { publicKeyFromBase64, verifyJsonSignature } from "./crypto.js";
+import { M } from "./m.js";
 import { redact } from "./events.js";
 import { MatrixError } from "./errors.js";
 import { getState } from "./authrules.js";
@@ -13,7 +14,7 @@ var PolicyServers = class {
 	/** The room's policy server, if the room uses one (valid `m.room.policy` and a joined user on `via`). */
 	async policyOf(roomId) {
 		const state = await this.hs.rooms.currentState(roomId);
-		const content = getState(state, "m.room.policy", "")?.content;
+		const content = getState(state, M.ROOM.POLICY, "")?.content;
 		const via = content?.via;
 		const ed25519 = content?.public_keys?.ed25519;
 		if (typeof via !== "string" || typeof ed25519 !== "string") return null;
@@ -23,7 +24,7 @@ var PolicyServers = class {
 		} catch {
 			return null;
 		}
-		for (const ev of state.values()) if (ev.type === "m.room.member" && ev.content?.membership === "join" && typeof ev.state_key === "string" && domainOf(ev.state_key) === via) return {
+		for (const ev of state.values()) if (ev.type === M.ROOM.MEMBER && ev.content?.membership === "join" && typeof ev.state_key === "string" && domainOf(ev.state_key) === via) return {
 			via,
 			key
 		};
@@ -31,7 +32,7 @@ var PolicyServers = class {
 	}
 	/** The policy state event itself is never sent to the policy server. */
 	exempt(pdu) {
-		return pdu.type === "m.room.policy" && pdu.state_key === "";
+		return pdu.type === M.ROOM.POLICY && pdu.state_key === "";
 	}
 	validSignature(pdu, version, policy) {
 		const wire = this.hs.federation.toFederationPdu(pdu, version);

package/dist/core/push.d.ts

@@ -1,7 +1,6 @@
 import { ClientEvent } from "./events.js";
 import { StateMap } from "./authrules.js";
 import { StoredEvent } from "./rooms.js";
-import "./pushrules.js";
 import { Homeserver } from "../homeserver.js";
 //#region src/core/push.d.ts
 /**