@openclaw/matrix 2026.7.1-beta.6 → 2026.7.2-beta.1

package/dist/storage-BtSOar8T.js

@@ -0,0 +1,718 @@
+import { t as isRecord } from "./record-shared-CvzjvHRn.js";
+import { t as getMatrixRuntime } from "./runtime-CveSqMOP.js";
+import { n as resolveMatrixAccountStorageRoot } from "./storage-paths-B4_I9iqO.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { loadJsonFile } from "openclaw/plugin-sdk/json-store";
+//#region extensions/matrix/src/matrix/sqlite-state.ts
+function resolveStateDirOverride(options) {
+	if (!options) return;
+	if (options.stateDir) return options.stateDir;
+	if (options.stateRootDir) return options.stateRootDir;
+	return getMatrixRuntime().state.resolveStateDir(options.env ?? process.env, os.homedir);
+}
+function resolveMatrixSqliteStateKey(options) {
+	return resolveStateDirOverride(options) ?? "";
+}
+function resolveMatrixSqliteStateEnv(options) {
+	const stateDir = resolveStateDirOverride(options);
+	if (!stateDir) return options?.env;
+	return {
+		...options?.env ?? process.env,
+		OPENCLAW_STATE_DIR: stateDir
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/crypto-state-store.ts
+const STATE_KEY = "current";
+const RECOVERY_KEY_NAMESPACE = "recovery-key";
+const LEGACY_CRYPTO_MIGRATION_NAMESPACE = "legacy-crypto-migration";
+const IDB_SNAPSHOT_NAMESPACE = "idb-snapshot";
+const SMALL_STATE_MAX_ENTRIES = 10;
+const IDB_SNAPSHOT_MAX_ENTRIES = 2e4;
+const IDB_SNAPSHOT_MAX_CHUNKS = Math.floor((IDB_SNAPSHOT_MAX_ENTRIES - 1) / 2);
+const IDB_SNAPSHOT_CHUNK_BYTES = 24e3;
+const MATRIX_RECOVERY_KEY_FILENAME = "recovery-key.json";
+const MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME = "legacy-crypto-migration.json";
+const MATRIX_IDB_SNAPSHOT_FILENAME = "crypto-idb-snapshot.json";
+function openMatrixRecoveryKeyStoreOptions(storageRootDir) {
+	return {
+		namespace: RECOVERY_KEY_NAMESPACE,
+		maxEntries: SMALL_STATE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir) {
+	return {
+		namespace: LEGACY_CRYPTO_MIGRATION_NAMESPACE,
+		maxEntries: SMALL_STATE_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function openMatrixIdbSnapshotStoreOptions(storageRootDir) {
+	return {
+		namespace: IDB_SNAPSHOT_NAMESPACE,
+		maxEntries: IDB_SNAPSHOT_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function readMatrixRecoveryKeyState(storageRootDir) {
+	return readMatrixRecoveryKeyStateWithKey({
+		storageRootDir,
+		stateKey: STATE_KEY
+	});
+}
+function readMatrixRecoveryKeyStateForPath(recoveryKeyPath) {
+	return readMatrixRecoveryKeyStateWithKey({
+		storageRootDir: path.dirname(recoveryKeyPath),
+		stateKey: resolveRecoveryKeyStateKeyForPath(recoveryKeyPath)
+	});
+}
+function readMatrixRecoveryKeyStateWithKey(params) {
+	return normalizeMatrixStoredRecoveryKey(openSyncStore(openMatrixRecoveryKeyStoreOptions(params.storageRootDir)).lookup(params.stateKey));
+}
+function writeMatrixRecoveryKeyStateForPath(params) {
+	writeMatrixRecoveryKeyStateWithKey({
+		storageRootDir: path.dirname(params.recoveryKeyPath),
+		stateKey: resolveRecoveryKeyStateKeyForPath(params.recoveryKeyPath),
+		payload: params.payload
+	});
+}
+function writeMatrixRecoveryKeyStateWithKey(params) {
+	const payload = normalizeMatrixStoredRecoveryKey(params.payload);
+	if (!payload) throw new Error("Invalid Matrix recovery key state");
+	openSyncStore(openMatrixRecoveryKeyStoreOptions(params.storageRootDir)).register(params.stateKey, payload);
+}
+async function hasMatrixRecoveryKeyStateInStore(params) {
+	return normalizeMatrixStoredRecoveryKey(await params.store.lookup(STATE_KEY)) !== null;
+}
+async function writeMatrixRecoveryKeyStateToStore(params) {
+	const payload = normalizeMatrixStoredRecoveryKey(params.payload);
+	if (!payload) throw new Error("Invalid Matrix recovery key state");
+	await params.store.register(STATE_KEY, payload);
+}
+function readMatrixLegacyCryptoMigrationState(storageRootDir) {
+	return normalizeMatrixLegacyCryptoMigrationState(openSyncStore(openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir)).lookup(STATE_KEY));
+}
+function writeMatrixLegacyCryptoMigrationState(params) {
+	const state = normalizeMatrixLegacyCryptoMigrationState(params.state);
+	if (!state) throw new Error("Invalid Matrix legacy crypto migration state");
+	openSyncStore(openMatrixLegacyCryptoMigrationStoreOptions(params.storageRootDir)).register(STATE_KEY, state);
+}
+async function hasMatrixLegacyCryptoMigrationStateInStore(params) {
+	return normalizeMatrixLegacyCryptoMigrationState(await params.store.lookup(STATE_KEY)) !== null;
+}
+async function writeMatrixLegacyCryptoMigrationStateToStore(params) {
+	const state = normalizeMatrixLegacyCryptoMigrationState(params.state);
+	if (!state) throw new Error("Invalid Matrix legacy crypto migration state");
+	await params.store.register(STATE_KEY, state);
+}
+function readMatrixIdbSnapshotJson(storageRootDir) {
+	return readIdbSnapshotJsonFromStore(openSyncStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)));
+}
+function hasMatrixIdbSnapshotState(storageRootDir) {
+	return isIdbSnapshotMeta(openSyncStore(openMatrixIdbSnapshotStoreOptions(storageRootDir)).lookup(idbMetaKey()));
+}
+function writeMatrixIdbSnapshotJson(params) {
+	writeIdbSnapshotJsonToStore({
+		snapshotJson: params.snapshotJson,
+		databaseCount: params.databaseCount,
+		store: openSyncStore(openMatrixIdbSnapshotStoreOptions(params.storageRootDir))
+	});
+}
+async function hasMatrixIdbSnapshotStateInStore(params) {
+	return await readIdbSnapshotJsonFromAsyncStore(params.store) !== null;
+}
+async function writeMatrixIdbSnapshotJsonToStore(params) {
+	const rows = buildIdbSnapshotRows(params.snapshotJson, params.databaseCount);
+	for (const row of rows.chunks) await params.store.register(row.key, row.value);
+	await params.store.register(rows.meta.key, rows.meta.value);
+	for (const row of await params.store.entries()) if (row.key.startsWith(idbChunkKeyPrefix()) && !rows.nextChunkKeys.has(row.key)) await params.store.delete(row.key);
+}
+function migrateLegacyMatrixRecoveryKeyFileToStore(storageRootDir) {
+	return migrateLegacyMatrixRecoveryKeyFilePathToStore(path.join(storageRootDir, MATRIX_RECOVERY_KEY_FILENAME));
+}
+function migrateLegacyMatrixRecoveryKeyFilePathToStore(recoveryKeyPath) {
+	const existing = readMatrixRecoveryKeyStateForPath(recoveryKeyPath);
+	const legacy = readLegacyMatrixRecoveryKeyFile(recoveryKeyPath);
+	if (!existing && legacy) writeMatrixRecoveryKeyStateForPath({
+		recoveryKeyPath,
+		payload: legacy
+	});
+	return archiveLegacyStateFileIfPossible(recoveryKeyPath);
+}
+function migrateLegacyMatrixLegacyCryptoMigrationFileToStore(storageRootDir) {
+	const existing = readMatrixLegacyCryptoMigrationState(storageRootDir);
+	const legacy = readLegacyMatrixLegacyCryptoMigrationState(storageRootDir);
+	if (!existing && legacy) writeMatrixLegacyCryptoMigrationState({
+		storageRootDir,
+		state: legacy
+	});
+	return archiveLegacyStateFileIfPossible(path.join(storageRootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
+}
+function readLegacyMatrixRecoveryKeyState(storageRootDir) {
+	return readLegacyMatrixRecoveryKeyFile(path.join(storageRootDir, MATRIX_RECOVERY_KEY_FILENAME));
+}
+function readLegacyMatrixRecoveryKeyFile(filePath) {
+	return readJsonFileSync(filePath, normalizeMatrixStoredRecoveryKey);
+}
+function readLegacyMatrixLegacyCryptoMigrationState(storageRootDir) {
+	return readJsonFileSync(path.join(storageRootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME), normalizeMatrixLegacyCryptoMigrationState);
+}
+function scoreMatrixCryptoStateInStore(storageRootDir) {
+	if (!matrixCryptoStateDatabaseExists(storageRootDir)) return 0;
+	let score = 0;
+	try {
+		if (readMatrixLegacyCryptoMigrationState(storageRootDir)) score += 3;
+	} catch {}
+	try {
+		if (readMatrixRecoveryKeyState(storageRootDir)) score += 2;
+	} catch {}
+	try {
+		if (hasMatrixIdbSnapshotState(storageRootDir)) score += 2;
+	} catch {}
+	return score;
+}
+function matrixCryptoStateDatabaseExists(storageRootDir) {
+	return fs.existsSync(path.join(storageRootDir, "state", "openclaw.sqlite"));
+}
+function resolveRecoveryKeyStateKeyForPath(recoveryKeyPath) {
+	const basename = path.basename(recoveryKeyPath);
+	if (basename === "recovery-key.json") return STATE_KEY;
+	return `file:${createHash("sha256").update(basename, "utf8").digest("hex").slice(0, 32)}`;
+}
+function normalizeMatrixStoredRecoveryKey(value) {
+	if (!isRecord(value) || value.version !== 1 || typeof value.createdAt !== "string" || typeof value.privateKeyBase64 !== "string" || !value.privateKeyBase64.trim()) return null;
+	return {
+		version: 1,
+		createdAt: value.createdAt,
+		keyId: typeof value.keyId === "string" ? value.keyId : null,
+		...typeof value.encodedPrivateKey === "string" ? { encodedPrivateKey: value.encodedPrivateKey } : {},
+		privateKeyBase64: value.privateKeyBase64,
+		...isRecord(value.keyInfo) ? { keyInfo: {
+			...value.keyInfo.passphrase !== void 0 ? { passphrase: value.keyInfo.passphrase } : {},
+			...typeof value.keyInfo.name === "string" ? { name: value.keyInfo.name } : {}
+		} } : {}
+	};
+}
+function normalizeMatrixLegacyCryptoMigrationState(value) {
+	if (!isRecord(value) || value.version !== 1 || typeof value.accountId !== "string") return null;
+	if (value.restoreStatus !== "pending" && value.restoreStatus !== "completed" && value.restoreStatus !== "manual-action-required") return null;
+	const roomKeyCounts = isRecord(value.roomKeyCounts) && typeof value.roomKeyCounts.total === "number" && typeof value.roomKeyCounts.backedUp === "number" ? {
+		total: value.roomKeyCounts.total,
+		backedUp: value.roomKeyCounts.backedUp
+	} : null;
+	return {
+		version: 1,
+		...value.source === "matrix-bot-sdk-rust" ? { source: value.source } : {},
+		accountId: value.accountId,
+		...typeof value.deviceId === "string" || value.deviceId === null ? { deviceId: value.deviceId } : {},
+		roomKeyCounts,
+		...typeof value.backupVersion === "string" || value.backupVersion === null ? { backupVersion: value.backupVersion } : {},
+		...typeof value.decryptionKeyImported === "boolean" ? { decryptionKeyImported: value.decryptionKeyImported } : {},
+		restoreStatus: value.restoreStatus,
+		...typeof value.detectedAt === "string" ? { detectedAt: value.detectedAt } : {},
+		...typeof value.restoredAt === "string" ? { restoredAt: value.restoredAt } : {},
+		...typeof value.importedCount === "number" ? { importedCount: value.importedCount } : {},
+		...typeof value.totalCount === "number" ? { totalCount: value.totalCount } : {},
+		...typeof value.lastError === "string" || value.lastError === null ? { lastError: value.lastError } : {}
+	};
+}
+function openSyncStore(options) {
+	return getMatrixRuntime().state.openSyncKeyedStore(options);
+}
+function readJsonFileSync(filePath, normalize) {
+	try {
+		return normalize(JSON.parse(fs.readFileSync(filePath, "utf8")));
+	} catch {
+		return null;
+	}
+}
+function archiveLegacyStateFileIfPossible(filePath) {
+	if (!fs.existsSync(filePath)) return false;
+	const archivedPath = `${filePath}.migrated`;
+	if (fs.existsSync(archivedPath)) return false;
+	fs.renameSync(filePath, archivedPath);
+	return true;
+}
+function readIdbSnapshotJsonFromStore(store) {
+	const meta = store.lookup(idbMetaKey());
+	if (!isIdbSnapshotMeta(meta)) return null;
+	const chunks = readIdbSnapshotChunks(meta, (key) => store.lookup(key));
+	return chunks ? chunks.join("") : null;
+}
+async function readIdbSnapshotJsonFromAsyncStore(store) {
+	const meta = await store.lookup(idbMetaKey());
+	if (!isIdbSnapshotMeta(meta)) return null;
+	const chunks = await readIdbSnapshotChunksAsync(meta, (key) => store.lookup(key));
+	return chunks ? chunks.join("") : null;
+}
+function readIdbSnapshotChunks(meta, lookup) {
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = lookup(idbChunkKey(meta.generation, index));
+		if (!isIdbSnapshotChunk(chunk) || chunk.index !== index) return null;
+		chunks.push(chunk.data);
+	}
+	const snapshotJson = chunks.join("");
+	if (meta.digest !== digestText(snapshotJson)) return null;
+	return chunks;
+}
+async function readIdbSnapshotChunksAsync(meta, lookup) {
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = await lookup(idbChunkKey(meta.generation, index));
+		if (!isIdbSnapshotChunk(chunk) || chunk.index !== index) return null;
+		chunks.push(chunk.data);
+	}
+	const snapshotJson = chunks.join("");
+	if (meta.digest !== digestText(snapshotJson)) return null;
+	return chunks;
+}
+function writeIdbSnapshotJsonToStore(params) {
+	const rows = buildIdbSnapshotRows(params.snapshotJson, params.databaseCount);
+	for (const row of rows.chunks) params.store.register(row.key, row.value);
+	params.store.register(rows.meta.key, rows.meta.value);
+	for (const row of params.store.entries()) if (row.key.startsWith(idbChunkKeyPrefix()) && !rows.nextChunkKeys.has(row.key)) params.store.delete(row.key);
+}
+function buildIdbSnapshotRows(snapshotJson, databaseCount) {
+	const generation = randomUUID().replaceAll("-", "");
+	const chunks = chunkText(snapshotJson).map((data, index) => ({
+		key: idbChunkKey(generation, index),
+		value: {
+			kind: "snapshot-chunk",
+			index,
+			data
+		}
+	}));
+	return {
+		chunks,
+		nextChunkKeys: new Set(chunks.map((chunk) => chunk.key)),
+		meta: {
+			key: idbMetaKey(),
+			value: {
+				kind: "meta",
+				version: 1,
+				generation,
+				chunkCount: chunks.length,
+				digest: digestText(snapshotJson),
+				databaseCount,
+				persistedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}
+		}
+	};
+}
+function idbMetaKey() {
+	return `${STATE_KEY}:meta`;
+}
+function idbChunkKeyPrefix() {
+	return `${STATE_KEY}:snapshot:`;
+}
+function idbChunkKey(generation, index) {
+	return `${idbChunkKeyPrefix()}${generation}:${index}`;
+}
+function chunkText(value) {
+	const chunks = [];
+	let current = "";
+	let currentBytes = 0;
+	for (const char of value) {
+		const charBytes = Buffer.byteLength(char, "utf8");
+		if (current && currentBytes + charBytes > IDB_SNAPSHOT_CHUNK_BYTES) {
+			pushChunk(chunks, current);
+			current = "";
+			currentBytes = 0;
+		}
+		current += char;
+		currentBytes += charBytes;
+	}
+	if (current) pushChunk(chunks, current);
+	return chunks;
+}
+function pushChunk(chunks, chunk) {
+	if (chunks.length >= IDB_SNAPSHOT_MAX_CHUNKS) throw new Error("Matrix IndexedDB snapshot exceeds SQLite chunk limit");
+	chunks.push(chunk);
+}
+function digestText(value) {
+	return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function isIdbSnapshotMeta(value) {
+	return isRecord(value) && value.kind === "meta" && value.version === 1 && typeof value.generation === "string" && value.generation.trim() !== "" && typeof value.chunkCount === "number" && Number.isSafeInteger(value.chunkCount) && value.chunkCount >= 0 && value.chunkCount <= IDB_SNAPSHOT_MAX_CHUNKS && typeof value.digest === "string" && typeof value.databaseCount === "number" && Number.isSafeInteger(value.databaseCount) && value.databaseCount >= 0 && typeof value.persistedAt === "string";
+}
+function isIdbSnapshotChunk(value) {
+	return isRecord(value) && value.kind === "snapshot-chunk" && typeof value.index === "number" && Number.isSafeInteger(value.index) && value.index >= 0 && typeof value.data === "string";
+}
+//#endregion
+//#region extensions/matrix/src/matrix/client/storage.ts
+const DEFAULT_ACCOUNT_KEY = "default";
+const STORAGE_META_FILENAME = "storage-meta.json";
+const THREAD_BINDINGS_FILENAME = "thread-bindings.json";
+const STORAGE_META_NAMESPACE = "storage-meta";
+const STORAGE_META_STATE_KEY = "current";
+const STORAGE_META_MAX_ENTRIES = 10;
+function openMatrixStorageMetaStoreOptions(storageRootDir) {
+	return {
+		namespace: STORAGE_META_NAMESPACE,
+		maxEntries: STORAGE_META_MAX_ENTRIES,
+		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
+	};
+}
+function openStorageMetaStore(rootDir) {
+	return getMatrixRuntime().state.openSyncKeyedStore(openMatrixStorageMetaStoreOptions(rootDir));
+}
+function scoreStorageRoot(rootDir) {
+	let score = 0;
+	const metadata = readStoredRootMetadata(rootDir);
+	if (Object.keys(metadata).length > 0) score += 1;
+	if (metadata.currentTokenStateClaimed === true) score += 8;
+	if (fs.existsSync(path.join(rootDir, "crypto"))) score += 8;
+	if (fs.existsSync(path.join(rootDir, THREAD_BINDINGS_FILENAME))) score += 4;
+	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);
+	return score;
+}
+function resolveStorageRootMtimeMs(rootDir) {
+	try {
+		return fs.statSync(rootDir).mtimeMs;
+	} catch {
+		return 0;
+	}
+}
+function normalizeMatrixStorageMetadata(value) {
+	if (!isRecord(value)) return null;
+	const metadata = {};
+	if (typeof value.homeserver === "string" && value.homeserver.trim()) metadata.homeserver = value.homeserver.trim();
+	if (typeof value.userId === "string" && value.userId.trim()) metadata.userId = value.userId.trim();
+	if (typeof value.accountId === "string" && value.accountId.trim()) metadata.accountId = value.accountId.trim();
+	if (typeof value.accessTokenHash === "string" && value.accessTokenHash.trim()) metadata.accessTokenHash = value.accessTokenHash.trim();
+	if (typeof value.deviceId === "string" && value.deviceId.trim()) metadata.deviceId = value.deviceId.trim();
+	if (value.currentTokenStateClaimed === true) metadata.currentTokenStateClaimed = true;
+	if (typeof value.createdAt === "string" && value.createdAt.trim()) metadata.createdAt = value.createdAt.trim();
+	return Object.keys(metadata).length > 0 ? metadata : null;
+}
+async function hasMatrixStorageMetaStateInStore(params) {
+	return normalizeMatrixStorageMetadata(await params.store.lookup(STORAGE_META_STATE_KEY)) !== null;
+}
+async function writeMatrixStorageMetaStateToStore(params) {
+	await params.store.register(STORAGE_META_STATE_KEY, params.payload);
+}
+function readStoredRootMetadata(rootDir) {
+	if (fs.existsSync(path.join(rootDir, "state", "openclaw.sqlite"))) try {
+		const stored = normalizeMatrixStorageMetadata(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);
+	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;
+	if (params.deviceId && metadata.deviceId && metadata.deviceId.trim() && metadata.deviceId.trim() !== params.deviceId.trim()) return false;
+	if (params.requireExplicitDeviceMatch && params.deviceId && (!metadata.deviceId || metadata.deviceId.trim() !== params.deviceId.trim())) return false;
+	return true;
+}
+function resolvePreferredMatrixStorageRoot(params) {
+	const parentDir = path.dirname(params.canonicalRootDir);
+	const bestCurrentScore = scoreStorageRoot(params.canonicalRootDir);
+	const bestCurrentMtimeMs = resolveStorageRootMtimeMs(params.canonicalRootDir);
+	let best = {
+		rootDir: params.canonicalRootDir,
+		tokenHash: params.canonicalTokenHash,
+		score: bestCurrentScore,
+		mtimeMs: bestCurrentMtimeMs
+	};
+	if (!params.deviceId?.trim()) return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+	let siblingEntries;
+	try {
+		siblingEntries = fs.readdirSync(parentDir, { withFileTypes: true });
+	} catch {
+		return {
+			rootDir: best.rootDir,
+			tokenHash: best.tokenHash
+		};
+	}
+	const compatiblePopulatedSiblings = [];
+	const populatedTokenHashes = bestCurrentScore > 0 ? [params.canonicalTokenHash] : [];
+	for (const entry of siblingEntries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name === params.canonicalTokenHash) continue;
+		const candidateRootDir = path.join(parentDir, entry.name);
+		if (!isCompatibleStorageRoot({
+			candidateRootDir,
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accountKey: params.accountKey,
+			deviceId: params.deviceId,
+			requireExplicitDeviceMatch: Boolean(params.deviceId)
+		})) continue;
+		const candidateScore = scoreStorageRoot(candidateRootDir);
+		if (candidateScore <= 0) continue;
+		populatedTokenHashes.push(entry.name);
+		compatiblePopulatedSiblings.push({
+			rootDir: candidateRootDir,
+			tokenHash: entry.name,
+			score: candidateScore,
+			mtimeMs: resolveStorageRootMtimeMs(candidateRootDir)
+		});
+	}
+	const canonicalMetadata = readStoredRootMetadata(params.canonicalRootDir);
+	if (!(canonicalMetadata.accessTokenHash === params.canonicalTokenHash && canonicalMetadata.deviceId?.trim() === params.deviceId.trim() && canonicalMetadata.currentTokenStateClaimed === true)) {
+		for (const candidate of compatiblePopulatedSiblings) if (candidate.score > best.score || best.rootDir !== params.canonicalRootDir && candidate.score === best.score && candidate.mtimeMs > best.mtimeMs) best = {
+			rootDir: candidate.rootDir,
+			tokenHash: candidate.tokenHash,
+			score: candidate.score,
+			mtimeMs: candidate.mtimeMs
+		};
+	}
+	if (populatedTokenHashes.length > 1) getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" }).warn("matrix: multiple populated token-hash storage roots detected", {
+		parentDir,
+		canonicalTokenHash: params.canonicalTokenHash,
+		selectedTokenHash: best.tokenHash,
+		populatedTokenHashes,
+		populatedSiblingTokenHashes: compatiblePopulatedSiblings.map((root) => root.tokenHash),
+		populatedRootCount: populatedTokenHashes.length
+	});
+	return {
+		rootDir: best.rootDir,
+		tokenHash: best.tokenHash
+	};
+}
+function resolveMatrixStoragePaths(params) {
+	const env = params.env ?? process.env;
+	const canonical = resolveMatrixAccountStorageRoot({
+		stateDir: params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir),
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accessToken: params.accessToken,
+		accountId: params.accountId
+	});
+	const { rootDir, tokenHash } = resolvePreferredMatrixStorageRoot({
+		canonicalRootDir: canonical.rootDir,
+		canonicalTokenHash: canonical.tokenHash,
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountKey: canonical.accountKey,
+		deviceId: params.deviceId
+	});
+	return {
+		rootDir,
+		storagePath: path.join(rootDir, "bot-storage.json"),
+		cryptoPath: path.join(rootDir, "crypto"),
+		recoveryKeyPath: path.join(rootDir, MATRIX_RECOVERY_KEY_FILENAME),
+		idbSnapshotPath: path.join(rootDir, MATRIX_IDB_SNAPSHOT_FILENAME),
+		accountKey: canonical.accountKey,
+		tokenHash
+	};
+}
+function resolveMatrixStateFilePath(params) {
+	const storagePaths = resolveMatrixStoragePaths({
+		homeserver: params.auth.homeserver,
+		userId: params.auth.userId,
+		accessToken: params.auth.accessToken,
+		accountId: params.accountId ?? params.auth.accountId,
+		deviceId: params.auth.deviceId,
+		env: params.env,
+		stateDir: params.stateDir
+	});
+	return path.join(storagePaths.rootDir, params.filename);
+}
+async function maybeMigrateLegacyStorage(params) {
+	const hasAccountScopedLegacyStorageFile = fs.existsSync(params.storagePaths.storagePath);
+	const syncCache = hasAccountScopedLegacyStorageFile ? await import("./file-sync-store-Cxb0ckyX.js").then((n) => n.n) : null;
+	const hasAccountScopedLegacyStorage = hasAccountScopedLegacyStorageFile && await syncCache?.readLegacyMatrixSyncCacheState(params.storagePaths.rootDir) !== null;
+	const hasAccountScopedRecoveryKey = fs.existsSync(params.storagePaths.recoveryKeyPath);
+	const hasAccountScopedIdbSnapshot = fs.existsSync(params.storagePaths.idbSnapshotPath);
+	const hasAccountScopedLegacyCryptoMigration = fs.existsSync(path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME));
+	if (!hasAccountScopedLegacyStorage && !hasAccountScopedRecoveryKey && !hasAccountScopedIdbSnapshot && !hasAccountScopedLegacyCryptoMigration) return;
+	const logger = getMatrixRuntime().logging.getChildLogger({ module: "matrix-storage" });
+	fs.mkdirSync(params.storagePaths.rootDir, { recursive: true });
+	const moved = [];
+	const pendingArchives = [];
+	const skippedExistingTargets = [];
+	try {
+		if (hasAccountScopedLegacyStorage) await migrateLegacySyncCacheToSqlite({
+			sourceRootDir: params.storagePaths.rootDir,
+			sourcePath: params.storagePaths.storagePath,
+			targetRootDir: params.storagePaths.rootDir,
+			label: "account sync cache",
+			moved,
+			pendingArchives
+		});
+		if (hasAccountScopedRecoveryKey) {
+			migrateLegacyMatrixRecoveryKeyFileToStore(params.storagePaths.rootDir);
+			moved.push({
+				sourcePath: params.storagePaths.recoveryKeyPath,
+				targetPath: `${params.storagePaths.rootDir} SQLite recovery key state`,
+				label: "recovery key"
+			});
+		}
+		if (hasAccountScopedLegacyCryptoMigration) {
+			migrateLegacyMatrixLegacyCryptoMigrationFileToStore(params.storagePaths.rootDir);
+			moved.push({
+				sourcePath: path.join(params.storagePaths.rootDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME),
+				targetPath: `${params.storagePaths.rootDir} SQLite legacy crypto migration state`,
+				label: "legacy crypto migration"
+			});
+		}
+		if (hasAccountScopedIdbSnapshot) await migrateLegacyIdbSnapshotToSqlite({
+			storageRootDir: params.storagePaths.rootDir,
+			snapshotPath: params.storagePaths.idbSnapshotPath,
+			moved,
+			pendingArchives
+		});
+	} 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 });
+	}
+	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 (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 migrateLegacyIdbSnapshotToSqlite(params) {
+	if (readMatrixIdbSnapshotJson(params.storageRootDir)) {
+		params.pendingArchives.push({
+			sourcePath: params.snapshotPath,
+			label: "IndexedDB snapshot"
+		});
+		return;
+	}
+	const { readLegacyMatrixIdbSnapshotState } = await import("./idb-persistence-iUZoHZkp.js").then((n) => n.t);
+	const snapshot = await readLegacyMatrixIdbSnapshotState(params.storageRootDir);
+	if (!snapshot) return;
+	writeMatrixIdbSnapshotJson({
+		storageRootDir: params.storageRootDir,
+		snapshotJson: JSON.stringify(snapshot),
+		databaseCount: snapshot.length
+	});
+	params.moved.push({
+		sourcePath: params.snapshotPath,
+		targetPath: `${params.storageRootDir} SQLite IndexedDB snapshot state`,
+		label: "IndexedDB snapshot"
+	});
+	params.pendingArchives.push({
+		sourcePath: params.snapshotPath,
+		label: "IndexedDB snapshot"
+	});
+}
+async function migrateLegacySyncCacheToSqlite(params) {
+	const syncCache = await import("./file-sync-store-Cxb0ckyX.js").then((n) => n.n);
+	const persisted = await syncCache.readLegacyMatrixSyncCacheState(params.sourceRootDir);
+	if (!persisted) return;
+	const store = getMatrixRuntime().state.openKeyedStore(syncCache.openMatrixSyncCacheStoreOptions(params.targetRootDir));
+	if (!await syncCache.hasMatrixSyncCacheStateInStore({
+		storageRootDir: params.targetRootDir,
+		store
+	})) {
+		await syncCache.writeMatrixSyncCacheStateToStore({
+			storageRootDir: params.targetRootDir,
+			payload: persisted,
+			store
+		});
+		claimCurrentTokenStorageState({ rootDir: params.targetRootDir });
+		params.moved.push({
+			sourcePath: params.sourcePath,
+			targetPath: `${params.targetRootDir} SQLite sync cache`,
+			label: params.label
+		});
+	}
+	params.pendingArchives.push({
+		sourcePath: params.sourcePath,
+		label: params.label
+	});
+}
+function archiveLegacyStoragePath(params) {
+	const archivedLegacyStoragePath = `${params.sourcePath}.migrated`;
+	if (fs.existsSync(archivedLegacyStoragePath)) {
+		params.skippedExistingTargets.push(`- ${params.label} remains at ${params.sourcePath} because ${archivedLegacyStoragePath} already exists`);
+		return;
+	}
+	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 writeStoredRootMetadata(rootDir, payload) {
+	try {
+		const normalized = normalizeMatrixStorageMetadata(payload);
+		if (!normalized) return false;
+		openStorageMetaStore(rootDir).register(STORAGE_META_STATE_KEY, normalized);
+		return true;
+	} 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()
+	});
+}
+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()
+	});
+}
+function recordCurrentStorageMetaDeviceId(params) {
+	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()
+	});
+}
+function repairCurrentTokenStorageMetaDeviceId(params) {
+	return writeStorageMeta({
+		storagePaths: resolveMatrixStoragePaths({
+			homeserver: params.homeserver,
+			userId: params.userId,
+			accessToken: params.accessToken,
+			accountId: params.accountId,
+			env: params.env,
+			stateDir: params.stateDir
+		}),
+		homeserver: params.homeserver,
+		userId: params.userId,
+		accountId: params.accountId,
+		deviceId: params.deviceId
+	});
+}
+//#endregion
+export { writeMatrixRecoveryKeyStateForPath as A, readLegacyMatrixRecoveryKeyFile as C, writeMatrixIdbSnapshotJson as D, readMatrixRecoveryKeyStateForPath as E, resolveMatrixSqliteStateEnv as M, resolveMatrixSqliteStateKey as N, writeMatrixIdbSnapshotJsonToStore as O, readLegacyMatrixLegacyCryptoMigrationState as S, readMatrixIdbSnapshotJson as T, hasMatrixRecoveryKeyStateInStore as _, openMatrixStorageMetaStoreOptions as a, openMatrixLegacyCryptoMigrationStoreOptions as b, resolveMatrixStateFilePath as c, writeStorageMeta as d, MATRIX_IDB_SNAPSHOT_FILENAME as f, hasMatrixLegacyCryptoMigrationStateInStore as g, hasMatrixIdbSnapshotStateInStore as h, normalizeMatrixStorageMetadata as i, writeMatrixRecoveryKeyStateToStore as j, writeMatrixLegacyCryptoMigrationStateToStore as k, resolveMatrixStoragePaths as l, MATRIX_RECOVERY_KEY_FILENAME as m, hasMatrixStorageMetaStateInStore as n, recordCurrentStorageMetaDeviceId as o, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME as p, maybeMigrateLegacyStorage as r, repairCurrentTokenStorageMetaDeviceId as s, claimCurrentTokenStorageState as t, writeMatrixStorageMetaStateToStore as u, migrateLegacyMatrixRecoveryKeyFilePathToStore as v, readLegacyMatrixRecoveryKeyState as w, openMatrixRecoveryKeyStoreOptions as x, openMatrixIdbSnapshotStoreOptions as y };