@openclaw/matrix 2026.9.6 → 2026.9.7

package/dist/.setup/crypto-snapshot-doctor.runtime-CMWa1d9Y.mjs

@@ -1,91 +0,0 @@
-import { b as readMatrixIdbSnapshotJsonFromStore, o as MATRIX_IDB_SNAPSHOT_FILENAME, p as openMatrixIdbSnapshotStoreOptions, w as writeMatrixIdbSnapshotJsonToStore } from "./storage-metadata-fHN6Df2m.mjs";
-import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-B3fZXyF_.mjs";
-import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-c8uxcofH.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/deps-mtxF2mHI.mjs

@@ -1,169 +0,0 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import fs from "node:fs";
-import { runCommandWithTimeout } from "openclaw/plugin-sdk/process-runtime";
-//#region extensions/matrix/src/matrix/deps.ts
-const REQUIRED_MATRIX_PACKAGES = [
-	"matrix-js-sdk",
-	"@matrix-org/matrix-sdk-crypto-nodejs",
-	"@matrix-org/matrix-sdk-crypto-wasm"
-];
-const MIN_MATRIX_CRYPTO_NATIVE_BINDING_BYTES = 1e6;
-const MATRIX_COMMAND_OUTPUT_TAIL_BYTES = 65536;
-function resolveMissingMatrixPackages(resolveFn) {
-	const resolve = resolveFn ?? defaultResolveFn;
-	return REQUIRED_MATRIX_PACKAGES.filter((pkg) => {
-		try {
-			resolve(pkg);
-			return false;
-		} catch {
-			return true;
-		}
-	});
-}
-function isMatrixSdkAvailable() {
-	return resolveMissingMatrixPackages().length === 0;
-}
-function buildMatrixDepsMissingMessage(missing) {
-	return [`Matrix plugin dependencies are missing: ${missing.join(", ")}.`, "Repair this plugin with `openclaw plugins update matrix` or run `openclaw doctor --fix`."].join(" ");
-}
-let defaultMatrixCryptoRuntimeEnsurePromise = null;
-async function runFixedCommandWithTimeout(params) {
-	if (!params.argv[0]) return {
-		code: 1,
-		stdout: "",
-		stderr: "command is required"
-	};
-	try {
-		const result = await runCommandWithTimeout(params.argv, {
-			cwd: params.cwd,
-			env: params.env,
-			killProcessTree: true,
-			maxOutputBytes: MATRIX_COMMAND_OUTPUT_TAIL_BYTES,
-			outputCapture: "tail",
-			timeoutMs: params.timeoutMs
-		});
-		return {
-			code: result.termination === "timeout" ? 124 : result.code ?? 1,
-			stdout: result.stdout,
-			stderr: result.stderr || (result.termination === "timeout" ? `command timed out after ${params.timeoutMs}ms` : "")
-		};
-	} catch (error) {
-		return {
-			code: 1,
-			stdout: "",
-			stderr: error instanceof Error ? error.message : String(error)
-		};
-	}
-}
-function defaultRequireFn(id) {
-	return createRequire(import.meta.url)(id);
-}
-function defaultResolveFn(id) {
-	return createRequire(import.meta.url).resolve(id);
-}
-function isMissingMatrixCryptoRuntimeError(error) {
-	const message = formatErrorMessage(error);
-	return message.includes("@matrix-org/matrix-sdk-crypto-nodejs-") || message.includes("matrix-sdk-crypto-nodejs") || message.includes("download-lib.js");
-}
-function isMuslRuntime() {
-	try {
-		return !(process.report?.getReport?.())?.header?.glibcVersionRuntime;
-	} catch {
-		return true;
-	}
-}
-function resolveMatrixCryptoNativeBindingFilename() {
-	switch (process.platform) {
-		case "darwin": return process.arch === "arm64" ? "matrix-sdk-crypto.darwin-arm64.node" : process.arch === "x64" ? "matrix-sdk-crypto.darwin-x64.node" : null;
-		case "linux":
-			if (process.arch === "x64") return isMuslRuntime() ? "matrix-sdk-crypto.linux-x64-musl.node" : "matrix-sdk-crypto.linux-x64-gnu.node";
-			if (process.arch === "arm64" && !isMuslRuntime()) return "matrix-sdk-crypto.linux-arm64-gnu.node";
-			if (process.arch === "arm") return "matrix-sdk-crypto.linux-arm-gnueabihf.node";
-			if (process.arch === "s390x") return "matrix-sdk-crypto.linux-s390x-gnu.node";
-			return null;
-		case "win32": return process.arch === "x64" ? "matrix-sdk-crypto.win32-x64-msvc.node" : process.arch === "ia32" ? "matrix-sdk-crypto.win32-ia32-msvc.node" : process.arch === "arm64" ? "matrix-sdk-crypto.win32-arm64-msvc.node" : null;
-		default: return null;
-	}
-}
-function resolveMatrixCryptoNativeBindingPath(resolveFn) {
-	const filename = resolveMatrixCryptoNativeBindingFilename();
-	if (!filename) return null;
-	try {
-		return path.join(path.dirname(resolveFn("@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js")), filename);
-	} catch {
-		return null;
-	}
-}
-function removeIncompleteMatrixCryptoNativeBinding(params) {
-	const bindingPath = params.bindingPath;
-	if (!bindingPath) return;
-	try {
-		const stat = fs.statSync(bindingPath);
-		if (!stat.isFile() || stat.size >= MIN_MATRIX_CRYPTO_NATIVE_BINDING_BYTES) return;
-		fs.unlinkSync(bindingPath);
-		params.log?.(`matrix: removed incomplete native crypto runtime (${stat.size} bytes); it will be downloaded again`);
-	} catch (error) {
-		if (error.code !== "ENOENT") throw error;
-	}
-}
-async function ensureMatrixCryptoRuntime(params = {}) {
-	const usesDefaultRuntime = !params.requireFn && !params.resolveFn;
-	if (usesDefaultRuntime && defaultMatrixCryptoRuntimeEnsurePromise) {
-		await defaultMatrixCryptoRuntimeEnsurePromise;
-		return;
-	}
-	const ensurePromise = ensureMatrixCryptoRuntimeOnce(params);
-	if (!usesDefaultRuntime) {
-		await ensurePromise;
-		return;
-	}
-	defaultMatrixCryptoRuntimeEnsurePromise = ensurePromise.catch((error) => {
-		defaultMatrixCryptoRuntimeEnsurePromise = null;
-		throw error;
-	});
-	await defaultMatrixCryptoRuntimeEnsurePromise;
-}
-async function ensureMatrixCryptoRuntimeOnce(params) {
-	const resolveFn = params.resolveFn ?? defaultResolveFn;
-	const nativeBindingPath = resolveMatrixCryptoNativeBindingPath(resolveFn);
-	removeIncompleteMatrixCryptoNativeBinding({
-		bindingPath: nativeBindingPath,
-		log: params.log
-	});
-	const requireFn = params.requireFn ?? defaultRequireFn;
-	try {
-		requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
-		return;
-	} catch (err) {
-		if (!isMissingMatrixCryptoRuntimeError(err)) throw err;
-	}
-	const scriptPath = resolveFn("@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js");
-	params.log?.("matrix: bootstrapping native crypto runtime");
-	const result = await runFixedCommandWithTimeout({
-		argv: [process.execPath, scriptPath],
-		cwd: path.dirname(scriptPath),
-		timeoutMs: 3e5,
-		env: { COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" }
-	});
-	if (result.code !== 0) {
-		removeIncompleteMatrixCryptoNativeBinding({
-			bindingPath: nativeBindingPath,
-			log: params.log
-		});
-		throw new Error(result.stderr.trim() || result.stdout.trim() || "Matrix crypto runtime bootstrap failed.");
-	}
-	removeIncompleteMatrixCryptoNativeBinding({
-		bindingPath: nativeBindingPath,
-		log: params.log
-	});
-	requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
-}
-async function ensureMatrixSdkInstalled(params) {
-	const missing = resolveMissingMatrixPackages(params?.resolveFn);
-	if (missing.length === 0) return;
-	throw new Error(buildMatrixDepsMissingMessage(missing));
-}
-//#endregion
-export { ensureMatrixSdkInstalled as n, isMatrixSdkAvailable as r, ensureMatrixCryptoRuntime as t };

package/dist/.setup/device-health-CWOuIirq.mjs

@@ -1,21 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-//#region extensions/matrix/src/matrix/device-health.ts
-var device_health_exports = /* @__PURE__ */ __exportAll({
-	isOpenClawManagedMatrixDevice: () => isOpenClawManagedMatrixDevice,
-	summarizeMatrixDeviceHealth: () => summarizeMatrixDeviceHealth
-});
-const OPENCLAW_DEVICE_NAME_PREFIX = "OpenClaw ";
-function isOpenClawManagedMatrixDevice(displayName) {
-	return displayName?.startsWith(OPENCLAW_DEVICE_NAME_PREFIX) === true;
-}
-function summarizeMatrixDeviceHealth(devices) {
-	const currentDeviceId = devices.find((device) => device.current)?.deviceId ?? null;
-	const openClawDevices = devices.filter((device) => isOpenClawManagedMatrixDevice(device.displayName));
-	return {
-		currentDeviceId,
-		staleOpenClawDevices: openClawDevices.filter((device) => !device.current),
-		currentOpenClawDevices: openClawDevices.filter((device) => device.current)
-	};
-}
-//#endregion
-export { isOpenClawManagedMatrixDevice as n, summarizeMatrixDeviceHealth as r, device_health_exports as t };

package/dist/.setup/direct-management-B2Bno2xL.mjs

@@ -1,346 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
-import { a as MATRIX_REACTION_EVENT_TYPE, i as MATRIX_ANNOTATION_RELATION_TYPE } from "./send-currentness-BrGXL7b8.mjs";
-import { asOptionalRecord, normalizeNullableString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-//#region extensions/matrix/src/matrix/send/types.ts
-const MsgType = {
-	Text: "m.text",
-	Image: "m.image",
-	Audio: "m.audio",
-	Video: "m.video",
-	File: "m.file",
-	Notice: "m.notice"
-};
-const RelationType = {
-	Annotation: MATRIX_ANNOTATION_RELATION_TYPE,
-	Replace: "m.replace",
-	Thread: "m.thread"
-};
-const EventType = {
-	Direct: "m.direct",
-	Reaction: MATRIX_REACTION_EVENT_TYPE,
-	RoomMessage: "m.room.message"
-};
-const MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY = "com.openclaw.finalized_preview";
-/**
-* MSC4357 live marker key.
-* When present on event content, signals that the message is still being
-* streamed (e.g. an LLM generating a response). Supporting clients render
-* the message with a streaming animation until an edit without this marker
-* arrives, indicating the stream is complete.
-* @see https://github.com/matrix-org/matrix-spec-proposals/pull/4357
-*/
-const MSC4357_LIVE_KEY = "org.matrix.msc4357.live";
-//#endregion
-//#region extensions/matrix/src/matrix/relations.ts
-function relatedReplyEventId(relation) {
-	const reply = asOptionalRecord(relation?.["m.in_reply_to"]);
-	return typeof reply?.event_id === "string" ? reply.event_id : void 0;
-}
-function buildMatrixMessageRelation(params) {
-	const threadId = params.threadId?.trim();
-	const replyToId = params.replyToId?.trim();
-	const relatedId = replyToId || (threadId ? params.fallbackReplyToId?.trim() : void 0);
-	const reply = relatedId ? { "m.in_reply_to": { event_id: relatedId } } : void 0;
-	if (!threadId) return reply;
-	return {
-		rel_type: RelationType.Thread,
-		event_id: threadId,
-		...reply,
-		...relatedId && !replyToId ? { is_falling_back: true } : {}
-	};
-}
-function resolveMatrixReplyToEventId(content) {
-	const relation = asOptionalRecord(content["m.relates_to"]);
-	return relation?.rel_type === RelationType.Thread && relation.is_falling_back === true ? void 0 : relatedReplyEventId(relation);
-}
-function resolveMatrixThreadRootId(content) {
-	const relation = asOptionalRecord(content["m.relates_to"]);
-	if (relation?.rel_type !== RelationType.Thread) return;
-	return typeof relation.event_id === "string" ? relation.event_id : relatedReplyEventId(relation);
-}
-//#endregion
-//#region extensions/matrix/src/matrix/direct-room.ts
-var direct_room_exports = /* @__PURE__ */ __exportAll({
-	hasDirectMatrixMemberFlag: () => hasDirectMatrixMemberFlag,
-	inspectMatrixDirectRoomEvidence: () => inspectMatrixDirectRoomEvidence,
-	isStrictDirectMembership: () => isStrictDirectMembership,
-	isStrictDirectRoom: () => isStrictDirectRoom,
-	readJoinedMatrixMembers: () => readJoinedMatrixMembers
-});
-function normalizeJoinedMatrixMembers(joinedMembers) {
-	if (!Array.isArray(joinedMembers)) return [];
-	return joinedMembers.map((entry) => normalizeNullableString(entry)).filter((entry) => Boolean(entry));
-}
-function isStrictDirectMembership(params) {
-	const selfUserId = normalizeNullableString(params.selfUserId);
-	const remoteUserId = normalizeNullableString(params.remoteUserId);
-	const joinedMembers = params.joinedMembers ?? [];
-	return Boolean(selfUserId && remoteUserId && joinedMembers.length === 2 && joinedMembers.includes(selfUserId) && joinedMembers.includes(remoteUserId));
-}
-async function readJoinedMatrixMembers(client, roomId) {
-	try {
-		return normalizeJoinedMatrixMembers(await client.getJoinedRoomMembers(roomId));
-	} catch {
-		return null;
-	}
-}
-async function hasDirectMatrixMemberFlag(client, roomId, userId) {
-	const normalizedUserId = normalizeNullableString(userId);
-	if (!normalizedUserId) return null;
-	try {
-		const state = await client.getRoomStateEvent(roomId, "m.room.member", normalizedUserId);
-		if (state?.is_direct === true) return true;
-		if (state?.is_direct === false) return false;
-		return null;
-	} catch {
-		return null;
-	}
-}
-async function inspectMatrixDirectRoomEvidence(params) {
-	const selfUserId = params.selfUserId !== void 0 ? normalizeNullableString(params.selfUserId) : normalizeNullableString(await params.client.getUserId().catch(() => null));
-	const joinedMembers = await readJoinedMatrixMembers(params.client, params.roomId);
-	const strict = isStrictDirectMembership({
-		selfUserId,
-		remoteUserId: params.remoteUserId,
-		joinedMembers
-	});
-	if (!strict) return {
-		joinedMembers,
-		strict: false,
-		viaMemberState: false,
-		memberStateFlag: null
-	};
-	const memberStateFlag = await hasDirectMatrixMemberFlag(params.client, params.roomId, selfUserId);
-	return {
-		joinedMembers,
-		strict,
-		viaMemberState: memberStateFlag === true,
-		memberStateFlag
-	};
-}
-async function isStrictDirectRoom(params) {
-	return (await inspectMatrixDirectRoomEvidence({
-		client: params.client,
-		roomId: params.roomId,
-		remoteUserId: params.remoteUserId,
-		selfUserId: params.selfUserId
-	})).strict;
-}
-//#endregion
-//#region extensions/matrix/src/matrix/direct-management.ts
-var direct_management_exports = /* @__PURE__ */ __exportAll({
-	inspectMatrixDirectRooms: () => inspectMatrixDirectRooms,
-	persistMatrixDirectRoomMapping: () => persistMatrixDirectRoomMapping,
-	promoteMatrixDirectRoomCandidate: () => promoteMatrixDirectRoomCandidate,
-	repairMatrixDirectRooms: () => repairMatrixDirectRooms
-});
-const DIRECT_ACCOUNT_DATA_QUEUE_KEY = EventType.Direct;
-const directAccountDataWriteQueues = /* @__PURE__ */ new WeakMap();
-async function readMatrixDirectAccountData(client) {
-	try {
-		const direct = await client.getAccountData(EventType.Direct);
-		return direct && typeof direct === "object" && !Array.isArray(direct) ? direct : {};
-	} catch {
-		return {};
-	}
-}
-function normalizeRemoteUserId(remoteUserId) {
-	const normalized = normalizeOptionalString(remoteUserId) ?? "";
-	if (!isMatrixQualifiedUserId(normalized)) throw new Error(`Matrix user IDs must be fully qualified (got "${remoteUserId}")`);
-	return normalized;
-}
-function normalizeMappedRoomIds(direct, remoteUserId) {
-	const current = direct[remoteUserId];
-	if (!Array.isArray(current)) return [];
-	const seen = /* @__PURE__ */ new Set();
-	const normalized = [];
-	for (const value of current) {
-		const roomId = normalizeOptionalString(value) ?? "";
-		if (!roomId || seen.has(roomId)) continue;
-		seen.add(roomId);
-		normalized.push(roomId);
-	}
-	return normalized;
-}
-function normalizeRoomIdList(values) {
-	const seen = /* @__PURE__ */ new Set();
-	const normalized = [];
-	for (const value of values) {
-		const roomId = value.trim();
-		if (!roomId || seen.has(roomId)) continue;
-		seen.add(roomId);
-		normalized.push(roomId);
-	}
-	return normalized;
-}
-function hasMatrixDirectRoomMappings(params) {
-	const current = normalizeMappedRoomIds(params.directContent, params.remoteUserId);
-	const next = normalizeRoomIdList([...params.roomIds, ...current]);
-	return current.length === next.length && current.every((roomId, index) => roomId === next[index]);
-}
-function resolveDirectAccountDataWriteQueue(client) {
-	const existing = directAccountDataWriteQueues.get(client);
-	if (existing) return existing;
-	const created = new KeyedAsyncQueue();
-	directAccountDataWriteQueues.set(client, created);
-	return created;
-}
-async function writeMatrixDirectRoomMappings(params) {
-	return await resolveDirectAccountDataWriteQueue(params.client).enqueue(DIRECT_ACCOUNT_DATA_QUEUE_KEY, async () => {
-		const directContentBefore = await readMatrixDirectAccountData(params.client);
-		const directContentAfter = buildNextDirectContent({
-			directContent: directContentBefore,
-			remoteUserId: params.remoteUserId,
-			roomIds: params.roomIds
-		});
-		const changed = !hasMatrixDirectRoomMappings({
-			directContent: directContentBefore,
-			remoteUserId: params.remoteUserId,
-			roomIds: params.roomIds
-		});
-		if (changed) await params.client.setAccountData(EventType.Direct, directContentAfter);
-		return {
-			changed,
-			directContentBefore,
-			directContentAfter
-		};
-	});
-}
-async function classifyDirectRoomCandidate(params) {
-	const evidence = await inspectMatrixDirectRoomEvidence({
-		client: params.client,
-		roomId: params.roomId,
-		remoteUserId: params.remoteUserId,
-		selfUserId: params.selfUserId
-	});
-	return {
-		roomId: params.roomId,
-		joinedMembers: evidence.joinedMembers,
-		strict: evidence.strict && (params.source === "account-data" || evidence.memberStateFlag !== false),
-		explicit: evidence.strict && (params.source === "account-data" || evidence.memberStateFlag !== false) && (params.source === "account-data" || evidence.viaMemberState),
-		source: params.source
-	};
-}
-function buildNextDirectContent(params) {
-	const current = normalizeMappedRoomIds(params.directContent, params.remoteUserId);
-	const nextRooms = normalizeRoomIdList([...params.roomIds, ...current]);
-	return {
-		...params.directContent,
-		[params.remoteUserId]: nextRooms
-	};
-}
-async function persistMatrixDirectRoomMapping(params) {
-	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
-	return (await writeMatrixDirectRoomMappings({
-		client: params.client,
-		remoteUserId,
-		roomIds: [params.roomId]
-	})).changed;
-}
-async function promoteMatrixDirectRoomCandidate(params) {
-	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
-	const evidence = await inspectMatrixDirectRoomEvidence({
-		client: params.client,
-		roomId: params.roomId,
-		remoteUserId,
-		selfUserId: params.selfUserId
-	});
-	if (!evidence.strict) return {
-		classifyAsDirect: false,
-		repaired: false,
-		reason: "not-strict"
-	};
-	if (evidence.memberStateFlag === false) return {
-		classifyAsDirect: false,
-		repaired: false,
-		reason: "local-explicit-false"
-	};
-	try {
-		const repaired = await persistMatrixDirectRoomMapping({
-			client: params.client,
-			remoteUserId,
-			roomId: params.roomId
-		});
-		return {
-			classifyAsDirect: true,
-			repaired,
-			roomId: params.roomId,
-			reason: repaired ? "promoted" : "already-mapped"
-		};
-	} catch {
-		return {
-			classifyAsDirect: true,
-			repaired: false,
-			roomId: params.roomId,
-			reason: "repair-failed"
-		};
-	}
-}
-async function inspectMatrixDirectRooms(params) {
-	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
-	const selfUserId = normalizeOptionalString(await params.client.getUserId().catch(() => null)) ?? null;
-	const mappedRoomIds = normalizeMappedRoomIds(await readMatrixDirectAccountData(params.client), remoteUserId);
-	const mappedRooms = await Promise.all(mappedRoomIds.map(async (roomId) => await classifyDirectRoomCandidate({
-		client: params.client,
-		roomId,
-		remoteUserId,
-		selfUserId,
-		source: "account-data"
-	})));
-	const mappedStrict = mappedRooms.find((room) => room.strict);
-	let joinedRooms = [];
-	if (typeof params.client.getJoinedRooms === "function") try {
-		const resolved = await params.client.getJoinedRooms();
-		joinedRooms = Array.isArray(resolved) ? resolved : [];
-	} catch {
-		joinedRooms = [];
-	}
-	const discoveredStrictRooms = [];
-	for (const roomId of normalizeRoomIdList(joinedRooms)) {
-		if (mappedRoomIds.includes(roomId)) continue;
-		const candidate = await classifyDirectRoomCandidate({
-			client: params.client,
-			roomId,
-			remoteUserId,
-			selfUserId,
-			source: "joined"
-		});
-		if (candidate.strict) discoveredStrictRooms.push(candidate);
-	}
-	const discoveredStrictRoomIds = discoveredStrictRooms.map((room) => room.roomId);
-	const discoveredExplicit = discoveredStrictRooms.find((room) => room.explicit);
-	return {
-		selfUserId,
-		remoteUserId,
-		mappedRoomIds,
-		mappedRooms,
-		discoveredStrictRoomIds,
-		activeRoomId: mappedStrict?.roomId ?? discoveredExplicit?.roomId ?? discoveredStrictRoomIds[0] ?? null
-	};
-}
-async function repairMatrixDirectRooms(params) {
-	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
-	const inspected = await inspectMatrixDirectRooms({
-		client: params.client,
-		remoteUserId
-	});
-	const activeRoomId = inspected.activeRoomId ?? await params.client.createDirectRoom(remoteUserId, { encrypted: params.encrypted === true });
-	const createdRoomId = inspected.activeRoomId ? null : activeRoomId;
-	const mappingWrite = await writeMatrixDirectRoomMappings({
-		client: params.client,
-		remoteUserId,
-		roomIds: [activeRoomId, ...inspected.discoveredStrictRoomIds]
-	});
-	return {
-		...inspected,
-		activeRoomId,
-		createdRoomId,
-		changed: mappingWrite.changed,
-		directContentBefore: mappingWrite.directContentBefore,
-		directContentAfter: mappingWrite.directContentAfter
-	};
-}
-//#endregion
-export { MsgType as _, repairMatrixDirectRooms as a, isStrictDirectMembership as c, buildMatrixMessageRelation as d, resolveMatrixReplyToEventId as f, MSC4357_LIVE_KEY as g, MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY as h, promoteMatrixDirectRoomCandidate as i, isStrictDirectRoom as l, EventType as m, inspectMatrixDirectRooms as n, direct_room_exports as o, resolveMatrixThreadRootId as p, persistMatrixDirectRoomMapping as r, hasDirectMatrixMemberFlag as s, direct_management_exports as t, readJoinedMatrixMembers as u, RelationType as v };