@openclaw/matrix 2026.7.2-beta.4 → 2026.7.2-beta.5

package/dist/{send-CZCmDQu8.js → send-C9Ssx-iV.js}

@@ -5,13 +5,14 @@ import { r as normalizeMatrixResolvableTarget, t as isMatrixQualifiedUserId } fr
 import { n as MATRIX_REACTION_EVENT_TYPE, r as buildMatrixReactionContent, t as MATRIX_ANNOTATION_RELATION_TYPE } from "./reaction-common-DkrQdBSZ.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeNullableString, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { FormatCapabilityProfile, convertMarkdownTables, findCodeRegions, isInsideCode, markdownToIR, renderMarkdownWithMarkers, tokenizeHtmlTags } from "openclaw/plugin-sdk/text-chunking";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
 import { normalizePollInput } from "openclaw/plugin-sdk/poll-runtime";
-import { isVoiceMessageCompatibleAudio } from "openclaw/plugin-sdk/media-runtime";
 import MarkdownIt from "markdown-it";
 import { isAutoLinkedFileRef } from "openclaw/plugin-sdk/text-autolink-runtime";
+import { isVoiceMessageCompatibleAudio } from "openclaw/plugin-sdk/media-runtime";
 import { parseBuffer } from "music-metadata";
 import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 //#region extensions/matrix/src/matrix/poll-types.ts
@@ -228,36 +229,252 @@ function buildPollResponseContent(pollEventId, answerIds) {
 	};
 }
 //#endregion
-//#region extensions/matrix/src/matrix/send/client.ts
-const loadMatrixSendClientRuntime = createLazyRuntimeModule(() => import("./client-bootstrap-ZAaO9fZ-.js").then((n) => n.t));
-function resolveMediaMaxBytes(accountId, cfg) {
-	if (!cfg) throw new Error("Matrix media limits requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
-	const matrixCfg = resolveMatrixAccountConfig({
-		cfg: requireRuntimeConfig(cfg, "Matrix media limits"),
-		accountId
-	});
-	const mediaMaxMb = typeof matrixCfg.mediaMaxMb === "number" ? matrixCfg.mediaMaxMb : void 0;
-	if (typeof mediaMaxMb === "number") return mediaMaxMb * 1024 * 1024;
+//#region extensions/matrix/src/matrix/format-profile.ts
+function createMatrixPrivateMarkers(markdown, exhaustedMessage) {
+	const used = new Set(Array.from(markdown, (character) => character.charCodeAt(0)));
+	for (const match of markdown.matchAll(/&#(?:x([0-9a-f]+)|(\d+));/giu)) {
+		const radix = match[1] ? 16 : 10;
+		const value = Number.parseInt(match[1] ?? match[2] ?? "", radix);
+		if (Number.isFinite(value) && value <= 65535) used.add(value);
+	}
+	const markers = [];
+	for (let code = 57344; code <= 63743 && markers.length < 3; code += 1) if (!used.has(code)) markers.push(String.fromCharCode(code));
+	if (markers.length < 3) throw new Error(exhaustedMessage);
+	return {
+		open: markers[0] ?? "",
+		close: markers[1] ?? "",
+		padding: markers[2] ?? ""
+	};
 }
-async function withResolvedMatrixSendClient(opts, run) {
-	return await withResolvedMatrixClient({
-		...opts,
-		readiness: "started"
-	}, run, "persist");
+const MATRIX_FORMAT_PROFILE = FormatCapabilityProfile.define({
+	mechanism: "html",
+	constructs: {
+		taskList: "fallback",
+		image: "fallback"
+	},
+	chunk: {
+		limit: 4e3,
+		unit: "chars"
+	}
+});
+function isMarkdownEscaped(markdown, index) {
+	let slashCount = 0;
+	let cursor = index - 1;
+	while (cursor >= 0 && markdown[cursor] === "\\") {
+		slashCount += 1;
+		cursor -= 1;
+	}
+	return slashCount % 2 === 1;
 }
-async function withResolvedMatrixControlClient(opts, run) {
-	return await withResolvedMatrixClient({
-		...opts,
-		readiness: "none"
-	}, run);
+function projectMatrixMarkdown(markdown) {
+	return renderMarkdownWithMarkers({
+		text: (markdown ?? "").replace(/\r\n?/gu, "\n"),
+		styles: [],
+		links: []
+	}, {
+		styleMarkers: {},
+		escapeText: (text) => text
+	}, MATRIX_FORMAT_PROFILE);
 }
-async function withResolvedMatrixClient(opts, run, shutdownBehavior) {
-	if (opts.client) return await run(opts.client);
-	const { withResolvedRuntimeMatrixClient } = await loadMatrixSendClientRuntime();
-	return await withResolvedRuntimeMatrixClient(opts, run, shutdownBehavior);
+function renderMatrixMarkdownTables(markdown, mode) {
+	return MATRIX_FORMAT_PROFILE.constructs.table === "native" && (mode === "off" || mode === "block") ? markdown : convertMarkdownTables(markdown, mode);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/format-table-ranges.ts
+const tableParser = new MarkdownIt({
+	html: false,
+	linkify: false,
+	typographer: false
+});
+function findMatrixTableSourceRanges(markdown) {
+	const lineStarts = [0];
+	for (let index = 0; index < markdown.length; index += 1) if (markdown[index] === "\n") lineStarts.push(index + 1);
+	lineStarts.push(markdown.length);
+	return tableParser.parse(markdown, {}).flatMap((token) => {
+		if (token.type !== "table_open" || !token.map) return [];
+		return [{
+			start: lineStarts[token.map[0]] ?? 0,
+			end: lineStarts[token.map[1]] ?? markdown.length
+		}];
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/format-spoiler-ranges.ts
+const spoilerParser = new MarkdownIt({
+	html: false,
+	linkify: true,
+	typographer: false
+});
+function findInlineMetadataRanges(markdown, references) {
+	const ranges = [];
+	const labelStack = [];
+	const codeRegions = findCodeRegions(markdown);
+	const underlineTags = [...tokenizeHtmlTags(markdown)].filter((tag) => tag.name === "u" || tag.name === "ins");
+	for (let index = 0; index < markdown.length - 1; index += 1) {
+		const underlineTag = underlineTags.find((tag) => tag.start === index);
+		if (underlineTag) {
+			index = underlineTag.end - 1;
+			continue;
+		}
+		if (isInsideCode(index, codeRegions)) continue;
+		if (markdown[index] === "\n" && markdown[index + 1] === "\n") {
+			labelStack.length = 0;
+			continue;
+		}
+		if (markdown[index] === "[" && !isMarkdownEscaped(markdown, index)) {
+			labelStack.push(index);
+			continue;
+		}
+		if (markdown[index] === "]" && markdown[index + 1] === "(" && !isMarkdownEscaped(markdown, index) && labelStack.pop() !== void 0) {
+			const start = index + 2;
+			let cursor = start;
+			while (/[\s]/u.test(markdown[cursor] ?? "")) cursor += 1;
+			const destination = spoilerParser.helpers.parseLinkDestination(markdown, cursor, markdown.length);
+			if (destination.ok) {
+				cursor = destination.pos;
+				while (/[\s]/u.test(markdown[cursor] ?? "")) cursor += 1;
+				const title = spoilerParser.helpers.parseLinkTitle(markdown, cursor, markdown.length);
+				if (title.ok) {
+					cursor = title.pos;
+					while (/[\s]/u.test(markdown[cursor] ?? "")) cursor += 1;
+				}
+			}
+			if (destination.ok && markdown[cursor] === ")") {
+				ranges.push({
+					start,
+					end: cursor + 1
+				});
+				index = cursor;
+			}
+			continue;
+		}
+		if (markdown[index] === "]" && markdown[index + 1] === "[" && !isMarkdownEscaped(markdown, index) && labelStack.pop() !== void 0) {
+			let end = index + 2;
+			while (end < markdown.length && (markdown[end] !== "]" || isMarkdownEscaped(markdown, end))) end += 1;
+			const reference = spoilerParser.utils.normalizeReference(markdown.slice(index + 2, end));
+			if (end < markdown.length && references.has(reference)) {
+				ranges.push({
+					start: index + 2,
+					end
+				});
+				index = end;
+			}
+			continue;
+		}
+		if (markdown[index] === "]" && !isMarkdownEscaped(markdown, index)) labelStack.pop();
+		const autolink = /^<[A-Za-z][A-Za-z0-9+.-]{1,31}:[^<>\s]*>/u.exec(markdown.slice(index));
+		if (autolink && !isMarkdownEscaped(markdown, index)) {
+			ranges.push({
+				start: index,
+				end: index + autolink[0].length
+			});
+			index += autolink[0].length - 1;
+			continue;
+		}
+		const emailAutolink = /^<[^<>\s@]+@[^<>\s@]+>/u.exec(markdown.slice(index));
+		if (emailAutolink && !isMarkdownEscaped(markdown, index)) {
+			ranges.push({
+				start: index,
+				end: index + emailAutolink[0].length
+			});
+			index += emailAutolink[0].length - 1;
+		}
+	}
+	return ranges;
+}
+function findMatrixMarkdownMetadataRanges(markdown) {
+	const env = {};
+	const tokens = spoilerParser.parse(markdown, env);
+	const references = new Set(Object.keys(env.references ?? {}));
+	const lineStarts = [0];
+	for (let index = 0; index < markdown.length; index += 1) if (markdown[index] === "\n") lineStarts.push(index + 1);
+	lineStarts.push(markdown.length);
+	const ranges = tokens.flatMap((token) => {
+		if (token.type !== "inline" || !token.map) return [];
+		const start = lineStarts[token.map[0]] ?? 0;
+		const end = lineStarts[token.map[1]] ?? markdown.length;
+		return findInlineMetadataRanges(markdown.slice(start, end), references).map((range) => ({
+			start: start + range.start,
+			end: start + range.end
+		}));
+	});
+	for (const match of markdown.matchAll(/^\s*\[[^\]\n]+\]:\s*.+$/gmu)) {
+		const start = match.index ?? 0;
+		const labelEnd = match[0].indexOf("]:");
+		const reference = spoilerParser.utils.normalizeReference(match[0].slice(1, labelEnd));
+		if (references.has(reference)) {
+			let end = start + match[0].length;
+			const continuation = /^\n[ \t]+(?:"[^"\n]*"|'[^'\n]*'|\([^\n)]*\))[ \t]*/u.exec(markdown.slice(end));
+			end += continuation?.[0].length ?? 0;
+			ranges.push({
+				start,
+				end
+			});
+		}
+	}
+	const codeRegions = findCodeRegions(markdown);
+	for (const match of spoilerParser.linkify.match(markdown) ?? []) if (!isInsideCode(match.index, codeRegions)) ranges.push({
+		start: match.index,
+		end: match.lastIndex
+	});
+	return ranges;
+}
+function findMatrixSpoilerDelimiterOffsets(markdown) {
+	const projected = projectMatrixMarkdown(markdown);
+	const tokens = spoilerParser.parse(projected, {});
+	const lineStarts = [0];
+	for (let index = 0; index < projected.length; index += 1) if (projected[index] === "\n") lineStarts.push(index + 1);
+	lineStarts.push(projected.length);
+	const excludedRanges = [
+		...findCodeRegions(projected),
+		...findMatrixMarkdownMetadataRanges(projected),
+		...[...tokenizeHtmlTags(projected)].flatMap((tag) => tag.name === "u" || tag.name === "ins" ? [{
+			start: tag.start,
+			end: tag.end
+		}] : [])
+	];
+	const offsets = [];
+	for (const token of tokens) {
+		if (token.type !== "inline" || !token.map) continue;
+		const start = lineStarts[token.map[0]] ?? 0;
+		const end = lineStarts[token.map[1]] ?? projected.length;
+		const candidates = [];
+		for (let index = start; index < end - 1; index += 1) {
+			if (projected[index] !== "|" || projected[index + 1] !== "|") continue;
+			const excluded = excludedRanges.some((range) => index >= range.start && index < range.end);
+			if (isMarkdownEscaped(projected, index) || excluded) continue;
+			candidates.push(index);
+			index += 1;
+		}
+		candidates.length -= candidates.length % 2;
+		offsets.push(...candidates);
+	}
+	return [...new Set(offsets)].toSorted((left, right) => left - right);
+}
+function hasMatrixSpoilerMetadataCollision(markdown) {
+	const projected = projectMatrixMarkdown(markdown);
+	const ordinary = new Set(findMatrixSpoilerDelimiterOffsets(projected));
+	const tables = findMatrixTableSourceRanges(projected);
+	for (let index = 0; index < projected.length - 1; index += 1) {
+		if (projected[index] !== "|" || projected[index + 1] !== "|") continue;
+		if (ordinary.has(index) || isMarkdownEscaped(projected, index)) continue;
+		if (tables.some((range) => index >= range.start && index < range.end)) continue;
+		return true;
+	}
+	return false;
 }
 //#endregion
 //#region extensions/matrix/src/matrix/format.ts
+const MATRIX_STYLE_MARKERS = {
+	underline: {
+		open: "<u>",
+		close: "</u>"
+	},
+	spoiler: {
+		open: "<span data-mx-spoiler>",
+		close: "</span>"
+	}
+};
 const md = new MarkdownIt({
 	html: false,
 	linkify: true,
@@ -270,6 +487,27 @@ const ESCAPED_MENTION_SENTINEL = "";
 const MENTION_PATTERN = /@[A-Za-z0-9._=+\-/:[\]]+/g;
 const MATRIX_MENTION_USER_ID_PATTERN = new RegExp(`^@[A-Za-z0-9._=+\\-/]+:(?:${/(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)(?:\.(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?))*(?::\d+)?/.source}|\\[[0-9A-Fa-f:.]+\\](?::\\d+)?)$`);
 const TRIMMABLE_MENTION_SUFFIX = /[),.!?:;\]]/;
+const parseMatrixUnderline = (state, silent) => {
+	if (state.src.charCodeAt(state.pos) !== 60) return false;
+	const tag = tokenizeHtmlTags(state.src.slice(state.pos)).next().value;
+	if (!tag || tag.start !== 0 || tag.name !== "u" && tag.name !== "ins") return false;
+	if (!silent) {
+		const token = state.push(tag.selfClosing ? "text" : tag.closing ? "matrix_underline_close" : "matrix_underline_open", tag.selfClosing ? "" : "u", tag.selfClosing ? 0 : tag.closing ? -1 : 1);
+		if (tag.selfClosing) token.content = tag.raw;
+	}
+	state.pos += tag.end;
+	return true;
+};
+md.inline.ruler.before("html_inline", "matrix_underline", parseMatrixUnderline);
+md.renderer.rules.matrix_underline_open = () => MATRIX_STYLE_MARKERS.underline.open;
+md.renderer.rules.matrix_underline_close = () => MATRIX_STYLE_MARKERS.underline.close;
+md.renderer.rules.matrix_spoiler_open = () => MATRIX_STYLE_MARKERS.spoiler.open;
+md.renderer.rules.matrix_spoiler_close = () => MATRIX_STYLE_MARKERS.spoiler.close;
+md.core.ruler.after("inline", "matrix_spoilers", (state) => {
+	const markers = state.env.matrixSpoilerMarkers;
+	if (!markers) return;
+	for (const token of state.tokens) if (token.children?.length) token.children = normalizeMatrixSpoilerNesting(injectProtectedMatrixSpoilers(token.children, markers));
+});
 function shouldSuppressAutoLink(tokens, idx) {
 	const token = tokens[idx];
 	if (token?.type !== "link_open" || token.info !== "auto") return false;
@@ -277,7 +515,10 @@ function shouldSuppressAutoLink(tokens, idx) {
 	const label = tokens[idx + 1]?.type === "text" ? tokens[idx + 1]?.content ?? "" : "";
 	return Boolean(href && label && isAutoLinkedFileRef(href, label));
 }
-md.renderer.rules.image = (tokens, idx) => escapeHtml(tokens[idx]?.content ?? "");
+md.renderer.rules.image = (tokens, idx, options, env, self) => {
+	const token = tokens[idx];
+	return token?.children?.length ? self.renderInline(token.children, options, env) : escapeHtml(token?.content ?? "");
+};
 md.renderer.rules.html_block = (tokens, idx) => escapeHtml(tokens[idx]?.content ?? "");
 md.renderer.rules.html_inline = (tokens, idx) => escapeHtml(tokens[idx]?.content ?? "");
 md.renderer.rules.link_open = (tokens, idx, _options, _env, self) => shouldSuppressAutoLink(tokens, idx) ? "" : self.renderToken(tokens, idx, _options);
@@ -310,15 +551,6 @@ function maskEscapedMentions(markdown) {
 	}
 	return masked;
 }
-function isMarkdownEscaped(markdown, idx) {
-	let slashCount = 0;
-	let cursor = idx - 1;
-	while (cursor >= 0 && markdown[cursor] === "\\") {
-		slashCount += 1;
-		cursor -= 1;
-	}
-	return slashCount % 2 === 1;
-}
 function restoreEscapedMentions(text) {
 	return text.replaceAll(ESCAPED_MENTION_SENTINEL, "@");
 }
@@ -388,6 +620,67 @@ function createTextToken(sample, content) {
 	token.content = content;
 	return token;
 }
+function injectProtectedMatrixSpoilers(tokens, markers) {
+	const result = [];
+	for (const token of tokens) {
+		if (token.type !== "text") {
+			if (token.children?.length) token.children = normalizeMatrixSpoilerNesting(injectProtectedMatrixSpoilers(token.children, markers));
+			result.push(token);
+			continue;
+		}
+		let cursor = 0;
+		for (let index = 0; index < token.content.length; index += 1) {
+			const marker = token.content[index];
+			if (marker !== markers.open && marker !== markers.close || token.content[index + 1] !== markers.padding) continue;
+			if (index > cursor) result.push(createTextToken(token, token.content.slice(cursor, index)));
+			result.push(createToken(token, marker === markers.open ? "matrix_spoiler_open" : "matrix_spoiler_close", "span", marker === markers.open ? 1 : -1));
+			index += 1;
+			cursor = index + 1;
+		}
+		if (cursor < token.content.length) result.push(createTextToken(token, token.content.slice(cursor)));
+	}
+	return result;
+}
+function copyInlineToken(sample, type, tag, nesting) {
+	const token = createToken(sample, type, tag, nesting);
+	token.markup = sample.markup;
+	token.attrs = sample.attrs ? [...sample.attrs] : null;
+	return token;
+}
+function normalizeMatrixSpoilerNesting(tokens) {
+	const result = [];
+	const stack = [];
+	for (const token of tokens) {
+		if (token.nesting === 1) {
+			stack.push(token);
+			result.push(token);
+			continue;
+		}
+		if (token.nesting !== -1) {
+			result.push(token);
+			continue;
+		}
+		const openIndex = stack.findLastIndex((open) => open.tag === token.tag);
+		if (openIndex < 0) {
+			result.push(token);
+			continue;
+		}
+		if (openIndex === stack.length - 1) {
+			stack.pop();
+			result.push(token);
+			continue;
+		}
+		const crossing = stack.splice(openIndex + 1);
+		for (const open of crossing.toReversed()) result.push(copyInlineToken(open, open.type.replace(/_open$/u, "_close"), open.tag, -1));
+		stack.pop();
+		result.push(token);
+		for (const open of crossing) {
+			result.push(copyInlineToken(open, open.type, open.tag, 1));
+			stack.push(open);
+		}
+	}
+	return result;
+}
 function createMentionLinkTokens(params) {
 	const open = createToken(params.sample, "link_open", "a", 1);
 	open.attrSet("href", params.href);
@@ -497,14 +790,64 @@ function compactLooseListTokens(tokens) {
 		else if (token.type === "paragraph_close") currentItem.immediateParagraphCloseIndexes.push(index);
 	}
 }
-function markdownToMatrixHtml(markdown) {
-	const tokens = md.parse(markdown ?? "", {});
+function markdownToMatrixHtml(markdown, options = {}) {
+	if (hasMatrixSpoilerMetadataCollision(markdown)) return renderMatrixFallbackHtml(markdown);
+	const tokens = parseMatrixMarkdown(projectMatrixMarkdown(markdown), options.tableMode);
 	compactLooseListTokens(tokens);
 	return md.renderer.render(tokens, md.options, {}).trimEnd();
 }
+function protectMatrixSpoilerDelimiters(markdown) {
+	const offsets = findMatrixSpoilerDelimiterOffsets(markdown);
+	if (offsets.length === 0) return { markdown };
+	const markers = createMatrixPrivateMarkers(markdown, "Matrix spoiler formatting exhausted its private marker pool");
+	let protectedMarkdown = "";
+	let cursor = 0;
+	for (const [index, offset] of offsets.entries()) {
+		const marker = index % 2 === 0 ? markers.open : markers.close;
+		protectedMarkdown += `${markdown.slice(cursor, offset)}${marker}${markers.padding}`;
+		cursor = offset + 2;
+	}
+	protectedMarkdown += markdown.slice(cursor);
+	return {
+		markdown: protectedMarkdown,
+		markers
+	};
+}
+function parseMatrixMarkdown(markdown, tableMode) {
+	const protectedSpoilers = protectMatrixSpoilerDelimiters(markdown);
+	if (tableMode === "off") md.disable("table");
+	try {
+		return md.parse(protectedSpoilers.markdown, { matrixSpoilerMarkers: protectedSpoilers.markers });
+	} finally {
+		if (tableMode === "off") md.enable("table");
+	}
+}
+function markdownToMatrixBody(markdown) {
+	const projected = projectMatrixMarkdown(markdown);
+	const offsets = findMatrixSpoilerDelimiterOffsets(projected);
+	const metadataCollision = hasMatrixSpoilerMetadataCollision(projected);
+	if (offsets.length === 0 && !metadataCollision) return projected;
+	let body = projected;
+	if (metadataCollision) body = "[Spoiler]";
+	else for (let index = offsets.length - 2; index >= 0; index -= 2) {
+		const open = offsets[index];
+		const close = offsets[index + 1];
+		if (open !== void 0 && close !== void 0) body = `${body.slice(0, open)}[Spoiler]${body.slice(close + 2)}`;
+	}
+	return renderMarkdownWithMarkers(markdownToIR(body, {
+		enableHtmlUnderline: true,
+		headingStyle: "rich",
+		linkify: true
+	}), {
+		styleMarkers: {},
+		escapeText: (text) => text
+	}, MATRIX_FORMAT_PROFILE);
+}
+function renderMatrixFallbackHtml(markdown) {
+	return `<p>${escapeHtml(markdownToMatrixBody(markdown)).replaceAll("\n", "<br>\n")}</p>`;
+}
 async function resolveMarkdownMentionState(params) {
-	const markdown = maskEscapedMentions(params.markdown ?? "");
-	const tokens = md.parse(markdown, {});
+	const tokens = parseMatrixMarkdown(maskEscapedMentions(projectMatrixMarkdown(params.markdown)), params.tableMode);
 	restoreEscapedMentionsInBlockTokens(tokens);
 	const selfUserId = await resolveMatrixSelfUserId(params.client);
 	const userIds = [];
@@ -534,6 +877,17 @@ async function resolveMatrixMentionsInMarkdown(params) {
 }
 async function renderMarkdownToMatrixHtmlWithMentions(params) {
 	const state = await resolveMarkdownMentionState(params);
+	if (hasMatrixSpoilerMetadataCollision(params.markdown)) {
+		const redacted = markdownToMatrixBody(params.markdown);
+		const redactedState = await resolveMarkdownMentionState({
+			...params,
+			markdown: redacted
+		});
+		return {
+			html: renderMatrixFallbackHtml(params.markdown),
+			mentions: redactedState.mentions
+		};
+	}
 	compactLooseListTokens(state.tokens);
 	return {
 		html: md.renderer.render(state.tokens, md.options, {}).trimEnd() || void 0,
@@ -541,6 +895,189 @@ async function renderMarkdownToMatrixHtmlWithMentions(params) {
 	};
 }
 //#endregion
+//#region extensions/matrix/src/matrix/send/chunking.ts
+const getCore$2 = () => getMatrixRuntime();
+function protectMatrixUnderlineTags(markdown) {
+	const codeRegions = findCodeRegions(markdown);
+	const metadataRanges = findMatrixMarkdownMetadataRanges(markdown);
+	const tags = [...tokenizeHtmlTags(markdown)].filter((tag) => (tag.name === "u" || tag.name === "ins") && !tag.selfClosing && !isInsideCode(tag.start, codeRegions) && !isMarkdownEscaped(markdown, tag.start) && !metadataRanges.some((range) => tag.start >= range.start && tag.start < range.end));
+	if (tags.length === 0) return { markdown };
+	const markers = createMatrixPrivateMarkers(markdown, "Matrix underline chunking exhausted its private marker pool");
+	let depth = 0;
+	const replacements = tags.flatMap((tag) => {
+		if (!tag.closing) {
+			depth += 1;
+			return [{
+				tag,
+				marker: depth === 1 ? markers.open : ""
+			}];
+		}
+		if (depth === 0) return [];
+		depth -= 1;
+		return [{
+			tag,
+			marker: depth === 0 ? markers.close : ""
+		}];
+	});
+	let protectedMarkdown = markdown;
+	for (const { tag, marker } of replacements.toReversed()) protectedMarkdown = `${protectedMarkdown.slice(0, tag.start)}${marker}${markers.padding.repeat(tag.raw.length - marker.length)}${protectedMarkdown.slice(tag.end)}`;
+	return {
+		markdown: protectedMarkdown,
+		markers
+	};
+}
+function restoreMatrixStyleChunks(chunks, spoiler, underline) {
+	const stack = [];
+	const syntax = {
+		spoiler: {
+			open: "||",
+			close: "||",
+			markers: spoiler
+		},
+		underline: {
+			open: "<u>",
+			close: "</u>",
+			markers: underline
+		}
+	};
+	return chunks.map((chunk) => {
+		let restored = stack.map((style) => syntax[style].open).join("");
+		for (const character of chunk) {
+			const opening = Object.keys(syntax).find((style) => character === syntax[style].markers?.open);
+			const closing = Object.keys(syntax).find((style) => character === syntax[style].markers?.close);
+			if (opening) {
+				stack.push(opening);
+				restored += syntax[opening].open;
+			} else if (closing) {
+				const stackIndex = stack.lastIndexOf(closing);
+				if (stackIndex >= 0) {
+					const above = stack.slice(stackIndex + 1);
+					restored += above.toReversed().map((style) => syntax[style].close).join("");
+					restored += syntax[closing].close;
+					stack.splice(stackIndex, 1);
+					restored += above.map((style) => syntax[style].open).join("");
+				}
+			} else if (character !== spoiler?.padding && character !== underline?.padding) restored += character;
+		}
+		return restored + stack.toReversed().map((style) => syntax[style].close).join("");
+	});
+}
+function splitMatrixTableSegments(markdown) {
+	const segments = [];
+	let cursor = 0;
+	for (const range of findMatrixTableSourceRanges(markdown)) {
+		const plain = markdown.slice(cursor, range.start).replace(/(?:[ \t]*\n)+$/u, "");
+		if (plain.trim()) segments.push({
+			table: false,
+			text: plain
+		});
+		const rawTable = markdown.slice(range.start, range.end).trimEnd();
+		const indent = /^ +/u.exec(rawTable)?.[0] ?? "";
+		const table = indent ? rawTable.split("\n").map((line) => line.startsWith(indent) ? line.slice(indent.length) : line).join("\n") : rawTable;
+		segments.push({
+			table: true,
+			text: table
+		});
+		cursor = range.end;
+	}
+	const tail = markdown.slice(cursor).replace(/^(?:[ \t]*\n)+/u, "");
+	if (tail.trim()) segments.push({
+		table: false,
+		text: tail
+	});
+	return segments;
+}
+function prepareMatrixSingleText(text, opts) {
+	const normalizedText = text.replace(/\r\n?/gu, "\n");
+	const trimmedText = opts.preserveWhitespace ? normalizedText : normalizedText.trim();
+	const cfg = requireRuntimeConfig(opts.cfg, "Matrix text preparation");
+	const tableMode = opts.tableMode ?? getCore$2().channel.text.resolveMarkdownTableMode({
+		cfg,
+		channel: "matrix",
+		accountId: opts.accountId,
+		supportsBlockTables: MATRIX_FORMAT_PROFILE.constructs.table === "native"
+	});
+	const singleEventLimit = Math.min(getCore$2().channel.text.resolveTextChunkLimit(cfg, "matrix", opts.accountId), MATRIX_FORMAT_PROFILE.chunk.limit);
+	const convertedText = renderMatrixMarkdownTables(trimmedText, tableMode);
+	const eventTextLength = Math.max(convertedText.length, markdownToMatrixBody(convertedText).length);
+	return {
+		trimmedText,
+		convertedText,
+		singleEventLimit,
+		eventTextLength,
+		fitsInSingleEvent: eventTextLength <= singleEventLimit,
+		tableMode
+	};
+}
+function chunkMatrixText(text, opts) {
+	const preparedText = prepareMatrixSingleText(text, opts);
+	if (preparedText.fitsInSingleEvent) return {
+		...preparedText,
+		chunks: preparedText.convertedText ? [preparedText.convertedText] : []
+	};
+	const cfg = requireRuntimeConfig(opts.cfg, "Matrix text chunking");
+	const chunkMode = getCore$2().channel.text.resolveChunkMode(cfg, "matrix", opts.accountId);
+	const collisionRedacted = hasMatrixSpoilerMetadataCollision(preparedText.convertedText) ? markdownToMatrixBody(preparedText.convertedText) : void 0;
+	const chunkSegment = (segmentText) => {
+		const protectedUnderline = protectMatrixUnderlineTags(hasMatrixSpoilerMetadataCollision(segmentText) ? markdownToMatrixBody(segmentText) : segmentText);
+		const protectedSpoilers = protectMatrixSpoilerDelimiters(protectedUnderline.markdown);
+		const wrapperReserve = (protectedSpoilers.markers ? 4 : 0) + (protectedUnderline.markers ? 7 : 0);
+		const privateMarkers = [protectedSpoilers.markers, protectedUnderline.markers].flatMap((markers) => markers ? [
+			markers.open,
+			markers.close,
+			markers.padding
+		] : []);
+		let reserve = wrapperReserve;
+		while (reserve < preparedText.singleEventLimit) {
+			const protectedChunks = getCore$2().channel.text.chunkMarkdownTextWithMode(protectedSpoilers.markdown, preparedText.singleEventLimit - reserve, chunkMode);
+			const restored = restoreMatrixStyleChunks(protectedChunks, protectedSpoilers.markers, protectedUnderline.markers).filter((_, index) => {
+				return privateMarkers.reduce((value, marker) => value.replaceAll(marker, ""), protectedChunks[index] ?? "").length > 0;
+			});
+			const overflow = Math.max(0, ...restored.map((chunk) => Math.max(chunk.length, markdownToMatrixBody(chunk).length) - preparedText.singleEventLimit));
+			if (overflow === 0) return restored;
+			reserve += overflow;
+		}
+		throw new Error("Matrix text chunk limit is too small for formatted content");
+	};
+	const chunks = collisionRedacted !== void 0 ? chunkSegment(collisionRedacted) : preparedText.tableMode === "block" ? splitMatrixTableSegments(preparedText.convertedText).flatMap((segment) => {
+		if (!segment.table) return chunkSegment(segment.text);
+		return segment.text.length <= preparedText.singleEventLimit ? [segment.text] : chunkSegment(renderMatrixMarkdownTables(segment.text, "bullets"));
+	}) : chunkSegment(preparedText.convertedText);
+	return {
+		...preparedText,
+		chunks
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/send/client.ts
+const loadMatrixSendClientRuntime = createLazyRuntimeModule(() => import("./client-bootstrap-CkAnkzB6.js").then((n) => n.t));
+function resolveMediaMaxBytes(accountId, cfg) {
+	if (!cfg) throw new Error("Matrix media limits requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
+	const matrixCfg = resolveMatrixAccountConfig({
+		cfg: requireRuntimeConfig(cfg, "Matrix media limits"),
+		accountId
+	});
+	const mediaMaxMb = typeof matrixCfg.mediaMaxMb === "number" ? matrixCfg.mediaMaxMb : void 0;
+	if (typeof mediaMaxMb === "number") return mediaMaxMb * 1024 * 1024;
+}
+async function withResolvedMatrixSendClient(opts, run) {
+	return await withResolvedMatrixClient({
+		...opts,
+		readiness: "started"
+	}, run, "persist");
+}
+async function withResolvedMatrixControlClient(opts, run) {
+	return await withResolvedMatrixClient({
+		...opts,
+		readiness: "none"
+	}, run);
+}
+async function withResolvedMatrixClient(opts, run, shutdownBehavior) {
+	if (opts.client) return await run(opts.client);
+	const { withResolvedRuntimeMatrixClient } = await loadMatrixSendClientRuntime();
+	return await withResolvedRuntimeMatrixClient(opts, run, shutdownBehavior);
+}
+//#endregion
 //#region extensions/matrix/src/matrix/send/types.ts
 const MsgType = {
 	Text: "m.text",
@@ -572,15 +1109,21 @@ const MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY = "com.openclaw.finalized_preview";
 const MSC4357_LIVE_KEY = "org.matrix.msc4357.live";
 //#endregion
 //#region extensions/matrix/src/matrix/send/formatting.ts
-const getCore$2 = () => getMatrixRuntime();
+const getCore$1 = () => getMatrixRuntime();
 async function renderMatrixFormattedContent(params) {
 	const markdown = params.markdown ?? "";
-	if (params.includeMentions === false) return { html: markdownToMatrixHtml(markdown).trimEnd() || void 0 };
+	const body = markdownToMatrixBody(markdown);
+	if (params.includeMentions === false) return {
+		body,
+		html: markdownToMatrixHtml(markdown, { tableMode: params.tableMode }).trimEnd() || void 0
+	};
 	const { html, mentions } = await renderMarkdownToMatrixHtmlWithMentions({
 		markdown,
-		client: params.client
+		client: params.client,
+		tableMode: params.tableMode
 	});
 	return {
+		body,
 		html,
 		mentions
 	};
@@ -597,11 +1140,13 @@ function buildTextContent(body, relation, opts = {}) {
 	};
 }
 async function enrichMatrixFormattedContent(params) {
-	const { html, mentions } = await renderMatrixFormattedContent({
+	const { body, html, mentions } = await renderMatrixFormattedContent({
 		client: params.client,
 		markdown: params.markdown,
-		includeMentions: params.includeMentions
+		includeMentions: params.includeMentions,
+		tableMode: params.tableMode
 	});
+	params.content.body = body || params.content.body;
 	if (mentions) params.content["m.mentions"] = mentions;
 	else delete params.content["m.mentions"];
 	if (!html) {
@@ -658,7 +1203,7 @@ function buildThreadRelation(threadId, replyToId) {
 	return relation;
 }
 function resolveMatrixMsgType(contentType, _fileName) {
-	switch (getCore$2().media.mediaKindFromMime(contentType ?? "")) {
+	switch (getCore$1().media.mediaKindFromMime(contentType ?? "")) {
 		case "image": return MsgType.Image;
 		case "audio": return MsgType.Audio;
 		case "video": return MsgType.Video;
@@ -678,7 +1223,7 @@ function isMatrixVoiceCompatibleAudio(opts) {
 }
 //#endregion
 //#region extensions/matrix/src/matrix/send/media.ts
-const getCore$1 = () => getMatrixRuntime();
+const getCore = () => getMatrixRuntime();
 function buildMatrixMediaInfo(params) {
 	const base = {};
 	if (Number.isFinite(params.size)) base.size = params.size;
@@ -726,20 +1271,20 @@ function buildMediaContent(params) {
 const THUMBNAIL_MAX_SIDE = 800;
 const THUMBNAIL_QUALITY = 80;
 async function prepareImageInfo(params) {
-	const meta = await getCore$1().media.getImageMetadata(params.buffer).catch(() => null);
+	const meta = await getCore().media.getImageMetadata(params.buffer).catch(() => null);
 	if (!meta) return;
 	const imageInfo = {
 		w: meta.width,
 		h: meta.height
 	};
 	if (Math.max(meta.width, meta.height) > THUMBNAIL_MAX_SIDE) try {
-		const thumbBuffer = await getCore$1().media.resizeToJpeg({
+		const thumbBuffer = await getCore().media.resizeToJpeg({
 			buffer: params.buffer,
 			maxSide: THUMBNAIL_MAX_SIDE,
 			quality: THUMBNAIL_QUALITY,
 			withoutEnlargement: true
 		});
-		const thumbMeta = await getCore$1().media.getImageMetadata(thumbBuffer).catch(() => null);
+		const thumbMeta = await getCore().media.getImageMetadata(thumbBuffer).catch(() => null);
 		const result = await uploadMediaWithEncryption(params.client, thumbBuffer, {
 			contentType: "image/jpeg",
 			filename: "thumbnail.jpg",
@@ -807,18 +1352,13 @@ var direct_room_exports = /* @__PURE__ */ __exportAll({
 	isStrictDirectRoom: () => isStrictDirectRoom,
 	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));
+	return joinedMembers.map((entry) => normalizeNullableString(entry)).filter((entry) => Boolean(entry));
 }
 function isStrictDirectMembership(params) {
-	const selfUserId = trimMaybeString(params.selfUserId);
-	const remoteUserId = trimMaybeString(params.remoteUserId);
+	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));
 }
@@ -830,7 +1370,7 @@ async function readJoinedMatrixMembers(client, roomId) {
 	}
 }
 async function hasDirectMatrixMemberFlag(client, roomId, userId) {
-	const normalizedUserId = trimMaybeString(userId);
+	const normalizedUserId = normalizeNullableString(userId);
 	if (!normalizedUserId) return null;
 	try {
 		const state = await client.getRoomStateEvent(roomId, "m.room.member", normalizedUserId);
@@ -842,7 +1382,7 @@ async function hasDirectMatrixMemberFlag(client, roomId, userId) {
 	}
 }
 async function inspectMatrixDirectRoomEvidence(params) {
-	const selfUserId = params.selfUserId !== void 0 ? trimMaybeString(params.selfUserId) : trimMaybeString(await params.client.getUserId().catch(() => null));
+	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,
@@ -1166,8 +1706,6 @@ var send_exports = /* @__PURE__ */ __exportAll({
 	sendSingleTextMessageMatrix: () => sendSingleTextMessageMatrix,
 	sendTypingMatrix: () => sendTypingMatrix
 });
-const MATRIX_TEXT_LIMIT = 4e3;
-const getCore = () => getMatrixRuntime();
 function createMatrixSendReceipt(params) {
 	return createMessageReceiptFromOutboundResults({
 		kind: params.kind,
@@ -1230,32 +1768,6 @@ async function resolvePreviousEditMentions(params) {
 		body
 	});
 }
-function prepareMatrixSingleText(text, opts) {
-	const trimmedText = text.trim();
-	const cfg = requireRuntimeConfig(opts.cfg, "Matrix text preparation");
-	const tableMode = opts.tableMode ?? getCore().channel.text.resolveMarkdownTableMode({
-		cfg,
-		channel: "matrix",
-		accountId: opts.accountId
-	});
-	const convertedText = getCore().channel.text.convertMarkdownTables(trimmedText, tableMode);
-	const singleEventLimit = Math.min(getCore().channel.text.resolveTextChunkLimit(cfg, "matrix", opts.accountId), MATRIX_TEXT_LIMIT);
-	return {
-		trimmedText,
-		convertedText,
-		singleEventLimit,
-		fitsInSingleEvent: convertedText.length <= singleEventLimit
-	};
-}
-function chunkMatrixText(text, opts) {
-	const preparedText = prepareMatrixSingleText(text, opts);
-	const cfg = requireRuntimeConfig(opts.cfg, "Matrix text chunking");
-	const chunkMode = getCore().channel.text.resolveChunkMode(cfg, "matrix", opts.accountId);
-	return {
-		...preparedText,
-		chunks: getCore().channel.text.chunkMarkdownTextWithMode(preparedText.convertedText, preparedText.singleEventLimit, chunkMode)
-	};
-}
 async function sendMessageMatrix(to, message, opts) {
 	const trimmedMessage = message?.trim() ?? "";
 	if (!trimmedMessage && !opts.mediaUrl) throw new Error("Matrix send requires text or media");
@@ -1267,7 +1779,7 @@ async function sendMessageMatrix(to, message, opts) {
 	}, async (client) => {
 		const roomId = await resolveMatrixRoomId(client, to);
 		const cfg = requireRuntimeConfig(opts.cfg, "Matrix send");
-		const { chunks } = chunkMatrixText(trimmedMessage, {
+		const { chunks, tableMode } = chunkMatrixText(trimmedMessage, {
 			cfg,
 			accountId: opts.accountId
 		});
@@ -1344,7 +1856,8 @@ async function sendMessageMatrix(to, message, opts) {
 			await enrichMatrixFormattedContent({
 				client,
 				content,
-				markdown: captionMarkdown
+				markdown: captionMarkdown,
+				tableMode
 			});
 			const eventId = await sendContent(content, receiptKind);
 			lastMessageId = eventId ?? lastMessageId;
@@ -1352,26 +1865,28 @@ async function sendMessageMatrix(to, message, opts) {
 			const textChunks = useVoice ? chunks : rest;
 			const followupRelation = useVoice || threadId ? relation : void 0;
 			for (const chunk of textChunks) {
-				const text = chunk.trim();
-				if (!text) continue;
+				const text = chunk;
+				if (!text.trim()) continue;
 				const followup = buildTextContent(text, followupRelation);
 				await enrichMatrixFormattedContent({
 					client,
 					content: followup,
-					markdown: text
+					markdown: text,
+					tableMode
 				});
 				const followupEventId = await sendContent(followup, "text");
 				lastMessageId = followupEventId ?? lastMessageId;
 				if (followupEventId) platformMessageIds.push(followupEventId);
 			}
 		} else for (const chunk of chunks.length ? chunks : [""]) {
-			const text = chunk.trim();
-			if (!text) continue;
+			const text = chunk;
+			if (!text.trim()) continue;
 			const content = buildTextContent(text, relation);
 			await enrichMatrixFormattedContent({
 				client,
 				content,
-				markdown: text
+				markdown: text,
+				tableMode
 			});
 			const eventId = await sendContent(content, "text");
 			lastMessageId = eventId ?? lastMessageId;
@@ -1445,12 +1960,12 @@ async function sendReadReceiptMatrix(roomId, eventId, client) {
 	});
 }
 async function sendSingleTextMessageMatrix(roomId, text, opts) {
-	const { trimmedText, convertedText, singleEventLimit, fitsInSingleEvent } = prepareMatrixSingleText(text, {
+	const { trimmedText, convertedText, singleEventLimit, eventTextLength, fitsInSingleEvent, tableMode } = prepareMatrixSingleText(text, {
 		cfg: opts.cfg,
 		accountId: opts.accountId
 	});
 	if (!trimmedText) throw new Error("Matrix single-message send requires text");
-	if (!fitsInSingleEvent) throw new Error(`Matrix single-message text exceeds limit (${convertedText.length} > ${singleEventLimit})`);
+	if (!fitsInSingleEvent) throw new Error(`Matrix single-message text exceeds limit (${eventTextLength} > ${singleEventLimit})`);
 	return await withResolvedMatrixSendClient({
 		client: opts.client,
 		cfg: opts.cfg,
@@ -1464,7 +1979,8 @@ async function sendSingleTextMessageMatrix(roomId, text, opts) {
 			client,
 			content,
 			markdown: convertedText,
-			includeMentions: opts.includeMentions
+			includeMentions: opts.includeMentions,
+			tableMode
 		});
 		if (opts.live) content[MSC4357_LIVE_KEY] = {};
 		const eventId = await client.sendMessage(resolvedRoom, content);
@@ -1495,19 +2011,18 @@ async function editMessageMatrix(roomId, originalEventId, newText, opts) {
 		timeoutMs: opts.timeoutMs
 	}, async (client) => {
 		const resolvedRoom = await resolveMatrixRoomId(client, roomId);
-		const cfg = requireRuntimeConfig(opts.cfg, "Matrix message edit");
-		const tableMode = getCore().channel.text.resolveMarkdownTableMode({
-			cfg,
-			channel: "matrix",
-			accountId: opts.accountId
+		const { convertedText, tableMode } = prepareMatrixSingleText(newText, {
+			cfg: requireRuntimeConfig(opts.cfg, "Matrix message edit"),
+			accountId: opts.accountId,
+			preserveWhitespace: true
 		});
-		const convertedText = getCore().channel.text.convertMarkdownTables(newText, tableMode);
 		const newContent = withMatrixExtraContentFields(buildTextContent(convertedText, void 0, { msgtype: opts.msgtype }), opts.extraContent);
 		await enrichMatrixFormattedContent({
 			client,
 			content: newContent,
 			markdown: convertedText,
-			includeMentions: opts.includeMentions
+			includeMentions: opts.includeMentions,
+			tableMode
 		});
 		const previousEvent = await getPreviousMatrixEvent(client, resolvedRoom, originalEventId);
 		const replaceMentions = opts.includeMentions === false ? void 0 : diffMatrixMentions(extractMatrixMentions(newContent), await resolvePreviousEditMentions({
@@ -1524,7 +2039,7 @@ async function editMessageMatrix(roomId, originalEventId, newText, opts) {
 		}
 		const content = {
 			...newContent,
-			body: `* ${convertedText}`,
+			body: `* ${newContent.body}`,
 			...typeof newContent.formatted_body === "string" ? { formatted_body: `* ${newContent.formatted_body}` } : {},
 			"m.new_content": newContent,
 			"m.relates_to": replaceRelation
@@ -1551,4 +2066,4 @@ async function reactMatrixMessage(roomId, messageId, emoji, opts) {
 	});
 }
 //#endregion
-export { formatPollResultsAsText as C, parsePollStartContent as D, parsePollStart as E, resolvePollReferenceEventId as O, formatPollAsText as S, isPollStartType as T, readJoinedMatrixMembers as _, sendMessageMatrix as a, buildPollResponseContent as b, sendTypingMatrix as c, direct_management_exports as d, promoteMatrixDirectRoomCandidate as f, isStrictDirectMembership as g, hasDirectMatrixMemberFlag as h, reactMatrixMessage as i, send_exports as l, direct_room_exports as m, editMessageMatrix as n, sendPollMatrix as o, repairMatrixDirectRooms as p, prepareMatrixSingleText as r, sendSingleTextMessageMatrix as s, chunkMatrixText as t, resolveMatrixRoomId as u, MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY as v, isPollEventType as w, buildPollResultsSummary as x, MsgType as y };
+export { formatPollResultsAsText as C, parsePollStartContent as D, parsePollStart as E, resolvePollReferenceEventId as O, formatPollAsText as S, isPollStartType as T, MsgType as _, sendSingleTextMessageMatrix as a, buildPollResponseContent as b, resolveMatrixRoomId as c, repairMatrixDirectRooms as d, direct_room_exports as f, MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY as g, readJoinedMatrixMembers as h, sendPollMatrix as i, direct_management_exports as l, isStrictDirectMembership as m, reactMatrixMessage as n, sendTypingMatrix as o, hasDirectMatrixMemberFlag as p, sendMessageMatrix as r, send_exports as s, editMessageMatrix as t, promoteMatrixDirectRoomCandidate as u, chunkMatrixText as v, isPollEventType as w, buildPollResultsSummary as x, prepareMatrixSingleText as y };