@openclaw/matrix 2026.7.2-beta.4 → 2026.7.2-beta.7

package/dist/plugin-entry.handlers.runtime.js

@@ -2,7 +2,7 @@ import { t as formatMatrixErrorMessage } from "./errors-C47hvAF8.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/plugin-entry.runtime.ts
-const loadMatrixVerificationRuntime = createLazyRuntimeModule(() => import("./verification-DhMBWxOJ.js").then((n) => n.y));
+const loadMatrixVerificationRuntime = createLazyRuntimeModule(() => import("./verification-DYMQ1QpI.js").then((n) => n.y));
 function sendError(respond, err) {
 	respond(false, { error: formatMatrixErrorMessage(err) });
 }

package/dist/probe.runtime-BuieqmS3.js

@@ -0,0 +1,3 @@
+import { t as createMatrixClient } from "./create-client-BmSU-q-D.js";
+import "./client-Dbso3-0V.js";
+export { createMatrixClient };

package/dist/{profile-update-C2My3TML.js → profile-update-CffmyW_4.js}

@@ -1,6 +1,6 @@
 import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { l as resolveMatrixConfigPath, s as syncMatrixOwnProfile, u as updateMatrixAccountConfig } from "./setup-core-D6gyoyeg.js";
-import { n as withResolvedActionClient } from "./client-BwX6rURh.js";
+import { l as resolveMatrixConfigPath, s as syncMatrixOwnProfile, u as updateMatrixAccountConfig } from "./setup-core-BVfBv2ai.js";
+import { n as withResolvedActionClient } from "./client-6eRENr7k.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/actions/profile.ts
 async function updateMatrixOwnProfile(opts = {}) {

package/dist/{reaction-events-Cj6thhmc.js → reaction-events-B00WSi98.js}

@@ -6,9 +6,9 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-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("./approval-reaction-auth-DButmM13.js"));
+const loadApprovalReactionAuth = createLazyRuntimeModule(() => import("./approval-reaction-auth-BjOpELxu.js"));
 const loadExecApprovalResolver = createLazyRuntimeModule(() => import("./exec-approval-resolver-BCgqRtZS.js"));
-const loadMatrixSend = createLazyRuntimeModule(() => import("./send-CZCmDQu8.js").then((n) => n.l));
+const loadMatrixSend = createLazyRuntimeModule(() => import("./send-BldGYG8g.js").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";

package/dist/{recovery-key-store-0O8ARdT_.js → recovery-key-store-BNnHvXdk.js}

@@ -1,5 +1,5 @@
 import { n as formatMatrixErrorReason, t as formatMatrixErrorMessage } from "./errors-C47hvAF8.js";
-import { A as writeMatrixRecoveryKeyStateForPath, E as readMatrixRecoveryKeyStateForPath, S as readLegacyMatrixRecoveryKeyFile, _ as migrateLegacyMatrixRecoveryKeyFilePathToStore } from "./storage-BrkTJZov.js";
+import { A as writeMatrixRecoveryKeyStateForPath, E as readMatrixRecoveryKeyStateForPath, S as readLegacyMatrixRecoveryKeyFile, _ as migrateLegacyMatrixRecoveryKeyFilePathToStore } from "./storage-BvAkgzvT.js";
 import { n as LogService } from "./logger-D0GCSDQq.js";
 import path from "node:path";
 import { decodeRecoveryKey } from "matrix-js-sdk/lib/crypto-api/recovery-key.js";

package/dist/{resolve-targets-Dn11HT76.js → resolve-targets-nm2L48sh.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-B-5aQxwn.js";
-import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-B6fbX6jf.js";
+import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-C8dVBiCc.js";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/resolve-targets.ts
 var resolve_targets_exports = /* @__PURE__ */ __exportAll({ resolveMatrixTargets: () => resolveMatrixTargets });

package/dist/{resolver.runtime-Zguh0hH9.js → resolver.runtime-DS6uPaEe.js}

@@ -1,4 +1,4 @@
-import { t as resolveMatrixTargets } from "./resolve-targets-Dn11HT76.js";
+import { t as resolveMatrixTargets } from "./resolve-targets-nm2L48sh.js";
 //#region extensions/matrix/src/resolver.runtime.ts
 const matrixResolverRuntime = { resolveMatrixTargets };
 //#endregion

package/dist/{room-info-B6vKD5DF.js → room-info-CAFZ3Z9J.js}

@@ -1,14 +1,15 @@
 import { r as isMatrixNotFoundError } from "./errors-C47hvAF8.js";
-//#region extensions/matrix/src/matrix/monitor/room-info.ts
-const MAX_TRACKED_ROOM_INFO = 1024;
-const MAX_TRACKED_MEMBER_DISPLAY_NAMES = 4096;
-function rememberBounded(map, key, value, maxEntries) {
+//#region extensions/matrix/src/matrix/monitor/bounded-cache.ts
+function setBoundedMap(map, key, value, maxEntries) {
 	map.set(key, value);
-	if (map.size > maxEntries) {
-		const oldest = map.keys().next().value;
-		if (typeof oldest === "string") map.delete(oldest);
-	}
+	if (map.size <= maxEntries) return;
+	const oldest = map.keys().next();
+	if (!oldest.done) map.delete(oldest.value);
 }
+//#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();
@@ -28,7 +29,7 @@ function createMatrixRoomInfoResolver(client) {
 			name,
 			nameResolved
 		};
-		if (nameResolved) rememberBounded(roomNameCache, roomId, info, MAX_TRACKED_ROOM_INFO);
+		if (nameResolved) setBoundedMap(roomNameCache, roomId, info, MAX_ROOM_INFO);
 		return info;
 	};
 	const getRoomAliases = async (roomId) => {
@@ -51,7 +52,7 @@ function createMatrixRoomInfoResolver(client) {
 			altAliases,
 			aliasesResolved
 		};
-		if (aliasesResolved) rememberBounded(roomAliasCache, roomId, info, MAX_TRACKED_ROOM_INFO);
+		if (aliasesResolved) setBoundedMap(roomAliasCache, roomId, info, MAX_ROOM_INFO);
 		return info;
 	};
 	const getRoomInfo = async (roomId, opts = {}) => {
@@ -73,7 +74,7 @@ function createMatrixRoomInfoResolver(client) {
 		if (memberDisplayNameCache.has(cacheKey)) return memberDisplayNameCache.get(cacheKey) ?? userId;
 		const memberState = await client.getRoomStateEvent(roomId, "m.room.member", userId).catch(() => null);
 		const displayName = memberState && typeof memberState.displayname === "string" ? memberState.displayname : userId;
-		rememberBounded(memberDisplayNameCache, cacheKey, displayName, MAX_TRACKED_MEMBER_DISPLAY_NAMES);
+		setBoundedMap(memberDisplayNameCache, cacheKey, displayName, MAX_MEMBER_DISPLAY_NAMES);
 		return displayName;
 	};
 	return {
@@ -83,4 +84,4 @@ function createMatrixRoomInfoResolver(client) {
 	};
 }
 //#endregion
-export { createMatrixRoomInfoResolver as t };
+export { setBoundedMap as n, createMatrixRoomInfoResolver as t };

package/dist/{sdk-DiRXiRRf.js → sdk-bUytQHx7.js}

@@ -1,20 +1,121 @@
 import { n as formatMatrixErrorReason, r as isMatrixNotFoundError, t as formatMatrixErrorMessage } from "./errors-C47hvAF8.js";
-import { t as SqliteBackedMatrixSyncStore } from "./file-sync-store-DUEWCEjb.js";
+import { t as SqliteBackedMatrixSyncStore } from "./file-sync-store-DiiFsayX.js";
 import { n as LogService, r as noop, t as ConsoleLogger } from "./logger-D0GCSDQq.js";
 import { t as MATRIX_IDB_PERSIST_INTERVAL_MS } from "./idb-persistence-lock-DAJ49nZX.js";
-import { c as createMatrixStartupAbortError, u as throwIfMatrixStartupAborted } from "./shared-C7Vm9RxI.js";
-import { a as matrixEventToRaw, n as createMatrixGuardedFetch, o as parseMxc, t as MatrixAuthedHttpClient } from "./http-client-DOyTG9l2.js";
+import { c as createMatrixStartupAbortError, u as throwIfMatrixStartupAborted } from "./shared-CUMWxcMz.js";
+import { a as matrixEventToRaw, n as createMatrixGuardedFetch, o as parseMxc, t as MatrixAuthedHttpClient } from "./http-client-CycYxU9-.js";
 import { n as resolveMatrixRoomKeyBackupReadinessError } from "./backup-health-Dm_YMVFT.js";
-import { createMatrixJsSdkClientLogger } from "./logging-QH-48Gr6.js";
+import { t as createMatrixJsSdkClientLogger } from "./logging-DV-p52N0.js";
 import { n as isMatrixReadySyncState, r as isMatrixTerminalSyncState } from "./sync-state-CWbp0QSY.js";
-import { n as isRepairableSecretStorageAccessError, t as MatrixRecoveryKeyStore } from "./recovery-key-store-0O8ARdT_.js";
+import { n as isRepairableSecretStorageAccessError, t as MatrixRecoveryKeyStore } from "./recovery-key-store-BNnHvXdk.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeNullableString, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { ClientEvent, Filter, MatrixEventEvent, Preset, createClient } from "matrix-js-sdk/lib/matrix.js";
 import { EventEmitter } from "node:events";
 import { VerificationMethod } from "matrix-js-sdk/lib/types.js";
-//#region extensions/matrix/src/matrix/sdk.ts
+//#region extensions/matrix/src/matrix/sdk/client-device-info.ts
+async function resolveMatrixCrossSigningPublicationStatus(params) {
+	if (!params.userId) return {
+		userId: null,
+		masterKeyPublished: false,
+		selfSigningKeyPublished: false,
+		userSigningKeyPublished: false,
+		published: false
+	};
+	try {
+		const response = await params.query();
+		const masterKeyPublished = Boolean(response.master_keys?.[params.userId]);
+		const selfSigningKeyPublished = Boolean(response.self_signing_keys?.[params.userId]);
+		const userSigningKeyPublished = Boolean(response.user_signing_keys?.[params.userId]);
+		return {
+			userId: params.userId,
+			masterKeyPublished,
+			selfSigningKeyPublished,
+			userSigningKeyPublished,
+			published: masterKeyPublished && selfSigningKeyPublished && userSigningKeyPublished
+		};
+	} catch {
+		return {
+			userId: params.userId,
+			masterKeyPublished: false,
+			selfSigningKeyPublished: false,
+			userSigningKeyPublished: false,
+			published: false
+		};
+	}
+}
+async function listMatrixOwnDevices(client) {
+	const currentDeviceId = client.getDeviceId()?.trim() || null;
+	const devices = await client.getDevices();
+	return (Array.isArray(devices?.devices) ? devices.devices : []).map((device) => ({
+		deviceId: device.device_id,
+		displayName: device.display_name?.trim() || null,
+		lastSeenIp: device.last_seen_ip?.trim() || null,
+		lastSeenTs: typeof device.last_seen_ts === "number" && Number.isFinite(device.last_seen_ts) ? device.last_seen_ts : null,
+		current: currentDeviceId !== null && device.device_id === currentDeviceId
+	}));
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/client-event-bridge.ts
+function registerMatrixClientBridge(params) {
+	params.client.on(ClientEvent.Event, (event) => {
+		const roomId = event.getRoomId();
+		if (!roomId) return;
+		const raw = matrixEventToRaw(event, { contentMode: "original" });
+		const isEncryptedEvent = raw.type === "m.room.encrypted";
+		params.emitter.emit("room.event", roomId, raw);
+		if (isEncryptedEvent) params.emitter.emit("room.encrypted_event", roomId, raw);
+		else if (params.decryptBridge.shouldEmitUnencryptedMessage(roomId, raw.event_id)) params.emitter.emit("room.message", roomId, raw);
+		const stateKey = raw.state_key ?? "";
+		const selfUserId = params.getSelfUserId();
+		const membership = raw.type === "m.room.member" ? raw.content.membership : void 0;
+		if (stateKey && selfUserId && stateKey === selfUserId) {
+			if (membership === "invite") params.emitter.emit("room.invite", roomId, raw);
+			else if (membership === "join") params.emitter.emit("room.join", roomId, raw);
+		}
+		if (isEncryptedEvent) params.decryptBridge.attachEncryptedEvent(event, roomId);
+	});
+	params.client.on(ClientEvent.Room, params.emitMembershipForRoom);
+	params.client.on(ClientEvent.Sync, (state, prevState, data) => {
+		params.setCurrentSyncState(state);
+		const error = data && typeof data === "object" && "error" in data ? data.error : void 0;
+		params.emitter.emit("sync.state", state, prevState, error);
+	});
+	params.client.on(ClientEvent.SyncUnexpectedError, (error) => {
+		params.emitter.emit("sync.unexpected_error", error);
+	});
+}
+function emitMatrixMembershipForRoom(params) {
+	const roomId = params.room.roomId.trim();
+	if (!roomId || !params.selfUserId) return;
+	const membership = params.room.getMyMembership();
+	const raw = {
+		event_id: `$membership-${roomId}-${Date.now()}`,
+		type: "m.room.member",
+		sender: params.selfUserId,
+		state_key: params.selfUserId,
+		content: { membership },
+		origin_server_ts: Date.now(),
+		unsigned: { age: 0 }
+	};
+	if (membership === "invite") {
+		params.emitter.emit("room.invite", roomId, raw);
+		return;
+	}
+	if (membership === "join") params.emitter.emit("room.join", roomId, raw);
+}
+function refreshMatrixDmRoomIds(direct, dmRoomIds) {
+	dmRoomIds.clear();
+	if (!direct || typeof direct !== "object") return false;
+	for (const value of Object.values(direct)) {
+		if (!Array.isArray(value)) continue;
+		for (const roomId of value) if (typeof roomId === "string" && roomId.trim()) dmRoomIds.add(roomId);
+	}
+	return true;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/client-support.ts
 const MATRIX_STATUS_DIAGNOSTIC_TIMEOUT_MS = 1e4;
 const DEFAULT_MATRIX_LOCAL_TIMEOUT_MS = 6e4;
 function resolveMatrixLocalTimeoutMs(raw) {
@@ -93,19 +194,14 @@ function createMatrixExplicitBootstrapOptions(params) {
 		strict: params?.strict !== false
 	};
 }
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/client-base.ts
 let loadedMatrixCryptoRuntime = null;
-const loadMatrixCryptoRuntime = createLazyRuntimeModule(() => import("./crypto-runtime-_j7TpS7k.js").then((runtime) => {
+const loadMatrixCryptoRuntime = createLazyRuntimeModule(() => import("./crypto-runtime-D9_6J5tZ.js").then((runtime) => {
 	loadedMatrixCryptoRuntime = runtime;
 	return runtime;
 }));
-const normalizeOptionalString$1 = normalizeNullableString;
-function isUnsupportedAuthenticatedMediaEndpointError(err) {
-	const statusCode = err?.statusCode;
-	if (statusCode === 404 || statusCode === 405 || statusCode === 501) return true;
-	const message = formatMatrixErrorReason(err);
-	return message.includes("m_unrecognized") || message.includes("unrecognized request") || message.includes("method not allowed") || message.includes("not implemented");
-}
-var MatrixClient = class {
+var MatrixClientBase = class {
 	constructor(homeserver, accessToken, opts = {}) {
 		this.emitter = new EventEmitter();
 		this.bridgeRegistered = false;
@@ -134,7 +230,8 @@ var MatrixClient = class {
 		this.initialSyncLimit = opts.initialSyncLimit;
 		this.syncFilter = opts.syncFilter;
 		this.encryptionEnabled = opts.encryption === true;
-		this.password = opts.password;
+		const { password: loginPassword } = opts;
+		this.password = loginPassword;
 		this.syncStore = opts.storageRootDir ? new SqliteBackedMatrixSyncStore(opts.storageRootDir) : void 0;
 		this.idbSnapshotPath = opts.idbSnapshotPath;
 		this.cryptoDatabasePrefix = opts.cryptoDatabasePrefix;
@@ -414,6 +511,16 @@ var MatrixClient = class {
 			LogService.warn("MatrixClientLite", "Failed to initialize rust crypto:", err);
 		}
 	}
+};
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/client-core.ts
+function isUnsupportedAuthenticatedMediaEndpointError(err) {
+	const statusCode = err?.statusCode;
+	if (statusCode === 404 || statusCode === 405 || statusCode === 501) return true;
+	const message = formatMatrixErrorReason(err);
+	return message.includes("m_unrecognized") || message.includes("unrecognized request") || message.includes("method not allowed") || message.includes("not implemented");
+}
+var MatrixClientCore = class extends MatrixClientBase {
 	async getUserId() {
 		const fromClient = this.client.getUserId();
 		if (fromClient) {
@@ -588,6 +695,11 @@ var MatrixClient = class {
 			timeoutMs: this.localTimeoutMs
 		});
 	}
+};
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/client-verification.ts
+const normalizeOptionalString$1 = normalizeNullableString;
+var MatrixClientVerification = class extends MatrixClientCore {
 	async getRoomKeyBackupStatus() {
 		if (!this.encryptionEnabled) return {
 			serverVersion: null,
@@ -715,6 +827,83 @@ var MatrixClient = class {
 			ownIdentity.free?.();
 		}
 	}
+	async resolveActiveRoomKeyBackupVersion(crypto) {
+		if (typeof crypto.getActiveSessionBackupVersion !== "function") return null;
+		const version = await crypto.getActiveSessionBackupVersion().catch(() => null);
+		return normalizeOptionalString$1(version);
+	}
+	async resolveCachedRoomKeyBackupDecryptionKey(crypto) {
+		const read = Reflect.get(crypto, "getSessionBackupPrivateKey");
+		if (typeof read !== "function") return null;
+		const key = await read.call(crypto).catch(() => null);
+		return key ? key.length > 0 : false;
+	}
+	async resolveRoomKeyBackupLocalState(crypto) {
+		const [activeVersion, decryptionKeyCached] = await Promise.all([this.resolveActiveRoomKeyBackupVersion(crypto), this.resolveCachedRoomKeyBackupDecryptionKey(crypto)]);
+		return {
+			activeVersion,
+			decryptionKeyCached
+		};
+	}
+	async shouldForceSecretStorageRecreationForBackupReset(crypto) {
+		if (await this.resolveCachedRoomKeyBackupDecryptionKey(crypto) !== false) return false;
+		const loadSessionBackupPrivateKeyFromSecretStorage = crypto.loadSessionBackupPrivateKeyFromSecretStorage;
+		if (typeof loadSessionBackupPrivateKeyFromSecretStorage !== "function") return false;
+		try {
+			await loadSessionBackupPrivateKeyFromSecretStorage.call(crypto);
+			return false;
+		} catch (err) {
+			return isRepairableSecretStorageAccessError(err);
+		}
+	}
+	async resolveRoomKeyBackupTrustState(crypto, fallbackVersion) {
+		let serverVersion = fallbackVersion;
+		let trusted = null;
+		let matchesDecryptionKey = null;
+		if (typeof crypto.getKeyBackupInfo === "function") {
+			const info = await crypto.getKeyBackupInfo().catch(() => null);
+			serverVersion = normalizeOptionalString$1(info?.version) ?? serverVersion;
+			if (info && typeof crypto.isKeyBackupTrusted === "function") {
+				const trustInfo = await crypto.isKeyBackupTrusted(info).catch(() => null);
+				trusted = typeof trustInfo?.trusted === "boolean" ? trustInfo.trusted : null;
+				matchesDecryptionKey = typeof trustInfo?.matchesDecryptionKey === "boolean" ? trustInfo.matchesDecryptionKey : null;
+			}
+		}
+		return {
+			serverVersion,
+			trusted,
+			matchesDecryptionKey
+		};
+	}
+	async resolveDefaultSecretStorageKeyId(crypto) {
+		const getSecretStorageStatus = crypto?.getSecretStorageStatus;
+		if (typeof getSecretStorageStatus !== "function") return;
+		return (await getSecretStorageStatus.call(crypto).catch(() => null))?.defaultKeyId;
+	}
+	async resolveRoomKeyBackupVersion() {
+		try {
+			const response = await this.doRequest("GET", "/_matrix/client/v3/room_keys/version");
+			return normalizeOptionalString$1(response.version);
+		} catch {
+			return null;
+		}
+	}
+	async enableTrustedRoomKeyBackupIfPossible(crypto) {
+		if (typeof crypto.checkKeyBackupAndEnable !== "function") return;
+		await crypto.checkKeyBackupAndEnable();
+	}
+	async ensureRoomKeyBackupEnabled(crypto) {
+		if (await this.resolveRoomKeyBackupVersion()) return;
+		LogService.info("MatrixClientLite", "No room key backup version found on server, creating one via secret storage bootstrap");
+		await this.recoveryKeyStore.bootstrapSecretStorageWithRecoveryKey(crypto, { setupNewKeyBackup: true });
+		const createdVersion = await this.resolveRoomKeyBackupVersion();
+		if (!createdVersion) throw new Error("Matrix room key backup is still missing after bootstrap");
+		LogService.info("MatrixClientLite", `Room key backup enabled (version ${createdVersion})`);
+	}
+};
+//#endregion
+//#region extensions/matrix/src/matrix/sdk.ts
+var MatrixClient = class extends MatrixClientVerification {
 	async verifyWithRecoveryKey(rawRecoveryKey) {
 		const fail = async (error, fields = {}) => {
 			const status = await this.getOwnDeviceVerificationStatus();
@@ -959,34 +1148,10 @@ var MatrixClient = class {
 	}
 	async getOwnCrossSigningPublicationStatus() {
 		const userId = this.client.getUserId() ?? this.selfUserId ?? null;
-		if (!userId) return {
-			userId: null,
-			masterKeyPublished: false,
-			selfSigningKeyPublished: false,
-			userSigningKeyPublished: false,
-			published: false
-		};
-		try {
-			const response = await this.doRequest("POST", "/_matrix/client/v3/keys/query", void 0, { device_keys: { [userId]: [] } });
-			const masterKeyPublished = Boolean(response.master_keys?.[userId]);
-			const selfSigningKeyPublished = Boolean(response.self_signing_keys?.[userId]);
-			const userSigningKeyPublished = Boolean(response.user_signing_keys?.[userId]);
-			return {
-				userId,
-				masterKeyPublished,
-				selfSigningKeyPublished,
-				userSigningKeyPublished,
-				published: masterKeyPublished && selfSigningKeyPublished && userSigningKeyPublished
-			};
-		} catch {
-			return {
-				userId,
-				masterKeyPublished: false,
-				selfSigningKeyPublished: false,
-				userSigningKeyPublished: false,
-				published: false
-			};
-		}
+		return await resolveMatrixCrossSigningPublicationStatus({
+			userId,
+			query: async () => await this.doRequest("POST", "/_matrix/client/v3/keys/query", void 0, { device_keys: userId ? { [userId]: [] } : {} })
+		});
 	}
 	async bootstrapOwnDeviceVerification(params) {
 		const pendingVerifications = async () => this.crypto ? (await this.crypto.listVerifications()).length : 0;
@@ -1042,15 +1207,7 @@ var MatrixClient = class {
 		};
 	}
 	async listOwnDevices() {
-		const currentDeviceId = this.client.getDeviceId()?.trim() || null;
-		const devices = await this.client.getDevices();
-		return (Array.isArray(devices?.devices) ? devices.devices : []).map((device) => ({
-			deviceId: device.device_id,
-			displayName: device.display_name?.trim() || null,
-			lastSeenIp: device.last_seen_ip?.trim() || null,
-			lastSeenTs: typeof device.last_seen_ts === "number" && Number.isFinite(device.last_seen_ts) ? device.last_seen_ts : null,
-			current: currentDeviceId !== null && device.device_id === currentDeviceId
-		}));
+		return await listMatrixOwnDevices(this.client);
 	}
 	async deleteOwnDevices(deviceIds) {
 		const uniqueDeviceIds = uniqueStrings(normalizeStringEntries(deviceIds));
@@ -1082,145 +1239,34 @@ var MatrixClient = class {
 			remainingDevices: await this.listOwnDevices()
 		};
 	}
-	async resolveActiveRoomKeyBackupVersion(crypto) {
-		if (typeof crypto.getActiveSessionBackupVersion !== "function") return null;
-		const version = await crypto.getActiveSessionBackupVersion().catch(() => null);
-		return normalizeOptionalString$1(version);
-	}
-	async resolveCachedRoomKeyBackupDecryptionKey(crypto) {
-		const getSessionBackupPrivateKey = crypto.getSessionBackupPrivateKey;
-		if (typeof getSessionBackupPrivateKey !== "function") return null;
-		const key = await getSessionBackupPrivateKey.call(crypto).catch(() => null);
-		return key ? key.length > 0 : false;
-	}
-	async resolveRoomKeyBackupLocalState(crypto) {
-		const [activeVersion, decryptionKeyCached] = await Promise.all([this.resolveActiveRoomKeyBackupVersion(crypto), this.resolveCachedRoomKeyBackupDecryptionKey(crypto)]);
-		return {
-			activeVersion,
-			decryptionKeyCached
-		};
-	}
-	async shouldForceSecretStorageRecreationForBackupReset(crypto) {
-		if (await this.resolveCachedRoomKeyBackupDecryptionKey(crypto) !== false) return false;
-		const loadSessionBackupPrivateKeyFromSecretStorage = crypto.loadSessionBackupPrivateKeyFromSecretStorage;
-		if (typeof loadSessionBackupPrivateKeyFromSecretStorage !== "function") return false;
-		try {
-			await loadSessionBackupPrivateKeyFromSecretStorage.call(crypto);
-			return false;
-		} catch (err) {
-			return isRepairableSecretStorageAccessError(err);
-		}
-	}
-	async resolveRoomKeyBackupTrustState(crypto, fallbackVersion) {
-		let serverVersion = fallbackVersion;
-		let trusted = null;
-		let matchesDecryptionKey = null;
-		if (typeof crypto.getKeyBackupInfo === "function") {
-			const info = await crypto.getKeyBackupInfo().catch(() => null);
-			serverVersion = normalizeOptionalString$1(info?.version) ?? serverVersion;
-			if (info && typeof crypto.isKeyBackupTrusted === "function") {
-				const trustInfo = await crypto.isKeyBackupTrusted(info).catch(() => null);
-				trusted = typeof trustInfo?.trusted === "boolean" ? trustInfo.trusted : null;
-				matchesDecryptionKey = typeof trustInfo?.matchesDecryptionKey === "boolean" ? trustInfo.matchesDecryptionKey : null;
-			}
-		}
-		return {
-			serverVersion,
-			trusted,
-			matchesDecryptionKey
-		};
-	}
-	async resolveDefaultSecretStorageKeyId(crypto) {
-		const getSecretStorageStatus = crypto?.getSecretStorageStatus;
-		if (typeof getSecretStorageStatus !== "function") return;
-		return (await getSecretStorageStatus.call(crypto).catch(() => null))?.defaultKeyId;
-	}
-	async resolveRoomKeyBackupVersion() {
-		try {
-			const response = await this.doRequest("GET", "/_matrix/client/v3/room_keys/version");
-			return normalizeOptionalString$1(response.version);
-		} catch {
-			return null;
-		}
-	}
-	async enableTrustedRoomKeyBackupIfPossible(crypto) {
-		if (typeof crypto.checkKeyBackupAndEnable !== "function") return;
-		await crypto.checkKeyBackupAndEnable();
-	}
-	async ensureRoomKeyBackupEnabled(crypto) {
-		if (await this.resolveRoomKeyBackupVersion()) return;
-		LogService.info("MatrixClientLite", "No room key backup version found on server, creating one via secret storage bootstrap");
-		await this.recoveryKeyStore.bootstrapSecretStorageWithRecoveryKey(crypto, { setupNewKeyBackup: true });
-		const createdVersion = await this.resolveRoomKeyBackupVersion();
-		if (!createdVersion) throw new Error("Matrix room key backup is still missing after bootstrap");
-		LogService.info("MatrixClientLite", `Room key backup enabled (version ${createdVersion})`);
-	}
 	registerBridge() {
-		if (this.bridgeRegistered || !this.decryptBridge) return;
-		this.bridgeRegistered = true;
 		const decryptBridge = this.decryptBridge;
-		this.client.on(ClientEvent.Event, (event) => {
-			const roomId = event.getRoomId();
-			if (!roomId) return;
-			const raw = matrixEventToRaw(event, { contentMode: "original" });
-			const isEncryptedEvent = raw.type === "m.room.encrypted";
-			this.emitter.emit("room.event", roomId, raw);
-			if (isEncryptedEvent) this.emitter.emit("room.encrypted_event", roomId, raw);
-			else if (decryptBridge.shouldEmitUnencryptedMessage(roomId, raw.event_id)) this.emitter.emit("room.message", roomId, raw);
-			const stateKey = raw.state_key ?? "";
-			const selfUserId = this.client.getUserId() ?? this.selfUserId ?? "";
-			const membership = raw.type === "m.room.member" ? raw.content.membership : void 0;
-			if (stateKey && selfUserId && stateKey === selfUserId) {
-				if (membership === "invite") this.emitter.emit("room.invite", roomId, raw);
-				else if (membership === "join") this.emitter.emit("room.join", roomId, raw);
+		if (this.bridgeRegistered || !decryptBridge) return;
+		this.bridgeRegistered = true;
+		registerMatrixClientBridge({
+			client: this.client,
+			decryptBridge,
+			emitter: this.emitter,
+			emitMembershipForRoom: (room) => this.emitMembershipForRoom(room),
+			getSelfUserId: () => this.client.getUserId() ?? this.selfUserId ?? "",
+			setCurrentSyncState: (state) => {
+				this.currentSyncState = state;
 			}
-			if (isEncryptedEvent) decryptBridge.attachEncryptedEvent(event, roomId);
-		});
-		this.client.on(ClientEvent.Room, (room) => {
-			this.emitMembershipForRoom(room);
-		});
-		this.client.on(ClientEvent.Sync, (state, prevState, data) => {
-			this.currentSyncState = state;
-			const error = data && typeof data === "object" && "error" in data ? data.error : void 0;
-			this.emitter.emit("sync.state", state, prevState, error);
-		});
-		this.client.on(ClientEvent.SyncUnexpectedError, (error) => {
-			this.emitter.emit("sync.unexpected_error", error);
 		});
 	}
 	emitMembershipForRoom(room) {
-		const roomId = room.roomId.trim();
-		if (!roomId) return;
-		const membership = room.getMyMembership();
-		const selfUserId = this.client.getUserId() ?? this.selfUserId ?? "";
-		if (!selfUserId) return;
-		const raw = {
-			event_id: `$membership-${roomId}-${Date.now()}`,
-			type: "m.room.member",
-			sender: selfUserId,
-			state_key: selfUserId,
-			content: { membership },
-			origin_server_ts: Date.now(),
-			unsigned: { age: 0 }
-		};
-		if (membership === "invite") {
-			this.emitter.emit("room.invite", roomId, raw);
-			return;
-		}
-		if (membership === "join") this.emitter.emit("room.join", roomId, raw);
+		emitMatrixMembershipForRoom({
+			client: this.client,
+			emitter: this.emitter,
+			room,
+			selfUserId: this.client.getUserId() ?? this.selfUserId ?? ""
+		});
 	}
 	emitOutstandingInviteEvents() {
 		for (const room of this.client.getRooms()) this.emitMembershipForRoom(room);
 	}
 	async refreshDmCache() {
-		const direct = await this.getAccountData("m.direct");
-		this.dmRoomIds.clear();
-		if (!direct || typeof direct !== "object") return false;
-		for (const value of Object.values(direct)) {
-			if (!Array.isArray(value)) continue;
-			for (const roomId of value) if (typeof roomId === "string" && roomId.trim()) this.dmRoomIds.add(roomId);
-		}
-		return true;
+		return refreshMatrixDmRoomIds(await this.getAccountData("m.direct"), this.dmRoomIds);
 	}
 };
 //#endregion