@openclaw/matrix 2026.9.6 → 2026.9.7

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

@@ -0,0 +1,49 @@
+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/doctor-contract-De6geW0h.mjs

@@ -0,0 +1,350 @@
+import "node:module";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Returns a non-array record or null. */
+function asNullableRecord$1(value) {
+	return isRecord$1(value) ? value : null;
+}
+//#endregion
+//#region src/config/channel-config-normalization.ts
+/** Applies one channel-specific doctor migration to every object-shaped account. */
+function normalizeChannelAccounts(params) {
+	const rawAccounts = asNullableRecord$1(params.entry.accounts);
+	if (!rawAccounts) return {
+		entry: params.entry,
+		changed: false
+	};
+	let changed = false;
+	const accounts = { ...rawAccounts };
+	for (const [accountId, value] of Object.entries(rawAccounts)) {
+		const account = asNullableRecord$1(value);
+		if (!account) continue;
+		const normalized = params.normalizeAccount({
+			account,
+			accountId,
+			pathPrefix: `${params.pathPrefix}.accounts.${accountId}`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			accounts[accountId] = normalized.entry;
+			changed = true;
+		}
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			accounts
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
+}
+/** Applies the same channel-specific doctor migration at root and account scope. */
+function normalizeChannelConfigEntries$1(params) {
+	const changes = params.changes ?? [];
+	const channels = params.cfg.channels;
+	const entry = asNullableRecord$1(channels?.[params.channelId]);
+	if (!entry) return {
+		config: params.cfg,
+		changes
+	};
+	const channelPath = `channels.${params.channelId}`;
+	const root = params.normalizeEntry({
+		entry,
+		pathPrefix: channelPath,
+		changes
+	});
+	const accounts = normalizeChannelAccounts({
+		entry: root.entry,
+		pathPrefix: channelPath,
+		changes,
+		normalizeAccount: (accountParams) => params.normalizeEntry({
+			entry: accountParams.account,
+			accountId: accountParams.accountId,
+			pathPrefix: accountParams.pathPrefix,
+			changes: accountParams.changes
+		})
+	});
+	if (!root.changed && !accounts.changed) return {
+		config: params.cfg,
+		changes
+	};
+	return {
+		config: {
+			...params.cfg,
+			channels: {
+				...channels,
+				[params.channelId]: accounts.entry
+			}
+		},
+		changes
+	};
+}
+//#endregion
+//#region src/plugin-sdk/legacy-webhook-listener-migration.ts
+/** Preserve explicitly configured webhook listeners while moving ingress onto Gateway routes. */
+function createLegacyWebhookListenerDoctorContract(params) {
+	const portKey = params.portKey ?? "webhookPort";
+	const hostKey = params.hostKey === void 0 ? "webhookHost" : params.hostKey;
+	const source = (entry) => params.webhookKey ? asNullableRecord$1(entry[params.webhookKey]) : entry;
+	const hasLegacy = (value) => {
+		const entry = asNullableRecord$1(value);
+		const listener = entry && source(entry);
+		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
+	};
+	const prefix = `channels.${params.channelKey}`;
+	return {
+		legacyConfigRules: [{
+			path: ["channels", params.channelKey],
+			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
+			match: (value) => {
+				const accounts = asNullableRecord$1(asNullableRecord$1(value)?.accounts);
+				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
+			}
+		}],
+		normalizeCompatibilityConfig: ({ cfg }) => {
+			const root = asNullableRecord$1(asNullableRecord$1(cfg.channels)?.[params.channelKey]);
+			const inherited = root && source(root);
+			const canonicalRoot = asNullableRecord$1(root?.legacyWebhook);
+			return normalizeChannelConfigEntries$1({
+				cfg,
+				channelId: params.channelKey,
+				normalizeEntry: ({ entry, accountId, pathPrefix, changes }) => {
+					const listener = source(entry);
+					if (!listener || !hasLegacy(entry)) return {
+						entry,
+						changed: false
+					};
+					const next = { ...entry };
+					const port = Object.hasOwn(listener, portKey) ? listener[portKey] : (accountId ? canonicalRoot?.port ?? inherited?.[portKey] : void 0) ?? params.defaultPort;
+					const inheritedHost = accountId ? canonicalRoot ? canonicalRoot.host : (hostKey ? inherited?.[hostKey] : void 0) ?? params.defaultHost : params.defaultHost;
+					const host = hostKey ? listener[hostKey] ?? inheritedHost : inheritedHost;
+					const legacyPath = [pathPrefix, params.webhookKey].filter(Boolean).join(".");
+					if (Object.hasOwn(entry, "legacyWebhook")) changes.push(`Removed ${legacyPath} legacy listener keys; ${pathPrefix}.legacyWebhook is already configured.`);
+					else if (accountId && root?.legacyWebhook === false) changes.push(`Removed ${legacyPath} legacy listener keys; ${prefix}.legacyWebhook: false keeps this account's inherited listener disabled.`);
+					else {
+						next.legacyWebhook = {
+							port,
+							...host !== void 0 ? { host } : {}
+						};
+						changes.push(`Moved ${legacyPath} listener settings to ${pathPrefix}.legacyWebhook. Point the external callback or reverse proxy at the Gateway port and webhook path, verify delivery, then set legacyWebhook: false to disable legacy forwarding.`);
+					}
+					const updated = params.webhookKey ? { ...listener } : next;
+					delete updated[portKey];
+					if (hostKey) delete updated[hostKey];
+					if (params.webhookKey) {
+						if (Object.keys(updated).length) next[params.webhookKey] = updated;
+						else delete next[params.webhookKey];
+					}
+					return {
+						entry: next,
+						changed: true
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/runtime-doctor-migrations
+var runtime_doctor_migrations_exports = /* @__PURE__ */ __exportAll({ createLegacyWebhookListenerDoctorContract: () => createLegacyWebhookListenerDoctorContract });
+import * as import_openclaw_plugin_sdk_runtime_doctor_migrations from "openclaw/plugin-sdk/runtime-doctor-migrations";
+__reExport(runtime_doctor_migrations_exports, import_openclaw_plugin_sdk_runtime_doctor_migrations);
+//#endregion
+//#region extensions/matrix/src/doctor-contract.ts
+function parseMatrixStreamingMode(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim().toLowerCase();
+	return normalized === "partial" || normalized === "quiet" || normalized === "progress" || normalized === "off" ? normalized : null;
+}
+const streamingAliasMigration = (0, runtime_doctor_migrations_exports.defineChannelAliasMigration)({
+	channelId: "matrix",
+	streaming: {
+		defaultMode: "off",
+		resolveMode: (entry) => {
+			const streaming = isRecord(entry.streaming) ? entry.streaming : null;
+			const parsed = parseMatrixStreamingMode(streaming ? streaming.mode : entry.streaming);
+			if (parsed) return parsed;
+			return entry.streaming === true ? "partial" : "off";
+		}
+	},
+	accountStreamingReplacesRoot: true
+});
+const roomAllowMigration = (0, runtime_doctor_migrations_exports.defineKeyMoveMigration)({
+	scope: ["*"],
+	from: ["allow"],
+	to: ["enabled"],
+	sourceOwn: false,
+	match: (value) => typeof value === "boolean",
+	targetIsSet: (value) => typeof value === "boolean",
+	movedMessage: ({ sourcePath, targetPath, mappedValue }) => `Moved ${sourcePath} → ${targetPath} (${String(mappedValue)}).`,
+	existingMessage: ({ sourcePath, targetPath, targetValue }) => `Moved ${sourcePath} → ${targetPath} (${String(targetValue)}).`
+});
+function hasLegacyTrustedDmPolicy(value) {
+	const root = isRecord(value) ? value : null;
+	if (!root) return false;
+	return (isRecord(root.dm) ? root.dm : null)?.policy === "trusted";
+}
+function migrateLegacyTrustedDmPolicy(params) {
+	const dm = isRecord(params.entry.dm) ? params.entry.dm : null;
+	if (!dm || dm.policy !== "trusted") return {
+		entry: params.entry,
+		changed: false
+	};
+	const allowFromRaw = dm.allowFrom;
+	const allowFromEntries = Array.isArray(allowFromRaw) ? allowFromRaw.filter((entry) => typeof entry === "string" && entry.trim().length > 0).length : 0;
+	const nextPolicy = allowFromEntries > 0 ? "allowlist" : "pairing";
+	const nextDm = {
+		...dm,
+		policy: nextPolicy
+	};
+	params.changes.push(`Migrated ${params.pathPrefix}.dm.policy "trusted" → "${nextPolicy}" (legacy alias removed; ${allowFromEntries > 0 ? `preserved ${allowFromEntries} ${params.pathPrefix}.dm.allowFrom ${allowFromEntries === 1 ? "entry" : "entries"}` : "no allowFrom entries present, defaulting to pairing for safety"}).`);
+	return {
+		entry: {
+			...params.entry,
+			dm: nextDm
+		},
+		changed: true
+	};
+}
+const legacyConfigRules = [
+	...streamingAliasMigration.legacyConfigRules,
+	{
+		path: ["channels", "matrix"],
+		message: "channels.matrix.allowPrivateNetwork is legacy; use channels.matrix.network.dangerouslyAllowPrivateNetwork instead. Run \"openclaw doctor --fix\".",
+		match: (value) => (0, runtime_doctor_migrations_exports.hasLegacyFlatAllowPrivateNetworkAlias)(isRecord(value) ? value : {})
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.allowPrivateNetwork is legacy; use channels.matrix.accounts.<id>.network.dangerouslyAllowPrivateNetwork instead. Run \"openclaw doctor --fix\".",
+		match: (value) => (0, runtime_doctor_migrations_exports.hasLegacyAccountStreamingAliases)(value, (account) => (0, runtime_doctor_migrations_exports.hasLegacyFlatAllowPrivateNetworkAlias)(isRecord(account) ? account : {}))
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"groups"
+		],
+		message: "channels.matrix.groups.<room>.allow is legacy; use channels.matrix.groups.<room>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: roomAllowMigration.hasLegacy
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"rooms"
+		],
+		message: "channels.matrix.rooms.<room>.allow is legacy; use channels.matrix.rooms.<room>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: roomAllowMigration.hasLegacy
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.{groups,rooms}.<room>.allow is legacy; use channels.matrix.accounts.<id>.{groups,rooms}.<room>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: (value) => (0, runtime_doctor_migrations_exports.hasLegacyAccountStreamingAliases)(value, (account) => {
+			if (!isRecord(account)) return false;
+			return roomAllowMigration.hasLegacy(account.groups) || roomAllowMigration.hasLegacy(account.rooms);
+		})
+	},
+	{
+		path: ["channels", "matrix"],
+		message: "channels.matrix.dm.policy \"trusted\" is legacy; use \"allowlist\" (with allowFrom entries) or \"pairing\" instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyTrustedDmPolicy
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.dm.policy \"trusted\" is legacy; use \"allowlist\" (with allowFrom entries) or \"pairing\" instead. Run \"openclaw doctor --fix\".",
+		match: (value) => (0, runtime_doctor_migrations_exports.hasLegacyAccountStreamingAliases)(value, hasLegacyTrustedDmPolicy)
+	}
+];
+function normalizeMatrixEntry(params) {
+	const network = (0, runtime_doctor_migrations_exports.migrateLegacyFlatAllowPrivateNetworkAlias)(params);
+	const dmPolicy = migrateLegacyTrustedDmPolicy({
+		...params,
+		entry: network.entry
+	});
+	let entry = dmPolicy.entry;
+	let changed = network.changed || dmPolicy.changed;
+	for (const section of ["groups", "rooms"]) {
+		const roomMap = isRecord(entry[section]) ? entry[section] : null;
+		if (!roomMap) continue;
+		const normalized = roomAllowMigration.normalize({
+			entry: roomMap,
+			pathPrefix: `${params.pathPrefix}.${section}`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			entry = Object.assign({}, entry, { [section]: normalized.entry });
+			changed = true;
+		}
+	}
+	return {
+		entry,
+		changed
+	};
+}
+function normalizeCompatibilityConfig({ cfg }) {
+	const changes = [];
+	const withoutJunkStreamMode = (0, runtime_doctor_migrations_exports.stripRetiredChannelKeys)({
+		cfg,
+		channelId: "matrix",
+		keys: /* @__PURE__ */ new Set(["streamMode"]),
+		scope: "root-and-accounts",
+		onRemove: ({ key, pathPrefix }) => changes.push(`Removed ${pathPrefix}.${key} (never read by the Matrix runtime).`)
+	}).config;
+	const aliases = streamingAliasMigration.normalizeChannelConfig({
+		cfg: withoutJunkStreamMode,
+		changes
+	});
+	return (0, runtime_doctor_migrations_exports.normalizeChannelConfigEntries)({
+		cfg: aliases.config,
+		channelId: "matrix",
+		changes,
+		normalizeEntry: normalizeMatrixEntry
+	});
+}
+//#endregion
+export { __exportAll as i, normalizeCompatibilityConfig as n, runtime_doctor_migrations_exports as r, legacyConfigRules as t };

package/dist/.setup/draft-stream-CdVMstpR.mjs

@@ -0,0 +1,157 @@
+import { _ as MsgType } from "./direct-management-Cn2t8n1V.mjs";
+import { a as sendSingleTextMessageMatrix, m as prepareMatrixSingleText, t as editMessageMatrix } from "./send-GOF64QRc.mjs";
+import { createFinalizableDraftLifecycle } from "openclaw/plugin-sdk/channel-outbound";
+//#region extensions/matrix/src/matrix/draft-stream.ts
+const DEFAULT_THROTTLE_MS = 1e3;
+function createMatrixDraftStream(params) {
+	const { roomId, client, cfg, threadId, accountId, log } = params;
+	const useLive = params.mode !== "quiet";
+	const previewOptions = {
+		client,
+		cfg,
+		threadId,
+		accountId,
+		msgtype: useLive ? MsgType.Text : MsgType.Notice,
+		includeMentions: false
+	};
+	let currentEventId;
+	let lastSentText = "";
+	let lastSentContent = "";
+	const streamState = {
+		stopped: false,
+		final: false
+	};
+	let sendFailed = false;
+	let finalizeInPlaceBlocked = false;
+	let liveFinalized = false;
+	let replyToId = params.replyToId;
+	const sendOrEdit = async (text) => {
+		const trimmed = text.trimEnd();
+		if (!trimmed.trim()) return false;
+		const preparedText = prepareMatrixSingleText(trimmed, {
+			cfg,
+			accountId,
+			preserveWhitespace: true
+		});
+		if (!preparedText.fitsInSingleEvent) {
+			finalizeInPlaceBlocked = true;
+			if (!currentEventId) sendFailed = true;
+			streamState.stopped = true;
+			log?.(`draft-stream: preview exceeded single-event limit (${preparedText.convertedText.length} > ${preparedText.singleEventLimit})`);
+			return false;
+		}
+		if (sendFailed) return false;
+		if (preparedText.trimmedText === lastSentText) return true;
+		try {
+			if (!currentEventId) {
+				currentEventId = (await sendSingleTextMessageMatrix(roomId, preparedText.trimmedText, {
+					...previewOptions,
+					replyToId,
+					live: useLive
+				})).messageId;
+				lastSentText = preparedText.trimmedText;
+				lastSentContent = preparedText.convertedText;
+				log?.(`draft-stream: created message ${currentEventId}${useLive ? " (MSC4357 live)" : ""}`);
+			} else {
+				await editMessageMatrix(roomId, currentEventId, preparedText.trimmedText, {
+					...previewOptions,
+					live: useLive
+				});
+				lastSentText = preparedText.trimmedText;
+				lastSentContent = preparedText.convertedText;
+			}
+			return true;
+		} catch (err) {
+			log?.(`draft-stream: send/edit failed: ${String(err)}`);
+			if (err instanceof Error && err.message.startsWith("Matrix single-message text exceeds limit")) finalizeInPlaceBlocked = true;
+			if (!currentEventId) sendFailed = true;
+			streamState.stopped = true;
+			return false;
+		}
+	};
+	const { loop, update, stop: stopDraft, discardPending, seal, clear, retire, cleanupPending } = createFinalizableDraftLifecycle({
+		throttleMs: DEFAULT_THROTTLE_MS,
+		state: streamState,
+		sendOrEditStreamMessage: sendOrEdit,
+		readMessageId: () => currentEventId,
+		clearMessageId: () => {
+			currentEventId = void 0;
+			lastSentText = "";
+			lastSentContent = "";
+		},
+		isValidMessageId: (id) => typeof id === "string" && id.length > 0,
+		deleteMessage: async (id) => {
+			await client.redactEvent(roomId, id);
+		},
+		warn: log,
+		warnPrefix: "matrix draft preview cleanup failed"
+	});
+	log?.(`draft-stream: ready (throttleMs=${DEFAULT_THROTTLE_MS})`);
+	const finalizeLive = async () => {
+		if (useLive && !liveFinalized && currentEventId && lastSentText) {
+			liveFinalized = true;
+			try {
+				await editMessageMatrix(roomId, currentEventId, lastSentText, {
+					...previewOptions,
+					live: false
+				});
+				log?.(`draft-stream: finalized ${currentEventId} (MSC4357 stream ended)`);
+				return true;
+			} catch (err) {
+				log?.(`draft-stream: finalize edit failed: ${String(err)}`);
+				finalizeInPlaceBlocked = true;
+				return false;
+			}
+		}
+		return true;
+	};
+	const stop = async () => {
+		await stopDraft();
+		return currentEventId;
+	};
+	const resetCurrentMessage = () => {
+		currentEventId = void 0;
+		lastSentText = "";
+		lastSentContent = "";
+		sendFailed = false;
+		finalizeInPlaceBlocked = false;
+		liveFinalized = false;
+		loop.resetPending();
+		loop.resetThrottleWindow();
+	};
+	const reset = () => {
+		replyToId = params.preserveReplyId ? params.replyToId : void 0;
+		streamState.stopped = false;
+		streamState.final = false;
+		resetCurrentMessage();
+	};
+	const deleteCurrentMessage = async () => {
+		loop.resetPending();
+		await loop.waitForInFlight();
+		const retiredEventId = currentEventId;
+		resetCurrentMessage();
+		if (retiredEventId) await retire(retiredEventId);
+	};
+	return {
+		update,
+		flush: loop.flush,
+		stop,
+		discardPending,
+		seal,
+		clear,
+		cleanupPending,
+		deleteCurrentMessage,
+		finalizeLive,
+		reset,
+		eventId: () => currentEventId,
+		content: () => lastSentContent || void 0,
+		matchesPreparedText: (text) => prepareMatrixSingleText(text.trimEnd(), {
+			cfg,
+			accountId,
+			preserveWhitespace: true
+		}).trimmedText === lastSentText,
+		mustDeliverFinalNormally: () => sendFailed || finalizeInPlaceBlocked
+	};
+}
+//#endregion
+export { createMatrixDraftStream };

package/dist/.setup/encryption-guidance-B6797jNA.mjs

@@ -0,0 +1,16 @@
+import { s as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-B7axQ80R.mjs";
+import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
+import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/encryption-guidance.ts
+function resolveMatrixEncryptionConfigPath(cfg, accountId) {
+	const effectiveAccountId = normalizeOptionalAccountId(accountId) ?? resolveMatrixDefaultOrOnlyAccountId(cfg);
+	return resolveMatrixConfigFieldPath(cfg, effectiveAccountId, "encryption");
+}
+function formatMatrixEncryptionUnavailableError(cfg, accountId) {
+	return `Matrix encryption is not available (enable ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true)`;
+}
+function formatMatrixEncryptedEventDisabledWarning(cfg, accountId) {
+	return `matrix: encrypted event received without encryption enabled; set ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true and verify the device to decrypt`;
+}
+//#endregion
+export { formatMatrixEncryptionUnavailableError as n, formatMatrixEncryptedEventDisabledWarning as t };