@openclaw/matrix 2026.7.2-beta.7 → 2026.7.34

package/dist/{sdk-bUytQHx7.js → .setup/sdk-He1quVAq.mjs}

@@ -1,121 +1,368 @@
-import { n as formatMatrixErrorReason, r as isMatrixNotFoundError, t as formatMatrixErrorMessage } from "./errors-C47hvAF8.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-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 { 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-BNnHvXdk.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { n as formatMatrixErrorReason, r as isMatrixNotFoundError, t as formatMatrixErrorMessage } from "./errors-C47hvAF8.mjs";
+import { E as writeMatrixRecoveryKeyStateForPath, c as migrateLegacyMatrixRecoveryKeyFilePathToStore, m as readLegacyMatrixRecoveryKeyFile, y as readMatrixRecoveryKeyStateForPath } from "./crypto-state-store-B43k3z3W.mjs";
+import { n as LogService, r as noop, t as ConsoleLogger } from "./logger-DpoogOgz.mjs";
+import { t as SqliteBackedMatrixSyncStore } from "./file-sync-store-DU0cnYAz.mjs";
+import { t as MATRIX_IDB_PERSIST_INTERVAL_MS } from "./idb-persistence-lock-B3fZXyF_.mjs";
+import { a as throwIfMatrixStartupAborted, r as createMatrixStartupAbortError } from "./client-DFBQtzCe.mjs";
+import { a as matrixEventToRaw, n as createMatrixGuardedFetch, o as parseMxc, t as MatrixAuthedHttpClient } from "./http-client-C954In2D.mjs";
+import { n as resolveMatrixRoomKeyBackupReadinessError } from "./backup-health-Dm_YMVFT.mjs";
+import { createMatrixJsSdkClientLogger } from "./logging-CgxQOJJP.mjs";
+import { n as isMatrixReadySyncState, r as isMatrixTerminalSyncState } from "./sync-state-CWbp0QSY.mjs";
+import { createRequire } from "node:module";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeNullableString, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
 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/client-device-info.ts
-async function resolveMatrixCrossSigningPublicationStatus(params) {
-	if (!params.userId) return {
-		userId: null,
-		masterKeyPublished: false,
-		selfSigningKeyPublished: false,
-		userSigningKeyPublished: false,
-		published: false
-	};
+import { SyncApi, SyncState } from "matrix-js-sdk/lib/sync.js";
+import { decodeRecoveryKey } from "matrix-js-sdk/lib/crypto-api/recovery-key.js";
+//#region extensions/matrix/src/matrix/sdk/client-sync-quiesce.ts
+const MATRIX_SYNC_QUIESCE_TIMEOUT_MS = 5e3;
+const MATRIX_JS_SDK_SYNC_VERSION = "41.9.0-rc.0";
+const matrixJsSdkPackage = createRequire(import.meta.url)("matrix-js-sdk/package.json");
+function requireMatrixClassicSyncInternals(syncApi) {
+	return syncApi;
+}
+function assertMatrixJsSdkSyncVersion() {
+	const version = matrixJsSdkPackage.version;
+	if (version !== MATRIX_JS_SDK_SYNC_VERSION) throw new Error(`Matrix sync quiesce requires matrix-js-sdk ${MATRIX_JS_SDK_SYNC_VERSION}; found ${String(version)}`);
+}
+async function quiesceMatrixClientSync(params) {
+	await params.syncStore?.freezeSyncCursorPersistence();
 	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]);
+		assertMatrixJsSdkSyncVersion();
+	} catch (error) {
+		params.syncStore?.discardPendingSyncCursorPersistence();
+		throw error;
+	}
+	const syncApi = params.client.syncApi;
+	if (syncApi === void 0 && !params.started) return;
+	if (!(syncApi instanceof SyncApi)) {
+		params.syncStore?.discardPendingSyncCursorPersistence();
+		throw new Error(syncApi === void 0 ? "Matrix sync quiesce requires the classic matrix-js-sdk SyncApi, but none is active" : "Matrix sync quiesce rejected a sliding or unknown matrix-js-sdk sync implementation");
+	}
+	const syncState = syncApi.getSyncState();
+	if (syncState === SyncState.Stopped) {
+		params.markStopped();
+		return;
+	}
+	const disconnectedBeforeStop = syncState === SyncState.Error || syncState === SyncState.Reconnecting;
+	const syncInternals = requireMatrixClassicSyncInternals(syncApi);
+	const keepaliveResolvers = disconnectedBeforeStop ? syncInternals.connectionReturnedResolvers : void 0;
+	await new Promise((resolve, reject) => {
+		let settled = false;
+		const settle = (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			params.emitter.off("sync.state", onSyncState);
+			if (error) reject(error);
+			else {
+				params.markStopped();
+				resolve();
+			}
+		};
+		const onSyncState = (state) => {
+			if (state === "STOPPED") settle();
+		};
+		const timeout = setTimeout(() => {
+			params.syncStore?.discardPendingSyncCursorPersistence();
+			settle(/* @__PURE__ */ new Error("Matrix classic sync did not reach STOPPED within 5000ms"));
+		}, MATRIX_SYNC_QUIESCE_TIMEOUT_MS);
+		timeout.unref?.();
+		params.emitter.on("sync.state", onSyncState);
+		try {
+			syncApi.stop();
+			if (keepaliveResolvers && syncInternals.connectionReturnedResolvers === keepaliveResolvers) {
+				syncInternals.connectionReturnedResolvers = void 0;
+				keepaliveResolvers.reject("SyncApi.stop() was called");
+				settle();
+			}
+		} catch (error) {
+			params.syncStore?.discardPendingSyncCursorPersistence();
+			settle(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/recovery-key-store.ts
+function isRepairableSecretStorageAccessError(err) {
+	const message = formatMatrixErrorReason(err);
+	if (!message) return false;
+	if (message.includes("getsecretstoragekey callback returned falsey")) return true;
+	if (message.includes("decrypting secret") && message.includes("bad mac")) return true;
+	return false;
+}
+var MatrixRecoveryKeyStore = class {
+	constructor(recoveryKeyPath) {
+		this.secretStorageKeyCache = /* @__PURE__ */ new Map();
+		this.stagedRecoveryKey = null;
+		this.stagedRecoveryKeyUsed = false;
+		this.stagedCacheKeyIds = /* @__PURE__ */ new Set();
+		this.recoveryKeyPath = recoveryKeyPath;
+		this.storageRootDir = recoveryKeyPath ? path.dirname(recoveryKeyPath) : void 0;
+		if (this.recoveryKeyPath) try {
+			migrateLegacyMatrixRecoveryKeyFilePathToStore(this.recoveryKeyPath);
+		} catch (err) {
+			this.legacyRecoveryKeyPathOnMigrationFailure = this.recoveryKeyPath;
+			LogService.warn("MatrixClientLite", "Failed to migrate Matrix recovery key state:", err);
+		}
+	}
+	buildCryptoCallbacks() {
 		return {
-			userId: params.userId,
-			masterKeyPublished,
-			selfSigningKeyPublished,
-			userSigningKeyPublished,
-			published: masterKeyPublished && selfSigningKeyPublished && userSigningKeyPublished
+			getSecretStorageKey: async ({ keys }) => {
+				const requestedKeyIds = Object.keys(keys ?? {});
+				if (requestedKeyIds.length === 0) return null;
+				const staged = this.resolveStagedSecretStorageKey(requestedKeyIds);
+				if (staged) return staged;
+				for (const keyId of requestedKeyIds) {
+					const cached = this.secretStorageKeyCache.get(keyId);
+					if (cached) return [keyId, new Uint8Array(cached.key)];
+				}
+				const stored = this.loadStoredRecoveryKey();
+				if (!stored?.privateKeyBase64) return null;
+				const privateKey = new Uint8Array(Buffer.from(stored.privateKeyBase64, "base64"));
+				if (privateKey.length === 0) return null;
+				if (stored.keyId && requestedKeyIds.includes(stored.keyId)) {
+					this.rememberSecretStorageKey(stored.keyId, privateKey, stored.keyInfo);
+					return [stored.keyId, privateKey];
+				}
+				const firstRequestedKeyId = requestedKeyIds[0];
+				if (!firstRequestedKeyId) return null;
+				this.rememberSecretStorageKey(firstRequestedKeyId, privateKey, stored.keyInfo);
+				return [firstRequestedKeyId, privateKey];
+			},
+			cacheSecretStorageKey: (keyId, keyInfo, key) => {
+				const privateKey = new Uint8Array(key);
+				const normalizedKeyInfo = {
+					passphrase: keyInfo?.passphrase,
+					name: typeof keyInfo?.name === "string" ? keyInfo.name : void 0
+				};
+				this.rememberSecretStorageKey(keyId, privateKey, normalizedKeyInfo);
+				const stored = this.loadStoredRecoveryKey();
+				this.saveRecoveryKeyToDisk({
+					keyId,
+					keyInfo: normalizedKeyInfo,
+					privateKey,
+					encodedPrivateKey: stored?.encodedPrivateKey
+				});
+			}
 		};
-	} catch {
+	}
+	getRecoveryKeySummary() {
+		const stored = this.loadStoredRecoveryKey();
+		if (!stored) return null;
 		return {
-			userId: params.userId,
-			masterKeyPublished: false,
-			selfSigningKeyPublished: false,
-			userSigningKeyPublished: false,
-			published: false
+			encodedPrivateKey: stored.encodedPrivateKey,
+			keyId: stored.keyId,
+			createdAt: stored.createdAt
 		};
 	}
-}
-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);
+	getSecretStorageKeyCandidate(keyId) {
+		const normalizedKeyId = keyId.trim();
+		if (!normalizedKeyId) return null;
+		const staged = this.resolveStagedSecretStorageKey([normalizedKeyId]);
+		if (staged) return staged[1];
+		const stored = this.loadStoredRecoveryKey();
+		if (!stored?.privateKeyBase64) return null;
+		const privateKey = new Uint8Array(Buffer.from(stored.privateKeyBase64, "base64"));
+		if (privateKey.length === 0) return null;
+		this.rememberSecretStorageKey(normalizedKeyId, privateKey, stored.keyInfo);
+		return privateKey;
+	}
+	resolveEncodedRecoveryKeyInput(params) {
+		const encodedPrivateKey = params.encodedPrivateKey.trim();
+		if (!encodedPrivateKey) throw new Error("Matrix recovery key is required");
+		let privateKey;
+		try {
+			privateKey = decodeRecoveryKey(encodedPrivateKey);
+		} catch (err) {
+			throw new Error(`Invalid Matrix recovery key: ${formatMatrixErrorMessage(err)}`, { cause: err });
 		}
-		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;
+		const keyId = typeof params.keyId === "string" && params.keyId.trim() ? params.keyId.trim() : null;
+		return {
+			encodedPrivateKey,
+			privateKey,
+			keyId,
+			keyInfo: params.keyInfo ?? this.loadStoredRecoveryKey()?.keyInfo
+		};
 	}
-	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;
-}
+	storeEncodedRecoveryKey(params) {
+		const prepared = this.resolveEncodedRecoveryKeyInput(params);
+		this.saveRecoveryKeyToDisk({
+			keyId: prepared.keyId,
+			keyInfo: prepared.keyInfo,
+			privateKey: prepared.privateKey,
+			encodedPrivateKey: prepared.encodedPrivateKey
+		});
+		if (prepared.keyId) this.rememberSecretStorageKey(prepared.keyId, prepared.privateKey, prepared.keyInfo);
+		return this.getRecoveryKeySummary() ?? {};
+	}
+	stageEncodedRecoveryKey(params) {
+		const prepared = this.resolveEncodedRecoveryKeyInput(params);
+		this.discardStagedRecoveryKey();
+		this.stagedRecoveryKey = {
+			version: 1,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			keyId: prepared.keyId,
+			encodedPrivateKey: prepared.encodedPrivateKey,
+			privateKeyBase64: Buffer.from(prepared.privateKey).toString("base64"),
+			keyInfo: prepared.keyInfo
+		};
+	}
+	hasStagedRecoveryKeyBeenUsed() {
+		return this.stagedRecoveryKeyUsed;
+	}
+	commitStagedRecoveryKey(params) {
+		if (!this.stagedRecoveryKey) return this.getRecoveryKeySummary();
+		const staged = this.stagedRecoveryKey;
+		const privateKey = new Uint8Array(Buffer.from(staged.privateKeyBase64, "base64"));
+		const keyId = typeof params?.keyId === "string" && params.keyId.trim() ? params.keyId.trim() : staged.keyId;
+		this.saveRecoveryKeyToDisk({
+			keyId,
+			keyInfo: params?.keyInfo ?? staged.keyInfo,
+			privateKey,
+			encodedPrivateKey: staged.encodedPrivateKey
+		});
+		this.clearStagedRecoveryKeyTracking();
+		return this.getRecoveryKeySummary();
+	}
+	discardStagedRecoveryKey() {
+		for (const keyId of this.stagedCacheKeyIds) this.secretStorageKeyCache.delete(keyId);
+		this.clearStagedRecoveryKeyTracking();
+	}
+	async bootstrapSecretStorageWithRecoveryKey(crypto, options = {}) {
+		let status = null;
+		const getSecretStorageStatus = crypto.getSecretStorageStatus;
+		if (typeof getSecretStorageStatus === "function") try {
+			status = await getSecretStorageStatus.call(crypto);
+		} catch (err) {
+			LogService.warn("MatrixClientLite", "Failed to read secret storage status:", err);
+		}
+		const hasDefaultSecretStorageKey = Boolean(status?.defaultKeyId);
+		const hasKnownInvalidSecrets = Object.values(status?.secretStorageKeyValidityMap ?? {}).some((valid) => !valid);
+		let generatedRecoveryKey = false;
+		const storedRecovery = this.loadStoredRecoveryKey();
+		const stagedRecovery = this.stagedRecoveryKey;
+		const sourceRecovery = options.forceNewRecoveryKey === true ? null : stagedRecovery ?? storedRecovery;
+		let recoveryKey = sourceRecovery ? {
+			keyInfo: sourceRecovery.keyInfo,
+			privateKey: new Uint8Array(Buffer.from(sourceRecovery.privateKeyBase64, "base64")),
+			encodedPrivateKey: sourceRecovery.encodedPrivateKey
+		} : null;
+		if (recoveryKey && status?.defaultKeyId) {
+			const defaultKeyId = status.defaultKeyId;
+			if (!stagedRecovery) {
+				this.rememberSecretStorageKey(defaultKeyId, recoveryKey.privateKey, recoveryKey.keyInfo);
+				if (storedRecovery && storedRecovery.keyId !== defaultKeyId) this.saveRecoveryKeyToDisk({
+					keyId: defaultKeyId,
+					keyInfo: recoveryKey.keyInfo,
+					privateKey: recoveryKey.privateKey,
+					encodedPrivateKey: recoveryKey.encodedPrivateKey
+				});
+			}
+		}
+		const ensureRecoveryKey = async () => {
+			if (recoveryKey) {
+				if (stagedRecovery) this.stagedRecoveryKeyUsed = true;
+				return recoveryKey;
+			}
+			if (typeof crypto.createRecoveryKeyFromPassphrase !== "function") throw new Error("Matrix crypto backend does not support recovery key generation (createRecoveryKeyFromPassphrase missing)");
+			recoveryKey = await crypto.createRecoveryKeyFromPassphrase();
+			this.saveRecoveryKeyToDisk(recoveryKey);
+			generatedRecoveryKey = true;
+			return recoveryKey;
+		};
+		const shouldRecreateSecretStorage = options.forceNewSecretStorage === true || !hasDefaultSecretStorageKey || !recoveryKey && status?.ready === false || hasKnownInvalidSecrets;
+		if (hasKnownInvalidSecrets) recoveryKey = null;
+		const secretStorageOptions = { setupNewKeyBackup: options.setupNewKeyBackup === true };
+		if (shouldRecreateSecretStorage) {
+			secretStorageOptions.setupNewSecretStorage = true;
+			secretStorageOptions.createSecretStorageKey = ensureRecoveryKey;
+		}
+		try {
+			await crypto.bootstrapSecretStorage(secretStorageOptions);
+		} catch (err) {
+			if (!(options.allowSecretStorageRecreateWithoutRecoveryKey === true && hasDefaultSecretStorageKey && isRepairableSecretStorageAccessError(err))) throw err;
+			recoveryKey = null;
+			LogService.warn("MatrixClientLite", "Secret storage exists on the server but local recovery material cannot unlock it; recreating secret storage during explicit bootstrap.");
+			await crypto.bootstrapSecretStorage({
+				setupNewSecretStorage: true,
+				setupNewKeyBackup: options.setupNewKeyBackup === true,
+				createSecretStorageKey: ensureRecoveryKey
+			});
+		}
+		if (generatedRecoveryKey && this.storageRootDir) LogService.warn("MatrixClientLite", "Generated Matrix recovery key and saved it to Matrix SQLite state. Keep the displayed recovery key secure.");
+	}
+	clearStagedRecoveryKeyTracking() {
+		this.stagedRecoveryKey = null;
+		this.stagedRecoveryKeyUsed = false;
+		this.stagedCacheKeyIds.clear();
+	}
+	resolveStagedSecretStorageKey(requestedKeyIds) {
+		const staged = this.stagedRecoveryKey;
+		if (!staged?.privateKeyBase64) return null;
+		const privateKey = new Uint8Array(Buffer.from(staged.privateKeyBase64, "base64"));
+		if (privateKey.length === 0) return null;
+		const keyId = staged.keyId && requestedKeyIds.includes(staged.keyId) ? staged.keyId : requestedKeyIds[0];
+		if (!keyId) return null;
+		this.rememberStagedSecretStorageKey(keyId, privateKey, staged.keyInfo);
+		this.stagedCacheKeyIds.add(keyId);
+		return [keyId, privateKey];
+	}
+	rememberStagedSecretStorageKey(keyId, key, keyInfo) {
+		this.stagedRecoveryKeyUsed = true;
+		this.rememberSecretStorageKey(keyId, key, keyInfo);
+	}
+	rememberSecretStorageKey(keyId, key, keyInfo) {
+		if (!keyId.trim()) return;
+		this.secretStorageKeyCache.set(keyId, {
+			key: new Uint8Array(key),
+			keyInfo
+		});
+	}
+	loadStoredRecoveryKey() {
+		if (!this.recoveryKeyPath) return null;
+		try {
+			const stored = readMatrixRecoveryKeyStateForPath(this.recoveryKeyPath);
+			if (stored) return stored;
+		} catch {}
+		if (this.legacyRecoveryKeyPathOnMigrationFailure) return readLegacyMatrixRecoveryKeyFile(this.legacyRecoveryKeyPathOnMigrationFailure);
+		return null;
+	}
+	saveRecoveryKeyToDisk(params) {
+		if (!this.recoveryKeyPath) return;
+		try {
+			const payload = {
+				version: 1,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				keyId: typeof params.keyId === "string" ? params.keyId : null,
+				encodedPrivateKey: params.encodedPrivateKey,
+				privateKeyBase64: Buffer.from(params.privateKey).toString("base64"),
+				keyInfo: params.keyInfo ? {
+					passphrase: params.keyInfo.passphrase,
+					name: params.keyInfo.name
+				} : void 0
+			};
+			writeMatrixRecoveryKeyStateForPath({
+				recoveryKeyPath: this.recoveryKeyPath,
+				payload
+			});
+		} catch (err) {
+			LogService.warn("MatrixClientLite", "Failed to persist recovery key:", err);
+		}
+	}
+};
 //#endregion
-//#region extensions/matrix/src/matrix/sdk/client-support.ts
+//#region extensions/matrix/src/matrix/sdk.ts
+var sdk_exports = /* @__PURE__ */ __exportAll({
+	ConsoleLogger: () => ConsoleLogger,
+	LogService: () => LogService,
+	MatrixClient: () => MatrixClient
+});
 const MATRIX_STATUS_DIAGNOSTIC_TIMEOUT_MS = 1e4;
 const DEFAULT_MATRIX_LOCAL_TIMEOUT_MS = 6e4;
 function resolveMatrixLocalTimeoutMs(raw) {
@@ -194,14 +441,19 @@ 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-D9_6J5tZ.js").then((runtime) => {
+const loadMatrixCryptoRuntime = createLazyRuntimeModule(() => import("./crypto-runtime-D-cZa8P0.mjs").then((runtime) => {
 	loadedMatrixCryptoRuntime = runtime;
 	return runtime;
 }));
-var MatrixClientBase = class {
+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 {
 	constructor(homeserver, accessToken, opts = {}) {
 		this.emitter = new EventEmitter();
 		this.bridgeRegistered = false;
@@ -210,7 +462,9 @@ var MatrixClientBase = class {
 		this.dmRoomIds = /* @__PURE__ */ new Set();
 		this.cryptoInitialized = false;
 		this.sendQueue = new KeyedAsyncQueue();
+		this.syncQuiescePromise = null;
 		this.stopPersistPromise = null;
+		this.sdkStopped = false;
 		this.verificationSummaryListenerBound = false;
 		this.currentSyncState = null;
 		this.dms = {
@@ -230,8 +484,7 @@ var MatrixClientBase = class {
 		this.initialSyncLimit = opts.initialSyncLimit;
 		this.syncFilter = opts.syncFilter;
 		this.encryptionEnabled = opts.encryption === true;
-		const { password: loginPassword } = opts;
-		this.password = loginPassword;
+		this.password = opts.password;
 		this.syncStore = opts.storageRootDir ? new SqliteBackedMatrixSyncStore(opts.storageRootDir) : void 0;
 		this.idbSnapshotPath = opts.idbSnapshotPath;
 		this.cryptoDatabasePrefix = opts.cryptoDatabasePrefix;
@@ -388,6 +641,7 @@ var MatrixClientBase = class {
 	}
 	async startSyncSession(opts) {
 		if (this.started) return;
+		if (this.sdkStopped) throw new Error("Matrix client has been fully stopped and cannot be restarted; acquire a new shared client generation");
 		throwIfMatrixStartupAborted(opts.abortSignal);
 		await this.ensureCryptoSupportInitialized();
 		throwIfMatrixStartupAborted(opts.abortSignal);
@@ -425,43 +679,57 @@ var MatrixClientBase = class {
 		if (this.started) return;
 		await this.startSyncSession({ bootstrapCrypto: false });
 	}
-	stopSyncWithoutPersist() {
+	stopSdkClient() {
+		if (this.sdkStopped) return;
 		if (this.idbPersistTimer) {
 			clearInterval(this.idbPersistTimer);
 			this.idbPersistTimer = null;
 		}
 		this.currentSyncState = null;
 		this.client.stopClient();
+		this.sdkStopped = true;
 		this.started = false;
 	}
+	async quiesceSync() {
+		this.syncQuiescePromise ??= quiesceMatrixClientSync({
+			client: this.client,
+			emitter: this.emitter,
+			markStopped: () => {
+				this.started = false;
+			},
+			started: this.started,
+			syncStore: this.syncStore
+		});
+		await this.syncQuiescePromise;
+	}
 	async drainPendingDecryptions(reason = "matrix client shutdown") {
 		await this.decryptBridge?.drainPendingDecryptions(reason);
 	}
 	stop() {
-		this.stopSyncWithoutPersist();
-		this.decryptBridge?.stop();
-		this.syncStore?.markCleanShutdown();
-		if (loadedMatrixCryptoRuntime) {
-			const { persistIdbToDisk } = loadedMatrixCryptoRuntime;
-			this.stopPersistPromise = Promise.all([persistIdbToDisk({
-				snapshotPath: this.idbSnapshotPath,
-				databasePrefix: this.cryptoDatabasePrefix
-			}).catch(noop), this.syncStore?.flush().catch(noop)]).then(() => void 0);
+		this.stopAndPersist().catch(() => this.stopWithoutPersist()).catch(noop);
+	}
+	async stopAndPersist() {
+		if (this.stopPersistPromise) {
+			await this.stopPersistPromise;
 			return;
 		}
-		this.stopPersistPromise = loadMatrixCryptoRuntime().then(async ({ persistIdbToDisk }) => {
-			await Promise.all([persistIdbToDisk({
+		this.stopPersistPromise = (async () => {
+			await this.quiesceSync();
+			this.stopSdkClient();
+			this.decryptBridge?.stop();
+			await (loadedMatrixCryptoRuntime ?? await loadMatrixCryptoRuntime()).persistIdbToDisk({
 				snapshotPath: this.idbSnapshotPath,
-				databasePrefix: this.cryptoDatabasePrefix
-			}).catch(noop), this.syncStore?.flush().catch(noop)]);
-		}).catch(noop).then(() => void 0);
-	}
-	async stopAndPersist() {
-		this.stop();
+				databasePrefix: this.cryptoDatabasePrefix,
+				strict: true
+			});
+			this.syncStore?.markCleanShutdown();
+			await this.syncStore?.flush();
+		})();
 		await this.stopPersistPromise;
 	}
 	stopWithoutPersist() {
-		this.stopSyncWithoutPersist();
+		this.syncStore?.discardPendingSyncCursorPersistence();
+		this.stopSdkClient();
 		this.decryptBridge?.stop();
 		this.stopPersistPromise = Promise.resolve();
 	}
@@ -475,13 +743,15 @@ var MatrixClientBase = class {
 		if (!cryptoBootstrapper) return;
 		const initial = await cryptoBootstrapper.bootstrap(crypto, MATRIX_INITIAL_CRYPTO_BOOTSTRAP_OPTIONS);
 		throwIfMatrixStartupAborted(abortSignal);
-		if (!initial.crossSigningPublished || initial.ownDeviceVerified === false) if ((await this.getOwnDeviceVerificationStatus()).signedByOwner) LogService.warn("MatrixClientLite", "Cross-signing/bootstrap is incomplete for an already owner-signed device; skipping automatic reset and preserving the current identity. Restore the recovery key or run an explicit verification bootstrap if repair is needed.");
-		else try {
-			const repaired = await cryptoBootstrapper.bootstrap(crypto, MATRIX_AUTOMATIC_REPAIR_BOOTSTRAP_OPTIONS);
-			throwIfMatrixStartupAborted(abortSignal);
-			if (repaired.crossSigningPublished && repaired.ownDeviceVerified !== false) LogService.info("MatrixClientLite", "Cross-signing/bootstrap recovered after forced reset");
-		} catch (err) {
-			LogService.warn("MatrixClientLite", "Failed to recover cross-signing/bootstrap with forced reset:", err);
+		if (!initial.crossSigningPublished || initial.ownDeviceVerified === false) {
+			if ((await this.getOwnDeviceVerificationStatus()).signedByOwner) LogService.warn("MatrixClientLite", "Cross-signing/bootstrap is incomplete for an already owner-signed device; skipping automatic reset and preserving the current identity. Restore the recovery key or run an explicit verification bootstrap if repair is needed.");
+			else try {
+				const repaired = await cryptoBootstrapper.bootstrap(crypto, MATRIX_AUTOMATIC_REPAIR_BOOTSTRAP_OPTIONS);
+				throwIfMatrixStartupAborted(abortSignal);
+				if (repaired.crossSigningPublished && repaired.ownDeviceVerified !== false) LogService.info("MatrixClientLite", "Cross-signing/bootstrap recovered after forced reset");
+			} catch (err) {
+				LogService.warn("MatrixClientLite", "Failed to recover cross-signing/bootstrap with forced reset:", err);
+			}
 		}
 		this.cryptoBootstrapped = true;
 	}
@@ -511,16 +781,6 @@ var MatrixClientBase = 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) {
@@ -543,13 +803,13 @@ var MatrixClientCore = class extends MatrixClientBase {
 		return Object.keys(joined);
 	}
 	hasSyncedJoinedRoomMember(roomId, userId) {
-		return this.client.getRoom(roomId)?.getMember(userId)?.membership === "join";
+		return (this.client.getRoom?.(roomId))?.currentState?.getMember?.(userId)?.membership === "join";
 	}
 	async getRoomStateEvent(roomId, eventType, stateKey = "") {
 		return await this.client.getStateEvent(roomId, eventType, stateKey) ?? {};
 	}
 	async getAccountData(eventType) {
-		return await this.client.getAccountDataFromServer(eventType) ?? void 0;
+		return this.client.getAccountData(eventType)?.getContent() ?? void 0;
 	}
 	async setAccountData(eventType, content) {
 		await this.client.setAccountData(eventType, content);
@@ -695,11 +955,6 @@ var MatrixClientCore = class extends MatrixClientBase {
 			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,
@@ -728,14 +983,16 @@ var MatrixClientVerification = class extends MatrixClientCore {
 		let keyLoadAttempted = false;
 		let keyLoadError = null;
 		if (serverVersion && (shouldLoadBackupKey || shouldActivateBackup)) {
-			if (shouldLoadBackupKey) if (typeof crypto.loadSessionBackupPrivateKeyFromSecretStorage === "function") {
-				keyLoadAttempted = true;
-				try {
-					await crypto.loadSessionBackupPrivateKeyFromSecretStorage();
-				} catch (err) {
-					keyLoadError = formatMatrixErrorMessage(err);
-				}
-			} else keyLoadError = "Matrix crypto backend does not support loading backup keys from secret storage";
+			if (shouldLoadBackupKey) {
+				if (typeof crypto.loadSessionBackupPrivateKeyFromSecretStorage === "function") {
+					keyLoadAttempted = true;
+					try {
+						await crypto.loadSessionBackupPrivateKeyFromSecretStorage();
+					} catch (err) {
+						keyLoadError = formatMatrixErrorMessage(err);
+					}
+				} else keyLoadError = "Matrix crypto backend does not support loading backup keys from secret storage";
+			}
 			if (!keyLoadError) await this.enableTrustedRoomKeyBackupIfPossible(crypto);
 			({activeVersion, decryptionKeyCached} = await this.resolveRoomKeyBackupLocalState(crypto));
 			({serverVersion, trusted, matchesDecryptionKey} = await this.resolveRoomKeyBackupTrustState(crypto, serverVersion));
@@ -776,6 +1033,9 @@ var MatrixClientVerification = class extends MatrixClientCore {
 			signedByOwner: deviceStatus?.signedByOwner === true
 		};
 	}
+	async refreshOwnDeviceKeys() {
+		await this.client.getCrypto()?.userHasCrossSigningKeys(await this.getUserId(), true);
+	}
 	async getOwnDeviceVerificationStatus() {
 		const recoveryKey = this.recoveryKeyStore.getRecoveryKeySummary();
 		const userId = this.client.getUserId() ?? this.selfUserId ?? null;
@@ -827,83 +1087,6 @@ var MatrixClientVerification = class extends MatrixClientCore {
 			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();
@@ -1148,10 +1331,34 @@ var MatrixClient = class extends MatrixClientVerification {
 	}
 	async getOwnCrossSigningPublicationStatus() {
 		const userId = this.client.getUserId() ?? this.selfUserId ?? null;
-		return await resolveMatrixCrossSigningPublicationStatus({
-			userId,
-			query: async () => await this.doRequest("POST", "/_matrix/client/v3/keys/query", void 0, { device_keys: userId ? { [userId]: [] } : {} })
-		});
+		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
+			};
+		}
 	}
 	async bootstrapOwnDeviceVerification(params) {
 		const pendingVerifications = async () => this.crypto ? (await this.crypto.listVerifications()).length : 0;
@@ -1207,7 +1414,15 @@ var MatrixClient = class extends MatrixClientVerification {
 		};
 	}
 	async listOwnDevices() {
-		return await listMatrixOwnDevices(this.client);
+		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
+		}));
 	}
 	async deleteOwnDevices(deviceIds) {
 		const uniqueDeviceIds = uniqueStrings(normalizeStringEntries(deviceIds));
@@ -1239,35 +1454,151 @@ var MatrixClient = class extends MatrixClientVerification {
 			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() {
-		const decryptBridge = this.decryptBridge;
-		if (this.bridgeRegistered || !decryptBridge) return;
+		if (this.bridgeRegistered || !this.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;
+		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 (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) {
-		emitMatrixMembershipForRoom({
-			client: this.client,
-			emitter: this.emitter,
-			room,
-			selfUserId: this.client.getUserId() ?? this.selfUserId ?? ""
-		});
+		const roomObj = room;
+		const roomId = roomObj.roomId?.trim();
+		if (!roomId) return;
+		const membership = roomObj.getMyMembership?.() ?? roomObj.selfMembership ?? void 0;
+		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);
 	}
 	emitOutstandingInviteEvents() {
-		for (const room of this.client.getRooms()) this.emitMembershipForRoom(room);
+		const listRooms = this.client.getRooms;
+		if (typeof listRooms !== "function") return;
+		const rooms = listRooms.call(this.client);
+		if (!Array.isArray(rooms)) return;
+		for (const room of rooms) this.emitMembershipForRoom(room);
 	}
 	async refreshDmCache() {
-		return refreshMatrixDmRoomIds(await this.getAccountData("m.direct"), this.dmRoomIds);
+		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;
 	}
 };
 //#endregion
-export { ConsoleLogger, LogService, MatrixClient };
+export { ConsoleLogger, LogService, MatrixClient, isRepairableSecretStorageAccessError as n, sdk_exports as t };