@openclaw/matrix 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/crypto-snapshot-doctor.runtime-44FrCPR7.mjs

@@ -1,91 +0,0 @@
-import { b as readMatrixIdbSnapshotJsonFromStore, o as MATRIX_IDB_SNAPSHOT_FILENAME, p as openMatrixIdbSnapshotStoreOptions, w as writeMatrixIdbSnapshotJsonToStore } from "./storage-metadata-BDRZ7vpX.mjs";
-import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-D_mDu4Cf.mjs";
-import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-DBvfre1X.mjs";
-import { randomUUID } from "node:crypto";
-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";
-//#region extensions/matrix/src/matrix/crypto-snapshot-doctor.runtime.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
-export { migrateLegacyMatrixIdbSnapshot };

package/dist/.setup/doctor-DMvEBx6o.mjs

@@ -1,49 +0,0 @@
-import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "openclaw/plugin-sdk/doctor-repair-runtime";
-//#region extensions/matrix/src/doctor.ts
-async function collectMatrixInstallPathWarnings(cfg) {
-	const issue = await detectPluginInstallPathIssue({
-		pluginId: "matrix",
-		install: cfg.plugins?.installs?.matrix
-	});
-	if (!issue) return [];
-	return formatPluginInstallPathIssue({
-		issue,
-		pluginLabel: "Matrix",
-		defaultInstallCommand: "openclaw plugins install @openclaw/matrix"
-	}).map((entry) => `- ${entry}`);
-}
-async function cleanStaleMatrixPluginConfig(cfg) {
-	const issue = await detectPluginInstallPathIssue({
-		pluginId: "matrix",
-		install: cfg.plugins?.installs?.matrix
-	});
-	if (!issue || issue.kind !== "missing-path") return {
-		config: cfg,
-		changes: []
-	};
-	const { config, actions } = removePluginFromConfig(cfg, "matrix");
-	const removed = [];
-	if (actions.install) removed.push("install record");
-	if (actions.loadPath) removed.push("load path");
-	if (actions.entry) removed.push("plugin entry");
-	if (actions.allowlist) removed.push("allowlist entry");
-	if (removed.length === 0) return {
-		config: cfg,
-		changes: []
-	};
-	return {
-		config,
-		changes: [`Removed stale Matrix plugin references (${removed.join(", ")}). The previous install path no longer exists: ${issue.path}`]
-	};
-}
-async function runMatrixDoctorSequence(params) {
-	const warningNotes = [];
-	const installWarnings = await collectMatrixInstallPathWarnings(params.cfg);
-	if (installWarnings.length > 0) warningNotes.push(installWarnings.join("\n"));
-	return {
-		changeNotes: [],
-		warningNotes
-	};
-}
-//#endregion
-export { cleanStaleMatrixPluginConfig, collectMatrixInstallPathWarnings, runMatrixDoctorSequence };

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

@@ -1,227 +0,0 @@
-import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { C as writeMatrixIdbSnapshotJson, o as MATRIX_IDB_SNAPSHOT_FILENAME, y as readMatrixIdbSnapshotJson } from "./storage-metadata-BDRZ7vpX.mjs";
-import { n as LogService } from "./logger-CVv56jzH.mjs";
-import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-D_mDu4Cf.mjs";
-import path from "node:path";
-import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
-import fs from "node:fs";
-import { withFileLock } from "openclaw/plugin-sdk/file-lock";
-import { indexedDB } from "fake-indexeddb";
-//#region extensions/matrix/src/matrix/sdk/idb-persistence.ts
-const LEGACY_SNAPSHOT_DIAGNOSTIC = {
-	code: "matrix-idb-snapshot-requires-doctor",
-	message: "Matrix IndexedDB snapshot exists outside canonical SQLite state",
-	remediation: "openclaw doctor --fix"
-};
-var MatrixIdbSnapshotMigrationRequiredError = class extends Error {
-	constructor() {
-		super(`${LEGACY_SNAPSHOT_DIAGNOSTIC.message}; run ${LEGACY_SNAPSHOT_DIAGNOSTIC.remediation}`);
-		this.code = LEGACY_SNAPSHOT_DIAGNOSTIC.code;
-		this.remediation = LEGACY_SNAPSHOT_DIAGNOSTIC.remediation;
-		this.name = "MatrixIdbSnapshotMigrationRequiredError";
-	}
-};
-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 isValidMatrixIdbSnapshotJson(data) {
-	try {
-		return parseSnapshotPayload(data) !== null;
-	} catch {
-		return false;
-	}
-}
-function idbReq(req) {
-	return new Promise((resolve, reject) => {
-		req.addEventListener("success", () => resolve(req.result), { once: true });
-		req.addEventListener("error", () => reject(toErrorObject(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 idbReq(idb.open(name, version));
-		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) {
-		const request = idb.open(dbSnap.name, dbSnap.version);
-		request.addEventListener("upgradeneeded", () => {
-			const db = request.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
-				});
-			}
-		});
-		const db = await idbReq(request);
-		try {
-			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((resolve, reject) => {
-					tx.addEventListener("complete", () => resolve(), { once: true });
-					tx.addEventListener("abort", () => reject(toErrorObject(tx.error, "IndexedDB restore transaction aborted")), { once: true });
-				});
-			}
-		} finally {
-			db.close();
-		}
-	}
-}
-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 readCanonicalSnapshotJson(snapshotPath, stateRuntime) {
-	let storedSnapshotJson;
-	try {
-		storedSnapshotJson = await readMatrixIdbSnapshotJson(path.dirname(snapshotPath), stateRuntime);
-	} catch (err) {
-		if (fs.existsSync(snapshotPath)) throwLegacySnapshotMigrationRequired();
-		throw err;
-	}
-	throwIfLegacySnapshotNeedsDoctor(snapshotPath, storedSnapshotJson);
-	return storedSnapshotJson;
-}
-async function restoreIdbFromDisk(snapshotPath, stateRuntime) {
-	const resolvedPath = snapshotPath ?? resolveDefaultIdbSnapshotPath();
-	let callbackStarted = false;
-	try {
-		const snapshotStateRuntime = stateRuntime ?? getMatrixRuntime().state;
-		return await withFileLock(resolvedPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
-			callbackStarted = true;
-			const storedSnapshotJson = await readCanonicalSnapshotJson(resolvedPath, snapshotStateRuntime);
-			if (!storedSnapshotJson) return false;
-			const snapshot = parseSnapshotPayload(storedSnapshotJson);
-			if (!snapshot) return false;
-			await restoreIndexedDatabases(snapshot);
-			LogService.info("IdbPersistence", `Restored ${snapshot.length} IndexedDB database(s) from Matrix SQLite state`);
-			return true;
-		});
-	} catch (err) {
-		if (err instanceof MatrixIdbSnapshotMigrationRequiredError) throw err;
-		if (!callbackStarted && fs.existsSync(resolvedPath)) throwLegacySnapshotMigrationRequired();
-		LogService.warn("IdbPersistence", "Failed to restore IndexedDB snapshot from SQLite:", err);
-		return false;
-	}
-}
-async function persistIdbToDisk(params) {
-	const snapshotPath = params?.snapshotPath ?? resolveDefaultIdbSnapshotPath();
-	let callbackStarted = false;
-	try {
-		const stateRuntime = params?.stateRuntime ?? getMatrixRuntime().state;
-		fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
-		const persistedCount = await withFileLock(snapshotPath, MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS, async () => {
-			callbackStarted = true;
-			const storageRootDir = path.dirname(snapshotPath);
-			await readCanonicalSnapshotJson(snapshotPath, stateRuntime);
-			const snapshot = await dumpIndexedDatabases(params?.databasePrefix);
-			if (params?.abortSignal?.aborted || snapshot.length === 0) return 0;
-			await writeMatrixIdbSnapshotJson({
-				storageRootDir,
-				snapshotJson: JSON.stringify(snapshot),
-				databaseCount: snapshot.length,
-				stateRuntime
-			});
-			return snapshot.length;
-		});
-		if (persistedCount === 0) return;
-		LogService.debug("IdbPersistence", `Persisted ${persistedCount} IndexedDB database(s) to Matrix SQLite state`);
-	} catch (err) {
-		if (err instanceof MatrixIdbSnapshotMigrationRequiredError) throw err;
-		if (!callbackStarted && fs.existsSync(snapshotPath)) throwLegacySnapshotMigrationRequired();
-		LogService.warn("IdbPersistence", "Failed to persist IndexedDB snapshot:", err);
-		if (params?.strict) throw err;
-	}
-}
-function readLegacyMatrixIdbSnapshotStateUnlocked(storageRootDir) {
-	const snapshotPath = path.join(storageRootDir, MATRIX_IDB_SNAPSHOT_FILENAME);
-	if (!fs.existsSync(snapshotPath)) return null;
-	const data = fs.readFileSync(snapshotPath, "utf8");
-	try {
-		return parseSnapshotPayload(data);
-	} catch {
-		return null;
-	}
-}
-function throwIfLegacySnapshotNeedsDoctor(snapshotPath, storedSnapshotJson) {
-	if (fs.existsSync(snapshotPath) && (!storedSnapshotJson || !isValidMatrixIdbSnapshotJson(storedSnapshotJson))) throwLegacySnapshotMigrationRequired();
-}
-function throwLegacySnapshotMigrationRequired() {
-	LogService.warn("IdbPersistence", LEGACY_SNAPSHOT_DIAGNOSTIC);
-	throw new MatrixIdbSnapshotMigrationRequiredError();
-}
-//#endregion
-export { restoreIdbFromDisk as i, persistIdbToDisk as n, readLegacyMatrixIdbSnapshotStateUnlocked as r, isValidMatrixIdbSnapshotJson as t };

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

@@ -1,27 +0,0 @@
-//#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 resolveRetriesForMinimumWindowMs(retries, minimumWindowMs) {
-	const resolved = {
-		...retries,
-		retries: 0
-	};
-	let total = 0;
-	while (total < minimumWindowMs) {
-		total += Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** resolved.retries));
-		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/logger-CVv56jzH.mjs

@@ -1,74 +0,0 @@
-import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { format } from "node:util";
-import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
-//#region extensions/matrix/src/matrix/sdk/logger.ts
-function noop() {}
-let forceConsoleLogging = false;
-function setMatrixConsoleLogging(enabled) {
-	forceConsoleLogging = enabled;
-}
-function resolveRuntimeLogger(module) {
-	if (forceConsoleLogging) return null;
-	try {
-		return getMatrixRuntime().logging.getChildLogger({ module: `matrix:${module}` });
-	} catch {
-		return null;
-	}
-}
-function formatMessage(module, messageOrObject) {
-	if (messageOrObject.length === 0) return `[${module}]`;
-	return redactSensitiveText(`[${module}] ${format(...messageOrObject)}`);
-}
-var ConsoleLogger = class {
-	emit(level, module, ...messageOrObject) {
-		const runtimeLogger = resolveRuntimeLogger(module);
-		const message = formatMessage(module, messageOrObject);
-		if (runtimeLogger) {
-			if (level === "debug") {
-				runtimeLogger.debug?.(message);
-				return;
-			}
-			runtimeLogger[level](message);
-			return;
-		}
-		console[level](message);
-	}
-	trace(module, ...messageOrObject) {
-		this.emit("debug", module, ...messageOrObject);
-	}
-	debug(module, ...messageOrObject) {
-		this.emit("debug", module, ...messageOrObject);
-	}
-	info(module, ...messageOrObject) {
-		this.emit("info", module, ...messageOrObject);
-	}
-	warn(module, ...messageOrObject) {
-		this.emit("warn", module, ...messageOrObject);
-	}
-	error(module, ...messageOrObject) {
-		this.emit("error", module, ...messageOrObject);
-	}
-};
-let activeLogger = new ConsoleLogger();
-const LogService = {
-	setLogger(logger) {
-		activeLogger = logger;
-	},
-	trace(module, ...messageOrObject) {
-		activeLogger.trace(module, ...messageOrObject);
-	},
-	debug(module, ...messageOrObject) {
-		activeLogger.debug(module, ...messageOrObject);
-	},
-	info(module, ...messageOrObject) {
-		activeLogger.info(module, ...messageOrObject);
-	},
-	warn(module, ...messageOrObject) {
-		activeLogger.warn(module, ...messageOrObject);
-	},
-	error(module, ...messageOrObject) {
-		activeLogger.error(module, ...messageOrObject);
-	}
-};
-//#endregion
-export { setMatrixConsoleLogging as i, LogService as n, noop as r, ConsoleLogger as t };

package/dist/.setup/startup-verification-Aiy_xVdI.mjs

@@ -1,204 +0,0 @@
-import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { O as resolveMatrixSqliteStateEnv } from "./storage-metadata-BDRZ7vpX.mjs";
-import { o as resolveMatrixStoragePaths, r as recordCurrentStorageMetaDeviceId } from "./storage-BXS2cB2i.mjs";
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
-import fs from "node:fs/promises";
-import { tryReadJson } from "@openclaw/fs-safe/json";
-//#region extensions/matrix/src/matrix/monitor/startup-verification.ts
-const STARTUP_VERIFICATION_STATE_FILENAME = "startup-verification.json";
-const STARTUP_VERIFICATION_NAMESPACE = "startup-verification";
-const STARTUP_VERIFICATION_MIGRATIONS_NAMESPACE = "startup-verification-migrations";
-const STARTUP_VERIFICATION_MAX_ENTRIES = 1e3;
-const DEFAULT_STARTUP_VERIFICATION_MODE = "if-unverified";
-const DEFAULT_STARTUP_VERIFICATION_COOLDOWN_HOURS = 24;
-const DEFAULT_STARTUP_VERIFICATION_FAILURE_COOLDOWN_MS = 36e5;
-function normalizeCooldownHours(value) {
-	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_STARTUP_VERIFICATION_COOLDOWN_HOURS;
-	return Math.max(0, value);
-}
-async function resolveStartupVerificationStatePath(params) {
-	const storagePaths = await resolveMatrixStoragePaths({
-		homeserver: params.auth.homeserver,
-		userId: params.auth.userId,
-		accessToken: params.auth.accessToken,
-		accountId: params.auth.accountId,
-		deviceId: params.auth.deviceId,
-		env: params.env,
-		stateDir: params.stateDir
-	});
-	return path.join(storagePaths.rootDir, STARTUP_VERIFICATION_STATE_FILENAME);
-}
-function buildStartupVerificationKey(auth) {
-	return auth.accountId.trim() || "default";
-}
-function createStartupVerificationStore(params) {
-	return getMatrixRuntime().state.openKeyedStore({
-		namespace: STARTUP_VERIFICATION_NAMESPACE,
-		maxEntries: STARTUP_VERIFICATION_MAX_ENTRIES,
-		env: resolveMatrixSqliteStateEnv(params)
-	});
-}
-function createStartupVerificationMigrationStore(params) {
-	return getMatrixRuntime().state.openKeyedStore({
-		namespace: STARTUP_VERIFICATION_MIGRATIONS_NAMESPACE,
-		maxEntries: STARTUP_VERIFICATION_MAX_ENTRIES,
-		env: resolveMatrixSqliteStateEnv(params)
-	});
-}
-function buildStartupVerificationImportKey(params) {
-	const accountId = buildStartupVerificationKey(params.auth);
-	return `${accountId}:${createHash("sha256").update(accountId).update("\0").update(params.legacyFilePath).digest("hex")}`;
-}
-async function readLegacyStartupVerificationState(filePath) {
-	const value = await tryReadJson(filePath);
-	return value && typeof value === "object" ? value : null;
-}
-async function readStartupVerificationState(params) {
-	const store = createStartupVerificationStore(params);
-	const key = buildStartupVerificationKey(params.auth);
-	const value = await store.lookup(key);
-	if (value && typeof value === "object") return value;
-	const migrationStore = createStartupVerificationMigrationStore(params);
-	const legacyImportKey = buildStartupVerificationImportKey({
-		auth: params.auth,
-		legacyFilePath: params.legacyFilePath
-	});
-	if (await migrationStore.lookup(legacyImportKey)) return null;
-	const legacy = await readLegacyStartupVerificationState(params.legacyFilePath);
-	if (legacy) await store.register(key, legacy).then(async () => {
-		if (typeof legacy.deviceId === "string" && legacy.deviceId.trim()) await recordCurrentStorageMetaDeviceId({
-			rootDir: path.dirname(params.legacyFilePath),
-			deviceId: legacy.deviceId
-		});
-		await migrationStore.register(legacyImportKey, { importedAt: Date.now() });
-		await fs.rm(params.legacyFilePath, { force: true }).catch(() => {});
-	}).catch(() => {});
-	return legacy;
-}
-async function writeStartupVerificationState(params) {
-	await createStartupVerificationStore(params).register(buildStartupVerificationKey(params.auth), params.state);
-	await createStartupVerificationMigrationStore(params).register(buildStartupVerificationImportKey({
-		auth: params.auth,
-		legacyFilePath: params.legacyFilePath
-	}), { importedAt: Date.now() }).catch(() => {});
-	if (typeof params.state.deviceId === "string" && params.state.deviceId.trim()) await recordCurrentStorageMetaDeviceId({
-		rootDir: path.dirname(params.legacyFilePath),
-		deviceId: params.state.deviceId
-	});
-	await fs.rm(params.legacyFilePath, { force: true }).catch(() => {});
-}
-async function clearStartupVerificationState(params) {
-	await createStartupVerificationStore(params).delete(buildStartupVerificationKey(params.auth)).catch(() => {});
-	await createStartupVerificationMigrationStore(params).register(buildStartupVerificationImportKey({
-		auth: params.auth,
-		legacyFilePath: params.legacyFilePath
-	}), { importedAt: Date.now() }).catch(() => {});
-	await fs.rm(params.legacyFilePath, { force: true }).catch(() => {});
-}
-function resolveStateCooldownMs(state, cooldownMs) {
-	if (state?.outcome === "failed") return Math.min(cooldownMs, DEFAULT_STARTUP_VERIFICATION_FAILURE_COOLDOWN_MS);
-	return cooldownMs;
-}
-function resolveRetryAfterMs(params) {
-	const attemptedAtMs = Date.parse(params.attemptedAt ?? "");
-	if (!Number.isFinite(attemptedAtMs)) return;
-	const remaining = attemptedAtMs + params.cooldownMs - params.nowMs;
-	return remaining > 0 ? remaining : void 0;
-}
-function resolveStartupVerificationTimestamp(nowMs) {
-	return timestampMsToIsoString(nowMs) ?? timestampMsToIsoString(Date.now()) ?? "1970-01-01T00:00:00.000Z";
-}
-function resolveStartupVerificationRetryAfterMs(params) {
-	if (!params.state || params.stateCooldownMs <= 0) return;
-	if (params.state.userId && params.verification.userId && params.state.userId !== params.verification.userId) return;
-	if (params.state.deviceId && params.verification.deviceId && params.state.deviceId !== params.verification.deviceId) return;
-	return resolveRetryAfterMs({
-		attemptedAt: params.state.attemptedAt,
-		cooldownMs: params.stateCooldownMs,
-		nowMs: params.nowMs
-	});
-}
-async function ensureMatrixStartupVerification(params) {
-	if (params.auth.encryption !== true || !params.client.crypto) return { kind: "unsupported" };
-	const verification = await params.client.getOwnDeviceVerificationStatus();
-	const statePath = params.stateFilePath ?? await resolveStartupVerificationStatePath({
-		auth: params.auth,
-		env: params.env,
-		stateDir: params.stateDir
-	});
-	const stateLocation = {
-		auth: params.auth,
-		env: params.env,
-		stateDir: params.stateDir ?? path.dirname(statePath),
-		legacyFilePath: statePath
-	};
-	const mode = params.accountConfig.startupVerification ?? DEFAULT_STARTUP_VERIFICATION_MODE;
-	if (verification.verified || mode === "off") {
-		await clearStartupVerificationState(stateLocation);
-		return {
-			kind: verification.verified ? "verified" : "disabled",
-			verification
-		};
-	}
-	if ((await params.client.crypto.listVerifications().catch(() => [])).some((entry) => entry.isSelfVerification && !entry.completed && entry.pending)) return {
-		kind: "pending",
-		verification
-	};
-	const cooldownMs = normalizeCooldownHours(params.accountConfig.startupVerificationCooldownHours) * 60 * 60 * 1e3;
-	const nowMs = params.nowMs ?? Date.now();
-	const attemptedAt = resolveStartupVerificationTimestamp(nowMs);
-	const state = await readStartupVerificationState(stateLocation);
-	const retryAfterMs = resolveStartupVerificationRetryAfterMs({
-		state,
-		verification,
-		stateCooldownMs: resolveStateCooldownMs(state, cooldownMs),
-		nowMs
-	});
-	if (retryAfterMs !== void 0) return {
-		kind: "cooldown",
-		verification,
-		retryAfterMs
-	};
-	try {
-		const request = await params.client.crypto.requestVerification({ ownUser: true });
-		await writeStartupVerificationState({
-			...stateLocation,
-			state: {
-				userId: verification.userId,
-				deviceId: verification.deviceId,
-				attemptedAt,
-				outcome: "requested",
-				requestId: request.id,
-				transactionId: request.transactionId
-			}
-		});
-		return {
-			kind: "requested",
-			verification,
-			requestId: request.id,
-			transactionId: request.transactionId ?? void 0
-		};
-	} catch (err) {
-		const error = formatErrorMessage(err);
-		await writeStartupVerificationState({
-			...stateLocation,
-			state: {
-				userId: verification.userId,
-				deviceId: verification.deviceId,
-				attemptedAt,
-				outcome: "failed",
-				error
-			}
-		}).catch(() => {});
-		return {
-			kind: "request-failed",
-			verification,
-			error
-		};
-	}
-}
-//#endregion
-export { ensureMatrixStartupVerification };