@openclaw/matrix 2026.10.5-beta.4 → 2026.10.10-beta.2

package/dist/.setup/{reaction-events-CTSvOlXO.mjs → reaction-events-BG9spedG.mjs}

@@ -1,16 +1,16 @@
 import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
-import { a as resolveMatrixThreadRouting, i as resolveMatrixInboundRoute } from "./channel-BcwGspPw.mjs";
+import { a as resolveMatrixThreadRouting, i as resolveMatrixInboundRouteAsync } from "./channel-Dw4_imdd.mjs";
 import { c as extractMatrixReactionAnnotation } from "./send-currentness-C2rMVVIQ.mjs";
 import { p as resolveMatrixThreadRootId } from "./direct-management-B3wYhx_M.mjs";
-import { i as resolveMatrixApprovalReactionTargetWithPersistence, o as unregisterMatrixApprovalReactionTargetsForApproval } from "./approval-reactions-DhB6gNPU.mjs";
+import { i as resolveMatrixApprovalReactionTargetWithPersistence, o as unregisterMatrixApprovalReactionTargetsForApproval } from "./approval-reactions-D2pEUrFS.mjs";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { getSessionBindingService } from "openclaw/plugin-sdk/session-binding-runtime";
 //#region extensions/matrix/src/matrix/monitor/reaction-events.ts
-const loadApprovalReactionAuth = createLazyRuntimeModule(() => import("./channel-BcwGspPw.mjs").then((n) => n.s));
+const loadApprovalReactionAuth = createLazyRuntimeModule(() => import("./channel-Dw4_imdd.mjs").then((n) => n.s));
 const loadExecApprovalResolver = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/approval-gateway-runtime"));
-const loadMatrixSend = createLazyRuntimeModule(() => import("./send-LCOuTVc1.mjs").then((n) => n.s));
+const loadMatrixSend = createLazyRuntimeModule(() => import("./send-BprM-Wmx.mjs").then((n) => n.s));
 function buildMatrixApprovalTerminalText(result) {
 	const approval = result.approval;
 	const terminalLabel = approval.status === "allowed" ? approval.decision === "allow-always" ? "Allowed always" : "Allowed once" : approval.status === "denied" ? "Denied" : approval.status === "expired" ? "Expired" : "Cancelled";
@@ -142,7 +142,7 @@ async function handleInboundMatrixReaction(params) {
 		messageId: reaction.eventId,
 		threadRootId
 	});
-	const { route, runtimeBindingId } = resolveMatrixInboundRoute({
+	const { route, runtimeBindingId } = await resolveMatrixInboundRouteAsync({
 		cfg: params.cfg,
 		accountId: params.accountId,
 		roomId: params.roomId,
@@ -152,7 +152,7 @@ async function handleInboundMatrixReaction(params) {
 		threadId: thread.threadId,
 		resolveAgentRoute: params.core.channel.routing.resolveAgentRoute
 	});
-	if (runtimeBindingId) getSessionBindingService().touch(runtimeBindingId, params.event.origin_server_ts, {
+	if (runtimeBindingId) await getSessionBindingService().touchAsync(runtimeBindingId, params.event.origin_server_ts, {
 		channel: "matrix",
 		accountId: params.accountId
 	});

package/dist/.setup/{resolve-targets-BVVbbvP6.mjs → resolve-targets-BJ5sIKeM.mjs}

@@ -1,6 +1,6 @@
 import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 import { i as normalizeMatrixMessagingTarget, n as isMatrixQualifiedUserId } from "./target-ids-HhcaKX1n.mjs";
-import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-B1WbfSHo.mjs";
+import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-BpSz-FQB.mjs";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/resolve-targets.ts
 var resolve_targets_exports = /* @__PURE__ */ __exportAll({ resolveMatrixTargets: () => resolveMatrixTargets });

package/dist/.setup/{retired-state-DW5pLH05.mjs → retired-state-DOCruzWd.mjs}

@@ -11,19 +11,20 @@ function chunkMatrixStateJson(value, maxBytes, maxChunks, limitMessage) {
 		if (chunks.length >= maxChunks) throw new Error(limitMessage);
 		chunks.push(chunk);
 	};
-	let current = "";
+	let chunkStart = 0;
 	let currentBytes = 0;
-	for (const char of value) {
-		const charBytes = Buffer.byteLength(char, "utf8");
-		if (current && currentBytes + charBytes > maxBytes) {
-			pushChunk(current);
-			current = "";
+	for (let index = 0; index < value.length;) {
+		const codePoint = value.codePointAt(index);
+		const charBytes = codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+		if (index > chunkStart && currentBytes + charBytes > maxBytes) {
+			pushChunk(value.slice(chunkStart, index));
+			chunkStart = index;
 			currentBytes = 0;
 		}
-		current += char;
 		currentBytes += charBytes;
+		index += codePoint > 65535 ? 2 : 1;
 	}
-	if (current) pushChunk(current);
+	if (chunkStart < value.length) pushChunk(value.slice(chunkStart));
 	return chunks;
 }
 async function readMatrixStateChunks(store, keys, kind) {
@@ -61,8 +62,7 @@ function resolveMatrixSqliteStateEnv(options) {
 		OPENCLAW_STATE_DIR: stateDir
 	};
 }
-async function updateMatrixKeyedState(store, key, update, legacyUpdate, onUndefined = "keep") {
-	if (!store.observe || !store.compareAndApply) return await legacyUpdate();
+async function updateMatrixKeyedState(store, key, update, onUndefined = "keep") {
 	let observation = await store.observe(key);
 	for (;;) {
 		const value = update(observation.value);

package/dist/.setup/{room-info-9Uqlpt1V.mjs → room-info-BE7bbX_c.mjs}

@@ -1,6 +1,6 @@
-import { w as setBoundedMap } from "./send-LCOuTVc1.mjs";
-import { c as EventType } from "./messages-B1CZqU8u.mjs";
-import { r as withResolvedRoomAction } from "./client-BlTvpEWC.mjs";
+import { w as setBoundedMap } from "./send-BprM-Wmx.mjs";
+import { s as EventType } from "./messages-_XHVg3do.mjs";
+import { r as withResolvedRoomAction } from "./client-BKiiI29H.mjs";
 import { n as isMatrixNotFoundError } from "./errors-Bw4EHwKX.mjs";
 import { filterStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/matrix/actions/room.ts

package/dist/.setup/runtime-setter-api-i2MOXoT3.mjs

@@ -0,0 +1,2 @@
+export { i as setMatrixRuntime, a as setMatrixRuntimeLifecycle } from "./runtime-1kn1P6io.mjs";
+import "../runtime-setter-api.js";

package/dist/.setup/{sdk-Cfc6m7fY.mjs → sdk-ByU8So5S.mjs}

@@ -1,16 +1,18 @@
 import { i as __exportAll } from "./doctor-contract-CsTNmbMa.mjs";
 import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { r as assertMatrixSupportedStateFile } from "./retired-state-DW5pLH05.mjs";
-import { d as writeMatrixRecoveryKeyStateForPathAsync, l as readMatrixRecoveryKeyStateForPathAsync } from "./storage-DkC6bHgA.mjs";
+import { r as assertMatrixSupportedStateFile } from "./retired-state-DOCruzWd.mjs";
+import { a as readMatrixRecoveryKeyStateForPathAsync, l as writeMatrixRecoveryKeyStateForPathAsync } from "./crypto-state-store-D4wrCvFs.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-CxNgMQqH.mjs";
+import { i as createMatrixStartupAbortError, o as throwIfMatrixStartupAborted, r as awaitMatrixStartupWithAbort } from "./client-C4Gibhzl.mjs";
 import { n as isMatrixNotFoundError, t as formatMatrixErrorReason } from "./errors-Bw4EHwKX.mjs";
-import { i as createMatrixStartupAbortError, o as throwIfMatrixStartupAborted, r as awaitMatrixStartupWithAbort } from "./client-vPPbaxNp.mjs";
 import { n as createMatrixGuardedFetch, t as MatrixAuthedHttpClient } from "./http-client-ByR4STVQ.mjs";
 import { n as resolveMatrixRoomKeyBackupReadinessError } from "./backup-health-Dm_YMVFT.mjs";
 import { r as noop, t as LogService } from "./logger-CXQnpXCt.mjs";
 import { t as createMatrixJsSdkClientLogger } from "./logging-BKV8TYQq.mjs";
+import { t as acquireMatrixCryptoStoreOwnership } from "./crypto-store-ownership-Z_Y5WRKr.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-D-xHScuo.mjs";
+import { t as MATRIX_IDB_PERSIST_INTERVAL_MS } from "./idb-persistence-lock-Bh3ZLIsE.mjs";
 import { createRequire } from "node:module";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
@@ -19,10 +21,10 @@ import { createHash } from "node:crypto";
 import path from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
 import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
 import { captureChannelReadAuthority, withEffectAuthority } from "openclaw/plugin-sdk/fetch-runtime";
-import { ClientEvent, EventType, Filter, MatrixError, MatrixEventEvent, MsgType, Preset, createClient } from "matrix-js-sdk/lib/matrix.js";
+import { ClientEvent, EventType, Filter, MatrixError, MsgType, Preset, createClient } from "matrix-js-sdk/lib/matrix.js";
 import { EventEmitter } from "node:events";
 import { RoomEvent } from "matrix-js-sdk/lib/models/room.js";
 import { VerificationMethod } from "matrix-js-sdk/lib/types.js";
@@ -132,6 +134,25 @@ function refreshMatrixDmRoomIds(direct, dmRoomIds) {
 	return true;
 }
 //#endregion
+//#region extensions/matrix/src/matrix/sdk/client-crypto-bootstrap.ts
+async function bootstrapMatrixClientCrypto(params) {
+	const { crypto, bootstrapper, abortSignal } = params;
+	if (!crypto || !bootstrapper) return false;
+	const initial = await bootstrapper.bootstrap(crypto, MATRIX_INITIAL_CRYPTO_BOOTSTRAP_OPTIONS);
+	throwIfMatrixStartupAborted(abortSignal);
+	if (!initial.crossSigningPublished || initial.ownDeviceVerified === false) {
+		if ((await params.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 bootstrapper.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);
+		}
+	}
+	return true;
+}
+//#endregion
 //#region extensions/matrix/src/matrix/sdk/client-sync-quiesce.ts
 const MATRIX_SYNC_QUIESCE_TIMEOUT_MS = 5e3;
 const MATRIX_JS_SDK_SYNC_VERSION = "42.4.0";
@@ -242,18 +263,102 @@ async function waitForMatrixInitialSyncReady(params) {
 	}
 }
 //#endregion
-//#region extensions/matrix/src/matrix/sdk/idb-persistence-lock.ts
-const MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
-const MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS = {
-	retries: {
-		retries: 18,
-		factor: 2,
-		minTimeout: 50,
-		maxTimeout: 5e3,
-		randomize: true
-	},
-	stale: 3e5
-};
+//#region extensions/matrix/src/matrix/sdk/crypto-store-lifecycle.ts
+async function closeMatrixCryptoStores(closeRecoveryKeys, releaseOwnership, teardownComplete) {
+	const recovery = await Promise.allSettled([closeRecoveryKeys()]);
+	const release = teardownComplete ? await Promise.allSettled([releaseOwnership()]) : [];
+	const failures = [...recovery, ...release].filter((result) => result.status === "rejected").map((result) => result.reason);
+	if (failures.length > 1) throw new AggregateError(failures, "Failed to close Matrix crypto stores");
+	if (failures.length === 1) throw failures[0];
+}
+/** Final publication is allowed only for a generation that initialized under custody. */
+async function persistMatrixFinalState(params) {
+	if (params.cryptoInitialized) {
+		if (params.snapshotPath && !params.ownership) throw new Error("Refusing Matrix crypto snapshot publication without ownership");
+		await params.persistSnapshot();
+	}
+	if (!params.encryptionEnabled || params.cryptoInitialized) params.syncStore?.markCleanShutdown();
+	await params.syncStore?.flush();
+	if (params.cryptoInitialized) await params.ownership?.sealSafeState();
+}
+/** Join an in-flight crypto initialization before a generation can be retired. */
+function createMatrixCryptoInitializationGate() {
+	let pending = null;
+	let failure = null;
+	return {
+		get pending() {
+			return pending;
+		},
+		get failure() {
+			return failure;
+		},
+		recordFailure(error) {
+			failure = { error };
+		},
+		async run(initialize, abortSignal) {
+			if (failure) throw new Error("Matrix crypto initialization failed; restart this process before retrying", { cause: failure.error });
+			if (pending) {
+				await pending;
+				abortSignal?.throwIfAborted();
+				return;
+			}
+			const task = initialize();
+			pending = task;
+			try {
+				await task;
+			} finally {
+				if (pending === task) pending = null;
+			}
+		}
+	};
+}
+/** Quiescence failure forbids publication but still requires teardown under custody. */
+async function runMatrixClientShutdown(params) {
+	const failures = [];
+	let persist = params.persist;
+	try {
+		try {
+			await params.quiesceSync();
+		} catch (error) {
+			if (persist) failures.push(error);
+			persist = false;
+		}
+		if (!persist) params.discardSync();
+		await params.stop(persist);
+	} catch (error) {
+		failures.push(error);
+		params.discardSync();
+	} finally {
+		try {
+			await params.closeStores();
+		} catch (error) {
+			failures.push(error);
+		}
+	}
+	if (failures.length === 1) throw failures[0];
+	if (failures.length > 1) throw new AggregateError(failures, "Failed to shut down Matrix client generation");
+}
+/** SDK crypto stop is not retryable after throwing: it marks itself stopped before store closure. */
+function createMatrixSdkStopGate() {
+	let stopped = false;
+	let failure = null;
+	return {
+		get stopped() {
+			return stopped || failure !== null;
+		},
+		stop(stopSdk) {
+			if (stopped) return;
+			if (failure) throw failure.error;
+			try {
+				stopSdk();
+				stopped = true;
+			} catch (error) {
+				failure = { error };
+				throw error;
+			}
+		}
+	};
+}
 //#endregion
 //#region extensions/matrix/src/matrix/sdk/live-room-readiness.ts
 async function withMatrixLiveEncryptedRoom(owner, run, params) {
@@ -309,7 +414,6 @@ async function probeMatrixLiveEncryptedRoom(params) {
 		for (;;) {
 			changed = false;
 			assertActive();
-			const sync = params.getSync();
 			const room = params.client.getRoom(params.roomId);
 			const crypto = params.client.getCrypto();
 			const isCurrent = () => {
@@ -319,7 +423,7 @@ async function probeMatrixLiveEncryptedRoom(params) {
 			if (isCurrent() && crypto) {
 				const encrypted = await crypto.isEncryptionEnabledInRoom(params.roomId);
 				assertActive();
-				if (params.getSync().revision !== sync.revision || !isCurrent()) continue;
+				if (!isCurrent()) continue;
 				if (encrypted) return () => {
 					assertActive();
 					if (!isCurrent()) throw new Error("Matrix live encrypted room changed before dispatch; retry the send");
@@ -714,7 +818,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-CpJ0b7vY.mjs").then((runtime) => {
+const loadMatrixCryptoRuntime = createLazyRuntimeModule(() => import("./crypto-runtime-D8yY7kjD.mjs").then((runtime) => {
 	loadedMatrixCryptoRuntime = runtime;
 	return runtime;
 }));
@@ -739,19 +843,21 @@ var MatrixClientBase = class {
 		this.currentSyncState = null;
 		this.currentSyncError = void 0;
 		this.currentSyncFromCache = false;
-		this.currentSyncRevision = 0;
 		this.transactionScopeId = null;
 		this.transactionScopePromise = null;
 		this.messageWireDispatchGuards = new MatrixMessageWireDispatchGuards();
 		this.requestAbortController = new AbortController();
 		this.cryptoRequestOwner = new AsyncLocalStorage();
 		this.startupPromise = null;
-		this.cryptoInitializationPromise = null;
+		this.cryptoInitializationGate = createMatrixCryptoInitializationGate();
 		this.liveRoomReadinessOperations = /* @__PURE__ */ new Set();
-		this.sdkStopped = false;
+		this.sdkStopGate = createMatrixSdkStopGate();
+		this.generationTeardownComplete = false;
 		this.stopDiscardPromise = null;
 		this.idbPersistPromise = null;
 		this.idbPersistAbortController = null;
+		this.cryptoStoreOwnership = null;
+		this.sdkIndexedDbSession = null;
 		this.assertClientActive = () => {
 			this.requestAbortController.signal.throwIfAborted();
 		};
@@ -898,7 +1004,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");
+		if (this.sdkStopGate.stopped) throw new Error("Matrix client has been fully stopped and cannot be restarted; acquire a new shared client generation");
 		const assertCurrent = this.captureRequestAuthority();
 		assertCurrent?.();
 		this.assertClientActive();
@@ -986,12 +1092,11 @@ var MatrixClientBase = class {
 			assertActive: () => {
 				this.assertClientActive();
 				opts.assertCurrent?.();
-				if (this.sdkStopped || this.syncQuiescePromise) throw new Error("Matrix client is stopping; acquire a new client before sending");
+				if (this.sdkStopGate.stopped || 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
+				fromCache: this.currentSyncFromCache
 			})
 		});
 	}
@@ -1002,14 +1107,6 @@ var MatrixClientBase = class {
 		if (this.started) return;
 		await this.startSyncSession({ bootstrapCrypto: false });
 	}
-	stopSdkClient() {
-		if (this.sdkStopped) return;
-		this.currentSyncState = null;
-		this.currentSyncError = void 0;
-		this.sdkStopped = true;
-		this.client.stopClient();
-		this.started = false;
-	}
 	async quiesceSync() {
 		this.syncQuiescePromise ??= quiesceMatrixClientSync({
 			client: this.client,
@@ -1028,122 +1125,138 @@ var MatrixClientBase = class {
 	stop() {
 		this.stopAndPersist().catch(() => this.stopWithoutPersist()).catch(noop);
 	}
+	async releaseCryptoStoreOwnership() {
+		const ownership = this.cryptoStoreOwnership;
+		this.cryptoStoreOwnership = null;
+		await ownership?.release();
+	}
 	async stopClientGeneration(persist) {
-		try {
-			if (persist) await this.quiesceSync();
-			else {
-				await this.quiesceSync().catch(noop);
-				this.syncStore?.discardPendingSyncCursorPersistence();
-			}
-			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();
-			const activePeriodicPersist = this.idbPersistPromise;
-			try {
-				this.stopSdkClient();
-				this.decryptBridge?.stop();
-			} finally {
-				this.cryptoRequestOwner.disable();
-			}
-			await Promise.all([this.recoveryKeyStore.close(), activePeriodicPersist]);
-			if (persist) {
-				await (loadedMatrixCryptoRuntime ?? await loadMatrixCryptoRuntime()).persistIdbToDisk({
+		await runMatrixClientShutdown({
+			persist,
+			quiesceSync: () => this.quiesceSync(),
+			discardSync: () => this.syncStore?.discardPendingSyncCursorPersistence(),
+			stop: async (publishFinalState) => {
+				this.abortPendingRequests();
+				await this.startupPromise?.catch(noop);
+				await this.cryptoInitializationGate.pending?.catch(noop);
+				await Promise.allSettled(this.liveRoomReadinessOperations);
+				clearInterval(this.idbPersistTimer ?? void 0);
+				this.idbPersistTimer = null;
+				this.idbPersistAbortController?.abort();
+				const activePeriodicPersist = this.idbPersistPromise;
+				try {
+					this.sdkStopGate.stop(() => {
+						this.currentSyncState = null;
+						this.currentSyncError = void 0;
+						this.client.stopClient();
+						this.started = false;
+					});
+				} finally {
+					this.decryptBridge?.stop();
+					this.cryptoRequestOwner.disable();
+				}
+				await this.sdkIndexedDbSession?.retire();
+				await Promise.all([this.recoveryKeyStore.close(), activePeriodicPersist]);
+				if (this.cryptoInitializationGate.failure) throw new Error("Matrix crypto initialization failed; restart this process before recovery", { cause: this.cryptoInitializationGate.failure.error });
+				this.generationTeardownComplete = true;
+				if (publishFinalState) await persistMatrixFinalState({
+					encryptionEnabled: this.encryptionEnabled,
+					cryptoInitialized: this.cryptoInitialized,
+					ownership: this.cryptoStoreOwnership,
 					snapshotPath: this.idbSnapshotPath,
-					databasePrefix: this.cryptoDatabasePrefix,
-					strict: true,
-					stateRuntime: this.stateRuntime
+					persistSnapshot: async () => {
+						await (loadedMatrixCryptoRuntime ?? await loadMatrixCryptoRuntime()).persistIdbToDisk({
+							snapshotPath: this.idbSnapshotPath,
+							databasePrefix: this.cryptoDatabasePrefix,
+							strict: true,
+							stateRuntime: this.stateRuntime
+						});
+					},
+					syncStore: this.syncStore
 				});
-				this.syncStore?.markCleanShutdown();
-				await this.syncStore?.flush();
-			}
-		} finally {
-			await this.recoveryKeyStore.close();
-		}
+			},
+			closeStores: () => closeMatrixCryptoStores(() => this.recoveryKeyStore.close(), () => this.releaseCryptoStoreOwnership(), this.generationTeardownComplete)
+		});
 	}
 	async stopAndPersist() {
-		this.stopPersistPromise ??= this.stopClientGeneration(true);
-		await this.stopPersistPromise;
+		await (this.stopPersistPromise ??= this.stopClientGeneration(true));
 	}
 	stopWithoutPersist() {
 		if (!this.stopPersistPromise) this.stopPersistPromise = this.stopDiscardPromise = this.stopClientGeneration(false);
-		return this.stopDiscardPromise ??= this.stopPersistPromise.catch(() => this.stopClientGeneration(false));
+		return this.stopDiscardPromise ??= this.stopPersistPromise.catch(() => this.generationTeardownComplete ? void 0 : this.stopClientGeneration(false));
 	}
 	async bootstrapCryptoIfNeeded(abortSignal) {
 		if (!this.encryptionEnabled || !this.cryptoInitialized || this.cryptoBootstrapped) return;
 		throwIfMatrixStartupAborted(abortSignal);
 		await this.ensureCryptoSupportInitialized();
-		const crypto = this.client.getCrypto();
-		if (!crypto) return;
-		const cryptoBootstrapper = this.cryptoBootstrapper;
-		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);
-			}
-		}
-		this.cryptoBootstrapped = true;
+		this.cryptoBootstrapped = await bootstrapMatrixClientCrypto({
+			crypto: this.client.getCrypto(),
+			bootstrapper: this.cryptoBootstrapper,
+			getOwnDeviceVerificationStatus: () => this.getOwnDeviceVerificationStatus(),
+			abortSignal
+		});
 	}
 	async initializeCryptoIfNeeded(abortSignal) {
-		if (!this.encryptionEnabled) return;
-		if (this.cryptoInitializationPromise) {
-			await this.cryptoInitializationPromise;
-			throwIfMatrixStartupAborted(abortSignal);
-			return;
-		}
-		if (this.cryptoInitialized) return;
-		const initialization = this.initializeCrypto(abortSignal ? AbortSignal.any([abortSignal, this.requestAbortController.signal]) : this.requestAbortController.signal);
-		this.cryptoInitializationPromise = initialization;
-		try {
-			await initialization;
-		} finally {
-			if (this.cryptoInitializationPromise === initialization) this.cryptoInitializationPromise = null;
-		}
+		if (!this.encryptionEnabled || this.cryptoInitialized && !this.cryptoInitializationGate.pending) return;
+		await this.cryptoInitializationGate.run(() => this.initializeCrypto(abortSignal ? AbortSignal.any([abortSignal, this.requestAbortController.signal]) : this.requestAbortController.signal), abortSignal);
 	}
 	async initializeCrypto(abortSignal) {
 		throwIfMatrixStartupAborted(abortSignal);
-		const { persistIdbToDisk, restoreIdbFromDisk } = await loadMatrixCryptoRuntime();
-		await restoreIdbFromDisk(this.idbSnapshotPath, this.stateRuntime);
-		throwIfMatrixStartupAborted(abortSignal);
+		const { persistIdbToDisk, restoreIdbFromDisk, resolveDefaultIdbSnapshotPath, beginMatrixSdkIndexedDbSession } = await loadMatrixCryptoRuntime();
+		this.idbSnapshotPath ??= resolveDefaultIdbSnapshotPath();
+		if (!this.cryptoStoreOwnership) this.cryptoStoreOwnership = await acquireMatrixCryptoStoreOwnership(this.idbSnapshotPath, {
+			signal: abortSignal,
+			stateRuntime: this.stateRuntime
+		});
+		let rustCryptoInitializationStarted = false;
 		try {
-			await this.client.initRustCrypto({ cryptoDatabasePrefix: this.cryptoDatabasePrefix });
-			this.cryptoInitialized = true;
+			await restoreIdbFromDisk(this.idbSnapshotPath, this.stateRuntime, this.cryptoDatabasePrefix);
 			throwIfMatrixStartupAborted(abortSignal);
-			await persistIdbToDisk({
-				snapshotPath: this.idbSnapshotPath,
-				databasePrefix: this.cryptoDatabasePrefix,
-				abortSignal,
-				stateRuntime: this.stateRuntime
-			});
+			await this.cryptoStoreOwnership?.armUnsafeState();
 			throwIfMatrixStartupAborted(abortSignal);
-			this.idbPersistTimer = setInterval(() => {
-				if (this.idbPersistPromise) return;
-				const abortController = new AbortController();
-				this.idbPersistAbortController = abortController;
-				this.idbPersistPromise = persistIdbToDisk({
+			this.sdkIndexedDbSession = beginMatrixSdkIndexedDbSession(this.cryptoDatabasePrefix);
+			try {
+				rustCryptoInitializationStarted = true;
+				await this.client.initRustCrypto({ cryptoDatabasePrefix: this.cryptoDatabasePrefix });
+				this.cryptoInitialized = true;
+				throwIfMatrixStartupAborted(abortSignal);
+				await persistIdbToDisk({
 					snapshotPath: this.idbSnapshotPath,
 					databasePrefix: this.cryptoDatabasePrefix,
-					abortSignal: abortController.signal,
+					abortSignal,
 					stateRuntime: this.stateRuntime
-				}).catch(noop).finally(() => {
-					this.idbPersistPromise = null;
-					this.idbPersistAbortController = null;
 				});
-			}, MATRIX_IDB_PERSIST_INTERVAL_MS);
-			this.idbPersistTimer.unref?.();
-		} catch (err) {
-			throwIfMatrixStartupAborted(abortSignal);
-			LogService.warn("MatrixClientLite", "Failed to initialize rust crypto:", err);
+				throwIfMatrixStartupAborted(abortSignal);
+				this.idbPersistTimer = setInterval(() => {
+					if (this.idbPersistPromise) return;
+					const abortController = new AbortController();
+					this.idbPersistAbortController = abortController;
+					this.idbPersistPromise = persistIdbToDisk({
+						snapshotPath: this.idbSnapshotPath,
+						databasePrefix: this.cryptoDatabasePrefix,
+						abortSignal: abortController.signal,
+						stateRuntime: this.stateRuntime
+					}).catch(noop).finally(() => {
+						this.idbPersistPromise = null;
+						this.idbPersistAbortController = null;
+					});
+				}, MATRIX_IDB_PERSIST_INTERVAL_MS);
+				this.idbPersistTimer.unref?.();
+			} catch (err) {
+				if (!this.cryptoInitialized) {
+					this.cryptoInitializationGate.recordFailure(err);
+					throw err;
+				}
+				throwIfMatrixStartupAborted(abortSignal);
+				LogService.warn("MatrixClientLite", "Failed to initialize rust crypto:", err);
+			}
+		} catch (error) {
+			if (!this.cryptoInitialized && !rustCryptoInitializationStarted) try {
+				await this.cryptoStoreOwnership?.cancelUnsafeState();
+			} finally {
+				await this.releaseCryptoStoreOwnership();
+			}
+			throw error;
 		}
 	}
 };
@@ -1352,17 +1465,8 @@ var MatrixClientCore = class extends MatrixClientBase {
 		const rawEvent = await this.client.fetchRoomEvent(roomId, eventId);
 		if (rawEvent.type !== "m.room.encrypted") return rawEvent;
 		const event = this.client.getEventMapper()(rawEvent);
-		let decryptedEvent;
-		const onDecrypted = (candidate) => {
-			decryptedEvent = candidate;
-		};
-		event.once(MatrixEventEvent.Decrypted, onDecrypted);
-		try {
-			await this.client.decryptEventIfNeeded(event);
-		} finally {
-			event.off(MatrixEventEvent.Decrypted, onDecrypted);
-		}
-		return matrixEventToRaw(decryptedEvent ?? event);
+		await this.client.decryptEventIfNeeded(event);
+		return matrixEventToRaw(event);
 	}
 	async getRelations(roomId, eventId, relationType, eventType, opts = {}) {
 		const result = await this.client.relations(roomId, eventId, relationType, eventType, opts);
@@ -1849,7 +1953,6 @@ var MatrixClient = class extends MatrixClientVerification {
 				this.currentSyncState = state;
 				this.currentSyncError = error;
 				this.currentSyncFromCache = fromCache;
-				this.currentSyncRevision += 1;
 			}
 		});
 	}
@@ -1868,4 +1971,4 @@ var MatrixClient = class extends MatrixClientVerification {
 	}
 };
 //#endregion
-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 };
+export { MatrixClient, isRepairableSecretStorageAccessError as a, trustMatrixOwnIdentity as i, isMatrixDeviceOwnerVerified as n, isMatrixDeviceVerifiedInCurrentClient as r, sdk_exports as t };