@openclaw/matrix 2026.9.6 → 2026.9.8

package/dist/.setup/profile-B3DD2jYa.mjs

@@ -0,0 +1,100 @@
+import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/profile.ts
+var profile_exports = /* @__PURE__ */ __exportAll({
+	isSupportedMatrixAvatarSource: () => isSupportedMatrixAvatarSource,
+	syncMatrixOwnProfile: () => syncMatrixOwnProfile
+});
+const MATRIX_PROFILE_AVATAR_MAX_BYTES = 10485760;
+function isMatrixMxcUri(value) {
+	return normalizeLowercaseStringOrEmpty(value).startsWith("mxc://");
+}
+function isMatrixHttpAvatarUri(value) {
+	const normalized = normalizeLowercaseStringOrEmpty(value);
+	return normalized.startsWith("https://") || normalized.startsWith("http://");
+}
+function isSupportedMatrixAvatarSource(value) {
+	return isMatrixMxcUri(value) || isMatrixHttpAvatarUri(value);
+}
+async function uploadAvatarMedia(params) {
+	const media = await params.loadAvatar(params.avatarSource, params.avatarMaxBytes);
+	return await params.client.uploadContent(media.buffer, media.contentType, media.fileName || "avatar");
+}
+async function resolveAvatarUrl(params) {
+	const avatarPath = normalizeOptionalString(params.avatarPath) ?? null;
+	if (avatarPath) {
+		if (!params.loadAvatarFromPath) throw new Error("Matrix avatar path upload requires a media loader.");
+		return {
+			resolvedAvatarUrl: await uploadAvatarMedia({
+				client: params.client,
+				avatarSource: avatarPath,
+				avatarMaxBytes: params.avatarMaxBytes,
+				loadAvatar: params.loadAvatarFromPath
+			}),
+			uploadedAvatarSource: "path",
+			convertedAvatarFromHttp: false
+		};
+	}
+	const avatarUrl = normalizeOptionalString(params.avatarUrl) ?? null;
+	if (!avatarUrl || isMatrixMxcUri(avatarUrl)) return {
+		resolvedAvatarUrl: avatarUrl,
+		uploadedAvatarSource: null,
+		convertedAvatarFromHttp: false
+	};
+	if (!isMatrixHttpAvatarUri(avatarUrl)) throw new Error("Matrix avatar URL must be an mxc:// URI or an http(s) URL.");
+	if (!params.loadAvatarFromUrl) throw new Error("Matrix avatar URL conversion requires a media loader.");
+	return {
+		resolvedAvatarUrl: await uploadAvatarMedia({
+			client: params.client,
+			avatarSource: avatarUrl,
+			avatarMaxBytes: params.avatarMaxBytes,
+			loadAvatar: params.loadAvatarFromUrl
+		}),
+		uploadedAvatarSource: "http",
+		convertedAvatarFromHttp: true
+	};
+}
+async function syncMatrixOwnProfile(params) {
+	const desiredDisplayName = normalizeOptionalString(params.displayName) ?? null;
+	const avatar = await resolveAvatarUrl({
+		client: params.client,
+		avatarUrl: params.avatarUrl ?? null,
+		avatarPath: params.avatarPath ?? null,
+		avatarMaxBytes: params.avatarMaxBytes ?? MATRIX_PROFILE_AVATAR_MAX_BYTES,
+		loadAvatarFromUrl: params.loadAvatarFromUrl,
+		loadAvatarFromPath: params.loadAvatarFromPath
+	});
+	const desiredAvatarUrl = avatar.resolvedAvatarUrl;
+	if (!desiredDisplayName && !desiredAvatarUrl) return {
+		skipped: true,
+		displayNameUpdated: false,
+		avatarUpdated: false,
+		...avatar,
+		resolvedAvatarUrl: null
+	};
+	let currentDisplayName;
+	let currentAvatarUrl;
+	try {
+		const currentProfile = await params.client.getUserProfile(params.userId);
+		currentDisplayName = normalizeOptionalString(currentProfile.displayname);
+		currentAvatarUrl = normalizeOptionalString(currentProfile.avatar_url);
+	} catch {}
+	let displayNameUpdated = false;
+	let avatarUpdated = false;
+	if (desiredDisplayName && currentDisplayName !== desiredDisplayName) {
+		await params.client.setDisplayName(desiredDisplayName);
+		displayNameUpdated = true;
+	}
+	if (desiredAvatarUrl && currentAvatarUrl !== desiredAvatarUrl) {
+		await params.client.setAvatarUrl(desiredAvatarUrl);
+		avatarUpdated = true;
+	}
+	return {
+		skipped: false,
+		displayNameUpdated,
+		avatarUpdated,
+		...avatar
+	};
+}
+//#endregion
+export { profile_exports as n, syncMatrixOwnProfile as r, isSupportedMatrixAvatarSource as t };

package/dist/.setup/profile-update-CmxIAd4c.mjs

@@ -0,0 +1,66 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { n as resolveMatrixConfigPath } from "./config-paths-CnREYb1Y.mjs";
+import { n as updateMatrixAccountConfig } from "./config-update-5m1Un5gJ.mjs";
+import { r as syncMatrixOwnProfile } from "./profile-B3DD2jYa.mjs";
+import { n as withResolvedActionClient } from "./client-BXATebyo.mjs";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/actions/profile.ts
+async function updateMatrixOwnProfile(opts = {}) {
+	const displayName = opts.displayName?.trim();
+	const avatarUrl = opts.avatarUrl?.trim();
+	const avatarPath = opts.avatarPath?.trim();
+	const runtime = getMatrixRuntime();
+	return await withResolvedActionClient(opts, async (client) => {
+		const userId = await client.getUserId();
+		return await syncMatrixOwnProfile({
+			client,
+			userId,
+			displayName: displayName || void 0,
+			avatarUrl: avatarUrl || void 0,
+			avatarPath: avatarPath || void 0,
+			loadAvatarFromUrl: async (url, maxBytes) => await runtime.media.loadWebMedia(url, maxBytes),
+			loadAvatarFromPath: async (path, maxBytes) => await runtime.media.loadWebMedia(path, {
+				maxBytes,
+				localRoots: opts.mediaLocalRoots
+			})
+		});
+	}, "persist");
+}
+//#endregion
+//#region extensions/matrix/src/profile-update.ts
+async function applyMatrixProfileUpdate(params) {
+	const runtime = getMatrixRuntime();
+	const persistedCfg = runtime.config.current();
+	const accountId = normalizeAccountId(params.account);
+	const displayName = params.displayName?.trim() || null;
+	const avatarUrl = params.avatarUrl?.trim() || null;
+	const avatarPath = params.avatarPath?.trim() || null;
+	if (!displayName && !avatarUrl && !avatarPath) throw new Error("Provide name/displayName and/or avatarUrl/avatarPath.");
+	const synced = await updateMatrixOwnProfile({
+		cfg: params.cfg ?? persistedCfg,
+		accountId,
+		displayName: displayName ?? void 0,
+		avatarUrl: avatarUrl ?? void 0,
+		avatarPath: avatarPath ?? void 0,
+		mediaLocalRoots: params.mediaLocalRoots
+	});
+	const persistedAvatarUrl = synced.uploadedAvatarSource && synced.resolvedAvatarUrl ? synced.resolvedAvatarUrl : avatarUrl;
+	const updated = updateMatrixAccountConfig(persistedCfg, accountId, {
+		name: displayName ?? void 0,
+		avatarUrl: persistedAvatarUrl ?? void 0
+	});
+	await runtime.config.replaceConfigFile({
+		nextConfig: updated,
+		afterWrite: { mode: "auto" }
+	});
+	const { skipped: _skipped, ...profile } = synced;
+	return {
+		accountId,
+		displayName,
+		avatarUrl: persistedAvatarUrl ?? null,
+		profile,
+		configPath: resolveMatrixConfigPath(updated, accountId)
+	};
+}
+//#endregion
+export { updateMatrixOwnProfile as n, applyMatrixProfileUpdate as t };

package/dist/.setup/reaction-events-mnzc_JvP.mjs

@@ -0,0 +1,168 @@
+import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { a as resolveMatrixThreadRouting, i as resolveMatrixInboundRoute } from "./channel-DXenXmj0.mjs";
+import { c as extractMatrixReactionAnnotation } from "./send-currentness-C2rMVVIQ.mjs";
+import { p as resolveMatrixThreadRootId } from "./direct-management-Cn2t8n1V.mjs";
+import { i as resolveMatrixApprovalReactionTargetWithPersistence, o as unregisterMatrixApprovalReactionTargetsForApproval } from "./approval-reactions-BrS5ECU0.mjs";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { getSessionBindingService } from "openclaw/plugin-sdk/session-binding-runtime";
+//#region extensions/matrix/src/matrix/monitor/reaction-events.ts
+const loadApprovalReactionAuth = createLazyRuntimeModule(() => import("./channel-DXenXmj0.mjs").then((n) => n.s));
+const loadExecApprovalResolver = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/approval-gateway-runtime"));
+const loadMatrixSend = createLazyRuntimeModule(() => import("./send-GOF64QRc.mjs").then((n) => n.s));
+function buildMatrixApprovalTerminalText(result) {
+	const approval = result.approval;
+	const terminalLabel = approval.status === "allowed" ? approval.decision === "allow-always" ? "Allowed always" : "Allowed once" : approval.status === "denied" ? "Denied" : approval.status === "expired" ? "Expired" : "Cancelled";
+	return `${result.applied ? "Resolved" : "Already resolved"}: ${terminalLabel}\n\nID: ${approval.id}`;
+}
+async function retireMatrixApprovalReactionTargets(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const registeredTargets = await unregisterMatrixApprovalReactionTargetsForApproval({
+		accountId,
+		approvalId: params.approvalId,
+		approvalKind: params.approvalKind
+	});
+	const targets = /* @__PURE__ */ new Map();
+	for (const target of [...registeredTargets, {
+		accountId,
+		roomId: params.roomId,
+		eventId: params.targetEventId
+	}]) targets.set(JSON.stringify([
+		target.accountId,
+		target.roomId,
+		target.eventId
+	]), target);
+	const { editMessageMatrix } = await loadMatrixSend();
+	const terminalText = buildMatrixApprovalTerminalText(params.result);
+	const failedUpdates = (await Promise.allSettled(Array.from(targets.values(), async (target) => {
+		await editMessageMatrix(target.roomId, target.eventId, terminalText, {
+			cfg: params.cfg,
+			accountId: target.accountId,
+			client: params.client
+		});
+	}))).filter((update) => update.status === "rejected").length;
+	if (failedUpdates > 0) params.logVerboseMessage(`matrix: failed to terminalize ${failedUpdates} approval prompt(s) id=${params.approvalId}`);
+}
+function resolveMatrixReactionNotificationMode(params) {
+	const matrixConfig = params.cfg.channels?.matrix;
+	return resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).reactionNotifications ?? matrixConfig?.reactionNotifications ?? "own";
+}
+async function maybeResolveMatrixApprovalReaction(params) {
+	if (!params.target) return false;
+	const { isMatrixApprovalReactionAuthorizedSender } = await loadApprovalReactionAuth();
+	if (!isMatrixApprovalReactionAuthorizedSender({
+		...params,
+		approvalKind: params.target.approvalKind
+	})) return false;
+	const { resolveApprovalOverGateway } = await loadExecApprovalResolver();
+	try {
+		const result = await resolveApprovalOverGateway({
+			cfg: params.cfg,
+			approvalId: params.target.approvalId,
+			approvalKind: params.target.approvalKind,
+			decision: params.target.decision,
+			channel: "matrix",
+			accountId: params.accountId,
+			senderId: params.senderId
+		});
+		await retireMatrixApprovalReactionTargets({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			client: params.client,
+			roomId: params.roomId,
+			targetEventId: params.targetEventId,
+			approvalId: params.target.approvalId,
+			approvalKind: params.target.approvalKind,
+			result,
+			logVerboseMessage: params.logVerboseMessage
+		});
+		const canonicalDecision = "decision" in result.approval ? result.approval.decision : "none";
+		params.logVerboseMessage(`matrix: approval reaction resolved id=${params.target.approvalId} sender=${params.senderId} applied=${result.applied} status=${result.approval.status} decision=${canonicalDecision}`);
+		return true;
+	} catch (err) {
+		if (isApprovalNotFoundError(err)) {
+			await unregisterMatrixApprovalReactionTargetsForApproval({
+				accountId: params.accountId,
+				approvalId: params.target.approvalId,
+				approvalKind: params.target.approvalKind
+			});
+			params.logVerboseMessage(`matrix: approval reaction ignored for expired approval id=${params.target.approvalId} sender=${params.senderId}`);
+			return true;
+		}
+		params.logVerboseMessage(`matrix: approval reaction failed id=${params.target.approvalId} sender=${params.senderId}: ${String(err)}`);
+		throw err;
+	}
+}
+async function handleInboundMatrixReaction(params) {
+	const reaction = extractMatrixReactionAnnotation(params.event.content);
+	if (!reaction?.eventId) return;
+	if (params.senderId === params.selfUserId) return;
+	const approvalTarget = await resolveMatrixApprovalReactionTargetWithPersistence({
+		accountId: params.accountId,
+		roomId: params.roomId,
+		eventId: reaction.eventId,
+		reactionKey: reaction.key
+	});
+	if (await maybeResolveMatrixApprovalReaction({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		senderId: params.senderId,
+		target: approvalTarget,
+		targetEventId: reaction.eventId,
+		roomId: params.roomId,
+		client: params.client,
+		logVerboseMessage: params.logVerboseMessage
+	})) return;
+	const notificationMode = resolveMatrixReactionNotificationMode({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (notificationMode === "off") return;
+	const targetEvent = await params.client.getEvent(params.roomId, reaction.eventId).catch((err) => {
+		params.logVerboseMessage(`matrix: failed resolving reaction target room=${params.roomId} id=${reaction.eventId}: ${String(err)}`);
+		return null;
+	});
+	const targetSender = targetEvent && typeof targetEvent.sender === "string" ? targetEvent.sender.trim() : "";
+	if (!targetSender) return;
+	if (notificationMode === "own" && targetSender !== params.selfUserId) return;
+	const targetContent = targetEvent && targetEvent.content && typeof targetEvent.content === "object" ? targetEvent.content : void 0;
+	const threadRootId = targetContent ? resolveMatrixThreadRootId(targetContent) : void 0;
+	const accountConfig = resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const thread = resolveMatrixThreadRouting({
+		isDirectMessage: params.isDirectMessage,
+		threadReplies: accountConfig.threadReplies ?? "inbound",
+		dmThreadReplies: accountConfig.dm?.threadReplies,
+		messageId: reaction.eventId,
+		threadRootId
+	});
+	const { route, runtimeBindingId } = resolveMatrixInboundRoute({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		roomId: params.roomId,
+		senderId: params.senderId,
+		isDirectMessage: params.isDirectMessage,
+		dmSessionScope: accountConfig.dm?.sessionScope ?? "per-user",
+		threadId: thread.threadId,
+		resolveAgentRoute: params.core.channel.routing.resolveAgentRoute
+	});
+	if (runtimeBindingId) getSessionBindingService().touch(runtimeBindingId, params.event.origin_server_ts, {
+		channel: "matrix",
+		accountId: params.accountId
+	});
+	const text = `Matrix reaction added: ${reaction.key} by ${params.senderLabel} on msg ${reaction.eventId}`;
+	params.core.system.enqueueSystemEvent(text, {
+		sessionKey: route.sessionKey,
+		agentId: route.agentId,
+		contextKey: `matrix:reaction:add:${params.roomId}:${reaction.eventId}:${params.senderId}:${reaction.key}`
+	});
+	params.logVerboseMessage(`matrix: reaction event enqueued room=${params.roomId} target=${reaction.eventId} sender=${params.senderId} emoji=${reaction.key}`);
+}
+//#endregion
+export { handleInboundMatrixReaction };

package/dist/.setup/resolve-targets-BFq3q4c9.mjs

@@ -0,0 +1,87 @@
+import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { r as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
+import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-_sw-Q7KO.mjs";
+import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/resolve-targets.ts
+var resolve_targets_exports = /* @__PURE__ */ __exportAll({ resolveMatrixTargets: () => resolveMatrixTargets });
+function normalizeLookupQuery(query) {
+	return normalizeOptionalLowercaseString(query) ?? "";
+}
+function findExactDirectoryMatches(matches, query) {
+	const normalized = normalizeLookupQuery(query);
+	if (!normalized) return [];
+	return matches.filter((match) => {
+		const id = normalizeOptionalLowercaseString(match.id);
+		const name = normalizeOptionalLowercaseString(match.name);
+		const handle = normalizeOptionalLowercaseString(match.handle);
+		return normalized === id || normalized === name || normalized === handle;
+	});
+}
+function pickBestDirectoryMatch(matches, query, kind) {
+	const exact = findExactDirectoryMatches(matches, query);
+	if (kind === "user") return exact.length === 1 ? { best: exact[0] } : { note: matches.length === 0 ? "no matches" : exact.length > 1 ? "multiple exact matches; use full Matrix ID" : "no exact match; use full Matrix ID" };
+	const candidates = exact.length > 0 ? exact : matches;
+	return {
+		best: candidates[0],
+		note: candidates.length > 1 ? `multiple ${exact.length > 0 ? "exact " : ""}matches; chose first` : void 0
+	};
+}
+async function readCachedMatches(cache, query, lookup) {
+	const key = normalizeLookupQuery(query);
+	if (!key) return [];
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const matches = await lookup(query.trim());
+	cache.set(key, matches);
+	return matches;
+}
+async function resolveMatrixTargets(params) {
+	const results = [];
+	const lookupCache = /* @__PURE__ */ new Map();
+	const lookup = params.kind === "user" ? listMatrixDirectoryPeersLive : listMatrixDirectoryGroupsLive;
+	for (const input of params.inputs) {
+		const trimmed = input.trim();
+		if (!trimmed) {
+			results.push({
+				input,
+				resolved: false,
+				note: "empty input"
+			});
+			continue;
+		}
+		const normalizedTarget = normalizeMatrixMessagingTarget(trimmed);
+		if (normalizedTarget && (params.kind === "user" ? isMatrixQualifiedUserId(normalizedTarget) : normalizedTarget.startsWith("!"))) {
+			results.push({
+				input,
+				resolved: true,
+				id: normalizedTarget
+			});
+			continue;
+		}
+		try {
+			const { best, note } = pickBestDirectoryMatch(await readCachedMatches(lookupCache, trimmed, (query) => lookup({
+				cfg: params.cfg,
+				accountId: params.accountId,
+				query,
+				limit: 5
+			})), trimmed, params.kind);
+			results.push({
+				input,
+				resolved: Boolean(best?.id),
+				id: best?.id,
+				name: best?.name,
+				note
+			});
+		} catch (err) {
+			params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
+			results.push({
+				input,
+				resolved: false,
+				note: "lookup failed"
+			});
+		}
+	}
+	return results;
+}
+//#endregion
+export { resolve_targets_exports as n, resolveMatrixTargets as t };

package/dist/.setup/room-info-BbTGRJcR.mjs

@@ -0,0 +1,134 @@
+import { D as setBoundedMap, E as resolveMatrixRoomId } from "./send-GOF64QRc.mjs";
+import { c as EventType } from "./messages-Buz27pi5.mjs";
+import { n as withResolvedActionClient, r as withResolvedRoomAction } from "./client-BXATebyo.mjs";
+import { n as isMatrixNotFoundError } from "./errors-DKVS3_DO.mjs";
+import { filterStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/actions/room.ts
+async function getMatrixMemberInfo(userId, opts) {
+	return await withResolvedActionClient(opts, async (client) => {
+		const roomId = await resolveMatrixRoomId(client, opts.roomId);
+		if (!(await client.getJoinedRoomMembers(roomId)).includes(userId)) throw new Error(`User ${userId} is not a member of room ${roomId}`);
+		const profile = await client.getUserProfile(userId);
+		return {
+			userId,
+			profile: {
+				displayName: profile?.displayname ?? null,
+				avatarUrl: profile?.avatar_url ?? null
+			},
+			membership: null,
+			powerLevel: null,
+			displayName: profile?.displayname ?? null,
+			roomId
+		};
+	});
+}
+async function getMatrixRoomInfo(roomId, opts = {}) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		const name = await client.getRoomStateEvent(resolvedRoom, "m.room.name", "").then((state) => typeof state?.name === "string" ? state.name : null).catch(() => null);
+		const topic = await client.getRoomStateEvent(resolvedRoom, EventType.RoomTopic, "").then((state) => typeof state?.topic === "string" ? state.topic : null).catch(() => null);
+		const aliases = await client.getRoomStateEvent(resolvedRoom, "m.room.canonical_alias", "").then((state) => ({
+			canonicalAlias: typeof state?.alias === "string" ? state.alias : null,
+			altAliases: filterStringEntries(state?.alt_aliases)
+		})).catch(() => ({
+			canonicalAlias: null,
+			altAliases: []
+		}));
+		const memberCount = await client.getJoinedRoomMembers(resolvedRoom).then((members) => members.length).catch(() => null);
+		return {
+			roomId: resolvedRoom,
+			name,
+			topic,
+			...aliases,
+			memberCount
+		};
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/room-info.ts
+const MAX_ROOM_INFO = 1024;
+const MAX_MEMBER_DISPLAY_NAMES = 4096;
+function createMatrixRoomInfoResolver(client) {
+	const roomNameCache = /* @__PURE__ */ new Map();
+	const roomAliasCache = /* @__PURE__ */ new Map();
+	const memberDisplayNameCache = /* @__PURE__ */ new Map();
+	const getRoomName = async (roomId) => {
+		const cached = roomNameCache.get(roomId);
+		if (cached) return cached;
+		let name;
+		let nameResolved = false;
+		try {
+			const nameState = await client.getRoomStateEvent(roomId, "m.room.name", "");
+			nameResolved = true;
+			if (nameState && typeof nameState.name === "string") name = nameState.name;
+		} catch (err) {
+			if (isMatrixNotFoundError(err)) nameResolved = true;
+		}
+		const info = {
+			name,
+			nameResolved
+		};
+		if (nameResolved) setBoundedMap(roomNameCache, roomId, info, MAX_ROOM_INFO);
+		return info;
+	};
+	const getRoomAliases = async (roomId) => {
+		const cached = roomAliasCache.get(roomId);
+		if (cached) return cached;
+		let canonicalAlias;
+		let altAliases = [];
+		let aliasesResolved = false;
+		try {
+			const aliasState = await client.getRoomStateEvent(roomId, "m.room.canonical_alias", "");
+			aliasesResolved = true;
+			if (aliasState && typeof aliasState.alias === "string") canonicalAlias = aliasState.alias;
+			const rawAliases = aliasState?.alt_aliases;
+			if (Array.isArray(rawAliases)) altAliases = rawAliases.filter((entry) => typeof entry === "string");
+		} catch (err) {
+			if (isMatrixNotFoundError(err)) aliasesResolved = true;
+		}
+		const info = {
+			canonicalAlias,
+			altAliases,
+			aliasesResolved
+		};
+		if (aliasesResolved) setBoundedMap(roomAliasCache, roomId, info, MAX_ROOM_INFO);
+		return info;
+	};
+	const getRoomInfo = async (roomId, opts = {}) => {
+		const { name, nameResolved } = await getRoomName(roomId);
+		if (!opts.includeAliases) return {
+			name,
+			altAliases: [],
+			nameResolved,
+			aliasesResolved: false
+		};
+		return {
+			name,
+			nameResolved,
+			...await getRoomAliases(roomId)
+		};
+	};
+	const getMemberDisplayName = async (roomId, userId) => {
+		const cacheKey = `${roomId}:${userId}`;
+		const cached = memberDisplayNameCache.get(cacheKey);
+		if (cached !== void 0) return cached;
+		let memberState;
+		try {
+			memberState = await client.getRoomStateEvent(roomId, "m.room.member", userId);
+		} catch {
+			return userId;
+		}
+		const displayName = memberState && typeof memberState.displayname === "string" ? memberState.displayname : userId;
+		setBoundedMap(memberDisplayNameCache, cacheKey, displayName, MAX_MEMBER_DISPLAY_NAMES);
+		return displayName;
+	};
+	const invalidateMemberDisplayName = (roomId, userId) => {
+		memberDisplayNameCache.delete(`${roomId}:${userId}`);
+	};
+	return {
+		getRoomInfo,
+		getMemberDisplayName,
+		invalidateMemberDisplayName
+	};
+}
+//#endregion
+export { getMatrixMemberInfo as n, getMatrixRoomInfo as r, createMatrixRoomInfoResolver as t };