@openclaw/matrix 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/{sdk-DmRVM0VA.mjs → sdk-CgQGkCsS.mjs}

@@ -1,16 +1,16 @@
-import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { E as writeMatrixRecoveryKeyStateForPathAsync, _ as readLegacyMatrixRecoveryKeyFile, f as migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync, x as readMatrixRecoveryKeyStateForPathAsync } from "./storage-metadata-BDRZ7vpX.mjs";
-import { r as withoutMatrixSendCurrentness, t as captureMatrixSendCurrentness } from "./send-currentness-C2rMVVIQ.mjs";
+import { r as assertMatrixSupportedStateFile } from "./retired-state-BXUQ2I-C.mjs";
+import { d as writeMatrixRecoveryKeyStateForPathAsync, l as readMatrixRecoveryKeyStateForPathAsync } from "./storage-D7agewjH.mjs";
+import { n as withMatrixSendCurrentness, r as withoutMatrixSendCurrentness, t as captureMatrixSendCurrentness } from "./send-currentness-C2rMVVIQ.mjs";
 import { i as parseMxc, r as matrixEventToRaw } from "./event-helpers-CspuhE9k.mjs";
 import { n as isMatrixNotFoundError, t as formatMatrixErrorReason } from "./errors-DKVS3_DO.mjs";
-import { i as createMatrixStartupAbortError, o as throwIfMatrixStartupAborted, r as awaitMatrixStartupWithAbort } from "./client-Ccv77kwh.mjs";
-import { n as createMatrixGuardedFetch, t as MatrixAuthedHttpClient } from "./http-client-C1XvVD3K.mjs";
+import { i as createMatrixStartupAbortError, o as throwIfMatrixStartupAborted, r as awaitMatrixStartupWithAbort } from "./client-kmih04ng.mjs";
+import { n as createMatrixGuardedFetch, t as MatrixAuthedHttpClient } from "./http-client-DfJY5Ck0.mjs";
 import { n as resolveMatrixRoomKeyBackupReadinessError } from "./backup-health-Dm_YMVFT.mjs";
-import { n as LogService, r as noop, t as ConsoleLogger } from "./logger-CVv56jzH.mjs";
-import { t as createMatrixJsSdkClientLogger } from "./logging-mhnFQGzB.mjs";
-import { t as MATRIX_IDB_PERSIST_INTERVAL_MS } from "./idb-persistence-lock-D_mDu4Cf.mjs";
-import { a as isMatrixAccessTokenInvalidatedError, c as resolveMatrixLocalTimeoutMs, f as isMatrixReadySyncState, i as createMatrixExplicitBootstrapOptions, l as unresolvedMatrixDeviceVerificationStatus, n as MATRIX_INITIAL_CRYPTO_BOOTSTRAP_OPTIONS, o as resolveMatrixDiagnostic, p as isMatrixTerminalSyncState, r as MATRIX_STATUS_DIAGNOSTIC_TIMEOUT_MS, s as resolveMatrixDiagnosticResult, t as MATRIX_AUTOMATIC_REPAIR_BOOTSTRAP_OPTIONS, u as unresolvedMatrixRoomKeyBackupStatus } from "./client-support-Bn9Bk0-H.mjs";
+import { r as noop, t as LogService } from "./logger-CXQnpXCt.mjs";
+import { t as createMatrixJsSdkClientLogger } from "./logging-BKV8TYQq.mjs";
+import { a as isMatrixAccessTokenInvalidatedError, c as resolveMatrixLocalTimeoutMs, f as isMatrixReadySyncState, i as createMatrixExplicitBootstrapOptions, l as unresolvedMatrixDeviceVerificationStatus, n as MATRIX_INITIAL_CRYPTO_BOOTSTRAP_OPTIONS, o as resolveMatrixDiagnostic, p as isMatrixTerminalSyncState, r as MATRIX_STATUS_DIAGNOSTIC_TIMEOUT_MS, s as resolveMatrixDiagnosticResult, t as MATRIX_AUTOMATIC_REPAIR_BOOTSTRAP_OPTIONS, u as unresolvedMatrixRoomKeyBackupStatus } from "./client-support-D7BlioUb.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";
@@ -19,6 +19,7 @@ import path from "node:path";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { captureChannelReadAuthority } from "openclaw/plugin-sdk/fetch-runtime";
 import { ClientEvent, EventType, Filter, MatrixError, MatrixEventEvent, MsgType, Preset, createClient } from "matrix-js-sdk/lib/matrix.js";
 import { EventEmitter } from "node:events";
@@ -30,34 +31,21 @@ import { MatrixScheduler } from "matrix-js-sdk/lib/scheduler.js";
 import { EventStatus } from "matrix-js-sdk/lib/models/event-status.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
+	let response;
+	if (params.userId) try {
+		response = await params.query();
+	} catch {}
+	const userId = params.userId || null;
+	const masterKeyPublished = Boolean(userId && response?.master_keys?.[userId]);
+	const selfSigningKeyPublished = Boolean(userId && response?.self_signing_keys?.[userId]);
+	const userSigningKeyPublished = Boolean(userId && response?.user_signing_keys?.[userId]);
+	return {
+		userId,
+		masterKeyPublished,
+		selfSigningKeyPublished,
+		userSigningKeyPublished,
+		published: masterKeyPublished && selfSigningKeyPublished && userSigningKeyPublished
 	};
-	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;
@@ -104,7 +92,8 @@ function registerMatrixClientBridge(params) {
 	params.client.on(ClientEvent.Sync, (state, prevState, data) => {
 		initialSyncComplete ||= state === "PREPARED" || state === "SYNCING";
 		const error = data && typeof data === "object" && "error" in data ? data.error : void 0;
-		params.setCurrentSyncState(state, error);
+		const fromCache = data != null && typeof data === "object" && "fromCache" in data && data.fromCache === true;
+		params.setCurrentSyncState(state, error, fromCache);
 		params.emitter.emit("sync.state", state, prevState, error);
 	});
 	params.client.on(ClientEvent.SyncUnexpectedError, (error) => {
@@ -265,6 +254,115 @@ async function waitForMatrixInitialSyncReady(params) {
 	});
 }
 //#endregion
+//#region extensions/matrix/src/matrix/sdk/idb-persistence-lock.ts
+const MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
+const IDB_SNAPSHOT_LOCK_STALE_MS = 3e5;
+const IDB_SNAPSHOT_LOCK_RETRY_BASE = {
+	factor: 2,
+	minTimeout: 50,
+	maxTimeout: 5e3,
+	randomize: true
+};
+function resolveRetriesForMinimumWindowMs(retries, minimumWindowMs) {
+	const resolved = {
+		...retries,
+		retries: 0
+	};
+	let total = 0;
+	while (total < minimumWindowMs) {
+		total += Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** resolved.retries));
+		resolved.retries += 1;
+	}
+	return resolved;
+}
+const MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS = {
+	retries: resolveRetriesForMinimumWindowMs(IDB_SNAPSHOT_LOCK_RETRY_BASE, MATRIX_IDB_PERSIST_INTERVAL_MS),
+	stale: IDB_SNAPSHOT_LOCK_STALE_MS
+};
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/live-room-readiness.ts
+async function withMatrixLiveEncryptedRoom(owner, run, params) {
+	const signal = AbortSignal.any([params.generationSignal, ...params.abortSignal ? [params.abortSignal] : []]);
+	const active = (async () => {
+		signal.throwIfAborted();
+		params.assertActive();
+		await params.initializeCrypto();
+		signal.throwIfAborted();
+		params.assertActive();
+		return await probeMatrixLiveEncryptedRoom({
+			...params,
+			signal
+		});
+	})();
+	params.operations.add(active);
+	active.finally(() => params.operations.delete(active)).catch(noop);
+	const stopped = createDeferred();
+	const onSyncState = (state) => {
+		if (state === "STOPPED") stopped.reject(/* @__PURE__ */ new Error("Matrix sync stopped while waiting for a live encrypted room"));
+	};
+	params.emitter.on("sync.state", onSyncState);
+	let assertCurrent;
+	try {
+		onSyncState(params.getSync().state);
+		assertCurrent = await Promise.race([awaitMatrixStartupWithAbort(active, signal), stopped.promise]);
+	} finally {
+		params.emitter.off("sync.state", onSyncState);
+	}
+	assertCurrent();
+	return await withMatrixSendCurrentness(owner, assertCurrent, () => run(assertCurrent));
+}
+async function probeMatrixLiveEncryptedRoom(params) {
+	let changed;
+	let wake;
+	const onChange = () => {
+		changed = true;
+		wake?.();
+	};
+	const assertActive = () => {
+		params.signal.throwIfAborted();
+		params.assertActive();
+		if (params.getSync().state === "STOPPED") throw new Error("Matrix sync stopped while waiting for a live encrypted room");
+	};
+	const events = [
+		"sync.state",
+		"room.event",
+		"room.join"
+	];
+	for (const event of events) params.emitter.on(event, onChange);
+	params.signal.addEventListener("abort", onChange);
+	try {
+		for (;;) {
+			changed = false;
+			assertActive();
+			const sync = params.getSync();
+			const room = params.client.getRoom(params.roomId);
+			const crypto = params.client.getCrypto();
+			const isCurrent = () => {
+				const current = params.getSync();
+				return !current.fromCache && (current.state === "PREPARED" || current.state === "SYNCING") && room != null && params.client.getRoom(params.roomId) === room && room.getMyMembership() === "join" && room.hasEncryptionStateEvent() && crypto != null && params.client.getCrypto() === crypto;
+			};
+			if (isCurrent() && crypto) {
+				const encrypted = await crypto.isEncryptionEnabledInRoom(params.roomId);
+				assertActive();
+				if (params.getSync().revision !== sync.revision || !isCurrent()) continue;
+				if (encrypted) return () => {
+					assertActive();
+					if (!isCurrent()) throw new Error("Matrix live encrypted room changed before dispatch; retry the send");
+				};
+			}
+			if (!changed) {
+				await new Promise((resolve) => {
+					wake = resolve;
+				});
+				wake = void 0;
+			}
+		}
+	} finally {
+		for (const event of events) params.emitter.off(event, onChange);
+		params.signal.removeEventListener("abort", onChange);
+	}
+}
+//#endregion
 //#region extensions/matrix/src/matrix/sdk/message-wire-dispatch.ts
 function resolveMessageWireDispatch(resource, init) {
 	if ((init?.method ?? (resource instanceof Request ? resource.method : "GET")).toUpperCase() !== "PUT") return null;
@@ -339,18 +437,7 @@ var MatrixRecoveryKeyStore = class {
 		this.closed = false;
 		this.recoveryKeyPath = recoveryKeyPath;
 		this.storageRootDir = recoveryKeyPath ? path.dirname(recoveryKeyPath) : void 0;
-		if (recoveryKeyPath) {
-			this.stateRuntime = stateRuntime ?? getMatrixRuntime().state;
-			const runtime = this.stateRuntime;
-			this.enqueuePersistence(async () => {
-				try {
-					await migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync(recoveryKeyPath, runtime);
-				} catch (err) {
-					this.legacyRecoveryKeyPathOnMigrationFailure = recoveryKeyPath;
-					LogService.warn("MatrixClientLite", "Failed to migrate Matrix recovery key state:", err);
-				}
-			});
-		}
+		if (recoveryKeyPath) this.stateRuntime = stateRuntime ?? getMatrixRuntime().state;
 	}
 	enqueuePersistence(run) {
 		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Matrix recovery key store is closed"));
@@ -597,12 +684,12 @@ var MatrixRecoveryKeyStore = class {
 	}
 	async loadStoredRecoveryKey() {
 		if (!this.recoveryKeyPath || !this.stateRuntime) return null;
+		await assertMatrixSupportedStateFile(this.recoveryKeyPath);
 		try {
-			const stored = await readMatrixRecoveryKeyStateForPathAsync(this.recoveryKeyPath, this.stateRuntime);
-			if (stored) return stored;
-		} catch {}
-		if (this.legacyRecoveryKeyPathOnMigrationFailure) return readLegacyMatrixRecoveryKeyFile(this.legacyRecoveryKeyPathOnMigrationFailure);
-		return null;
+			return await readMatrixRecoveryKeyStateForPathAsync(this.recoveryKeyPath, this.stateRuntime);
+		} catch {
+			return null;
+		}
 	}
 	saveRecoveryKeyToDisk(params, preserveEncodedPrivateKey = false) {
 		return this.enqueuePersistence(() => this.persistRecoveryKey(params, preserveEncodedPrivateKey));
@@ -610,6 +697,7 @@ var MatrixRecoveryKeyStore = class {
 	async persistRecoveryKey(params, preserveEncodedPrivateKey = false) {
 		if (!this.recoveryKeyPath || !this.stateRuntime) return;
 		try {
+			await assertMatrixSupportedStateFile(this.recoveryKeyPath);
 			const payload = {
 				version: 1,
 				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -675,7 +763,7 @@ var MatrixSendScheduler = class extends MatrixScheduler {
 //#region extensions/matrix/src/matrix/sdk/client-base.ts
 const MATRIX_ENCRYPTED_STARTUP_TIMEOUT_MS = 6e4;
 let loadedMatrixCryptoRuntime = null;
-const loadMatrixCryptoRuntime = createLazyRuntimeModule(() => import("./crypto-runtime-DPjIDF8H.mjs").then((runtime) => {
+const loadMatrixCryptoRuntime = createLazyRuntimeModule(() => import("./crypto-runtime-B2AjWo-i.mjs").then((runtime) => {
 	loadedMatrixCryptoRuntime = runtime;
 	return runtime;
 }));
@@ -697,9 +785,10 @@ var MatrixClientBase = class {
 		this.sendQueue = new KeyedAsyncQueue();
 		this.syncQuiescePromise = null;
 		this.stopPersistPromise = null;
-		this.verificationSummaryListenerBound = false;
 		this.currentSyncState = null;
 		this.currentSyncError = void 0;
+		this.currentSyncFromCache = false;
+		this.currentSyncRevision = 0;
 		this.transactionScopeId = null;
 		this.transactionScopePromise = null;
 		this.messageWireDispatchGuards = new MatrixMessageWireDispatchGuards();
@@ -707,6 +796,7 @@ var MatrixClientBase = class {
 		this.cryptoRequestOwner = new AsyncLocalStorage();
 		this.startupPromise = null;
 		this.cryptoInitializationPromise = null;
+		this.liveRoomReadinessOperations = /* @__PURE__ */ new Set();
 		this.sdkStopped = false;
 		this.stopDiscardPromise = null;
 		this.idbPersistPromise = null;
@@ -742,8 +832,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.syncStore;
 		this.idbSnapshotPath = opts.idbSnapshotPath;
 		this.cryptoDatabasePrefix = opts.cryptoDatabasePrefix;
@@ -813,11 +902,14 @@ var MatrixClientBase = class {
 			}
 		});
 		if (!this.encryptionEnabled) return;
-		this.verificationManager ??= new runtime.MatrixVerificationManager({ trustOwnDeviceAfterSas: async (deviceId) => {
-			const crypto = this.client.getCrypto();
-			if (typeof crypto?.crossSignDevice !== "function") return;
-			await crypto.crossSignDevice(deviceId);
-		} });
+		this.verificationManager ??= new runtime.MatrixVerificationManager({
+			onSummaryChanged: (summary) => this.emitter.emit("verification.summary", summary),
+			trustOwnDeviceAfterSas: async (deviceId) => {
+				const crypto = this.client.getCrypto();
+				if (typeof crypto?.crossSignDevice !== "function") return;
+				await crypto.crossSignDevice(deviceId);
+			}
+		});
 		this.cryptoBootstrapper ??= new runtime.MatrixCryptoBootstrapper({
 			getUserId: () => this.getUserId(),
 			getPassword: () => this.password,
@@ -845,12 +937,6 @@ var MatrixClientBase = class {
 			isRoomEncrypted: async (roomId) => await this.getMessageWireEventType(roomId) === "m.room.encrypted",
 			downloadContent: (mxcUrl, opts) => this.downloadContent(mxcUrl, opts)
 		});
-		if (!this.verificationSummaryListenerBound) {
-			this.verificationSummaryListenerBound = true;
-			this.verificationManager.onSummaryChanged((summary) => {
-				this.emitter.emit("verification.summary", summary);
-			});
-		}
 	}
 	async start(opts = {}) {
 		await this.startSyncSession({
@@ -905,7 +991,7 @@ var MatrixClientBase = class {
 			checkActive();
 			throwIfMatrixStartupAborted(signal);
 			if (this.encryptionEnabled && this.cryptoInitialized) {
-				const { reconcileJoinedRoomEncryption } = await import("./joined-room-encryption-TZoOKXgh.mjs");
+				const { reconcileJoinedRoomEncryption } = await import("./joined-room-encryption-BAD70N5n.mjs");
 				checkActive();
 				await this.withClientCryptoWork(() => reconcileJoinedRoomEncryption(this.client, signal, checkActive), signal);
 				checkActive();
@@ -934,6 +1020,30 @@ var MatrixClientBase = class {
 		await this.withClientCryptoWork(() => this.initializeCryptoIfNeeded());
 		assertCurrent?.();
 	}
+	abortPendingRequests() {
+		this.requestAbortController.abort(/* @__PURE__ */ new Error("Matrix client generation is no longer active."));
+	}
+	async withLiveEncryptedRoom(roomId, run, opts = {}) {
+		return await withMatrixLiveEncryptedRoom(this, run, {
+			client: this.client,
+			emitter: this.emitter,
+			roomId,
+			generationSignal: this.requestAbortController.signal,
+			abortSignal: opts.abortSignal,
+			operations: this.liveRoomReadinessOperations,
+			initializeCrypto: () => this.withClientCryptoWork(() => this.prepareForOneOff()),
+			assertActive: () => {
+				this.assertClientActive();
+				opts.assertCurrent?.();
+				if (this.sdkStopped || this.syncQuiescePromise) throw new Error("Matrix client is stopping; acquire a new client before sending");
+			},
+			getSync: () => ({
+				state: this.currentSyncState,
+				fromCache: this.currentSyncFromCache,
+				revision: this.currentSyncRevision
+			})
+		});
+	}
 	hasPersistedSyncState() {
 		return this.syncStore?.hasSavedSyncFromCleanShutdown() === true;
 	}
@@ -974,9 +1084,10 @@ var MatrixClientBase = class {
 				await this.quiesceSync().catch(noop);
 				this.syncStore?.discardPendingSyncCursorPersistence();
 			}
-			this.requestAbortController.abort(/* @__PURE__ */ new Error("Matrix client generation is no longer active."));
+			this.abortPendingRequests();
 			await this.startupPromise?.catch(noop);
 			await this.cryptoInitializationPromise?.catch(noop);
+			await Promise.allSettled(this.liveRoomReadinessOperations);
 			clearInterval(this.idbPersistTimer ?? void 0);
 			this.idbPersistTimer = null;
 			this.idbPersistAbortController?.abort();
@@ -1336,6 +1447,24 @@ var MatrixClientCore = class extends MatrixClientBase {
 	}
 };
 //#endregion
+//#region extensions/matrix/src/matrix/sdk/verification-status.ts
+function isMatrixDeviceOwnerVerified(status) {
+	return status?.crossSigningVerified === true;
+}
+function isMatrixDeviceVerifiedInCurrentClient(status) {
+	return status?.isVerified?.() === true || status?.localVerified === true || isMatrixDeviceOwnerVerified(status);
+}
+async function trustMatrixOwnIdentity(crypto) {
+	const ownIdentity = typeof crypto.getOwnIdentity === "function" ? await crypto.getOwnIdentity().catch(() => void 0) : void 0;
+	if (!ownIdentity) return;
+	try {
+		if (typeof ownIdentity.isVerified === "function" && ownIdentity.isVerified()) return;
+		if (typeof ownIdentity.verify === "function") await ownIdentity.verify();
+	} finally {
+		ownIdentity.free?.();
+	}
+}
+//#endregion
 //#region extensions/matrix/src/matrix/sdk/client-verification.ts
 var MatrixClientVerification = class extends MatrixClientCore {
 	async refreshOwnDeviceKeys() {
@@ -1431,29 +1560,12 @@ var MatrixClientVerification = class extends MatrixClientCore {
 			serverDeviceKnown
 		};
 	}
-	async getOwnDeviceIdentityVerificationStatus() {
-		const userId = this.client.getUserId() ?? this.selfUserId ?? null;
-		const deviceId = this.client.getDeviceId()?.trim() || null;
-		const deviceVerification = await this.getDeviceVerificationStatus(userId, deviceId);
-		return {
-			...deviceVerification,
-			verified: deviceVerification.crossSigningVerified
-		};
-	}
 	async trustOwnIdentityAfterSelfVerification() {
 		if (!this.encryptionEnabled) return;
 		await this.ensureStartedForCryptoControlPlane();
 		await this.ensureCryptoSupportInitialized();
 		const crypto = this.client.getCrypto();
-		const ownIdentity = crypto && typeof crypto.getOwnIdentity === "function" ? await crypto.getOwnIdentity().catch(() => void 0) : void 0;
-		if (!ownIdentity) return;
-		try {
-			if (typeof ownIdentity.isVerified === "function" && ownIdentity.isVerified()) return;
-			if (typeof ownIdentity.verify !== "function") return;
-			await ownIdentity.verify();
-		} finally {
-			ownIdentity.free?.();
-		}
+		if (crypto) await trustMatrixOwnIdentity(crypto);
 	}
 	async resolveActiveRoomKeyBackupVersion(crypto) {
 		if (typeof crypto.getActiveSessionBackupVersion !== "function") return null;
@@ -1531,20 +1643,16 @@ var MatrixClientVerification = class extends MatrixClientCore {
 };
 //#endregion
 //#region extensions/matrix/src/matrix/sdk.ts
-var sdk_exports = /* @__PURE__ */ __exportAll({
-	ConsoleLogger: () => ConsoleLogger,
-	LogService: () => LogService,
-	MatrixClient: () => MatrixClient
-});
+var sdk_exports = /* @__PURE__ */ __exportAll({ MatrixClient: () => MatrixClient });
 var MatrixClient = class extends MatrixClientVerification {
 	async verifyWithRecoveryKey(rawRecoveryKey) {
-		const fail = async (error, fields = {}) => {
+		const fail = async (error) => {
 			const status = await this.getOwnDeviceVerificationStatus();
 			return {
 				success: false,
-				recoveryKeyAccepted: fields.recoveryKeyAccepted ?? false,
-				backupUsable: fields.backupUsable ?? false,
-				deviceOwnerVerified: fields.deviceOwnerVerified ?? status.verified,
+				recoveryKeyAccepted: false,
+				backupUsable: false,
+				deviceOwnerVerified: status.verified,
 				error,
 				...status
 			};
@@ -1568,102 +1676,37 @@ var MatrixClient = class extends MatrixClientVerification {
 			return await fail(formatErrorMessage(err));
 		}
 		const storedRecoveryKeyMatches = (await this.recoveryKeyStore.getRecoveryKeySummary())?.encodedPrivateKey?.trim() === trimmedRecoveryKey;
-		if (backupUsableBeforeStagedRecovery && storedRecoveryKeyMatches) {
-			const status = await this.getOwnDeviceVerificationStatus();
+		const settleRecoveryKey = async (status, keyValidated, reusingStoredKey = false) => {
 			const backupUsable = resolveMatrixRoomKeyBackupReadinessError(status.backup, { requireServerBackup: true }) === null;
 			const backupError = resolveMatrixRoomKeyBackupReadinessError(status.backup, { requireServerBackup: false });
-			const recoveryKeyAccepted = backupUsable;
-			if (!status.verified) {
-				if (recoveryKeyAccepted) await this.recoveryKeyStore.commitStagedRecoveryKey({ keyId: stagedKeyId });
-				else await this.recoveryKeyStore.discardStagedRecoveryKey();
-				return {
-					success: false,
-					recoveryKeyAccepted,
-					backupUsable,
-					deviceOwnerVerified: false,
-					error: "Matrix recovery key was applied, but this device still lacks full Matrix identity trust. The recovery key can unlock usable backup material only when 'Backup usable' is yes; full identity trust still requires Matrix cross-signing verification.",
-					...status
-				};
-			}
-			if (backupError) {
-				await this.recoveryKeyStore.discardStagedRecoveryKey();
-				return {
-					success: false,
-					recoveryKeyAccepted,
-					backupUsable,
-					deviceOwnerVerified: true,
-					error: backupError,
-					...status
-				};
-			}
-			await this.recoveryKeyStore.commitStagedRecoveryKey({ keyId: stagedKeyId });
+			const recoveryKeyAccepted = reusingStoredKey ? backupUsable : keyValidated && (status.verified || backupUsable);
+			const error = !status.verified ? "Matrix recovery key was applied, but this device still lacks full Matrix identity trust. The recovery key can unlock usable backup material only when 'Backup usable' is yes; full identity trust still requires Matrix cross-signing verification." : backupError ?? (!keyValidated ? "Matrix recovery key could not be verified against active Matrix backup material; existing backup may be usable from previously loaded recovery material." : void 0);
+			const commit = status.verified ? !error : backupUsable && keyValidated;
+			if (commit) await this.recoveryKeyStore.commitStagedRecoveryKey({ keyId: stagedKeyId });
+			else await this.recoveryKeyStore.discardStagedRecoveryKey();
+			const committedStatus = commit && !reusingStoredKey ? await this.getOwnDeviceVerificationStatus() : status;
 			return {
-				success: true,
-				recoveryKeyAccepted: true,
+				success: !error,
+				recoveryKeyAccepted: error ? recoveryKeyAccepted : true,
 				backupUsable,
-				deviceOwnerVerified: true,
-				verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				...status
+				deviceOwnerVerified: status.verified,
+				...error ? { error } : { verifiedAt: (/* @__PURE__ */ new Date()).toISOString() },
+				...committedStatus
 			};
-		}
+		};
+		if (backupUsableBeforeStagedRecovery && storedRecoveryKeyMatches) return await settleRecoveryKey(await this.getOwnDeviceVerificationStatus(), true, true);
 		try {
 			const cryptoBootstrapper = this.cryptoBootstrapper;
 			if (!cryptoBootstrapper) return await fail("Matrix crypto bootstrapper is not available");
 			await cryptoBootstrapper.bootstrap(crypto, { allowAutomaticCrossSigningReset: false });
 			await this.enableTrustedRoomKeyBackupIfPossible(crypto);
 			const status = await this.getOwnDeviceVerificationStatus();
-			const backupError = resolveMatrixRoomKeyBackupReadinessError(status.backup, { requireServerBackup: false });
 			const backupUsable = resolveMatrixRoomKeyBackupReadinessError(status.backup, { requireServerBackup: true }) === null;
 			const stagedRecoveryKeyUsed = this.recoveryKeyStore.hasStagedRecoveryKeyBeenUsed();
 			const secretStorageStatus = typeof crypto.getSecretStorageStatus === "function" ? await crypto.getSecretStorageStatus().catch(() => null) : null;
 			const stagedRecoveryKeyConfirmedBySecretStorage = Boolean(stagedKeyId) && secretStorageStatus?.secretStorageKeyValidityMap?.[stagedKeyId ?? ""] === true;
 			const stagedRecoveryKeyRejectedBySecretStorage = Boolean(stagedKeyId) && secretStorageStatus?.secretStorageKeyValidityMap?.[stagedKeyId ?? ""] === false;
-			const stagedRecoveryKeyValidated = stagedRecoveryKeyUsed && (stagedRecoveryKeyConfirmedBySecretStorage || stagedRecoveryKeyUsed && !stagedRecoveryKeyRejectedBySecretStorage && !stagedRecoveryKeyConfirmedBySecretStorage && !backupUsableBeforeStagedRecovery && backupUsable) || storedRecoveryKeyMatches && backupUsable;
-			const recoveryKeyAccepted = stagedRecoveryKeyValidated && (status.verified || backupUsable);
-			if (!status.verified) {
-				if (backupUsable && stagedRecoveryKeyValidated) await this.recoveryKeyStore.commitStagedRecoveryKey({ keyId: stagedKeyId });
-				else await this.recoveryKeyStore.discardStagedRecoveryKey();
-				return {
-					success: false,
-					recoveryKeyAccepted,
-					backupUsable,
-					deviceOwnerVerified: false,
-					error: "Matrix recovery key was applied, but this device still lacks full Matrix identity trust. The recovery key can unlock usable backup material only when 'Backup usable' is yes; full identity trust still requires Matrix cross-signing verification.",
-					...recoveryKeyAccepted ? await this.getOwnDeviceVerificationStatus() : status
-				};
-			}
-			if (backupError) {
-				await this.recoveryKeyStore.discardStagedRecoveryKey();
-				return {
-					success: false,
-					recoveryKeyAccepted,
-					backupUsable,
-					deviceOwnerVerified: true,
-					error: backupError,
-					...status
-				};
-			}
-			if (!stagedRecoveryKeyValidated) {
-				await this.recoveryKeyStore.discardStagedRecoveryKey();
-				return {
-					success: false,
-					recoveryKeyAccepted: false,
-					backupUsable,
-					deviceOwnerVerified: true,
-					error: "Matrix recovery key could not be verified against active Matrix backup material; existing backup may be usable from previously loaded recovery material.",
-					...status
-				};
-			}
-			await this.recoveryKeyStore.commitStagedRecoveryKey({ keyId: stagedKeyId });
-			const committedStatus = await this.getOwnDeviceVerificationStatus();
-			return {
-				success: true,
-				recoveryKeyAccepted: true,
-				backupUsable,
-				deviceOwnerVerified: true,
-				verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				...committedStatus
-			};
+			return await settleRecoveryKey(status, stagedRecoveryKeyUsed && (stagedRecoveryKeyConfirmedBySecretStorage || stagedRecoveryKeyUsed && !stagedRecoveryKeyRejectedBySecretStorage && !stagedRecoveryKeyConfirmedBySecretStorage && !backupUsableBeforeStagedRecovery && backupUsable) || storedRecoveryKeyMatches && backupUsable);
 		} catch (err) {
 			await this.recoveryKeyStore.discardStagedRecoveryKey();
 			return await fail(formatErrorMessage(err));
@@ -1846,8 +1889,7 @@ var MatrixClient = class extends MatrixClientVerification {
 	async deleteOwnDevices(deviceIds) {
 		const uniqueDeviceIds = uniqueStrings(normalizeStringEntries(deviceIds));
 		const currentDeviceId = this.client.getDeviceId()?.trim() || null;
-		const protectedDeviceIds = uniqueDeviceIds.filter((deviceId) => deviceId === currentDeviceId);
-		if (protectedDeviceIds.length > 0) throw new Error(`Refusing to delete the current Matrix device: ${protectedDeviceIds[0]}`);
+		if (currentDeviceId !== null && uniqueDeviceIds.includes(currentDeviceId)) throw new Error(`Refusing to delete the current Matrix device: ${currentDeviceId}`);
 		const deleteWithAuth = async (authData) => {
 			await this.client.deleteMultipleDevices(uniqueDeviceIds, authData);
 		};
@@ -1883,9 +1925,11 @@ var MatrixClient = class extends MatrixClientVerification {
 			emitter: this.emitter,
 			emitMembershipForRoom: (room) => this.emitMembershipForRoom(room),
 			getSelfUserId: () => this.client.getUserId() ?? this.selfUserId ?? "",
-			setCurrentSyncState: (state, error) => {
+			setCurrentSyncState: (state, error, fromCache) => {
 				this.currentSyncState = state;
 				this.currentSyncError = error;
+				this.currentSyncFromCache = fromCache;
+				this.currentSyncRevision += 1;
 			}
 		});
 	}
@@ -1904,4 +1948,4 @@ var MatrixClient = class extends MatrixClientVerification {
 	}
 };
 //#endregion
-export { ConsoleLogger, LogService, MatrixClient, isRepairableSecretStorageAccessError as n, sdk_exports as t };
+export { MatrixClient, isRepairableSecretStorageAccessError as a, trustMatrixOwnIdentity as i, isMatrixDeviceOwnerVerified as n, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS as o, isMatrixDeviceVerifiedInCurrentClient as r, sdk_exports as t };