@openclaw/matrix 2026.7.2-beta.5 → 2026.7.33

package/dist/.setup/http-client-C954In2D.mjs

@@ -0,0 +1,390 @@
+import { t as buildTimeoutAbortSignal } from "./timeout-abort-signal-DMrgRFIy.mjs";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
+import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
+import { fetchWithRuntimeDispatcherOrMockedGlobal } from "openclaw/plugin-sdk/runtime-fetch";
+import { closeDispatcher, createPinnedDispatcher, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-dispatcher";
+//#region extensions/matrix/src/matrix/sdk/event-helpers.ts
+function matrixEventToRaw(event, opts = {}) {
+	const unsigned = event.getUnsigned?.() ?? {};
+	const eventWithOriginalContent = event;
+	const normalizedContent = preserveMatrixRelation(event, (opts.contentMode === "original" ? eventWithOriginalContent.getOriginalContent?.() ?? event.getContent?.() ?? {} : event.getContent?.() ?? eventWithOriginalContent.getOriginalContent?.() ?? {}) || {});
+	const raw = {
+		event_id: event.getId() ?? "",
+		sender: event.getSender() ?? "",
+		type: event.getType() ?? "",
+		origin_server_ts: event.getTs() ?? 0,
+		content: normalizedContent,
+		unsigned
+	};
+	const stateKey = resolveMatrixStateKey(event);
+	if (typeof stateKey === "string") raw.state_key = stateKey;
+	return raw;
+}
+function preserveMatrixRelation(event, content) {
+	if (Object.hasOwn(content, "m.relates_to")) return content;
+	const relation = resolveMatrixRelation(event);
+	return relation ? {
+		...content,
+		"m.relates_to": relation
+	} : content;
+}
+function resolveMatrixRelation(event) {
+	const originalRelation = (event.getOriginalContent?.())?.["m.relates_to"];
+	if (originalRelation) return originalRelation;
+	const wireRelation = (event.getWireContent?.())?.["m.relates_to"];
+	if (wireRelation) return wireRelation;
+	const rawContent = event.event?.content;
+	if (rawContent && typeof rawContent === "object") return rawContent["m.relates_to"];
+}
+function parseMxc(url) {
+	const match = /^mxc:\/\/([^/]+)\/(.+)$/.exec(url.trim());
+	if (!match) return null;
+	return {
+		server: match[1],
+		mediaId: match[2]
+	};
+}
+function buildHttpError(statusCode, bodyText) {
+	let message = `Matrix HTTP ${statusCode}`;
+	if (bodyText.trim()) try {
+		const parsed = JSON.parse(bodyText);
+		if (typeof parsed.error === "string" && parsed.error.trim()) message = parsed.error.trim();
+		else message = truncateUtf16Safe(bodyText, 500);
+	} catch {
+		message = truncateUtf16Safe(bodyText, 500);
+	}
+	return Object.assign(new Error(message), { statusCode });
+}
+function resolveMatrixStateKey(event) {
+	const direct = event.getStateKey?.();
+	if (typeof direct === "string") return direct;
+	const wireContent = event.getWireContent?.();
+	if (wireContent && typeof wireContent.state_key === "string") return wireContent.state_key;
+	const rawEvent = event.event;
+	if (rawEvent && typeof rawEvent.state_key === "string") return rawEvent.state_key;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/media-errors.ts
+const MATRIX_MEDIA_SIZE_LIMIT_ERROR_MESSAGE = "Matrix media exceeds configured size limit";
+var MatrixMediaSizeLimitError = class extends Error {
+	constructor(message = MATRIX_MEDIA_SIZE_LIMIT_ERROR_MESSAGE, options) {
+		super(message, options);
+		this.code = "MATRIX_MEDIA_SIZE_LIMIT";
+		this.name = "MatrixMediaSizeLimitError";
+	}
+};
+function isMatrixMediaSizeLimitError(err) {
+	if (err instanceof MatrixMediaSizeLimitError) return true;
+	if (!(err instanceof Error) || err.cause === void 0) return false;
+	return isMatrixMediaSizeLimitError(err.cause);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/read-response-with-limit.ts
+async function readResponseWithLimit$1(res, maxBytes, opts) {
+	return await readResponseWithLimit(res, maxBytes, {
+		...opts,
+		onIdleTimeout: opts?.onIdleTimeout ?? (({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`Matrix media download stalled: no data received for ${chunkTimeoutMs}ms`))
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/transport.ts
+const MATRIX_JSON_RESPONSE_MAX_BYTES = 8388608;
+const MATRIX_SDK_RESPONSE_MAX_BYTES = 67108864;
+function normalizeEndpoint(endpoint) {
+	if (!endpoint) return "/";
+	return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+}
+function applyQuery(url, qs) {
+	if (!qs) return;
+	for (const [key, rawValue] of Object.entries(qs)) {
+		if (rawValue === void 0 || rawValue === null) continue;
+		if (Array.isArray(rawValue)) {
+			for (const item of rawValue) {
+				if (item === void 0 || item === null) continue;
+				url.searchParams.append(key, String(item));
+			}
+			continue;
+		}
+		url.searchParams.set(key, String(rawValue));
+	}
+}
+function isRedirectStatus(statusCode) {
+	return statusCode >= 300 && statusCode < 400;
+}
+function toFetchUrl(resource) {
+	if (resource instanceof URL) return resource.toString();
+	if (typeof resource === "string") return resource;
+	return resource.url;
+}
+const MATRIX_STATE_AFTER_SYNC_PARAM = "org.matrix.msc4222.use_state_after";
+function withoutMatrixStateAfterSyncParam(rawUrl) {
+	let url;
+	try {
+		url = new URL(rawUrl);
+	} catch {
+		return rawUrl;
+	}
+	if (!url.pathname.endsWith("/sync") || !url.searchParams.has(MATRIX_STATE_AFTER_SYNC_PARAM)) return rawUrl;
+	url.searchParams.delete(MATRIX_STATE_AFTER_SYNC_PARAM);
+	return url.toString();
+}
+function buildBufferedResponse(params) {
+	const response = new Response(params.body, {
+		status: params.source.status,
+		statusText: params.source.statusText,
+		headers: new Headers(params.source.headers)
+	});
+	try {
+		Object.defineProperty(response, "url", {
+			value: params.source.url || params.url,
+			configurable: true
+		});
+	} catch {}
+	return response;
+}
+async function enforceDeclaredResponseSize(params) {
+	const contentLength = params.response.headers.get("content-length");
+	if (!contentLength) return;
+	let length;
+	try {
+		length = parseMediaContentLength(contentLength);
+	} catch (error) {
+		await params.response.body?.cancel(error).catch(() => void 0);
+		throw error;
+	}
+	if (length === null || length <= params.maxBytes) return;
+	const error = params.createError(length);
+	await params.response.body?.cancel(error).catch(() => void 0);
+	throw error;
+}
+async function fetchWithMatrixDispatcher(params) {
+	return await fetchWithRuntimeDispatcherOrMockedGlobal(params.url, params.init);
+}
+async function fetchWithMatrixGuardedRedirects(params) {
+	let currentUrl = new URL(params.url);
+	let method = (params.init?.method ?? "GET").toUpperCase();
+	let body = params.init?.body;
+	let headers = new Headers(params.init?.headers ?? {});
+	const maxRedirects = 5;
+	const visited = /* @__PURE__ */ new Set();
+	const { signal, cleanup } = buildTimeoutAbortSignal({
+		timeoutMs: params.timeoutMs,
+		signal: params.signal,
+		operation: "matrix.guarded-redirect-fetch",
+		url: params.url
+	});
+	for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {
+		let dispatcher;
+		try {
+			const pinned = await resolvePinnedHostnameWithPolicy(currentUrl.hostname, { policy: params.ssrfPolicy });
+			dispatcher = createPinnedDispatcher(pinned, params.dispatcherPolicy, params.ssrfPolicy);
+			const response = await fetchWithMatrixDispatcher({
+				url: currentUrl.toString(),
+				init: {
+					...params.init,
+					method,
+					body,
+					headers,
+					redirect: "manual",
+					signal,
+					dispatcher
+				}
+			});
+			if (!isRedirectStatus(response.status)) return {
+				response,
+				release: async () => {
+					cleanup();
+					await closeDispatcher(dispatcher);
+				},
+				finalUrl: currentUrl.toString()
+			};
+			const location = response.headers.get("location");
+			if (!location) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error(`Matrix redirect missing location header (${currentUrl.toString()})`);
+			}
+			const nextUrl = new URL(location, currentUrl);
+			if (nextUrl.protocol !== currentUrl.protocol) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error(`Blocked cross-protocol redirect (${currentUrl.protocol} -> ${nextUrl.protocol})`);
+			}
+			const nextUrlString = nextUrl.toString();
+			if (visited.has(nextUrlString)) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error("Redirect loop detected");
+			}
+			visited.add(nextUrlString);
+			if (nextUrl.origin !== currentUrl.origin) {
+				headers = new Headers(headers);
+				headers.delete("authorization");
+			}
+			if (response.status === 303 || (response.status === 301 || response.status === 302) && method !== "GET" && method !== "HEAD") {
+				method = "GET";
+				body = void 0;
+				headers = new Headers(headers);
+				headers.delete("content-type");
+				headers.delete("content-length");
+			}
+			response.body?.cancel();
+			await closeDispatcher(dispatcher);
+			currentUrl = nextUrl;
+		} catch (error) {
+			cleanup();
+			await closeDispatcher(dispatcher);
+			throw error;
+		}
+	}
+	cleanup();
+	throw new Error(`Too many redirects while requesting ${params.url}`);
+}
+function createMatrixGuardedFetch(params) {
+	return (async (resource, init) => {
+		const url = withoutMatrixStateAfterSyncParam(toFetchUrl(resource));
+		const { signal, ...requestInit } = init ?? {};
+		const { response, release } = await fetchWithMatrixGuardedRedirects({
+			url,
+			init: requestInit,
+			signal: signal ?? void 0,
+			ssrfPolicy: params.ssrfPolicy,
+			dispatcherPolicy: params.dispatcherPolicy
+		});
+		try {
+			await enforceDeclaredResponseSize({
+				response,
+				maxBytes: MATRIX_SDK_RESPONSE_MAX_BYTES,
+				createError: (length) => /* @__PURE__ */ new Error(`Matrix SDK response exceeds size limit (${length} bytes > ${MATRIX_SDK_RESPONSE_MAX_BYTES} bytes)`)
+			});
+			const body = await readResponseWithLimit$1(response, MATRIX_SDK_RESPONSE_MAX_BYTES, { onOverflow: ({ maxBytes, size }) => /* @__PURE__ */ new Error(`Matrix SDK response exceeds size limit (${size} bytes > ${maxBytes} bytes)`) });
+			return buildBufferedResponse({
+				source: response,
+				body: Uint8Array.from(body),
+				url
+			});
+		} finally {
+			await release();
+		}
+	});
+}
+async function performMatrixRequest(params) {
+	const isAbsoluteEndpoint = params.endpoint.startsWith("http://") || params.endpoint.startsWith("https://");
+	if (isAbsoluteEndpoint && params.allowAbsoluteEndpoint !== true) throw new Error(`Absolute Matrix endpoint is blocked by default: ${params.endpoint}. Set allowAbsoluteEndpoint=true to opt in.`);
+	const baseUrl = isAbsoluteEndpoint ? new URL(params.endpoint) : new URL(`${params.homeserver.replace(/\/+$/u, "")}${normalizeEndpoint(params.endpoint)}`);
+	applyQuery(baseUrl, params.qs);
+	const headers = new Headers();
+	headers.set("Accept", params.raw ? "*/*" : "application/json");
+	if (params.accessToken) headers.set("Authorization", `Bearer ${params.accessToken}`);
+	let body;
+	if (params.body !== void 0) {
+		if (params.body instanceof Uint8Array || params.body instanceof ArrayBuffer || typeof params.body === "string") body = params.body;
+		else {
+			headers.set("Content-Type", "application/json");
+			body = JSON.stringify(params.body);
+		}
+	}
+	const { response, release } = await fetchWithMatrixGuardedRedirects({
+		url: baseUrl.toString(),
+		init: {
+			method: params.method,
+			headers,
+			body
+		},
+		timeoutMs: params.timeoutMs,
+		ssrfPolicy: params.ssrfPolicy,
+		dispatcherPolicy: params.dispatcherPolicy
+	});
+	try {
+		if (params.raw) {
+			const rawMaxBytes = params.maxBytes ?? MATRIX_SDK_RESPONSE_MAX_BYTES;
+			await enforceDeclaredResponseSize({
+				response,
+				maxBytes: rawMaxBytes,
+				createError: (length) => new MatrixMediaSizeLimitError(`Matrix media exceeds configured size limit (${length} bytes > ${rawMaxBytes} bytes)`)
+			});
+			const bytes = await readResponseWithLimit$1(response, rawMaxBytes, {
+				onOverflow: ({ maxBytes, size }) => new MatrixMediaSizeLimitError(`Matrix media exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`),
+				chunkTimeoutMs: params.readIdleTimeoutMs
+			});
+			return {
+				response,
+				text: bytes.toString("utf8"),
+				buffer: bytes
+			};
+		}
+		const jsonMaxBytes = params.maxBytes ?? MATRIX_JSON_RESPONSE_MAX_BYTES;
+		await enforceDeclaredResponseSize({
+			response,
+			maxBytes: jsonMaxBytes,
+			createError: (length) => /* @__PURE__ */ new Error(`Matrix JSON response exceeds configured size limit (${length} bytes > ${jsonMaxBytes} bytes)`)
+		});
+		const buffer = await readResponseWithLimit$1(response, jsonMaxBytes, {
+			onOverflow: ({ maxBytes, size }) => /* @__PURE__ */ new Error(`Matrix JSON response exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`),
+			chunkTimeoutMs: params.readIdleTimeoutMs,
+			onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`Matrix JSON response stalled: no data received for ${chunkTimeoutMs}ms`)
+		});
+		return {
+			response,
+			text: buffer.toString("utf8"),
+			buffer
+		};
+	} finally {
+		await release();
+	}
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/http-client.ts
+var MatrixAuthedHttpClient = class {
+	constructor(params) {
+		this.homeserver = params.homeserver;
+		this.accessToken = params.accessToken;
+		this.ssrfPolicy = params.ssrfPolicy;
+		this.dispatcherPolicy = params.dispatcherPolicy;
+	}
+	async requestJson(params) {
+		const { response, text } = await performMatrixRequest({
+			homeserver: this.homeserver,
+			accessToken: this.accessToken,
+			method: params.method,
+			endpoint: params.endpoint,
+			qs: params.qs,
+			body: params.body,
+			timeoutMs: params.timeoutMs,
+			ssrfPolicy: this.ssrfPolicy,
+			dispatcherPolicy: this.dispatcherPolicy,
+			allowAbsoluteEndpoint: params.allowAbsoluteEndpoint
+		});
+		if (!response.ok) throw buildHttpError(response.status, text);
+		if ((response.headers.get("content-type") ?? "").includes("application/json")) {
+			if (!text.trim()) return {};
+			try {
+				return JSON.parse(text);
+			} catch {
+				throw Object.assign(/* @__PURE__ */ new Error("Matrix homeserver returned malformed JSON"), { statusCode: response.status });
+			}
+		}
+		return text;
+	}
+	async requestRaw(params) {
+		const { response, buffer } = await performMatrixRequest({
+			homeserver: this.homeserver,
+			accessToken: this.accessToken,
+			method: params.method,
+			endpoint: params.endpoint,
+			qs: params.qs,
+			timeoutMs: params.timeoutMs,
+			raw: true,
+			maxBytes: params.maxBytes,
+			readIdleTimeoutMs: params.readIdleTimeoutMs,
+			ssrfPolicy: this.ssrfPolicy,
+			dispatcherPolicy: this.dispatcherPolicy,
+			allowAbsoluteEndpoint: params.allowAbsoluteEndpoint
+		});
+		if (!response.ok) throw buildHttpError(response.status, buffer.toString("utf8"));
+		return buffer;
+	}
+};
+//#endregion
+export { matrixEventToRaw as a, isMatrixMediaSizeLimitError as i, createMatrixGuardedFetch as n, parseMxc as o, MatrixMediaSizeLimitError as r, MatrixAuthedHttpClient as t };

package/dist/.setup/idb-persistence-_HKTXkVC.mjs

@@ -0,0 +1,230 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { g as readMatrixIdbSnapshotJson, t as MATRIX_IDB_SNAPSHOT_FILENAME, x as writeMatrixIdbSnapshotJson } from "./crypto-state-store-B43k3z3W.mjs";
+import { n as LogService } from "./logger-DpoogOgz.mjs";
+import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-B3fZXyF_.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { indexedDB } from "fake-indexeddb";
+import { withFileLock } from "openclaw/plugin-sdk/file-lock";
+//#region extensions/matrix/src/matrix/sdk/idb-persistence.ts
+var idb_persistence_exports = /* @__PURE__ */ __exportAll({
+	persistIdbToDisk: () => persistIdbToDisk,
+	readLegacyMatrixIdbSnapshotState: () => readLegacyMatrixIdbSnapshotState,
+	restoreIdbFromDisk: () => restoreIdbFromDisk
+});
+function isValidIdbIndexSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.name === "string" && (typeof candidate.keyPath === "string" || Array.isArray(candidate.keyPath) && candidate.keyPath.every((entry) => typeof entry === "string")) && typeof candidate.multiEntry === "boolean" && typeof candidate.unique === "boolean";
+}
+function isValidIdbRecordSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	return "key" in value && "value" in value;
+}
+function isValidIdbStoreSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	const validKeyPath = candidate.keyPath === null || typeof candidate.keyPath === "string" || Array.isArray(candidate.keyPath) && candidate.keyPath.every((entry) => typeof entry === "string");
+	return typeof candidate.name === "string" && validKeyPath && typeof candidate.autoIncrement === "boolean" && Array.isArray(candidate.indexes) && candidate.indexes.every((entry) => isValidIdbIndexSnapshot(entry)) && Array.isArray(candidate.records) && candidate.records.every((entry) => isValidIdbRecordSnapshot(entry));
+}
+function isValidIdbDatabaseSnapshot(value) {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return typeof candidate.name === "string" && typeof candidate.version === "number" && Number.isFinite(candidate.version) && candidate.version > 0 && Array.isArray(candidate.stores) && candidate.stores.every((entry) => isValidIdbStoreSnapshot(entry));
+}
+function parseSnapshotPayload(data) {
+	const parsed = JSON.parse(data);
+	if (!Array.isArray(parsed) || parsed.length === 0) return null;
+	if (!parsed.every((entry) => isValidIdbDatabaseSnapshot(entry))) throw new Error("Malformed IndexedDB snapshot payload");
+	return parsed;
+}
+function idbReq(req) {
+	return new Promise((resolve, reject) => {
+		req.addEventListener("success", () => resolve(req.result), { once: true });
+		req.addEventListener("error", () => reject(toLintErrorObject(req.error, "Non-Error rejection")), { once: true });
+	});
+}
+async function dumpIndexedDatabases(databasePrefix) {
+	const idb = indexedDB;
+	const dbList = await idb.databases();
+	const snapshot = [];
+	const expectedPrefix = databasePrefix ? `${databasePrefix}::` : null;
+	for (const { name, version } of dbList) {
+		if (!name || !version) continue;
+		if (expectedPrefix && !name.startsWith(expectedPrefix)) continue;
+		const db = await new Promise((resolve, reject) => {
+			const r = idb.open(name, version);
+			r.addEventListener("success", () => resolve(r.result), { once: true });
+			r.addEventListener("error", () => reject(toLintErrorObject(r.error, "Non-Error rejection")), { once: true });
+		});
+		const stores = [];
+		for (const storeName of db.objectStoreNames) {
+			const store = db.transaction(storeName, "readonly").objectStore(storeName);
+			const storeInfo = {
+				name: storeName,
+				keyPath: store.keyPath,
+				autoIncrement: store.autoIncrement,
+				indexes: [],
+				records: []
+			};
+			for (const idxName of store.indexNames) {
+				const idx = store.index(idxName);
+				storeInfo.indexes.push({
+					name: idxName,
+					keyPath: idx.keyPath,
+					multiEntry: idx.multiEntry,
+					unique: idx.unique
+				});
+			}
+			const keys = await idbReq(store.getAllKeys());
+			const values = await idbReq(store.getAll());
+			storeInfo.records = keys.map((k, i) => ({
+				key: k,
+				value: values[i]
+			}));
+			stores.push(storeInfo);
+		}
+		snapshot.push({
+			name,
+			version,
+			stores
+		});
+		db.close();
+	}
+	return snapshot;
+}
+async function restoreIndexedDatabases(snapshot) {
+	const idb = indexedDB;
+	for (const dbSnap of snapshot) await new Promise((resolve, reject) => {
+		const r = idb.open(dbSnap.name, dbSnap.version);
+		r.addEventListener("upgradeneeded", () => {
+			const db = r.result;
+			for (const storeSnap of dbSnap.stores) {
+				const opts = {};
+				if (storeSnap.keyPath !== null) opts.keyPath = storeSnap.keyPath;
+				if (storeSnap.autoIncrement) opts.autoIncrement = true;
+				const store = db.createObjectStore(storeSnap.name, opts);
+				for (const idx of storeSnap.indexes) store.createIndex(idx.name, idx.keyPath, {
+					unique: idx.unique,
+					multiEntry: idx.multiEntry
+				});
+			}
+		});
+		r.addEventListener("success", () => {
+			(async () => {
+				const db = r.result;
+				for (const storeSnap of dbSnap.stores) {
+					if (storeSnap.records.length === 0) continue;
+					const tx = db.transaction(storeSnap.name, "readwrite");
+					const store = tx.objectStore(storeSnap.name);
+					for (const rec of storeSnap.records) if (storeSnap.keyPath !== null) store.put(rec.value);
+					else store.put(rec.value, rec.key);
+					await new Promise((res) => {
+						tx.addEventListener("complete", () => res(), { once: true });
+					});
+				}
+				db.close();
+				resolve();
+			})().catch(reject);
+		}, { once: true });
+		r.addEventListener("error", () => reject(toLintErrorObject(r.error, "Non-Error rejection")), { once: true });
+	});
+}
+function resolveDefaultIdbSnapshotPath() {
+	const stateDir = process.env.OPENCLAW_STATE_DIR || path.join(process.env.HOME || "/tmp", ".openclaw");
+	return path.join(stateDir, "matrix", "crypto-idb-snapshot.json");
+}
+async function restoreIdbFromDisk(snapshotPath) {
+	const candidatePaths = snapshotPath ? [snapshotPath] : [resolveDefaultIdbSnapshotPath()];
+	for (const resolvedPath of candidatePaths) {
+		const storageRootDir = path.dirname(resolvedPath);
+		try {
+			if (await withFileLock(resolvedPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+				try {
+					const storedSnapshotJson = readMatrixIdbSnapshotJson(storageRootDir);
+					if (storedSnapshotJson) {
+						const snapshot = parseSnapshotPayload(storedSnapshotJson);
+						if (snapshot) {
+							await restoreIndexedDatabases(snapshot);
+							LogService.info("IdbPersistence", `Restored ${snapshot.length} IndexedDB database(s) from Matrix SQLite state`);
+							return true;
+						}
+					}
+				} catch (err) {
+					LogService.warn("IdbPersistence", "Failed to restore IndexedDB snapshot from SQLite:", err);
+				}
+				if (!fs.existsSync(resolvedPath)) return false;
+				const data = fs.readFileSync(resolvedPath, "utf8");
+				const snapshot = parseSnapshotPayload(data);
+				if (!snapshot) return false;
+				let migratedToSqlite = false;
+				try {
+					writeMatrixIdbSnapshotJson({
+						storageRootDir,
+						snapshotJson: data,
+						databaseCount: snapshot.length
+					});
+					archiveLegacyIdbSnapshotFile(resolvedPath);
+					migratedToSqlite = true;
+				} catch (err) {
+					LogService.warn("IdbPersistence", `Failed to migrate IndexedDB snapshot to SQLite from ${resolvedPath}:`, err);
+				}
+				await restoreIndexedDatabases(snapshot);
+				LogService.info("IdbPersistence", migratedToSqlite ? `Migrated and restored ${snapshot.length} IndexedDB database(s) from ${resolvedPath}` : `Restored ${snapshot.length} IndexedDB database(s) from legacy snapshot ${resolvedPath}`);
+				return true;
+			})) return true;
+		} catch (err) {
+			LogService.warn("IdbPersistence", `Failed to restore IndexedDB snapshot from ${resolvedPath}:`, err);
+			continue;
+		}
+	}
+	return false;
+}
+async function persistIdbToDisk(params) {
+	const snapshotPath = params?.snapshotPath ?? resolveDefaultIdbSnapshotPath();
+	try {
+		fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+		const persistedCount = await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			const snapshot = await dumpIndexedDatabases(params?.databasePrefix);
+			if (snapshot.length === 0) return 0;
+			writeMatrixIdbSnapshotJson({
+				storageRootDir: path.dirname(snapshotPath),
+				snapshotJson: JSON.stringify(snapshot),
+				databaseCount: snapshot.length
+			});
+			archiveLegacyIdbSnapshotFile(snapshotPath);
+			return snapshot.length;
+		});
+		if (persistedCount === 0) return;
+		LogService.debug("IdbPersistence", `Persisted ${persistedCount} IndexedDB database(s) to Matrix SQLite state`);
+	} catch (err) {
+		LogService.warn("IdbPersistence", "Failed to persist IndexedDB snapshot:", err);
+		if (params?.strict) throw err;
+	}
+}
+async function readLegacyMatrixIdbSnapshotState(storageRootDir) {
+	const snapshotPath = path.join(storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
+	if (!fs.existsSync(snapshotPath)) return null;
+	try {
+		return await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
+			return parseSnapshotPayload(fs.readFileSync(snapshotPath, "utf8"));
+		});
+	} catch {
+		return null;
+	}
+}
+function archiveLegacyIdbSnapshotFile(snapshotPath) {
+	if (!fs.existsSync(snapshotPath)) return;
+	const archivedPath = `${snapshotPath}.migrated`;
+	if (fs.existsSync(archivedPath)) return;
+	fs.renameSync(snapshotPath, archivedPath);
+}
+function toLintErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
+}
+//#endregion
+export { restoreIdbFromDisk as i, persistIdbToDisk as n, readLegacyMatrixIdbSnapshotState as r, idb_persistence_exports as t };

package/dist/.setup/idb-persistence-lock-B3fZXyF_.mjs

@@ -0,0 +1,32 @@
+//#region extensions/matrix/src/matrix/sdk/idb-persistence-lock.ts
+const MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
+const IDB_SNAPSHOT_LOCK_STALE_MS = 3e5;
+const IDB_SNAPSHOT_LOCK_RETRY_BASE = {
+	factor: 2,
+	minTimeout: 50,
+	maxTimeout: 5e3,
+	randomize: true
+};
+function computeRetryDelayMs(retries, attempt) {
+	return Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** attempt));
+}
+function computeMinimumRetryWindowMs(retries) {
+	let total = 0;
+	const attempts = Math.max(1, retries.retries + 1);
+	for (let attempt = 0; attempt < attempts - 1; attempt += 1) total += computeRetryDelayMs(retries, attempt);
+	return total;
+}
+function resolveRetriesForMinimumWindowMs(retries, minimumWindowMs) {
+	const resolved = {
+		...retries,
+		retries: 0
+	};
+	while (computeMinimumRetryWindowMs(resolved) < minimumWindowMs) resolved.retries += 1;
+	return resolved;
+}
+const MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS = {
+	retries: resolveRetriesForMinimumWindowMs(IDB_SNAPSHOT_LOCK_RETRY_BASE, MATRIX_IDB_PERSIST_INTERVAL_MS),
+	stale: IDB_SNAPSHOT_LOCK_STALE_MS
+};
+//#endregion
+export { MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS as n, MATRIX_IDB_PERSIST_INTERVAL_MS as t };

package/dist/.setup/legacy-crypto-inspector-Byp8LCys.mjs

@@ -0,0 +1,42 @@
+import { t as ensureMatrixCryptoRuntime } from "./deps-Dy6yreL4.mjs";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region extensions/matrix/src/matrix/legacy-crypto-inspector.ts
+const MATRIX_CRYPTO_STORE_SQLITE = 0;
+function resolveLegacyMachineStorePath(params) {
+	const hashedDir = path.join(params.cryptoRootDir, crypto.createHash("sha256").update(params.deviceId).digest("hex"));
+	if (fs.existsSync(path.join(hashedDir, "matrix-sdk-crypto.sqlite3"))) return hashedDir;
+	if (fs.existsSync(path.join(params.cryptoRootDir, "matrix-sdk-crypto.sqlite3"))) return params.cryptoRootDir;
+	const match = fs.readdirSync(params.cryptoRootDir, { withFileTypes: true }).find((entry) => entry.isDirectory() && fs.existsSync(path.join(params.cryptoRootDir, entry.name, "matrix-sdk-crypto.sqlite3")));
+	return match ? path.join(params.cryptoRootDir, match.name) : null;
+}
+async function inspectLegacyMatrixCryptoStore(params) {
+	const machineStorePath = resolveLegacyMachineStorePath(params);
+	if (!machineStorePath) throw new Error(`Matrix legacy crypto store not found for device ${params.deviceId}`);
+	const requireFn = createRequire(import.meta.url);
+	await ensureMatrixCryptoRuntime({
+		requireFn,
+		resolveFn: requireFn.resolve.bind(requireFn),
+		log: params.log
+	});
+	const { DeviceId, OlmMachine, UserId } = requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
+	const machine = await OlmMachine.initialize(new UserId(params.userId), new DeviceId(params.deviceId), machineStorePath, "", MATRIX_CRYPTO_STORE_SQLITE);
+	try {
+		const [backupKeys, roomKeyCounts] = await Promise.all([machine.getBackupKeys(), machine.roomKeyCounts()]);
+		return {
+			deviceId: params.deviceId,
+			roomKeyCounts: roomKeyCounts ? {
+				total: typeof roomKeyCounts.total === "number" ? roomKeyCounts.total : 0,
+				backedUp: typeof roomKeyCounts.backedUp === "number" ? roomKeyCounts.backedUp : 0
+			} : null,
+			backupVersion: typeof backupKeys?.backupVersion === "string" && backupKeys.backupVersion.trim() ? backupKeys.backupVersion : null,
+			decryptionKeyBase64: typeof backupKeys?.decryptionKeyBase64 === "string" && backupKeys.decryptionKeyBase64.trim() ? backupKeys.decryptionKeyBase64 : null
+		};
+	} finally {
+		machine.close();
+	}
+}
+//#endregion
+export { inspectLegacyMatrixCryptoStore };