@openclaw/matrix 2026.7.2-beta.7 → 2026.7.34

package/dist/doctor-contract-api.js

@@ -1,334 +1,21 @@
-import { a as resolveMatrixDefaultOrOnlyAccountId, n as requiresExplicitMatrixDefaultAccount } from "./account-selection-kqquRzCf.js";
-import { t as isRecord$1 } from "./record-shared-CWWx6fvI.js";
-import { r as resolveMatrixCredentialsDir } from "./storage-paths-gUmSydsW.js";
-import { a as isMatrixCredentialRevocation, c as normalizeMatrixStoredCredentials, s as matrixCredentialsStoreKey, t as MATRIX_CREDENTIALS_NAMESPACE } from "./credentials-read-DVmFCm7X.js";
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BMSJkkAE.js";
-import { C as readLegacyMatrixRecoveryKeyState, O as writeMatrixIdbSnapshotJsonToStore, T as readMatrixIdbSnapshotJsonFromStore, a as openMatrixStorageMetaStoreOptions, b as openMatrixRecoveryKeyStoreOptions, f as MATRIX_IDB_SNAPSHOT_FILENAME, g as hasMatrixRecoveryKeyStateInStore, h as hasMatrixLegacyCryptoMigrationStateInStore, i as normalizeMatrixStorageMetadata, j as writeMatrixRecoveryKeyStateToStore, k as writeMatrixLegacyCryptoMigrationStateToStore, m as MATRIX_RECOVERY_KEY_FILENAME, n as hasMatrixStorageMetaStateInStore, p as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, u as writeMatrixStorageMetaStateToStore, v as openMatrixIdbSnapshotStoreOptions, x as readLegacyMatrixLegacyCryptoMigrationState, y as openMatrixLegacyCryptoMigrationStoreOptions } from "./storage-BvAkgzvT.js";
-import { a as readLegacyMatrixSyncCacheState, i as openMatrixSyncCacheStoreOptions, o as writeMatrixSyncCacheStateToStore, r as hasMatrixSyncCacheStateInStore } from "./file-sync-store-DiiFsayX.js";
-import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-DAJ49nZX.js";
-import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-B6x7dMsF.js";
-import { a as resolveMatrixInboundDedupeStateNamespace, n as MATRIX_INBOUND_DEDUPE_TTL_MS, r as buildMatrixInboundDedupeEventKey } from "./inbound-dedupe-CaBLblef.js";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { archiveLegacyStateSource } from "openclaw/plugin-sdk/runtime-doctor";
-import { createHash, randomUUID } from "node:crypto";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./.setup/doctor-contract-DNJw0fdq.mjs";
+import { D as writeMatrixRecoveryKeyStateToStore, S as writeMatrixIdbSnapshotJsonToStore, a as hasMatrixLegacyCryptoMigrationStateInStore, d as openMatrixLegacyCryptoMigrationStoreOptions, f as openMatrixRecoveryKeyStoreOptions, h as readLegacyMatrixRecoveryKeyState, i as hasMatrixIdbSnapshotStateInStore, n as MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, o as hasMatrixRecoveryKeyStateInStore, p as readLegacyMatrixLegacyCryptoMigrationState, r as MATRIX_RECOVERY_KEY_FILENAME, t as MATRIX_IDB_SNAPSHOT_FILENAME, u as openMatrixIdbSnapshotStoreOptions, w as writeMatrixLegacyCryptoMigrationStateToStore } from "./.setup/crypto-state-store-B43k3z3W.mjs";
+import { a as openMatrixStorageMetaStoreOptions, i as normalizeMatrixStorageMetadata, n as hasMatrixStorageMetaStateInStore, u as writeMatrixStorageMetaStateToStore } from "./.setup/storage-NGZq5zet.mjs";
+import { a as readLegacyMatrixSyncCacheState, i as openMatrixSyncCacheStoreOptions, o as writeMatrixSyncCacheStateToStore, r as hasMatrixSyncCacheStateInStore } from "./.setup/file-sync-store-DU0cnYAz.mjs";
+import { r as readLegacyMatrixIdbSnapshotState } from "./.setup/idb-persistence-_HKTXkVC.mjs";
 import path from "node:path";
-import fs from "node:fs";
-import fs$1 from "node:fs/promises";
-import { isDeepStrictEqual } from "node:util";
-import { withFileLock } from "openclaw/plugin-sdk/file-lock";
-import { createPersistentDedupeImportEntry } from "openclaw/plugin-sdk/persistent-dedupe";
-//#region extensions/matrix/src/matrix/crypto-snapshot-doctor.ts
-async function migrateLegacyMatrixIdbSnapshot(params) {
-	const snapshotPath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
-	try {
-		await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, () => migrateLegacyMatrixIdbSnapshotLocked(params));
-	} catch (err) {
-		params.warnings.push(`Failed locking Matrix IndexedDB snapshot for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
-	}
-}
-async function migrateLegacyMatrixIdbSnapshotLocked(params) {
-	const sourcePath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
-	let snapshot;
-	try {
-		snapshot = readLegacyMatrixIdbSnapshotStateUnlocked(params.storageRootDir);
-	} catch (err) {
-		params.warnings.push(`Failed reading Matrix IndexedDB snapshot legacy source for ${params.storageRootDir}: ${String(err)}; left source in place`);
-		return;
-	}
-	if (!snapshot) {
-		if (!fs.existsSync(sourcePath)) return;
-		const archived = await archiveLegacyMatrixIdbSnapshot(params);
-		params.warnings.push(archived ? `Matrix IndexedDB snapshot legacy source is invalid for ${params.storageRootDir}; archived without import` : `Matrix IndexedDB snapshot legacy source is invalid for ${params.storageRootDir}; left active because archival failed`);
-		return;
-	}
-	const snapshotJson = JSON.stringify(snapshot);
-	const store = params.context.openPluginStateKeyedStore(openMatrixIdbSnapshotStoreOptions(params.storageRootDir));
-	let persisted;
-	let hadPartialState;
-	try {
-		persisted = await readMatrixIdbSnapshotJsonFromStore({ store });
-		const persistedIsValid = persisted ? isValidMatrixIdbSnapshotJson(persisted) : false;
-		hadPartialState = !persistedIsValid && (await store.entries()).length > 0;
-		if (!persistedIsValid) persisted = null;
-	} catch (err) {
-		params.warnings.push(`Failed inspecting Matrix IndexedDB snapshot SQLite state for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
-		return;
-	}
-	if (persisted && !snapshotContentMatches(persisted, snapshot)) {
-		if (await archiveLegacyMatrixIdbSnapshot(params)) params.notices.push(`Kept the canonical Matrix IndexedDB snapshot in SQLite and archived a differing legacy source for ${params.storageRootDir}`);
-		return;
-	}
-	if (!persisted) {
-		try {
-			await writeMatrixIdbSnapshotJsonToStore({
-				snapshotJson,
-				databaseCount: snapshot.length,
-				store
-			});
-			persisted = await readMatrixIdbSnapshotJsonFromStore({ store });
-		} catch (err) {
-			params.warnings.push(`Failed importing Matrix IndexedDB snapshot for ${params.storageRootDir}: ${String(err)}; left legacy source in place`);
-			return;
-		}
-		if (!persisted || !snapshotContentMatches(persisted, snapshot)) {
-			params.warnings.push(`Failed verifying Matrix IndexedDB snapshot for ${params.storageRootDir}; left legacy source in place`);
-			return;
-		}
-		params.changes.push(hadPartialState ? `Repaired partial or invalid Matrix IndexedDB snapshot SQLite state for ${params.storageRootDir}` : `Migrated Matrix IndexedDB snapshot JSON to SQLite for ${params.storageRootDir}`);
-	}
-	await archiveLegacyMatrixIdbSnapshot(params);
-}
-function snapshotContentMatches(persistedJson, snapshot) {
-	try {
-		return isDeepStrictEqual(JSON.parse(persistedJson), snapshot);
-	} catch {
-		return false;
-	}
-}
-async function archiveLegacyMatrixIdbSnapshot(params) {
-	const sourcePath = path.join(params.storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
-	const archivePath = `${sourcePath}.migrated-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}-${randomUUID()}`;
-	try {
-		await fs$1.rename(sourcePath, archivePath);
-		params.changes.push(`Archived Matrix IndexedDB snapshot legacy source -> ${archivePath}`);
-		return true;
-	} catch (err) {
-		params.warnings.push(`Failed archiving Matrix IndexedDB snapshot legacy source: ${String(err)}`);
-		return false;
-	}
-}
-//#endregion
-//#region extensions/matrix/src/matrix/monitor/inbound-dedupe-migration.ts
-const LEGACY_SQLITE_NAMESPACE = "inbound-dedupe";
-const LEGACY_SQLITE_MAX_ENTRIES = 2e4;
-const LEGACY_MARKERS_NAMESPACE = "inbound-dedupe-migrations";
-const LEGACY_MARKERS_MAX_ENTRIES = 1e3;
-const LEGACY_JSON_VERSION = 1;
-const STORAGE_META_FILENAME = "storage-meta.json";
-const MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME = "inbound-dedupe.json";
-async function collectMatrixInboundDedupeSources(stateDir) {
-	const matrixRoot = path.join(stateDir, "matrix");
-	const sqliteRoots = /* @__PURE__ */ new Set();
-	const jsonRoots = /* @__PURE__ */ new Set();
-	async function visit(dir) {
-		let entries;
-		try {
-			entries = await fs$1.readdir(dir, { withFileTypes: true });
-		} catch {
-			return;
-		}
-		for (const entry of entries) {
-			const entryPath = path.join(dir, entry.name);
-			if (entry.isFile()) {
-				if (entry.name === "openclaw.sqlite" && path.basename(dir) === "state") sqliteRoots.add(path.dirname(dir));
-				else if (entry.name === "inbound-dedupe.json") jsonRoots.add(dir);
-				continue;
-			}
-			if (entry.isDirectory()) await visit(entryPath);
-		}
-	}
-	await visit(matrixRoot);
-	const matrixRootResolved = path.resolve(matrixRoot);
-	const isAccountRoot = (root) => path.resolve(root) !== matrixRootResolved;
-	return {
-		sqliteRoots: [...sqliteRoots].filter(isAccountRoot).toSorted(),
-		jsonRoots: [...jsonRoots].filter(isAccountRoot).toSorted()
-	};
-}
-function openLegacySqliteStore(io, storageRootDir) {
-	return io.context.openPluginStateKeyedStore({
-		namespace: LEGACY_SQLITE_NAMESPACE,
-		maxEntries: LEGACY_SQLITE_MAX_ENTRIES,
-		env: {
-			...io.env,
-			OPENCLAW_STATE_DIR: storageRootDir
-		}
-	});
-}
-function openLegacyMarkersStore(io, storageRootDir) {
-	return io.context.openPluginStateKeyedStore({
-		namespace: LEGACY_MARKERS_NAMESPACE,
-		maxEntries: LEGACY_MARKERS_MAX_ENTRIES,
-		env: {
-			...io.env,
-			OPENCLAW_STATE_DIR: storageRootDir
-		}
-	});
-}
-function normalizeLegacyTimestamp(raw) {
-	if (typeof raw !== "number" || !Number.isFinite(raw)) return null;
-	return Math.max(0, Math.floor(raw));
-}
-function parseLegacySqliteRow(row) {
-	const value = isRecord$1(row.value) ? row.value : {};
-	const roomId = typeof value.roomId === "string" ? value.roomId.trim() : "";
-	const eventId = typeof value.eventId === "string" ? value.eventId.trim() : "";
-	const ts = normalizeLegacyTimestamp(value.ts);
-	const separator = row.key.lastIndexOf(":");
-	if (!roomId || !eventId || ts === null || separator <= 0) return null;
-	const accountId = row.key.slice(0, separator);
-	const digest = createHash("sha256").update(accountId).update("\0").update(roomId).update("\0").update(eventId).digest("hex");
-	if (row.key.slice(separator + 1) !== digest) return null;
-	return {
-		accountId,
-		roomId,
-		eventId,
-		ts
-	};
-}
-/** Reads one storage root's legacy SQLite dedupe rows; throws on store errors. */
-async function readLegacyInboundDedupeSqliteSource(io, storageRootDir) {
-	const rows = await openLegacySqliteStore(io, storageRootDir).entries();
-	const markerRows = await openLegacyMarkersStore(io, storageRootDir).entries();
-	const markers = [];
-	for (const row of rows) {
-		const marker = parseLegacySqliteRow(row);
-		if (marker) markers.push(marker);
-	}
-	return {
-		markers,
-		legacyRowCount: rows.length + markerRows.length
-	};
-}
-/** Clears one storage root's retired legacy dedupe namespaces after import. */
-async function retireLegacyInboundDedupeSqliteRows(io, storageRootDir) {
-	await openLegacySqliteStore(io, storageRootDir).clear();
-	await openLegacyMarkersStore(io, storageRootDir).clear();
-}
-async function resolveJsonRootAccountId(storageRootDir) {
-	for (const filename of [STORAGE_META_FILENAME, `${STORAGE_META_FILENAME}.migrated`]) try {
-		const metadata = normalizeMatrixStorageMetadata(JSON.parse(await fs$1.readFile(path.join(storageRootDir, filename), "utf8")));
-		if (metadata?.accountId) return metadata.accountId;
-	} catch {}
-	return "default";
-}
-/**
-* Reads one storage root's legacy inbound-dedupe.json markers. Throws on file
-* read errors so a transiently unreadable file is never retired unread, and
-* returns null for malformed content so the caller can archive it explicitly.
-*/
-async function readLegacyInboundDedupeJsonSource(storageRootDir) {
-	const jsonPath = path.join(storageRootDir, MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME);
-	const raw = await fs$1.readFile(jsonPath, "utf8");
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return null;
-	}
-	if (!isRecord$1(parsed) || parsed.version !== LEGACY_JSON_VERSION || !Array.isArray(parsed.entries)) return null;
-	const accountId = await resolveJsonRootAccountId(storageRootDir);
-	const markers = [];
-	for (const entry of parsed.entries) {
-		if (!isRecord$1(entry) || typeof entry.key !== "string") continue;
-		const separator = entry.key.indexOf("|");
-		if (separator <= 0) continue;
-		const roomId = entry.key.slice(0, separator).trim();
-		const eventId = entry.key.slice(separator + 1).trim();
-		const ts = normalizeLegacyTimestamp(entry.ts);
-		if (!roomId || !eventId || ts === null) continue;
-		markers.push({
-			accountId,
-			roomId,
-			eventId,
-			ts
-		});
-	}
-	return markers;
-}
-/**
-* Imports the globally newest legacy markers into the claimable-dedupe store.
-* Never exceeds capacity: eviction is by row creation time, so letting fresh
-* imports overflow the namespace would evict the newer rows the runtime
-* committed since the upgrade. Throws on store errors so the caller keeps the
-* legacy sources for the next doctor attempt.
-*/
-async function importNewestInboundDedupeMarkers(params) {
-	const now = params.now ?? Date.now();
-	const stateMaxEntries = params.stateMaxEntries ?? 2e4;
-	const newestByKey = /* @__PURE__ */ new Map();
-	for (const marker of params.markers) {
-		const key = buildMatrixInboundDedupeEventKey(marker);
-		if (!key) continue;
-		const existing = newestByKey.get(key);
-		if (!existing || marker.ts > existing.ts) newestByKey.set(key, {
-			...marker,
-			key
-		});
-	}
-	const markers = [...newestByKey.values()].toSorted((left, right) => right.ts - left.ts);
-	const store = params.io.context.openPluginStateKeyedStore({
-		namespace: resolveMatrixInboundDedupeStateNamespace(),
-		maxEntries: stateMaxEntries,
-		defaultTtlMs: MATRIX_INBOUND_DEDUPE_TTL_MS,
-		env: params.io.env
-	});
-	let capacity = Math.max(0, stateMaxEntries - (await store.entries()).length);
-	let imported = 0;
-	for (const marker of markers) {
-		if (capacity <= 0) break;
-		const remainingTtlMs = MATRIX_INBOUND_DEDUPE_TTL_MS - (now - marker.ts);
-		if (remainingTtlMs <= 0) continue;
-		const entry = createPersistentDedupeImportEntry({
-			key: marker.key,
-			seenAt: marker.ts,
-			ttlMs: Math.max(1, Math.floor(remainingTtlMs))
-		});
-		if (await store.registerIfAbsent(entry.key, entry.value, { ttlMs: entry.ttlMs ?? 2592e6 })) {
-			imported += 1;
-			capacity -= 1;
-		}
-	}
-	return {
-		imported,
-		total: markers.length
-	};
-}
-//#endregion
+import fs from "node:fs/promises";
+import { legacyStateFileExists } from "openclaw/plugin-sdk/runtime-doctor";
 //#region extensions/matrix/doctor-contract-api.ts
 const MATRIX_SYNC_CACHE_FILENAME = "bot-storage.json";
 const MATRIX_STORAGE_META_FILENAME = "storage-meta.json";
-async function collectLegacyMatrixCredentialSources(params) {
-	const credentialsDir = resolveMatrixCredentialsDir(params.stateDir);
-	let entries;
-	try {
-		entries = await fs$1.readdir(credentialsDir, { withFileTypes: true });
-	} catch {
-		return [];
-	}
-	return entries.filter((entry) => entry.isFile() && /^credentials(?:-[a-z0-9._-]+)?\.json$/iu.test(entry.name)).toSorted((left, right) => {
-		if (left.name === "credentials.json") return 1;
-		if (right.name === "credentials.json") return -1;
-		return left.name.localeCompare(right.name);
-	}).map((entry) => {
-		const namedAccount = /^credentials(?:-([a-z0-9._-]+))?\.json$/iu.exec(entry.name)?.[1];
-		return {
-			accountId: namedAccount ? normalizeAccountId(namedAccount) : requiresExplicitMatrixDefaultAccount(params.config, params.env) ? null : normalizeAccountId(resolveMatrixDefaultOrOnlyAccountId(params.config, params.env)),
-			filePath: path.join(credentialsDir, entry.name)
-		};
-	});
-}
-async function readLegacyMatrixCredentials(source) {
-	if (!source.accountId) return null;
-	try {
-		const raw = JSON.parse(await fs$1.readFile(source.filePath, "utf8"));
-		const createdAt = isRecord(raw) && typeof raw.createdAt === "string" && raw.createdAt ? raw.createdAt : (await fs$1.stat(source.filePath)).mtime.toISOString();
-		return normalizeMatrixStoredCredentials(isRecord(raw) ? {
-			...raw,
-			createdAt
-		} : raw, source.accountId);
-	} catch {
-		return null;
-	}
-}
-async function collectLegacyMatrixStateRoots(stateDir, filename, options) {
+async function collectLegacyMatrixStateRoots(stateDir, filename) {
 	const matrixRoot = path.join(stateDir, "matrix");
 	const roots = [];
 	async function visit(dir) {
 		let entries;
 		try {
-			entries = await fs$1.readdir(dir, { withFileTypes: true });
+			entries = await fs.readdir(dir, { withFileTypes: true });
 		} catch {
 			return;
 		}
@@ -342,188 +29,47 @@ async function collectLegacyMatrixStateRoots(stateDir, filename, options) {
 		}
 	}
 	await visit(matrixRoot);
-	return roots.filter((root) => options?.includeMatrixRoot || path.resolve(root) !== path.resolve(matrixRoot)).toSorted();
+	return roots.filter((root) => path.resolve(root) !== path.resolve(matrixRoot)).toSorted();
 }
 async function collectLegacySyncCacheRoots(stateDir) {
 	return collectLegacyMatrixStateRoots(stateDir, MATRIX_SYNC_CACHE_FILENAME);
 }
 async function readLegacyMatrixStorageMetadata(storageRootDir) {
 	try {
-		return normalizeMatrixStorageMetadata(JSON.parse(await fs$1.readFile(path.join(storageRootDir, MATRIX_STORAGE_META_FILENAME), "utf8")));
+		return normalizeMatrixStorageMetadata(JSON.parse(await fs.readFile(path.join(storageRootDir, MATRIX_STORAGE_META_FILENAME), "utf8")));
 	} catch {
 		return null;
 	}
 }
 async function archiveLegacySyncCache(params) {
-	await archiveLegacyMatrixStateFile({
-		...params,
-		filename: MATRIX_SYNC_CACHE_FILENAME,
-		label: "Matrix sync cache"
-	});
+	const sourcePath = path.join(params.storageRootDir, MATRIX_SYNC_CACHE_FILENAME);
+	const archivedPath = `${sourcePath}.migrated`;
+	if (await legacyStateFileExists(archivedPath)) {
+		params.warnings.push(`Left migrated Matrix sync cache in place because ${archivedPath} already exists`);
+		return;
+	}
+	try {
+		await fs.rename(sourcePath, archivedPath);
+		params.changes.push(`Archived Matrix sync cache legacy source -> ${archivedPath}`);
+	} catch (err) {
+		params.warnings.push(`Failed archiving Matrix sync cache legacy source: ${String(err)}`);
+	}
 }
 async function archiveLegacyMatrixStateFile(params) {
-	const warningCount = params.warnings.length;
-	await archiveLegacyStateSource({
-		filePath: path.join(params.storageRootDir, params.filename),
-		label: params.label,
-		changes: params.changes,
-		warnings: params.warnings
-	});
-	if (params.notice && params.warnings.length === warningCount) params.notices?.push(params.notice);
+	const sourcePath = path.join(params.storageRootDir, params.filename);
+	const archivedPath = `${sourcePath}.migrated`;
+	if (await legacyStateFileExists(archivedPath)) {
+		params.warnings.push(`Left migrated ${params.label} in place because ${archivedPath} already exists`);
+		return;
+	}
+	try {
+		await fs.rename(sourcePath, archivedPath);
+		params.changes.push(`Archived ${params.label} legacy source -> ${archivedPath}`);
+	} catch (err) {
+		params.warnings.push(`Failed archiving ${params.label} legacy source: ${String(err)}`);
+	}
 }
 const stateMigrations = [
-	{
-		id: "matrix-credentials-json-to-plugin-state",
-		label: "Matrix credentials",
-		async detectLegacyState(params) {
-			const sources = await collectLegacyMatrixCredentialSources(params);
-			return sources.length > 0 ? { preview: [`Matrix credential JSON can migrate to SQLite (${sources.length} ${sources.length === 1 ? "file" : "files"})`] } : null;
-		},
-		async migrateLegacyState(params) {
-			const changes = [];
-			const warnings = [];
-			const sources = await collectLegacyMatrixCredentialSources(params);
-			const store = params.context.openPluginStateKeyedStore({
-				namespace: MATRIX_CREDENTIALS_NAMESPACE,
-				maxEntries: 256,
-				overflowPolicy: "reject-new"
-			});
-			for (const source of sources) {
-				if (!source.accountId) {
-					warnings.push(`Left ambiguous Matrix credential legacy source in place because no default account is selected: ${source.filePath}`);
-					continue;
-				}
-				const credentials = await readLegacyMatrixCredentials(source);
-				if (!credentials) {
-					warnings.push(`Left invalid Matrix credential legacy source in place: ${source.filePath}`);
-					continue;
-				}
-				const key = matrixCredentialsStoreKey(source.accountId);
-				const stored = await store.lookup(key);
-				if (isMatrixCredentialRevocation(stored, source.accountId)) {
-					changes.push(`Archived revoked Matrix credential legacy source for account ${source.accountId}`);
-					await archiveLegacyStateSource({
-						filePath: source.filePath,
-						label: "Matrix credentials",
-						changes,
-						warnings
-					});
-					continue;
-				}
-				const existing = normalizeMatrixStoredCredentials(stored, source.accountId);
-				if (existing && JSON.stringify(existing) !== JSON.stringify(credentials)) {
-					warnings.push(`Kept existing Matrix credentials for account ${source.accountId}; left differing legacy source in place`);
-					continue;
-				}
-				if (!existing) try {
-					await store.registerIfAbsent(key, credentials);
-				} catch (error) {
-					warnings.push(`Failed importing Matrix credentials for account ${source.accountId}: ${String(error)}; left legacy source in place`);
-					continue;
-				}
-				const persisted = normalizeMatrixStoredCredentials(await store.lookup(key), source.accountId);
-				if (!persisted || JSON.stringify(persisted) !== JSON.stringify(credentials)) {
-					warnings.push(`Failed verifying Matrix credentials for account ${source.accountId}; left legacy source in place`);
-					continue;
-				}
-				changes.push(`Migrated Matrix credentials for account ${source.accountId} to SQLite`);
-				await archiveLegacyStateSource({
-					filePath: source.filePath,
-					label: "Matrix credentials",
-					changes,
-					warnings
-				});
-			}
-			return {
-				changes,
-				warnings
-			};
-		}
-	},
-	{
-		id: "matrix-inbound-dedupe-to-claimable-dedupe",
-		label: "Matrix inbound dedupe markers",
-		async detectLegacyState(params) {
-			const io = {
-				context: params.context,
-				env: params.env
-			};
-			const preview = [];
-			const sources = await collectMatrixInboundDedupeSources(params.stateDir);
-			for (const storageRootDir of sources.sqliteRoots) {
-				try {
-					if ((await readLegacyInboundDedupeSqliteSource(io, storageRootDir)).legacyRowCount === 0) continue;
-				} catch {
-					continue;
-				}
-				preview.push(`Matrix inbound dedupe rows can migrate to the claimable dedupe store: ${storageRootDir}`);
-			}
-			for (const storageRootDir of sources.jsonRoots) preview.push(`Matrix inbound dedupe JSON can migrate to the claimable dedupe store: ${path.join(storageRootDir, MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME)}`);
-			return preview.length > 0 ? { preview } : null;
-		},
-		async migrateLegacyState(params) {
-			const io = {
-				context: params.context,
-				env: params.env
-			};
-			const changes = [];
-			const warnings = [];
-			const sources = await collectMatrixInboundDedupeSources(params.stateDir);
-			const gathered = [];
-			const sqliteRootsToRetire = [];
-			for (const storageRootDir of sources.sqliteRoots) try {
-				const source = await readLegacyInboundDedupeSqliteSource(io, storageRootDir);
-				if (source.legacyRowCount === 0) continue;
-				gathered.push(...source.markers);
-				sqliteRootsToRetire.push(storageRootDir);
-			} catch (err) {
-				warnings.push(`Failed reading Matrix inbound dedupe rows for ${storageRootDir}: ${String(err)}; left legacy rows in place`);
-			}
-			const jsonRootsToRetire = [];
-			for (const storageRootDir of sources.jsonRoots) try {
-				const markers = await readLegacyInboundDedupeJsonSource(storageRootDir);
-				if (markers === null) warnings.push(`Matrix inbound dedupe JSON for ${storageRootDir} is malformed; archived without import`);
-				else gathered.push(...markers);
-				jsonRootsToRetire.push(storageRootDir);
-			} catch (err) {
-				warnings.push(`Failed reading Matrix inbound dedupe JSON for ${storageRootDir}: ${String(err)}; left legacy file in place`);
-			}
-			if (sqliteRootsToRetire.length + jsonRootsToRetire.length === 0) return {
-				changes,
-				warnings
-			};
-			try {
-				const result = await importNewestInboundDedupeMarkers({
-					io,
-					markers: gathered
-				});
-				changes.push(`Migrated Matrix inbound dedupe markers to the claimable dedupe store (${result.imported} of ${result.total} entries)`);
-			} catch (err) {
-				warnings.push(`Failed importing Matrix inbound dedupe markers: ${String(err)}; left legacy sources in place`);
-				return {
-					changes,
-					warnings
-				};
-			}
-			for (const storageRootDir of sqliteRootsToRetire) try {
-				await retireLegacyInboundDedupeSqliteRows(io, storageRootDir);
-				changes.push(`Retired Matrix inbound dedupe rows for ${storageRootDir}`);
-			} catch (err) {
-				warnings.push(`Failed retiring Matrix inbound dedupe rows for ${storageRootDir}: ${String(err)}`);
-			}
-			for (const storageRootDir of jsonRootsToRetire) await archiveLegacyMatrixStateFile({
-				storageRootDir,
-				filename: MATRIX_LEGACY_INBOUND_DEDUPE_FILENAME,
-				label: "Matrix inbound dedupe",
-				changes,
-				warnings
-			});
-			return {
-				changes,
-				warnings
-			};
-		}
-	},
 	{
 		id: "matrix-storage-meta-json-to-plugin-state",
 		label: "Matrix storage metadata",
@@ -538,20 +84,18 @@ const stateMigrations = [
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
-			const notices = [];
 			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_STORAGE_META_FILENAME)) {
 				const payload = await readLegacyMatrixStorageMetadata(storageRootDir);
 				if (!payload) continue;
 				const store = params.context.openPluginStateKeyedStore(openMatrixStorageMetaStoreOptions(storageRootDir));
 				if (await hasMatrixStorageMetaStateInStore({ store })) {
+					warnings.push(`Skipped Matrix storage metadata import for ${storageRootDir} because SQLite already has metadata`);
 					await archiveLegacyMatrixStateFile({
 						storageRootDir,
 						filename: MATRIX_STORAGE_META_FILENAME,
 						label: "Matrix storage metadata",
 						changes,
-						warnings,
-						notices,
-						notice: `Kept existing Matrix storage metadata in SQLite and archived the legacy source for ${storageRootDir}`
+						warnings
 					});
 					continue;
 				}
@@ -570,8 +114,7 @@ const stateMigrations = [
 			}
 			return {
 				changes,
-				warnings,
-				...notices.length > 0 ? { notices } : {}
+				warnings
 			};
 		}
 	},
@@ -589,7 +132,6 @@ const stateMigrations = [
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
-			const notices = [];
 			for (const storageRootDir of await collectLegacySyncCacheRoots(params.stateDir)) {
 				const persisted = await readLegacyMatrixSyncCacheState(storageRootDir);
 				if (!persisted) continue;
@@ -598,12 +140,11 @@ const stateMigrations = [
 					storageRootDir,
 					store
 				})) {
+					warnings.push(`Skipped Matrix sync cache import for ${storageRootDir} because SQLite already has sync cache state`);
 					await archiveLegacySyncCache({
 						storageRootDir,
 						changes,
-						warnings,
-						notices,
-						notice: `Kept existing Matrix sync cache in SQLite and archived the legacy source for ${storageRootDir}`
+						warnings
 					});
 					continue;
 				}
@@ -621,8 +162,7 @@ const stateMigrations = [
 			}
 			return {
 				changes,
-				warnings,
-				...notices.length > 0 ? { notices } : {}
+				warnings
 			};
 		}
 	},
@@ -640,20 +180,18 @@ const stateMigrations = [
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
-			const notices = [];
 			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_RECOVERY_KEY_FILENAME)) {
 				const payload = readLegacyMatrixRecoveryKeyState(storageRootDir);
 				if (!payload) continue;
 				const store = params.context.openPluginStateKeyedStore(openMatrixRecoveryKeyStoreOptions(storageRootDir));
 				if (await hasMatrixRecoveryKeyStateInStore({ store })) {
+					warnings.push(`Skipped Matrix recovery-key import for ${storageRootDir} because SQLite already has recovery-key state`);
 					await archiveLegacyMatrixStateFile({
 						storageRootDir,
 						filename: MATRIX_RECOVERY_KEY_FILENAME,
 						label: "Matrix recovery key",
 						changes,
-						warnings,
-						notices,
-						notice: `Kept existing Matrix recovery key in SQLite and archived the legacy source for ${storageRootDir}`
+						warnings
 					});
 					continue;
 				}
@@ -672,40 +210,85 @@ const stateMigrations = [
 			}
 			return {
 				changes,
-				warnings,
-				...notices.length > 0 ? { notices } : {}
+				warnings
+			};
+		}
+	},
+	{
+		id: "matrix-idb-snapshot-json-to-plugin-state",
+		label: "Matrix IndexedDB snapshot",
+		async detectLegacyState(params) {
+			const previews = [];
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME)) {
+				if (!await readLegacyMatrixIdbSnapshotState(storageRootDir)) continue;
+				previews.push(`Matrix IndexedDB snapshot JSON can migrate to SQLite: ${storageRootDir}`);
+			}
+			return previews.length > 0 ? { preview: previews } : null;
+		},
+		async migrateLegacyState(params) {
+			const changes = [];
+			const warnings = [];
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME)) {
+				const snapshot = await readLegacyMatrixIdbSnapshotState(storageRootDir);
+				if (!snapshot) continue;
+				const store = params.context.openPluginStateKeyedStore(openMatrixIdbSnapshotStoreOptions(storageRootDir));
+				if (await hasMatrixIdbSnapshotStateInStore({ store })) {
+					warnings.push(`Skipped Matrix IndexedDB snapshot import for ${storageRootDir} because SQLite already has snapshot state`);
+					await archiveLegacyMatrixStateFile({
+						storageRootDir,
+						filename: MATRIX_IDB_SNAPSHOT_FILENAME,
+						label: "Matrix IndexedDB snapshot",
+						changes,
+						warnings
+					});
+					continue;
+				}
+				await writeMatrixIdbSnapshotJsonToStore({
+					snapshotJson: JSON.stringify(snapshot),
+					databaseCount: snapshot.length,
+					store
+				});
+				changes.push(`Migrated Matrix IndexedDB snapshot JSON to SQLite for ${storageRootDir}`);
+				await archiveLegacyMatrixStateFile({
+					storageRootDir,
+					filename: MATRIX_IDB_SNAPSHOT_FILENAME,
+					label: "Matrix IndexedDB snapshot",
+					changes,
+					warnings
+				});
+			}
+			return {
+				changes,
+				warnings
 			};
 		}
 	},
 	{
 		id: "matrix-legacy-crypto-migration-json-to-plugin-state",
-		label: "Matrix legacy crypto state",
+		label: "Matrix legacy crypto migration",
 		async detectLegacyState(params) {
 			const previews = [];
-			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, { includeMatrixRoot: true })) {
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME)) {
 				if (!readLegacyMatrixLegacyCryptoMigrationState(storageRootDir)) continue;
 				previews.push(`Matrix legacy crypto migration JSON can migrate to SQLite: ${storageRootDir}`);
 			}
-			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME, { includeMatrixRoot: true })) previews.push(`Matrix IndexedDB snapshot JSON can migrate to SQLite: ${storageRootDir}`);
 			return previews.length > 0 ? { preview: previews } : null;
 		},
 		async migrateLegacyState(params) {
 			const changes = [];
 			const warnings = [];
-			const notices = [];
-			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME, { includeMatrixRoot: true })) {
+			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME)) {
 				const state = readLegacyMatrixLegacyCryptoMigrationState(storageRootDir);
 				if (!state) continue;
 				const store = params.context.openPluginStateKeyedStore(openMatrixLegacyCryptoMigrationStoreOptions(storageRootDir));
 				if (await hasMatrixLegacyCryptoMigrationStateInStore({ store })) {
+					warnings.push(`Skipped Matrix legacy crypto migration import for ${storageRootDir} because SQLite already has migration state`);
 					await archiveLegacyMatrixStateFile({
 						storageRootDir,
 						filename: MATRIX_LEGACY_CRYPTO_MIGRATION_FILENAME,
 						label: "Matrix legacy crypto migration",
 						changes,
-						warnings,
-						notices,
-						notice: `Kept existing Matrix legacy crypto migration in SQLite and archived the legacy source for ${storageRootDir}`
+						warnings
 					});
 					continue;
 				}
@@ -722,17 +305,9 @@ const stateMigrations = [
 					warnings
 				});
 			}
-			for (const storageRootDir of await collectLegacyMatrixStateRoots(params.stateDir, MATRIX_IDB_SNAPSHOT_FILENAME, { includeMatrixRoot: true })) await migrateLegacyMatrixIdbSnapshot({
-				storageRootDir,
-				context: params.context,
-				changes,
-				notices,
-				warnings
-			});
 			return {
 				changes,
-				warnings,
-				...notices.length > 0 ? { notices } : {}
+				warnings
 			};
 		}
 	}