@openclaw/matrix 2026.7.2-beta.5 → 2026.7.33

package/dist/send-C9Ssx-iV.js

@@ -1,2069 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as resolveMatrixAccountConfig } from "./account-config-BZWN9tGS.js";
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { r as normalizeMatrixResolvableTarget, t as isMatrixQualifiedUserId } from "./target-ids-B-5aQxwn.js";
-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, 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 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
-/**
-* Matrix Poll Types (MSC3381)
-*
-* Defines types for Matrix poll events:
-* - m.poll.start - Creates a new poll
-* - m.poll.response - Records a vote
-* - m.poll.end - Closes a poll
-*/
-const M_POLL_START = "m.poll.start";
-const M_POLL_RESPONSE = "m.poll.response";
-const M_POLL_END = "m.poll.end";
-const ORG_POLL_START = "org.matrix.msc3381.poll.start";
-const ORG_POLL_RESPONSE = "org.matrix.msc3381.poll.response";
-const ORG_POLL_END = "org.matrix.msc3381.poll.end";
-const POLL_EVENT_TYPES = [
-	M_POLL_START,
-	M_POLL_RESPONSE,
-	M_POLL_END,
-	ORG_POLL_START,
-	ORG_POLL_RESPONSE,
-	ORG_POLL_END
-];
-const POLL_START_TYPES = [M_POLL_START, ORG_POLL_START];
-const POLL_RESPONSE_TYPES = [M_POLL_RESPONSE, ORG_POLL_RESPONSE];
-const POLL_END_TYPES = [M_POLL_END, ORG_POLL_END];
-function isPollStartType(eventType) {
-	return POLL_START_TYPES.includes(eventType);
-}
-function isPollResponseType(eventType) {
-	return POLL_RESPONSE_TYPES.includes(eventType);
-}
-function isPollEndType(eventType) {
-	return POLL_END_TYPES.includes(eventType);
-}
-function isPollEventType(eventType) {
-	return POLL_EVENT_TYPES.includes(eventType);
-}
-function getTextContent(text) {
-	if (!text) return "";
-	return text["m.text"] ?? text["org.matrix.msc1767.text"] ?? text.body ?? "";
-}
-function parsePollStart(content) {
-	const poll = content["m.poll.start"] ?? content[ORG_POLL_START] ?? content["m.poll"];
-	if (!poll) return null;
-	const question = getTextContent(poll.question).trim();
-	if (!question) return null;
-	const answers = poll.answers.map((answer) => ({
-		id: answer.id,
-		text: getTextContent(answer).trim()
-	})).filter((answer) => answer.id.trim().length > 0 && answer.text.length > 0);
-	if (answers.length === 0) return null;
-	const maxSelectionsRaw = poll.max_selections;
-	const maxSelections = typeof maxSelectionsRaw === "number" && Number.isFinite(maxSelectionsRaw) ? Math.floor(maxSelectionsRaw) : 1;
-	return {
-		question,
-		answers,
-		kind: poll.kind ?? "m.poll.disclosed",
-		maxSelections: Math.min(Math.max(maxSelections, 1), answers.length)
-	};
-}
-function parsePollStartContent(content) {
-	const parsed = parsePollStart(content);
-	if (!parsed) return null;
-	return {
-		eventId: "",
-		roomId: "",
-		sender: "",
-		senderName: "",
-		question: parsed.question,
-		answers: parsed.answers.map((answer) => answer.text),
-		kind: parsed.kind,
-		maxSelections: parsed.maxSelections
-	};
-}
-function formatPollAsText(summary) {
-	return [
-		"[Poll]",
-		summary.question,
-		"",
-		...summary.answers.map((answer, idx) => `${idx + 1}. ${answer}`)
-	].join("\n");
-}
-function resolvePollReferenceEventId(content) {
-	if (!content || typeof content !== "object") return null;
-	const relates = content["m.relates_to"];
-	if (!relates || typeof relates.event_id !== "string") return null;
-	const eventId = relates.event_id.trim();
-	return eventId.length > 0 ? eventId : null;
-}
-function parsePollResponseAnswerIds(content) {
-	if (!content || typeof content !== "object") return null;
-	const response = content[M_POLL_RESPONSE] ?? content[ORG_POLL_RESPONSE];
-	if (!response || !Array.isArray(response.answers)) return null;
-	return response.answers.filter((answer) => typeof answer === "string");
-}
-function buildPollResultsSummary(params) {
-	const parsed = parsePollStart(params.content);
-	if (!parsed) return null;
-	let pollClosedAt = Number.POSITIVE_INFINITY;
-	for (const event of params.relationEvents) {
-		if (event.unsigned?.redacted_because) continue;
-		if (!isPollEndType(typeof event.type === "string" ? event.type : "")) continue;
-		if (event.sender !== params.sender) continue;
-		const ts = typeof event.origin_server_ts === "number" && Number.isFinite(event.origin_server_ts) ? event.origin_server_ts : Number.POSITIVE_INFINITY;
-		if (ts < pollClosedAt) pollClosedAt = ts;
-	}
-	const answerIds = new Set(parsed.answers.map((answer) => answer.id));
-	const latestVoteBySender = /* @__PURE__ */ new Map();
-	const orderedRelationEvents = [...params.relationEvents].toSorted((left, right) => {
-		const leftTs = typeof left.origin_server_ts === "number" && Number.isFinite(left.origin_server_ts) ? left.origin_server_ts : Number.POSITIVE_INFINITY;
-		const rightTs = typeof right.origin_server_ts === "number" && Number.isFinite(right.origin_server_ts) ? right.origin_server_ts : Number.POSITIVE_INFINITY;
-		if (leftTs !== rightTs) return leftTs - rightTs;
-		return (left.event_id ?? "").localeCompare(right.event_id ?? "");
-	});
-	for (const event of orderedRelationEvents) {
-		if (event.unsigned?.redacted_because) continue;
-		if (!isPollResponseType(typeof event.type === "string" ? event.type : "")) continue;
-		const senderId = normalizeOptionalString(event.sender) ?? "";
-		if (!senderId) continue;
-		const eventTs = typeof event.origin_server_ts === "number" && Number.isFinite(event.origin_server_ts) ? event.origin_server_ts : Number.POSITIVE_INFINITY;
-		if (eventTs > pollClosedAt) continue;
-		const rawAnswers = parsePollResponseAnswerIds(event.content) ?? [];
-		const normalizedAnswers = Array.from(new Set(rawAnswers.map((answerId) => normalizeOptionalString(answerId) ?? "").filter((answerId) => answerIds.has(answerId)).slice(0, parsed.maxSelections)));
-		latestVoteBySender.set(senderId, {
-			ts: eventTs,
-			eventId: typeof event.event_id === "string" ? event.event_id : "",
-			answerIds: normalizedAnswers
-		});
-	}
-	const voteCounts = new Map(parsed.answers.map((answer) => [answer.id, 0]));
-	let totalVotes = 0;
-	for (const latestVote of latestVoteBySender.values()) {
-		if (latestVote.answerIds.length === 0) continue;
-		totalVotes += 1;
-		for (const answerId of latestVote.answerIds) voteCounts.set(answerId, (voteCounts.get(answerId) ?? 0) + 1);
-	}
-	return {
-		eventId: params.pollEventId,
-		roomId: params.roomId,
-		sender: params.sender,
-		senderName: params.senderName,
-		question: parsed.question,
-		answers: parsed.answers.map((answer) => answer.text),
-		kind: parsed.kind,
-		maxSelections: parsed.maxSelections,
-		entries: parsed.answers.map((answer) => ({
-			id: answer.id,
-			text: answer.text,
-			votes: voteCounts.get(answer.id) ?? 0
-		})),
-		totalVotes,
-		closed: Number.isFinite(pollClosedAt)
-	};
-}
-function formatPollResultsAsText(summary) {
-	const lines = [
-		summary.closed ? "[Poll closed]" : "[Poll]",
-		summary.question,
-		""
-	];
-	const revealResults = summary.kind === "m.poll.disclosed" || summary.closed;
-	for (const [index, entry] of summary.entries.entries()) {
-		if (!revealResults) {
-			lines.push(`${index + 1}. ${entry.text}`);
-			continue;
-		}
-		lines.push(`${index + 1}. ${entry.text} (${entry.votes} vote${entry.votes === 1 ? "" : "s"})`);
-	}
-	lines.push("");
-	if (!revealResults) lines.push("Responses are hidden until the poll closes.");
-	else lines.push(`Total voters: ${summary.totalVotes}`);
-	return lines.join("\n");
-}
-function buildTextContent$1(body) {
-	return {
-		"m.text": body,
-		"org.matrix.msc1767.text": body
-	};
-}
-function buildPollFallbackText(question, answers) {
-	if (answers.length === 0) return question;
-	return `${question}\n${answers.map((answer, idx) => `${idx + 1}. ${answer}`).join("\n")}`;
-}
-function buildPollStartContent(poll) {
-	const normalized = normalizePollInput(poll);
-	const answers = normalized.options.map((option, idx) => ({
-		id: `answer${idx + 1}`,
-		...buildTextContent$1(option)
-	}));
-	const isMultiple = normalized.maxSelections > 1;
-	const fallbackText = buildPollFallbackText(normalized.question, answers.map((answer) => getTextContent(answer)));
-	return {
-		[M_POLL_START]: {
-			question: buildTextContent$1(normalized.question),
-			kind: isMultiple ? "m.poll.undisclosed" : "m.poll.disclosed",
-			max_selections: normalized.maxSelections,
-			answers
-		},
-		"m.text": fallbackText,
-		"org.matrix.msc1767.text": fallbackText
-	};
-}
-function buildPollResponseContent(pollEventId, answerIds) {
-	return {
-		[M_POLL_RESPONSE]: { answers: answerIds },
-		[ORG_POLL_RESPONSE]: { answers: answerIds },
-		"m.relates_to": {
-			rel_type: "m.reference",
-			event_id: pollEventId
-		}
-	};
-}
-//#endregion
-//#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] ?? ""
-	};
-}
-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;
-}
-function projectMatrixMarkdown(markdown) {
-	return renderMarkdownWithMarkers({
-		text: (markdown ?? "").replace(/\r\n?/gu, "\n"),
-		styles: [],
-		links: []
-	}, {
-		styleMarkers: {},
-		escapeText: (text) => text
-	}, MATRIX_FORMAT_PROFILE);
-}
-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,
-	breaks: true,
-	typographer: false
-});
-md.enable("strikethrough");
-const { escapeHtml } = md.utils;
-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;
-	const href = token.attrGet("href") ?? "";
-	const label = tokens[idx + 1]?.type === "text" ? tokens[idx + 1]?.content ?? "" : "";
-	return Boolean(href && label && isAutoLinkedFileRef(href, label));
-}
-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);
-md.renderer.rules.link_close = (tokens, idx, _options, _env, self) => {
-	const openIdx = idx - 2;
-	if (openIdx >= 0 && shouldSuppressAutoLink(tokens, openIdx)) return "";
-	return self.renderToken(tokens, idx, _options);
-};
-function maskEscapedMentions(markdown) {
-	let masked = "";
-	let idx = 0;
-	let codeFenceLength = 0;
-	while (idx < markdown.length) {
-		if (markdown[idx] === "`" && !isMarkdownEscaped(markdown, idx)) {
-			let runLength = 1;
-			while (markdown[idx + runLength] === "`") runLength += 1;
-			if (codeFenceLength === 0) codeFenceLength = runLength;
-			else if (runLength === codeFenceLength) codeFenceLength = 0;
-			masked += markdown.slice(idx, idx + runLength);
-			idx += runLength;
-			continue;
-		}
-		if (codeFenceLength === 0 && markdown[idx] === "\\" && markdown[idx + 1] === "@") {
-			masked += ESCAPED_MENTION_SENTINEL;
-			idx += 2;
-			continue;
-		}
-		masked += markdown[idx] ?? "";
-		idx += 1;
-	}
-	return masked;
-}
-function restoreEscapedMentions(text) {
-	return text.replaceAll(ESCAPED_MENTION_SENTINEL, "@");
-}
-function restoreEscapedMentionsInCode(text) {
-	return text.replaceAll(ESCAPED_MENTION_SENTINEL, "\\@");
-}
-function restoreEscapedMentionsInBlockTokens(tokens) {
-	for (const token of tokens) if ((token.type === "fence" || token.type === "code_block") && token.content) token.content = restoreEscapedMentionsInCode(token.content);
-}
-function isMentionStartBoundary(charBefore) {
-	return !charBefore || !/[A-Za-z0-9_]/.test(charBefore);
-}
-function trimMentionSuffix(rawInput, endInput) {
-	let raw = rawInput;
-	let end = endInput;
-	while (raw.length > 1 && TRIMMABLE_MENTION_SUFFIX.test(raw.at(-1) ?? "")) {
-		if (raw.at(-1) === "]" && /\[[0-9A-Fa-f:.]+\](?::\d+)?$/i.test(raw)) break;
-		raw = raw.slice(0, -1);
-		end -= 1;
-	}
-	if (!raw.startsWith("@") || raw === "@") return null;
-	return {
-		raw,
-		end
-	};
-}
-function isMatrixMentionUserId(raw) {
-	return isMatrixQualifiedUserId(raw) && MATRIX_MENTION_USER_ID_PATTERN.test(raw);
-}
-function buildMentionCandidate(raw, start) {
-	const normalized = trimMentionSuffix(raw, start + raw.length);
-	if (!normalized) return null;
-	const kind = normalizeLowercaseStringOrEmpty(normalized.raw) === "@room" ? "room" : "user";
-	const base = {
-		raw: normalized.raw,
-		start,
-		end: normalized.end,
-		kind
-	};
-	if (kind === "room") return base;
-	const userCandidate = isMatrixMentionUserId(normalized.raw) ? {
-		...base,
-		userId: normalized.raw
-	} : null;
-	if (!userCandidate) return null;
-	return userCandidate;
-}
-function collectMentionCandidates(text) {
-	const mentions = [];
-	for (const match of text.matchAll(MENTION_PATTERN)) {
-		const raw = match[0];
-		const start = match.index ?? -1;
-		if (start < 0 || !raw) continue;
-		if (!isMentionStartBoundary(text[start - 1])) continue;
-		const candidate = buildMentionCandidate(raw, start);
-		if (!candidate) continue;
-		mentions.push(candidate);
-	}
-	return mentions;
-}
-function createToken(sample, type, tag, nesting) {
-	const TokenCtor = sample.constructor;
-	return new TokenCtor(type, tag, nesting);
-}
-function createTextToken(sample, content) {
-	const token = createToken(sample, "text", "", 0);
-	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);
-	return [
-		open,
-		createTextToken(params.sample, params.label),
-		createToken(params.sample, "link_close", "a", -1)
-	];
-}
-function resolveMentionUserId(match) {
-	if (match.kind !== "user") return null;
-	return match.userId ?? null;
-}
-async function resolveMatrixSelfUserId(client) {
-	const getUserId = client.getUserId;
-	if (typeof getUserId !== "function") return null;
-	return await Promise.resolve(getUserId.call(client)).catch(() => null);
-}
-function mutateInlineTokensWithMentions(params) {
-	const nextChildren = [];
-	let roomMentioned = false;
-	let insideLinkDepth = 0;
-	for (const child of params.children) {
-		if (child.type === "link_open") {
-			insideLinkDepth += 1;
-			nextChildren.push(child);
-			continue;
-		}
-		if (child.type === "link_close") {
-			insideLinkDepth = Math.max(0, insideLinkDepth - 1);
-			nextChildren.push(child);
-			continue;
-		}
-		if (child.type !== "text" || !child.content) {
-			nextChildren.push(child);
-			continue;
-		}
-		const visibleContent = restoreEscapedMentions(child.content);
-		if (insideLinkDepth > 0) {
-			nextChildren.push(createTextToken(child, visibleContent));
-			continue;
-		}
-		const matches = collectMentionCandidates(child.content);
-		if (matches.length === 0) {
-			nextChildren.push(createTextToken(child, visibleContent));
-			continue;
-		}
-		let cursor = 0;
-		for (const match of matches) {
-			if (match.start > cursor) nextChildren.push(createTextToken(child, restoreEscapedMentions(child.content.slice(cursor, match.start))));
-			cursor = match.end;
-			if (match.kind === "room") {
-				roomMentioned = true;
-				nextChildren.push(createTextToken(child, match.raw));
-				continue;
-			}
-			const resolvedUserId = resolveMentionUserId(match);
-			if (!resolvedUserId || resolvedUserId === params.selfUserId) {
-				nextChildren.push(createTextToken(child, match.raw));
-				continue;
-			}
-			if (!params.seenUserIds.has(resolvedUserId)) {
-				params.seenUserIds.add(resolvedUserId);
-				params.userIds.push(resolvedUserId);
-			}
-			nextChildren.push(...createMentionLinkTokens({
-				sample: child,
-				href: `https://matrix.to/#/${encodeURIComponent(resolvedUserId)}`,
-				label: match.raw
-			}));
-		}
-		if (cursor < child.content.length) nextChildren.push(createTextToken(child, restoreEscapedMentions(child.content.slice(cursor))));
-	}
-	return {
-		children: nextChildren,
-		roomMentioned
-	};
-}
-function compactLooseListTokens(tokens) {
-	const listItemStack = [];
-	for (const [index, token] of tokens.entries()) {
-		if (token.type === "list_item_open") {
-			listItemStack.push({
-				level: token.level,
-				immediateParagraphOpenIndexes: [],
-				immediateParagraphCloseIndexes: []
-			});
-			continue;
-		}
-		if (token.type === "list_item_close") {
-			const item = listItemStack.pop();
-			if (item && item.immediateParagraphOpenIndexes.length === 1 && item.immediateParagraphCloseIndexes.length === 1) {
-				const openIndex = item.immediateParagraphOpenIndexes[0];
-				const closeIndex = item.immediateParagraphCloseIndexes[0];
-				const openToken = openIndex === void 0 ? void 0 : tokens[openIndex];
-				const closeToken = closeIndex === void 0 ? void 0 : tokens[closeIndex];
-				if (openToken && closeToken) {
-					openToken.hidden = true;
-					closeToken.hidden = true;
-				}
-			}
-			continue;
-		}
-		const currentItem = listItemStack.at(-1);
-		if (!currentItem || token.level !== currentItem.level + 1) continue;
-		if (token.type === "paragraph_open") currentItem.immediateParagraphOpenIndexes.push(index);
-		else if (token.type === "paragraph_close") currentItem.immediateParagraphCloseIndexes.push(index);
-	}
-}
-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 tokens = parseMatrixMarkdown(maskEscapedMentions(projectMatrixMarkdown(params.markdown)), params.tableMode);
-	restoreEscapedMentionsInBlockTokens(tokens);
-	const selfUserId = await resolveMatrixSelfUserId(params.client);
-	const userIds = [];
-	const seenUserIds = /* @__PURE__ */ new Set();
-	let roomMentioned = false;
-	for (const token of tokens) {
-		if (!token.children?.length) continue;
-		const mutated = mutateInlineTokensWithMentions({
-			children: token.children,
-			userIds,
-			seenUserIds,
-			selfUserId
-		});
-		token.children = mutated.children;
-		roomMentioned ||= mutated.roomMentioned;
-	}
-	const mentions = {};
-	if (userIds.length > 0) mentions.user_ids = userIds;
-	if (roomMentioned) mentions.room = true;
-	return {
-		tokens,
-		mentions
-	};
-}
-async function resolveMatrixMentionsInMarkdown(params) {
-	return (await resolveMarkdownMentionState(params)).mentions;
-}
-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,
-		mentions: state.mentions
-	};
-}
-//#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",
-	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/send/formatting.ts
-const getCore$1 = () => getMatrixRuntime();
-async function renderMatrixFormattedContent(params) {
-	const markdown = params.markdown ?? "";
-	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,
-		tableMode: params.tableMode
-	});
-	return {
-		body,
-		html,
-		mentions
-	};
-}
-function buildTextContent(body, relation, opts = {}) {
-	const msgtype = opts.msgtype ?? MsgType.Text;
-	return relation ? {
-		msgtype,
-		body,
-		"m.relates_to": relation
-	} : {
-		msgtype,
-		body
-	};
-}
-async function enrichMatrixFormattedContent(params) {
-	const { body, html, mentions } = await renderMatrixFormattedContent({
-		client: params.client,
-		markdown: params.markdown,
-		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) {
-		delete params.content.format;
-		delete params.content.formatted_body;
-		return;
-	}
-	params.content.format = "org.matrix.custom.html";
-	params.content.formatted_body = html;
-}
-async function resolveMatrixMentionsForBody(params) {
-	return await resolveMatrixMentionsInMarkdown({
-		markdown: params.body ?? "",
-		client: params.client
-	});
-}
-function normalizeMentionUserIds(value) {
-	return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
-}
-function extractMatrixMentions(content) {
-	const rawMentions = content?.["m.mentions"];
-	if (!rawMentions || typeof rawMentions !== "object") return {};
-	const mentions = rawMentions;
-	const normalized = {};
-	const userIds = normalizeMentionUserIds(mentions.user_ids);
-	if (userIds.length > 0) normalized.user_ids = userIds;
-	if (mentions.room === true) normalized.room = true;
-	return normalized;
-}
-function diffMatrixMentions(current, previous) {
-	const previousUserIds = new Set(previous.user_ids ?? []);
-	const newUserIds = (current.user_ids ?? []).filter((userId) => !previousUserIds.has(userId));
-	const delta = {};
-	if (newUserIds.length > 0) delta.user_ids = newUserIds;
-	if (current.room && !previous.room) delta.room = true;
-	return delta;
-}
-function buildReplyRelation(replyToId) {
-	const trimmed = replyToId?.trim();
-	if (!trimmed) return;
-	return { "m.in_reply_to": { event_id: trimmed } };
-}
-function buildThreadRelation(threadId, replyToId) {
-	const trimmed = threadId.trim();
-	const relation = {
-		rel_type: RelationType.Thread,
-		event_id: trimmed
-	};
-	const fallbackReplyToId = replyToId?.trim();
-	if (fallbackReplyToId) {
-		relation.is_falling_back = true;
-		relation["m.in_reply_to"] = { event_id: fallbackReplyToId };
-	}
-	return relation;
-}
-function resolveMatrixMsgType(contentType, _fileName) {
-	switch (getCore$1().media.mediaKindFromMime(contentType ?? "")) {
-		case "image": return MsgType.Image;
-		case "audio": return MsgType.Audio;
-		case "video": return MsgType.Video;
-		default: return MsgType.File;
-	}
-}
-function resolveMatrixVoiceDecision(opts) {
-	if (!opts.wantsVoice) return { useVoice: false };
-	if (isMatrixVoiceCompatibleAudio(opts)) return { useVoice: true };
-	return { useVoice: false };
-}
-function isMatrixVoiceCompatibleAudio(opts) {
-	return isVoiceMessageCompatibleAudio({
-		contentType: opts.contentType,
-		fileName: opts.fileName
-	});
-}
-//#endregion
-//#region extensions/matrix/src/matrix/send/media.ts
-const getCore = () => getMatrixRuntime();
-function buildMatrixMediaInfo(params) {
-	const base = {};
-	if (Number.isFinite(params.size)) base.size = params.size;
-	if (params.mimetype) base.mimetype = params.mimetype;
-	if (params.imageInfo) {
-		const dimensional = {
-			...base,
-			...params.imageInfo
-		};
-		if (typeof params.durationMs === "number") return {
-			...dimensional,
-			duration: params.durationMs
-		};
-		return dimensional;
-	}
-	if (typeof params.durationMs === "number") return {
-		...base,
-		duration: params.durationMs
-	};
-	if (Object.keys(base).length === 0) return;
-	return base;
-}
-function buildMediaContent(params) {
-	const info = buildMatrixMediaInfo({
-		size: params.size,
-		mimetype: params.mimetype,
-		durationMs: params.durationMs,
-		imageInfo: params.imageInfo
-	});
-	const base = {
-		msgtype: params.msgtype,
-		body: params.body,
-		filename: params.filename,
-		info: info ?? void 0
-	};
-	if (!params.file && params.url) base.url = params.url;
-	if (params.file) base.file = params.file;
-	if (params.isVoice) {
-		base["org.matrix.msc3245.voice"] = {};
-		if (typeof params.durationMs === "number") base["org.matrix.msc1767.audio"] = { duration: params.durationMs };
-	}
-	if (params.relation) base["m.relates_to"] = params.relation;
-	return base;
-}
-const THUMBNAIL_MAX_SIDE = 800;
-const THUMBNAIL_QUALITY = 80;
-async function prepareImageInfo(params) {
-	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().media.resizeToJpeg({
-			buffer: params.buffer,
-			maxSide: THUMBNAIL_MAX_SIDE,
-			quality: THUMBNAIL_QUALITY,
-			withoutEnlargement: true
-		});
-		const thumbMeta = await getCore().media.getImageMetadata(thumbBuffer).catch(() => null);
-		const result = await uploadMediaWithEncryption(params.client, thumbBuffer, {
-			contentType: "image/jpeg",
-			filename: "thumbnail.jpg",
-			encrypted: params.encrypted === true
-		});
-		if (result.file) imageInfo.thumbnail_file = result.file;
-		else imageInfo.thumbnail_url = result.url;
-		if (thumbMeta) imageInfo.thumbnail_info = {
-			w: thumbMeta.width,
-			h: thumbMeta.height,
-			mimetype: "image/jpeg",
-			size: thumbBuffer.byteLength
-		};
-	} catch {}
-	return imageInfo;
-}
-async function resolveMediaDurationMs(params) {
-	if (params.kind !== "audio" && params.kind !== "video") return;
-	try {
-		const fileInfo = params.contentType || params.fileName ? {
-			mimeType: params.contentType,
-			size: params.buffer.byteLength,
-			path: params.fileName
-		} : void 0;
-		const durationSeconds = (await parseBuffer(params.buffer, fileInfo, {
-			duration: true,
-			skipCovers: true
-		})).format.duration;
-		if (typeof durationSeconds === "number" && Number.isFinite(durationSeconds)) return Math.max(0, Math.round(durationSeconds * 1e3));
-	} catch {}
-}
-async function uploadFile(client, file, params) {
-	return await client.uploadContent(file, params.contentType, params.filename);
-}
-async function uploadMediaWithEncryption(client, buffer, params) {
-	if (params.encrypted && client.crypto) {
-		const encrypted = await client.crypto.encryptMedia(buffer);
-		const mxc = await client.uploadContent(encrypted.buffer, params.contentType, params.filename);
-		return {
-			url: mxc,
-			file: {
-				url: mxc,
-				...encrypted.file
-			}
-		};
-	}
-	return { url: await uploadFile(client, buffer, params) };
-}
-/**
-* Upload media with optional encryption for E2EE rooms.
-*/
-async function uploadMediaMaybeEncrypted(client, roomId, buffer, params) {
-	const isEncrypted = Boolean(client.crypto && await client.crypto.isRoomEncrypted(roomId));
-	return await uploadMediaWithEncryption(client, buffer, {
-		...params,
-		encrypted: isEncrypted
-	});
-}
-//#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
-//#region extensions/matrix/src/matrix/send/targets.ts
-function normalizeTarget(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) throw new Error("Matrix target is required (room:<id> or #alias)");
-	return trimmed;
-}
-function normalizeThreadId(raw) {
-	return normalizeOptionalStringifiedId(raw) ?? null;
-}
-const MAX_DIRECT_ROOM_CACHE_SIZE = 1024;
-const directRoomCacheByClient = /* @__PURE__ */ new WeakMap();
-function resolveDirectRoomCache(client) {
-	const existing = directRoomCacheByClient.get(client);
-	if (existing) return existing;
-	const created = /* @__PURE__ */ new Map();
-	directRoomCacheByClient.set(client, created);
-	return created;
-}
-function setDirectRoomCached(client, key, value) {
-	const directRoomCache = resolveDirectRoomCache(client);
-	directRoomCache.set(key, value);
-	if (directRoomCache.size > MAX_DIRECT_ROOM_CACHE_SIZE) {
-		const oldest = directRoomCache.keys().next().value;
-		if (oldest !== void 0) directRoomCache.delete(oldest);
-	}
-}
-async function resolveDirectRoomId(client, userId) {
-	const trimmed = userId.trim();
-	if (!isMatrixQualifiedUserId(trimmed)) throw new Error(`Matrix user IDs must be fully qualified (got "${trimmed}")`);
-	const selfUserId = (await client.getUserId().catch(() => null))?.trim() || null;
-	const directRoomCache = resolveDirectRoomCache(client);
-	const cached = directRoomCache.get(trimmed);
-	if (cached && await isStrictDirectRoom({
-		client,
-		roomId: cached,
-		remoteUserId: trimmed,
-		selfUserId
-	})) return cached;
-	if (cached) directRoomCache.delete(trimmed);
-	const inspection = await inspectMatrixDirectRooms({
-		client,
-		remoteUserId: trimmed
-	});
-	if (inspection.activeRoomId) {
-		setDirectRoomCached(client, trimmed, inspection.activeRoomId);
-		if (inspection.mappedRoomIds[0] !== inspection.activeRoomId) await persistMatrixDirectRoomMapping({
-			client,
-			remoteUserId: trimmed,
-			roomId: inspection.activeRoomId
-		}).catch(() => {});
-		return inspection.activeRoomId;
-	}
-	throw new Error(`No direct room found for ${trimmed} (m.direct missing)`);
-}
-async function resolveMatrixRoomId(client, raw) {
-	const target = normalizeMatrixResolvableTarget(normalizeTarget(raw));
-	if (normalizeLowercaseStringOrEmpty(target).startsWith("user:")) return await resolveDirectRoomId(client, target.slice(5));
-	if (isMatrixQualifiedUserId(target)) return await resolveDirectRoomId(client, target);
-	if (target.startsWith("#")) {
-		const resolved = await client.resolveRoom(target);
-		if (!resolved) throw new Error(`Matrix alias ${target} could not be resolved`);
-		return resolved;
-	}
-	return target;
-}
-//#endregion
-//#region extensions/matrix/src/matrix/send.ts
-var send_exports = /* @__PURE__ */ __exportAll({
-	chunkMatrixText: () => chunkMatrixText,
-	editMessageMatrix: () => editMessageMatrix,
-	prepareMatrixSingleText: () => prepareMatrixSingleText,
-	reactMatrixMessage: () => reactMatrixMessage,
-	resolveMatrixMentionsForBody: () => resolveMatrixMentionsForBody,
-	resolveMatrixRoomId: () => resolveMatrixRoomId,
-	sendMessageMatrix: () => sendMessageMatrix,
-	sendPollMatrix: () => sendPollMatrix,
-	sendReadReceiptMatrix: () => sendReadReceiptMatrix,
-	sendSingleTextMessageMatrix: () => sendSingleTextMessageMatrix,
-	sendTypingMatrix: () => sendTypingMatrix
-});
-function createMatrixSendReceipt(params) {
-	return createMessageReceiptFromOutboundResults({
-		kind: params.kind,
-		...params.replyToId ? { replyToId: params.replyToId } : {},
-		...params.threadId ? { threadId: params.threadId } : {},
-		results: params.platformMessageIds.map((messageId) => ({
-			channel: "matrix",
-			messageId,
-			roomId: params.roomId
-		}))
-	});
-}
-function isMatrixClient(value) {
-	return typeof value.sendEvent === "function";
-}
-function normalizeMatrixClientResolveOpts(opts) {
-	if (!opts) return {};
-	if (isMatrixClient(opts)) return { client: opts };
-	return {
-		client: opts.client,
-		cfg: opts.cfg,
-		timeoutMs: opts.timeoutMs,
-		accountId: opts.accountId
-	};
-}
-function resolvePreviousEditContent(previousEvent) {
-	if (!previousEvent || typeof previousEvent !== "object") return;
-	const eventRecord = previousEvent;
-	if (!eventRecord.content || typeof eventRecord.content !== "object") return;
-	const content = eventRecord.content;
-	const newContent = content["m.new_content"];
-	return newContent && typeof newContent === "object" ? newContent : content;
-}
-function resolvePreviousThreadId(previousEvent) {
-	if (!previousEvent || typeof previousEvent !== "object") return;
-	const content = previousEvent.content;
-	if (!content || typeof content !== "object") return;
-	const relation = content["m.relates_to"];
-	if (!relation || typeof relation !== "object") return;
-	const relationRecord = relation;
-	if (relationRecord.rel_type !== RelationType.Thread || typeof relationRecord.event_id !== "string") return;
-	return normalizeThreadId(relationRecord.event_id) ?? void 0;
-}
-function hasMatrixMentionsMetadata(content) {
-	return Boolean(content && Object.hasOwn(content, "m.mentions"));
-}
-function withMatrixExtraContentFields(content, extraContent) {
-	if (!extraContent) return content;
-	return {
-		...content,
-		...extraContent
-	};
-}
-async function resolvePreviousEditMentions(params) {
-	if (hasMatrixMentionsMetadata(params.content)) return extractMatrixMentions(params.content);
-	const body = typeof params.content?.body === "string" ? params.content.body : "";
-	if (!body) return {};
-	return await resolveMatrixMentionsForBody({
-		client: params.client,
-		body
-	});
-}
-async function sendMessageMatrix(to, message, opts) {
-	const trimmedMessage = message?.trim() ?? "";
-	if (!trimmedMessage && !opts.mediaUrl) throw new Error("Matrix send requires text or media");
-	return await withResolvedMatrixSendClient({
-		client: opts.client,
-		cfg: opts.cfg,
-		timeoutMs: opts.timeoutMs,
-		accountId: opts.accountId
-	}, async (client) => {
-		const roomId = await resolveMatrixRoomId(client, to);
-		const cfg = requireRuntimeConfig(opts.cfg, "Matrix send");
-		const { chunks, tableMode } = chunkMatrixText(trimmedMessage, {
-			cfg,
-			accountId: opts.accountId
-		});
-		const threadId = normalizeThreadId(opts.threadId);
-		const relation = threadId ? buildThreadRelation(threadId, opts.replyToId) : buildReplyRelation(opts.replyToId);
-		let pendingExtraContent = opts.extraContent;
-		const sendContent = async (content, kind) => {
-			const contentWithExtra = withMatrixExtraContentFields(content, pendingExtraContent);
-			pendingExtraContent = void 0;
-			const eventId = await client.sendMessage(roomId, contentWithExtra);
-			if (eventId) await opts.onDeliveryResult?.({
-				messageId: eventId,
-				roomId,
-				primaryMessageId: eventId,
-				receipt: createMatrixSendReceipt({
-					roomId,
-					platformMessageIds: [eventId],
-					kind,
-					replyToId: opts.replyToId,
-					threadId
-				})
-			});
-			return eventId;
-		};
-		const platformMessageIds = [];
-		let lastMessageId = "";
-		let receiptKind = "text";
-		if (opts.mediaUrl) {
-			const maxBytes = resolveMediaMaxBytes(opts.accountId, cfg);
-			const media = await loadOutboundMediaFromUrl(opts.mediaUrl, {
-				maxBytes,
-				mediaAccess: opts.mediaAccess,
-				mediaLocalRoots: opts.mediaLocalRoots,
-				mediaReadFile: opts.mediaReadFile
-			});
-			const uploaded = await uploadMediaMaybeEncrypted(client, roomId, media.buffer, {
-				contentType: media.contentType,
-				filename: media.fileName
-			});
-			const durationMs = await resolveMediaDurationMs({
-				buffer: media.buffer,
-				contentType: media.contentType,
-				fileName: media.fileName,
-				kind: media.kind === "sticker" ? "unknown" : media.kind ?? "unknown"
-			});
-			const baseMsgType = resolveMatrixMsgType(media.contentType, media.fileName);
-			const { useVoice } = resolveMatrixVoiceDecision({
-				wantsVoice: opts.audioAsVoice === true,
-				contentType: media.contentType,
-				fileName: media.fileName
-			});
-			const msgtype = useVoice ? MsgType.Audio : baseMsgType;
-			receiptKind = useVoice ? "voice" : "media";
-			const imageInfo = msgtype === MsgType.Image ? await prepareImageInfo({
-				buffer: media.buffer,
-				client,
-				encrypted: Boolean(uploaded.file)
-			}) : void 0;
-			const [firstChunk, ...rest] = chunks;
-			const captionMarkdown = useVoice ? "" : firstChunk ?? "";
-			const content = buildMediaContent({
-				msgtype,
-				body: useVoice ? "Voice message" : captionMarkdown || media.fileName || "(file)",
-				url: uploaded.url,
-				file: uploaded.file,
-				filename: media.fileName,
-				mimetype: media.contentType,
-				size: media.buffer.byteLength,
-				durationMs,
-				relation,
-				isVoice: useVoice,
-				imageInfo
-			});
-			await enrichMatrixFormattedContent({
-				client,
-				content,
-				markdown: captionMarkdown,
-				tableMode
-			});
-			const eventId = await sendContent(content, receiptKind);
-			lastMessageId = eventId ?? lastMessageId;
-			if (eventId) platformMessageIds.push(eventId);
-			const textChunks = useVoice ? chunks : rest;
-			const followupRelation = useVoice || threadId ? relation : void 0;
-			for (const chunk of textChunks) {
-				const text = chunk;
-				if (!text.trim()) continue;
-				const followup = buildTextContent(text, followupRelation);
-				await enrichMatrixFormattedContent({
-					client,
-					content: followup,
-					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;
-			if (!text.trim()) continue;
-			const content = buildTextContent(text, relation);
-			await enrichMatrixFormattedContent({
-				client,
-				content,
-				markdown: text,
-				tableMode
-			});
-			const eventId = await sendContent(content, "text");
-			lastMessageId = eventId ?? lastMessageId;
-			if (eventId) platformMessageIds.push(eventId);
-		}
-		return {
-			messageId: lastMessageId || "unknown",
-			roomId,
-			primaryMessageId: platformMessageIds[0] ?? (lastMessageId || "unknown"),
-			receipt: createMatrixSendReceipt({
-				roomId,
-				platformMessageIds,
-				kind: receiptKind,
-				replyToId: opts.replyToId,
-				threadId
-			})
-		};
-	});
-}
-async function sendPollMatrix(to, poll, opts) {
-	if (!poll.question?.trim()) throw new Error("Matrix poll requires a question");
-	if (!poll.options?.length) throw new Error("Matrix poll requires options");
-	return await withResolvedMatrixSendClient({
-		client: opts.client,
-		cfg: opts.cfg,
-		timeoutMs: opts.timeoutMs,
-		accountId: opts.accountId
-	}, async (client) => {
-		const roomId = await resolveMatrixRoomId(client, to);
-		const pollContent = buildPollStartContent(poll);
-		const mentions = await resolveMatrixMentionsForBody({
-			client,
-			body: pollContent["m.text"] ?? pollContent["org.matrix.msc1767.text"] ?? poll.question ?? ""
-		});
-		const threadId = normalizeThreadId(opts.threadId);
-		const pollPayload = threadId ? {
-			...pollContent,
-			"m.relates_to": buildThreadRelation(threadId)
-		} : { ...pollContent };
-		pollPayload["m.mentions"] = mentions;
-		return {
-			eventId: await client.sendEvent(roomId, "m.poll.start", pollPayload) ?? "unknown",
-			roomId
-		};
-	});
-}
-async function sendTypingMatrix(roomId, typing, optsOrTimeoutMs, client) {
-	const opts = typeof optsOrTimeoutMs === "number" ? {
-		timeoutMs: optsOrTimeoutMs,
-		...client ? { client } : {}
-	} : {
-		...normalizeMatrixClientResolveOpts(optsOrTimeoutMs),
-		...client ? { client } : {}
-	};
-	await withResolvedMatrixControlClient({
-		client: opts.client,
-		cfg: opts.cfg,
-		timeoutMs: opts.timeoutMs,
-		accountId: opts.accountId
-	}, async (resolved) => {
-		const resolvedRoom = await resolveMatrixRoomId(resolved, roomId);
-		const resolvedTimeoutMs = typeof opts.timeoutMs === "number" ? opts.timeoutMs : 3e4;
-		await resolved.setTyping(resolvedRoom, typing, resolvedTimeoutMs);
-	});
-}
-async function sendReadReceiptMatrix(roomId, eventId, client) {
-	if (!eventId?.trim()) return;
-	await withResolvedMatrixControlClient({ client }, async (resolved) => {
-		const resolvedRoom = await resolveMatrixRoomId(resolved, roomId);
-		await resolved.sendReadReceipt(resolvedRoom, eventId.trim());
-	});
-}
-async function sendSingleTextMessageMatrix(roomId, text, opts) {
-	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 (${eventTextLength} > ${singleEventLimit})`);
-	return await withResolvedMatrixSendClient({
-		client: opts.client,
-		cfg: opts.cfg,
-		accountId: opts.accountId
-	}, async (client) => {
-		const resolvedRoom = await resolveMatrixRoomId(client, roomId);
-		const normalizedThreadId = normalizeThreadId(opts.threadId);
-		const relation = normalizedThreadId ? buildThreadRelation(normalizedThreadId, opts.replyToId) : buildReplyRelation(opts.replyToId);
-		const content = withMatrixExtraContentFields(buildTextContent(convertedText, relation, { msgtype: opts.msgtype }), opts.extraContent);
-		await enrichMatrixFormattedContent({
-			client,
-			content,
-			markdown: convertedText,
-			includeMentions: opts.includeMentions,
-			tableMode
-		});
-		if (opts.live) content[MSC4357_LIVE_KEY] = {};
-		const eventId = await client.sendMessage(resolvedRoom, content);
-		return {
-			messageId: eventId ?? "unknown",
-			roomId: resolvedRoom,
-			primaryMessageId: eventId ?? "unknown",
-			receipt: createMatrixSendReceipt({
-				roomId: resolvedRoom,
-				platformMessageIds: eventId ? [eventId] : [],
-				kind: "text",
-				replyToId: opts.replyToId,
-				threadId: normalizedThreadId
-			})
-		};
-	});
-}
-async function getPreviousMatrixEvent(client, roomId, eventId) {
-	const getEvent = client.getEvent;
-	if (typeof getEvent !== "function") return null;
-	return await Promise.resolve(getEvent.call(client, roomId, eventId)).catch(() => null);
-}
-async function editMessageMatrix(roomId, originalEventId, newText, opts) {
-	return await withResolvedMatrixSendClient({
-		client: opts.client,
-		cfg: opts.cfg,
-		accountId: opts.accountId,
-		timeoutMs: opts.timeoutMs
-	}, async (client) => {
-		const resolvedRoom = await resolveMatrixRoomId(client, roomId);
-		const { convertedText, tableMode } = prepareMatrixSingleText(newText, {
-			cfg: requireRuntimeConfig(opts.cfg, "Matrix message edit"),
-			accountId: opts.accountId,
-			preserveWhitespace: true
-		});
-		const newContent = withMatrixExtraContentFields(buildTextContent(convertedText, void 0, { msgtype: opts.msgtype }), opts.extraContent);
-		await enrichMatrixFormattedContent({
-			client,
-			content: newContent,
-			markdown: convertedText,
-			includeMentions: opts.includeMentions,
-			tableMode
-		});
-		const previousEvent = await getPreviousMatrixEvent(client, resolvedRoom, originalEventId);
-		const replaceMentions = opts.includeMentions === false ? void 0 : diffMatrixMentions(extractMatrixMentions(newContent), await resolvePreviousEditMentions({
-			client,
-			content: resolvePreviousEditContent(previousEvent)
-		}));
-		const replaceRelation = {
-			rel_type: RelationType.Replace,
-			event_id: originalEventId
-		};
-		const threadId = normalizeThreadId(opts.threadId);
-		if (threadId) {
-			if (resolvePreviousThreadId(previousEvent) !== threadId) throw new Error("Matrix edit cannot add or change the original event thread relation.");
-		}
-		const content = {
-			...newContent,
-			body: `* ${newContent.body}`,
-			...typeof newContent.formatted_body === "string" ? { formatted_body: `* ${newContent.formatted_body}` } : {},
-			"m.new_content": newContent,
-			"m.relates_to": replaceRelation
-		};
-		if (replaceMentions !== void 0) content["m.mentions"] = replaceMentions;
-		if (opts.live) {
-			content[MSC4357_LIVE_KEY] = {};
-			content["m.new_content"][MSC4357_LIVE_KEY] = {};
-		}
-		return await client.sendMessage(resolvedRoom, content) ?? "";
-	});
-}
-async function reactMatrixMessage(roomId, messageId, emoji, opts) {
-	const clientOpts = normalizeMatrixClientResolveOpts(opts);
-	await withResolvedMatrixSendClient({
-		client: clientOpts.client,
-		cfg: clientOpts.cfg,
-		timeoutMs: clientOpts.timeoutMs,
-		accountId: clientOpts.accountId ?? void 0
-	}, async (resolved) => {
-		const resolvedRoom = await resolveMatrixRoomId(resolved, roomId);
-		const reaction = buildMatrixReactionContent(messageId, emoji);
-		await resolved.sendEvent(resolvedRoom, EventType.Reaction, reaction);
-	});
-}
-//#endregion
-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 };