@openclaw/matrix 2026.7.2-beta.7 → 2026.7.34

package/dist/storage-BvAkgzvT.js

@@ -1,685 +0,0 @@
-import { t as isRecord } from "./record-shared-CWWx6fvI.js";
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { n as resolveMatrixAccountStorageRoot } from "./storage-paths-gUmSydsW.js";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { createHash, randomUUID } from "node:crypto";
-import path from "node:path";
-import fs from "node:fs";
-import { loadJsonFile } from "openclaw/plugin-sdk/json-store";
-import os from "node:os";
-//#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 readMatrixIdbSnapshotJsonFromStore(params) {
-	return await readIdbSnapshotJsonFromAsyncStore(params.store);
-}
-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, metadata = readStoredRootMetadata(rootDir)) {
-	let score = 0;
-	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 canonical = {
-		rootDir: params.canonicalRootDir,
-		tokenHash: params.canonicalTokenHash
-	};
-	const deviceId = params.deviceId?.trim();
-	if (!deviceId) return canonical;
-	const canonicalMetadata = 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 bestCurrentMtimeMs = resolveStorageRootMtimeMs(params.canonicalRootDir);
-	let best = {
-		rootDir: params.canonicalRootDir,
-		tokenHash: params.canonicalTokenHash,
-		score: bestCurrentScore,
-		mtimeMs: bestCurrentMtimeMs
-	};
-	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,
-			requireExplicitDeviceMatch: true
-		})) 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)
-		});
-	}
-	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-DiiFsayX.js").then((n) => n.n) : 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 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"
-			});
-		}
-	} 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 migrateLegacySyncCacheToSqlite(params) {
-	const syncCache = await import("./file-sync-store-DiiFsayX.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, readLegacyMatrixRecoveryKeyState as C, writeMatrixIdbSnapshotJson as D, readMatrixRecoveryKeyStateForPath as E, resolveMatrixSqliteStateEnv as M, resolveMatrixSqliteStateKey as N, writeMatrixIdbSnapshotJsonToStore as O, readLegacyMatrixRecoveryKeyFile as S, readMatrixIdbSnapshotJsonFromStore as T, migrateLegacyMatrixRecoveryKeyFilePathToStore as _, openMatrixStorageMetaStoreOptions as a, openMatrixRecoveryKeyStoreOptions as b, resolveMatrixStateFilePath as c, writeStorageMeta as d, MATRIX_IDB_SNAPSHOT_FILENAME as f, hasMatrixRecoveryKeyStateInStore as g, hasMatrixLegacyCryptoMigrationStateInStore 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, openMatrixIdbSnapshotStoreOptions as v, readMatrixIdbSnapshotJson as w, readLegacyMatrixLegacyCryptoMigrationState as x, openMatrixLegacyCryptoMigrationStoreOptions as y };