@openclaw/matrix 2026.9.4 → 2026.9.6

package/dist/{reaction-common-DkrQdBSZ.js → .setup/send-currentness-BrGXL7b8.mjs}

@@ -1,4 +1,5 @@
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region extensions/matrix/src/matrix/reaction-common.ts
 const MATRIX_ANNOTATION_RELATION_TYPE = "m.annotation";
 const MATRIX_REACTION_EVENT_TYPE = "m.reaction";
@@ -68,4 +69,22 @@ function selectOwnMatrixReactionEventIds(events, userId, emoji) {
 	return ids;
 }
 //#endregion
-export { extractMatrixReactionAnnotation as a, buildMatrixReactionRelationsPath as i, MATRIX_REACTION_EVENT_TYPE as n, selectOwnMatrixReactionEventIds as o, buildMatrixReactionContent as r, summarizeMatrixReactionEvents as s, MATRIX_ANNOTATION_RELATION_TYPE as t };
+//#region extensions/matrix/src/matrix/sdk/send-currentness.ts
+const sendCurrentness = new AsyncLocalStorage();
+function withMatrixSendCurrentness(client, assertCurrent, run) {
+	assertCurrent();
+	return sendCurrentness.run({
+		client,
+		assertCurrent
+	}, run);
+}
+function captureMatrixSendCurrentness(client) {
+	const scope = sendCurrentness.getStore();
+	return scope?.client === client ? scope.assertCurrent : void 0;
+}
+/** Shared sync and crypto work belongs to the client generation, not a sender. */
+function withoutMatrixSendCurrentness(run) {
+	return sendCurrentness.exit(run);
+}
+//#endregion
+export { MATRIX_REACTION_EVENT_TYPE as a, extractMatrixReactionAnnotation as c, MATRIX_ANNOTATION_RELATION_TYPE as i, selectOwnMatrixReactionEventIds as l, withMatrixSendCurrentness as n, buildMatrixReactionContent as o, withoutMatrixSendCurrentness as r, buildMatrixReactionRelationsPath as s, captureMatrixSendCurrentness as t, summarizeMatrixReactionEvents as u };

package/dist/{setup-bootstrap-sVqkwtSY.js → .setup/setup-bootstrap-A_WGFq1Y.mjs}

@@ -1,6 +1,6 @@
-import { a as resolveMatrixAccountConfig, n as hasExplicitMatrixAccountConfig } from "./account-config-CRsKoMqJ.js";
-import "./accounts-GwSAk9vY.js";
-import { n as bootstrapMatrixVerification } from "./verification-BbG-VC9S.js";
+import { a as resolveMatrixAccountConfig, n as hasExplicitMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import "./accounts-iThMol10.mjs";
+import { n as bootstrapMatrixVerification } from "./verification-0o8MOW9T.mjs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/matrix/src/setup-bootstrap.ts
 async function maybeBootstrapNewEncryptedMatrixAccount(params) {

package/dist/{setup-core-8keb-Yre.js → .setup/setup-core-D2hMbIi3.mjs}

@@ -1,9 +1,9 @@
-import { c as resolveMatrixEnvAuthReadiness } from "./account-selection-Bbtc483D.js";
-import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.js";
-import { r as resolveDefaultMatrixAccountId } from "./accounts-GwSAk9vY.js";
-import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.js";
-import { r as updateMatrixAccountConfig } from "./config-update-BnX26jCO.js";
-import { t as isSupportedMatrixAvatarSource } from "./profile-vmjsmhh4.js";
+import { l as resolveMatrixEnvAuthReadiness } from "./account-selection-BHkfU1eC.mjs";
+import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { r as resolveDefaultMatrixAccountId } from "./accounts-iThMol10.mjs";
+import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
+import { r as updateMatrixAccountConfig } from "./config-update-B_4qZ5bV.mjs";
+import { t as isSupportedMatrixAvatarSource } from "./profile-ClrB3IgR.mjs";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
 import { DEFAULT_ACCOUNT_ID, addWildcardAllowFrom, applyAccountNameToChannelSection, normalizeAccountId, normalizeAllowFromEntries, normalizeSecretInputString, patchTopLevelChannelConfigSection, prepareScopedSetupConfig, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
@@ -296,7 +296,7 @@ const matrixSetupAdapter = {
 		input
 	}),
 	afterAccountConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
-		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-sVqkwtSY.js");
+		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-A_WGFq1Y.mjs");
 		await runMatrixSetupBootstrapAfterConfigWrite({
 			previousCfg,
 			cfg,

package/dist/.setup/setup-plugin-api-JiRgm8s6.mjs

@@ -0,0 +1,3 @@
+import { n as matrixSetupPlugin } from "./channel.setup-C6KvBV8l.mjs";
+import "../setup-plugin-api.js";
+export { matrixSetupPlugin };

package/dist/{setup-surface-bcluelBI.js → .setup/setup-surface-BL3ha1l-.mjs}

@@ -1,12 +1,12 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { c as resolveMatrixEnvAuthReadiness, r as requiresExplicitMatrixDefaultAccount } from "./account-selection-Bbtc483D.js";
-import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.js";
-import { i as resolveMatrixAccount, r as resolveDefaultMatrixAccountId, t as listMatrixAccountIds } from "./accounts-GwSAk9vY.js";
-import { n as isMatrixRoomId } from "./target-ids-Nwx7cMVE.js";
-import { r as updateMatrixAccountConfig } from "./config-update-BnX26jCO.js";
-import { a as moveSingleMatrixAccountConfigToNamedAccount, i as createMatrixSetupDmPolicy } from "./setup-core-8keb-Yre.js";
-import { n as validateMatrixHomeserverUrl, r as isPrivateOrLoopbackHost, t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.js";
-import { n as ensureMatrixSdkInstalled, r as isMatrixSdkAvailable } from "./deps-mtxF2mHI.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { i as requiresExplicitMatrixDefaultAccount, l as resolveMatrixEnvAuthReadiness } from "./account-selection-BHkfU1eC.mjs";
+import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { i as resolveMatrixAccount, r as resolveDefaultMatrixAccountId, t as listMatrixAccountIds } from "./accounts-iThMol10.mjs";
+import { n as isMatrixRoomId } from "./target-ids-Nwx7cMVE.mjs";
+import { r as updateMatrixAccountConfig } from "./config-update-B_4qZ5bV.mjs";
+import { a as moveSingleMatrixAccountConfigToNamedAccount, i as createMatrixSetupDmPolicy } from "./setup-core-D2hMbIi3.mjs";
+import { n as validateMatrixHomeserverUrl, r as isPrivateOrLoopbackHost, t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.mjs";
+import { n as ensureMatrixSdkInstalled, r as isMatrixSdkAvailable } from "./deps-mtxF2mHI.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringifiedOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { formatDocsLink, hasConfiguredSecretInput, mergeAllowFromEntries, normalizeAccountId as normalizeAccountId$1, promptAccountId, promptChannelAccessConfig, setSetupChannelEnabled, splitSetupEntries } from "openclaw/plugin-sdk/setup";
@@ -91,7 +91,7 @@ async function promptMatrixAllowFrom(params) {
 			pending.push(part);
 		}
 		if (pending.length > 0) {
-			const { resolveMatrixTargets } = await import("./resolve-targets-K8D0HWPX.js").then((n) => n.n);
+			const { resolveMatrixTargets } = await import("./resolve-targets-BLz748lX.mjs").then((n) => n.n);
 			const results = await resolveMatrixTargets({
 				cfg,
 				accountId,
@@ -211,7 +211,7 @@ async function configureMatrixAccessPrompts(params) {
 						resolvedIds.push(cleaned);
 						continue;
 					}
-					const { listMatrixDirectoryGroupsLive } = await import("./directory-live-B8-GAVcc.js").then((n) => n.t);
+					const { listMatrixDirectoryGroupsLive } = await import("./directory-live-CxqkcYbT.mjs").then((n) => n.t);
 					const matches = await listMatrixDirectoryGroupsLive({
 						cfg: next,
 						accountId: params.accountId,
@@ -464,7 +464,7 @@ const matrixOnboardingAdapter = {
 		});
 	},
 	afterConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
-		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-sVqkwtSY.js");
+		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-A_WGFq1Y.mjs");
 		await runMatrixSetupBootstrapAfterConfigWrite({
 			previousCfg,
 			cfg,

package/dist/{startup-verification-BTSf31hS.js → .setup/startup-verification-Cp1Gf7pM.mjs}

@@ -1,6 +1,6 @@
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { k as resolveMatrixSqliteStateEnv } from "./storage-metadata-DYArLcq1.js";
-import { o as resolveMatrixStoragePaths, r as recordCurrentStorageMetaDeviceId } from "./storage-CV-pfV_2.js";
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { O as resolveMatrixSqliteStateEnv } from "./storage-metadata-fHN6Df2m.mjs";
+import { o as resolveMatrixStoragePaths, r as recordCurrentStorageMetaDeviceId } from "./storage-BXaFc0S4.mjs";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
@@ -19,8 +19,8 @@ function normalizeCooldownHours(value) {
 	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_STARTUP_VERIFICATION_COOLDOWN_HOURS;
 	return Math.max(0, value);
 }
-function resolveStartupVerificationStatePath(params) {
-	const storagePaths = resolveMatrixStoragePaths({
+async function resolveStartupVerificationStatePath(params) {
+	const storagePaths = await resolveMatrixStoragePaths({
 		homeserver: params.auth.homeserver,
 		userId: params.auth.userId,
 		accessToken: params.auth.accessToken,
@@ -69,7 +69,7 @@ async function readStartupVerificationState(params) {
 	if (await migrationStore.lookup(legacyImportKey)) return null;
 	const legacy = await readLegacyStartupVerificationState(params.legacyFilePath);
 	if (legacy) await store.register(key, legacy).then(async () => {
-		if (typeof legacy.deviceId === "string" && legacy.deviceId.trim()) recordCurrentStorageMetaDeviceId({
+		if (typeof legacy.deviceId === "string" && legacy.deviceId.trim()) await recordCurrentStorageMetaDeviceId({
 			rootDir: path.dirname(params.legacyFilePath),
 			deviceId: legacy.deviceId
 		});
@@ -84,7 +84,7 @@ async function writeStartupVerificationState(params) {
 		auth: params.auth,
 		legacyFilePath: params.legacyFilePath
 	}), { importedAt: Date.now() }).catch(() => {});
-	if (typeof params.state.deviceId === "string" && params.state.deviceId.trim()) recordCurrentStorageMetaDeviceId({
+	if (typeof params.state.deviceId === "string" && params.state.deviceId.trim()) await recordCurrentStorageMetaDeviceId({
 		rootDir: path.dirname(params.legacyFilePath),
 		deviceId: params.state.deviceId
 	});
@@ -127,7 +127,7 @@ function hasPendingSelfVerification(verifications) {
 async function ensureMatrixStartupVerification(params) {
 	if (params.auth.encryption !== true || !params.client.crypto) return { kind: "unsupported" };
 	const verification = await params.client.getOwnDeviceVerificationStatus();
-	const statePath = params.stateFilePath ?? resolveStartupVerificationStatePath({
+	const statePath = params.stateFilePath ?? await resolveStartupVerificationStatePath({
 		auth: params.auth,
 		env: params.env,
 		stateDir: params.stateDir

package/dist/{storage-CV-pfV_2.js → .setup/storage-BXaFc0S4.mjs}

@@ -1,6 +1,6 @@
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { n as isMatrixActiveTokenRootDirectory, r as resolveMatrixAccountStorageRoot } from "./storage-paths-DVCANXTc.js";
-import { C as scoreMatrixCryptoStateInStore, c as MATRIX_RECOVERY_KEY_FILENAME, d as migrateLegacyMatrixLegacyCryptoMigrationFileToStore, i as openMatrixStorageMetaStoreOptions, o as MATRIX_IDB_SNAPSHOT_FILENAME, p as migrateLegacyMatrixRecoveryKeyFileToStore, r as normalizeMatrixStorageMetadata, s as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, t as STORAGE_META_STATE_KEY } from "./storage-metadata-DYArLcq1.js";
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { n as isMatrixActiveTokenRootDirectory, r as resolveMatrixAccountStorageRoot } from "./storage-paths-DVCANXTc.mjs";
+import { S as scoreMatrixCryptoStateInStore, c as MATRIX_RECOVERY_KEY_FILENAME, d as migrateLegacyMatrixLegacyCryptoMigrationFileToStore, f as migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync, i as openMatrixStorageMetaStoreOptions, o as MATRIX_IDB_SNAPSHOT_FILENAME, r as normalizeMatrixStorageMetadata, s as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, t as STORAGE_META_STATE_KEY } from "./storage-metadata-fHN6Df2m.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import path from "node:path";
 import fs from "node:fs";
@@ -11,9 +11,9 @@ const DEFAULT_ACCOUNT_KEY = "default";
 const STORAGE_META_FILENAME = "storage-meta.json";
 const THREAD_BINDINGS_FILENAME = "thread-bindings.json";
 function openStorageMetaStore(rootDir) {
-	return getMatrixRuntime().state.openSyncKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
+	return getMatrixRuntime().state.openKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
 }
-function scoreStorageRoot(rootDir, metadata = readStoredRootMetadata(rootDir)) {
+async function scoreStorageRoot(rootDir, metadata) {
 	let score = 0;
 	if (Object.keys(metadata).length > 0) score += 1;
 	if (metadata.currentTokenStateClaimed === true) score += 8;
@@ -22,7 +22,7 @@ function scoreStorageRoot(rootDir, metadata = readStoredRootMetadata(rootDir)) {
 	if (fs.existsSync(path.join(rootDir, "legacy-crypto-migration.json"))) score += 3;
 	if (fs.existsSync(path.join(rootDir, "recovery-key.json"))) score += 2;
 	if (fs.existsSync(path.join(rootDir, "crypto-idb-snapshot.json"))) score += 2;
-	score += scoreMatrixCryptoStateInStore(rootDir);
+	score += await scoreMatrixCryptoStateInStore(rootDir);
 	return score;
 }
 function resolveStorageRootMtimeMs(rootDir) {
@@ -32,15 +32,15 @@ function resolveStorageRootMtimeMs(rootDir) {
 		return 0;
 	}
 }
-function readStoredRootMetadata(rootDir) {
+async function readStoredRootMetadata(rootDir) {
 	if (fs.existsSync(path.join(rootDir, "state", "openclaw.sqlite"))) try {
-		const stored = normalizeMatrixStorageMetadata(openStorageMetaStore(rootDir).lookup(STORAGE_META_STATE_KEY));
+		const stored = normalizeMatrixStorageMetadata(await openStorageMetaStore(rootDir).lookup(STORAGE_META_STATE_KEY));
 		if (stored) return stored;
 	} catch {}
 	return normalizeMatrixStorageMetadata(loadJsonFile(path.join(rootDir, STORAGE_META_FILENAME))) ?? {};
 }
 function isCompatibleStorageRoot(params) {
-	const metadata = readStoredRootMetadata(params.candidateRootDir);
+	const { metadata } = params;
 	if (metadata.homeserver && metadata.homeserver !== params.homeserver) return false;
 	if (metadata.userId && metadata.userId !== params.userId) return false;
 	if (metadata.accountId && normalizeAccountId(metadata.accountId) !== normalizeAccountId(params.accountKey)) return false;
@@ -48,17 +48,17 @@ function isCompatibleStorageRoot(params) {
 	if (params.requireExplicitDeviceMatch && params.deviceId && (!metadata.deviceId || metadata.deviceId.trim() !== params.deviceId.trim())) return false;
 	return true;
 }
-function resolvePreferredMatrixStorageRoot(params) {
+async function resolvePreferredMatrixStorageRoot(params) {
 	const canonical = {
 		rootDir: params.canonicalRootDir,
 		tokenHash: params.canonicalTokenHash
 	};
 	const deviceId = params.deviceId?.trim();
 	if (!deviceId) return canonical;
-	const canonicalMetadata = readStoredRootMetadata(params.canonicalRootDir);
+	const canonicalMetadata = await readStoredRootMetadata(params.canonicalRootDir);
 	if (canonicalMetadata.accessTokenHash === params.canonicalTokenHash && canonicalMetadata.deviceId?.trim() === deviceId && canonicalMetadata.currentTokenStateClaimed === true) return canonical;
 	const parentDir = path.dirname(params.canonicalRootDir);
-	const bestCurrentScore = scoreStorageRoot(params.canonicalRootDir, canonicalMetadata);
+	const bestCurrentScore = await scoreStorageRoot(params.canonicalRootDir, canonicalMetadata);
 	const bestCurrentMtimeMs = resolveStorageRootMtimeMs(params.canonicalRootDir);
 	let best = {
 		rootDir: params.canonicalRootDir,
@@ -82,15 +82,16 @@ function resolvePreferredMatrixStorageRoot(params) {
 		if (entry.name === params.canonicalTokenHash) continue;
 		if (!isMatrixActiveTokenRootDirectory(entry.name)) continue;
 		const candidateRootDir = path.join(parentDir, entry.name);
+		const metadata = await readStoredRootMetadata(candidateRootDir);
 		if (!isCompatibleStorageRoot({
-			candidateRootDir,
+			metadata,
 			homeserver: params.homeserver,
 			userId: params.userId,
 			accountKey: params.accountKey,
 			deviceId,
 			requireExplicitDeviceMatch: true
 		})) continue;
-		const candidateScore = scoreStorageRoot(candidateRootDir);
+		const candidateScore = await scoreStorageRoot(candidateRootDir, metadata);
 		if (candidateScore <= 0) continue;
 		populatedTokenHashes.push(entry.name);
 		compatiblePopulatedSiblings.push({
@@ -119,7 +120,7 @@ function resolvePreferredMatrixStorageRoot(params) {
 		tokenHash: best.tokenHash
 	};
 }
-function resolveMatrixStoragePaths(params) {
+async function resolveMatrixStoragePaths(params) {
 	const env = params.env ?? process.env;
 	const stateDir = params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir);
 	const canonical = resolveMatrixAccountStorageRoot({
@@ -129,7 +130,7 @@ function resolveMatrixStoragePaths(params) {
 		accessToken: params.accessToken,
 		accountId: params.accountId
 	});
-	const { rootDir, tokenHash } = resolvePreferredMatrixStorageRoot({
+	const { rootDir, tokenHash } = await resolvePreferredMatrixStorageRoot({
 		canonicalRootDir: canonical.rootDir,
 		canonicalTokenHash: canonical.tokenHash,
 		homeserver: params.homeserver,
@@ -147,8 +148,8 @@ function resolveMatrixStoragePaths(params) {
 		tokenHash
 	};
 }
-function resolveMatrixStateFilePath(params) {
-	const storagePaths = resolveMatrixStoragePaths({
+async function resolveMatrixStateFilePath(params) {
+	const storagePaths = await resolveMatrixStoragePaths({
 		homeserver: params.auth.homeserver,
 		userId: params.auth.userId,
 		accessToken: params.auth.accessToken,
@@ -161,14 +162,14 @@ function resolveMatrixStateFilePath(params) {
 }
 async function maybeMigrateLegacyStorage(params) {
 	const hasAccountScopedLegacyStorageFile = fs.existsSync(params.storagePaths.storagePath);
-	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./sync-cache-state-C-mhj3xb.js").then((n) => n.s) : null;
+	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./sync-cache-state-BMtGMxU1.mjs").then((n) => n.s) : null;
 	const hasAccountScopedLegacyStorage = hasAccountScopedLegacyStorageFile && await syncCache?.readLegacyMatrixSyncCacheState(params.storagePaths.rootDir) !== null;
 	const hasAccountScopedRecoveryKey = fs.existsSync(params.storagePaths.recoveryKeyPath);
 	const hasAccountScopedLegacyCryptoMigration = fs.existsSync(path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
 	if (!hasAccountScopedLegacyStorage && !hasAccountScopedRecoveryKey && !hasAccountScopedLegacyCryptoMigration) return;
 	const logger = getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" });
 	fs.mkdirSync(params.storagePaths.rootDir, { recursive: true });
-	const moved = [];
+	const migrations = [];
 	const pendingArchives = [];
 	const skippedExistingTargets = [];
 	try {
@@ -177,38 +178,37 @@ async function maybeMigrateLegacyStorage(params) {
 			sourcePath: params.storagePaths.storagePath,
 			targetRootDir: params.storagePaths.rootDir,
 			label: "account sync cache",
-			moved,
+			migrations,
 			pendingArchives
 		});
 		if (hasAccountScopedRecoveryKey) {
-			migrateLegacyMatrixRecoveryKeyFileToStore(params.storagePaths.rootDir);
-			moved.push({
+			await migrateLegacyMatrixRecoveryKeyFilePathToStoreAsync(params.storagePaths.recoveryKeyPath, getMatrixRuntime().state);
+			migrations.push({
 				sourcePath: params.storagePaths.recoveryKeyPath,
-				targetPath: `${params.storagePaths.rootDir} SQLite recovery key state`,
+				targetDescription: `${params.storagePaths.rootDir} SQLite recovery key state`,
 				label: "recovery key"
 			});
 		}
 		if (hasAccountScopedLegacyCryptoMigration) {
-			migrateLegacyMatrixLegacyCryptoMigrationFileToStore(params.storagePaths.rootDir);
-			moved.push({
+			await migrateLegacyMatrixLegacyCryptoMigrationFileToStore(params.storagePaths.rootDir);
+			migrations.push({
 				sourcePath: path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME),
-				targetPath: `${params.storagePaths.rootDir} SQLite legacy crypto migration state`,
+				targetDescription: `${params.storagePaths.rootDir} SQLite legacy crypto migration state`,
 				label: "legacy crypto migration"
 			});
 		}
 	} catch (err) {
-		const rollbackError = rollbackLegacyMoves(moved);
-		throw new Error(rollbackError ? `Failed migrating legacy Matrix client storage: ${String(err)}. Rollback also failed: ${rollbackError}` : `Failed migrating legacy Matrix client storage: ${String(err)}`, { cause: err });
+		throw new Error(`Failed migrating legacy Matrix client storage: ${String(err)}`, { cause: err });
 	}
 	for (const archive of pendingArchives) archiveLegacyStoragePath({
 		...archive,
 		skippedExistingTargets
 	});
-	if (moved.length > 0) logger.info(`matrix: migrated legacy client storage into ${params.storagePaths.rootDir}\n${moved.map((entry) => `- ${entry.label}: ${entry.sourcePath} -> ${entry.targetPath}`).join("\n")}`);
+	if (migrations.length > 0) logger.info(`matrix: migrated legacy client storage into ${params.storagePaths.rootDir}\n${migrations.map((entry) => `- ${entry.label}: ${entry.sourcePath} -> ${entry.targetDescription}`).join("\n")}`);
 	if (skippedExistingTargets.length > 0) logger.warn?.(`matrix: legacy client storage files were left in place because their migrated targets already existed.\n${skippedExistingTargets.join("\n")}`);
 }
 async function migrateLegacySyncCacheToSqlite(params) {
-	const syncCache = await import("./sync-cache-state-C-mhj3xb.js").then((n) => n.s);
+	const syncCache = await import("./sync-cache-state-BMtGMxU1.mjs").then((n) => n.s);
 	const persisted = await syncCache.readLegacyMatrixSyncCacheState(params.sourceRootDir);
 	if (!persisted) return;
 	const store = getMatrixRuntime().state.openKeyedStore(syncCache.openMatrixSyncCacheStoreOptions(params.targetRootDir));
@@ -221,10 +221,10 @@ async function migrateLegacySyncCacheToSqlite(params) {
 			payload: persisted,
 			store
 		});
-		claimCurrentTokenStorageState({ rootDir: params.targetRootDir });
-		params.moved.push({
+		await claimCurrentTokenStorageState({ rootDir: params.targetRootDir });
+		params.migrations.push({
 			sourcePath: params.sourcePath,
-			targetPath: `${params.targetRootDir} SQLite sync cache`,
+			targetDescription: `${params.targetRootDir} SQLite sync cache`,
 			label: params.label
 		});
 	}
@@ -241,79 +241,83 @@ function archiveLegacyStoragePath(params) {
 	}
 	fs.renameSync(params.sourcePath, archivedLegacyStoragePath);
 }
-function rollbackLegacyMoves(moved) {
-	for (const entry of moved.toReversed()) try {
-		if (!fs.existsSync(entry.targetPath) || fs.existsSync(entry.sourcePath)) continue;
-		fs.renameSync(entry.targetPath, entry.sourcePath);
-	} catch (err) {
-		return `${entry.label} (${entry.targetPath} -> ${entry.sourcePath}): ${String(err)}`;
-	}
-	return null;
+function prepareStorageMetaMutation(metadata, mutation) {
+	if (mutation.kind !== "initialize" && !metadata.accessTokenHash?.trim()) return null;
+	return normalizeMatrixStorageMetadata({
+		...mutation.kind === "initialize" ? mutation.metadata : metadata,
+		accountId: mutation.kind === "initialize" ? mutation.metadata.accountId : metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
+		deviceId: mutation.kind === "device" ? mutation.deviceId : mutation.kind === "initialize" ? mutation.metadata.deviceId ?? metadata.deviceId : metadata.deviceId,
+		currentTokenStateClaimed: mutation.kind === "claim" || (mutation.kind === "initialize" ? mutation.metadata.currentTokenStateClaimed ?? metadata.currentTokenStateClaimed === true : metadata.currentTokenStateClaimed === true),
+		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	});
 }
-function writeStoredRootMetadata(rootDir, payload) {
+async function mutateStorageMeta(rootDir, mutation) {
 	try {
-		const normalized = normalizeMatrixStorageMetadata(payload);
-		if (!normalized) return false;
-		openStorageMetaStore(rootDir).register(STORAGE_META_STATE_KEY, normalized);
-		return true;
+		const store = openStorageMetaStore(rootDir);
+		const decode = (value) => normalizeMatrixStorageMetadata(value) ?? normalizeMatrixStorageMetadata(loadJsonFile(path.join(rootDir, STORAGE_META_FILENAME))) ?? {};
+		if (!store.observe || !store.compareAndApply) {
+			const legacyStore = getMatrixRuntime().state.openSyncKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
+			const next = prepareStorageMetaMutation(decode(legacyStore.lookup(STORAGE_META_STATE_KEY)), mutation);
+			if (!next) return false;
+			legacyStore.register(STORAGE_META_STATE_KEY, next);
+			return true;
+		}
+		let observation = await store.observe(STORAGE_META_STATE_KEY);
+		for (;;) {
+			const next = prepareStorageMetaMutation(decode(observation.value), mutation);
+			if (!next) return false;
+			const result = await store.compareAndApply(STORAGE_META_STATE_KEY, observation.comparison, {
+				operation: "update",
+				action: "set",
+				value: next
+			});
+			if (result.status !== "conflict") return true;
+			observation = result.current;
+		}
 	} catch {
 		return false;
 	}
 }
-function writeStorageMeta(params) {
-	const existing = readStoredRootMetadata(params.storagePaths.rootDir);
-	return writeStoredRootMetadata(params.storagePaths.rootDir, {
-		homeserver: params.homeserver,
-		userId: params.userId,
-		accountId: params.accountId ?? DEFAULT_ACCOUNT_KEY,
-		accessTokenHash: params.storagePaths.tokenHash,
-		deviceId: params.deviceId ?? null,
-		currentTokenStateClaimed: params.currentTokenStateClaimed ?? existing.currentTokenStateClaimed === true,
-		createdAt: existing.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+async function writeStorageMeta(params) {
+	return mutateStorageMeta(params.storagePaths.rootDir, {
+		kind: "initialize",
+		metadata: {
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accountId: params.accountId ?? DEFAULT_ACCOUNT_KEY,
+			accessTokenHash: params.storagePaths.tokenHash,
+			deviceId: params.deviceId ?? null,
+			currentTokenStateClaimed: params.currentTokenStateClaimed
+		}
 	});
 }
-function claimCurrentTokenStorageState(params) {
-	const metadata = readStoredRootMetadata(params.rootDir);
-	if (!metadata.accessTokenHash?.trim()) return false;
-	return writeStoredRootMetadata(params.rootDir, {
-		homeserver: metadata.homeserver,
-		userId: metadata.userId,
-		accountId: metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
-		accessTokenHash: metadata.accessTokenHash,
-		deviceId: metadata.deviceId ?? null,
-		currentTokenStateClaimed: true,
-		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-	});
+async function claimCurrentTokenStorageState(params) {
+	return mutateStorageMeta(params.rootDir, { kind: "claim" });
 }
-function recordCurrentStorageMetaDeviceId(params) {
+async function recordCurrentStorageMetaDeviceId(params) {
+	const rootDir = params.rootDir;
 	const deviceId = params.deviceId.trim();
-	if (!deviceId) return false;
-	const metadata = readStoredRootMetadata(params.rootDir);
-	if (!metadata.accessTokenHash?.trim()) return false;
-	return writeStoredRootMetadata(params.rootDir, {
-		homeserver: metadata.homeserver,
-		userId: metadata.userId,
-		accountId: metadata.accountId ?? DEFAULT_ACCOUNT_KEY,
-		accessTokenHash: metadata.accessTokenHash,
-		deviceId,
-		currentTokenStateClaimed: metadata.currentTokenStateClaimed === true,
-		createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	if (!deviceId || !(await readStoredRootMetadata(rootDir)).accessTokenHash?.trim()) return false;
+	return mutateStorageMeta(rootDir, {
+		kind: "device",
+		deviceId
 	});
 }
-function repairCurrentTokenStorageMetaDeviceId(params) {
+async function repairCurrentTokenStorageMetaDeviceId(params) {
+	const { homeserver, userId, accessToken, accountId, deviceId, env, stateDir } = params;
 	return writeStorageMeta({
-		storagePaths: resolveMatrixStoragePaths({
-			homeserver: params.homeserver,
-			userId: params.userId,
-			accessToken: params.accessToken,
-			accountId: params.accountId,
-			env: params.env,
-			stateDir: params.stateDir
+		storagePaths: await resolveMatrixStoragePaths({
+			homeserver,
+			userId,
+			accessToken,
+			accountId,
+			env,
+			stateDir
 		}),
-		homeserver: params.homeserver,
-		userId: params.userId,
-		accountId: params.accountId,
-		deviceId: params.deviceId
+		homeserver,
+		userId,
+		accountId,
+		deviceId
 	});
 }
 //#endregion