@openclaw/matrix 2026.3.12 → 2026.5.9-beta.1

package/dist/deps-C6WqKY7m.js

@@ -0,0 +1,235 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+//#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;
+function resolveMissingMatrixPackages() {
+	try {
+		const req = createRequire(import.meta.url);
+		return REQUIRED_MATRIX_PACKAGES.filter((pkg) => {
+			try {
+				req.resolve(pkg);
+				return false;
+			} catch {
+				return true;
+			}
+		});
+	} catch {
+		return [...REQUIRED_MATRIX_PACKAGES];
+	}
+}
+function isMatrixSdkAvailable() {
+	return resolveMissingMatrixPackages().length === 0;
+}
+function resolvePluginRoot() {
+	const currentDir = path.dirname(fileURLToPath(import.meta.url));
+	return path.resolve(currentDir, "..", "..");
+}
+let defaultMatrixCryptoRuntimeEnsurePromise = null;
+async function runFixedCommandWithTimeout(params) {
+	return await new Promise((resolve) => {
+		const [command, ...args] = params.argv;
+		if (!command) {
+			resolve({
+				code: 1,
+				stdout: "",
+				stderr: "command is required"
+			});
+			return;
+		}
+		const proc = spawn(command, args, {
+			cwd: params.cwd,
+			env: {
+				...process.env,
+				...params.env
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+		let timer = null;
+		const killChildOnExit = () => {
+			if (!settled && proc.exitCode === null) proc.kill("SIGTERM");
+		};
+		const finalize = (result) => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			process.off("exit", killChildOnExit);
+			resolve(result);
+		};
+		process.once("exit", killChildOnExit);
+		proc.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		proc.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		timer = setTimeout(() => {
+			proc.kill("SIGKILL");
+			finalize({
+				code: 124,
+				stdout,
+				stderr: stderr || `command timed out after ${params.timeoutMs}ms`
+			});
+		}, params.timeoutMs);
+		proc.on("error", (err) => {
+			finalize({
+				code: 1,
+				stdout,
+				stderr: err.message
+			});
+		});
+		proc.on("close", (code) => {
+			finalize({
+				code: code ?? 1,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+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.runCommand && !params.resolveFn && !params.nodeExecutable;
+	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 (params.runCommand ?? runFixedCommandWithTimeout)({
+		argv: [params.nodeExecutable ?? 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) {
+	if (isMatrixSdkAvailable()) return;
+	const confirm = params.confirm;
+	if (confirm) {
+		if (!await confirm("Matrix requires matrix-js-sdk, @matrix-org/matrix-sdk-crypto-nodejs, and @matrix-org/matrix-sdk-crypto-wasm. Install now?")) throw new Error("Matrix requires matrix-js-sdk, @matrix-org/matrix-sdk-crypto-nodejs, and @matrix-org/matrix-sdk-crypto-wasm (install dependencies first).");
+	}
+	const root = resolvePluginRoot();
+	const command = fs.existsSync(path.join(root, "pnpm-lock.yaml")) ? ["pnpm", "install"] : [
+		"npm",
+		"install",
+		"--omit=dev",
+		"--silent"
+	];
+	params.runtime.log?.(`matrix: installing dependencies via ${command[0]} (${root})…`);
+	const result = await runFixedCommandWithTimeout({
+		argv: command,
+		cwd: root,
+		timeoutMs: 3e5,
+		env: { COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" }
+	});
+	if (result.code !== 0) throw new Error(result.stderr.trim() || result.stdout.trim() || "Matrix dependency install failed.");
+	if (!isMatrixSdkAvailable()) {
+		const missing = resolveMissingMatrixPackages();
+		throw new Error(missing.length > 0 ? `Matrix dependency install completed but required packages are still missing: ${missing.join(", ")}` : "Matrix dependency install completed but Matrix dependencies are still missing.");
+	}
+}
+//#endregion
+export { ensureMatrixSdkInstalled as n, isMatrixSdkAvailable as r, ensureMatrixCryptoRuntime as t };

package/dist/device-health-UVYpbA_W.js

@@ -0,0 +1,16 @@
+//#region extensions/matrix/src/matrix/device-health.ts
+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, summarizeMatrixDeviceHealth };

package/dist/direct-management-DMMMgtTB.js

@@ -0,0 +1,249 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { t as isMatrixQualifiedUserId } from "./target-ids-80nQ2gql.js";
+import { n as MATRIX_REACTION_EVENT_TYPE, t as MATRIX_ANNOTATION_RELATION_TYPE } from "./reaction-common-ejrL19w-.js";
+import { r as inspectMatrixDirectRoomEvidence } from "./direct-room-XkutHjES.js";
+import { 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/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 hasPrimaryMatrixDirectRoomMapping(params) {
+	return normalizeMappedRoomIds(params.directContent, params.remoteUserId)[0] === params.roomId;
+}
+function resolveDirectAccountDataWriteQueue(client) {
+	const existing = directAccountDataWriteQueues.get(client);
+	if (existing) return existing;
+	const created = new KeyedAsyncQueue();
+	directAccountDataWriteQueues.set(client, created);
+	return created;
+}
+async function writeMatrixDirectRoomMapping(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,
+			roomId: params.roomId
+		});
+		const changed = !hasPrimaryMatrixDirectRoomMapping({
+			directContent: directContentBefore,
+			remoteUserId: params.remoteUserId,
+			roomId: params.roomId
+		});
+		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.roomId, ...current]);
+	return {
+		...params.directContent,
+		[params.remoteUserId]: nextRooms
+	};
+}
+async function persistMatrixDirectRoomMapping(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	return (await writeMatrixDirectRoomMapping({
+		client: params.client,
+		remoteUserId,
+		roomId: 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 (!mappedStrict && 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 writeMatrixDirectRoomMapping({
+		client: params.client,
+		remoteUserId,
+		roomId: activeRoomId
+	});
+	return {
+		...inspected,
+		activeRoomId,
+		createdRoomId,
+		changed: mappingWrite.changed,
+		directContentBefore: mappingWrite.directContentBefore,
+		directContentAfter: mappingWrite.directContentAfter
+	};
+}
+//#endregion
+export { repairMatrixDirectRooms as a, MSC4357_LIVE_KEY as c, promoteMatrixDirectRoomCandidate as i, MsgType as l, inspectMatrixDirectRooms as n, EventType as o, persistMatrixDirectRoomMapping as r, MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY as s, direct_management_exports as t, RelationType as u };

package/dist/direct-room-XkutHjES.js

@@ -0,0 +1,76 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+//#region extensions/matrix/src/matrix/direct-room.ts
+var direct_room_exports = /* @__PURE__ */ __exportAll({
+	hasDirectMatrixMemberFlag: () => hasDirectMatrixMemberFlag,
+	inspectMatrixDirectRoomEvidence: () => inspectMatrixDirectRoomEvidence,
+	isStrictDirectMembership: () => isStrictDirectMembership,
+	isStrictDirectRoom: () => isStrictDirectRoom,
+	normalizeJoinedMatrixMembers: () => normalizeJoinedMatrixMembers,
+	readJoinedMatrixMembers: () => readJoinedMatrixMembers
+});
+function trimMaybeString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeJoinedMatrixMembers(joinedMembers) {
+	if (!Array.isArray(joinedMembers)) return [];
+	return joinedMembers.map((entry) => trimMaybeString(entry)).filter((entry) => Boolean(entry));
+}
+function isStrictDirectMembership(params) {
+	const selfUserId = trimMaybeString(params.selfUserId);
+	const remoteUserId = trimMaybeString(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 = trimMaybeString(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 ? trimMaybeString(params.selfUserId) : trimMaybeString(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
+export { isStrictDirectRoom as a, isStrictDirectMembership as i, hasDirectMatrixMemberFlag as n, readJoinedMatrixMembers as o, inspectMatrixDirectRoomEvidence as r, direct_room_exports as t };