@openclaw/matrix 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{send-BldGYG8g.js → send-ClHgDZLT.js}

@@ -1,249 +1,834 @@
 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 { i as normalizeMatrixResolvableTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.js";
 import { n as MATRIX_REACTION_EVENT_TYPE, r as buildMatrixReactionContent, t as MATRIX_ANNOTATION_RELATION_TYPE } from "./reaction-common-DkrQdBSZ.js";
+import { a as isStrictDirectRoom, r as inspectMatrixDirectRoomEvidence } from "./direct-room-RinHjtqX.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 { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { FormatCapabilityProfile, convertMarkdownTables, findCodeRegions, isInsideCode, markdownToIR, renderMarkdownWithMarkers, tokenizeHtmlTags } from "openclaw/plugin-sdk/text-chunking";
+import { createHash } from "node:crypto";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 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
+//#region extensions/matrix/src/matrix/send/client.ts
+const loadMatrixSendClientRuntime = createLazyRuntimeModule(() => import("./client-bootstrap-Co3RlItb.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 mediaMaxMb = resolveMatrixAccountConfig({
+		cfg: requireRuntimeConfig(cfg, "Matrix media limits"),
+		accountId
+	}).mediaMaxMb;
+	return typeof mediaMaxMb === "number" && mediaMaxMb > 0 ? mediaMaxMb * 1024 * 1024 : void 0;
+}
+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";
 /**
-* 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
+* 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 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);
+const MSC4357_LIVE_KEY = "org.matrix.msc4357.live";
+//#endregion
+//#region extensions/matrix/src/matrix/direct-management.ts
+var direct_management_exports = /* @__PURE__ */ __exportAll({
+	inspectMatrixDirectRooms: () => inspectMatrixDirectRooms,
+	persistMatrixDirectRoomMapping: () => persistMatrixDirectRoomMapping,
+	promoteMatrixDirectRoomCandidate: () => promoteMatrixDirectRoomCandidate,
+	repairMatrixDirectRooms: () => repairMatrixDirectRooms
+});
+const DIRECT_ACCOUNT_DATA_QUEUE_KEY = EventType.Direct;
+const directAccountDataWriteQueues = /* @__PURE__ */ new WeakMap();
+async function readMatrixDirectAccountData(client) {
+	try {
+		const direct = await client.getAccountData(EventType.Direct);
+		return direct && typeof direct === "object" && !Array.isArray(direct) ? direct : {};
+	} catch {
+		return {};
+	}
 }
-function isPollResponseType(eventType) {
-	return POLL_RESPONSE_TYPES.includes(eventType);
+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 isPollEndType(eventType) {
-	return POLL_END_TYPES.includes(eventType);
+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 isPollEventType(eventType) {
-	return POLL_EVENT_TYPES.includes(eventType);
+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 getTextContent(text) {
-	if (!text) return "";
-	return text["m.text"] ?? text["org.matrix.msc1767.text"] ?? text.body ?? "";
+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 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;
+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 {
-		question,
-		answers,
-		kind: poll.kind ?? "m.poll.disclosed",
-		maxSelections: Math.min(Math.max(maxSelections, 1), answers.length)
+		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 parsePollStartContent(content) {
-	const parsed = parsePollStart(content);
-	if (!parsed) return null;
+function buildNextDirectContent(params) {
+	const current = normalizeMappedRoomIds(params.directContent, params.remoteUserId);
+	const nextRooms = normalizeRoomIdList([...params.roomIds, ...current]);
 	return {
-		eventId: "",
-		roomId: "",
-		sender: "",
-		senderName: "",
-		question: parsed.question,
-		answers: parsed.answers.map((answer) => answer.text),
-		kind: parsed.kind,
-		maxSelections: parsed.maxSelections
+		...params.directContent,
+		[params.remoteUserId]: nextRooms
 	};
 }
-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");
+async function persistMatrixDirectRoomMapping(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	return (await writeMatrixDirectRoomMappings({
+		client: params.client,
+		remoteUserId,
+		roomIds: [params.roomId]
+	})).changed;
 }
-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 ?? "");
+async function promoteMatrixDirectRoomCandidate(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	const evidence = await inspectMatrixDirectRoomEvidence({
+		client: params.client,
+		roomId: params.roomId,
+		remoteUserId,
+		selfUserId: params.selfUserId
 	});
-	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
+	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"
+		};
 	}
-	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);
+}
+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 {
-		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)
+		selfUserId,
+		remoteUserId,
+		mappedRoomIds,
+		mappedRooms,
+		discoveredStrictRoomIds,
+		activeRoomId: mappedStrict?.roomId ?? discoveredExplicit?.roomId ?? discoveredStrictRoomIds[0] ?? null
 	};
 }
-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) {
+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 {
-		"m.text": body,
-		"org.matrix.msc1767.text": body
+		...inspected,
+		activeRoomId,
+		createdRoomId,
+		changed: mappingWrite.changed,
+		directContentBefore: mappingWrite.directContentBefore,
+		directContentAfter: mappingWrite.directContentAfter
 	};
 }
-function buildPollFallbackText(question, answers) {
-	if (answers.length === 0) return question;
-	return `${question}\n${answers.map((answer, idx) => `${idx + 1}. ${answer}`).join("\n")}`;
+//#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 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 normalizeThreadId(raw) {
+	return normalizeOptionalStringifiedId(raw) ?? null;
 }
-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
-		}
-	};
+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/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);
+//#region extensions/matrix/src/matrix/delivery-plan.ts
+const DELIVERY_PLAN_VERSION = 1;
+const DELIVERY_PLAN_NAMESPACE = "outbound-delivery-plans";
+const DELIVERY_PLAN_TTL_MS = 1440 * 60 * 1e3;
+var MatrixDeliveryPlanInvariantError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "MatrixDeliveryPlanInvariantError";
 	}
-	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);
+};
+function createDeliveryPlanStore() {
+	return getMatrixRuntime().state.openBlobStore({
+		namespace: DELIVERY_PLAN_NAMESPACE,
+		maxEntries: 1e4,
+		maxBytesPerEntry: 8 * 1024 * 1024,
+		maxBytesPerNamespace: 256 * 1024 * 1024,
+		overflowPolicy: "reject-new",
+		defaultTtlMs: DELIVERY_PLAN_TTL_MS
+	});
+}
+function requireIndex(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`Matrix durable delivery ${label} must be a non-negative integer`);
+	return value;
+}
+function requirePartCount(value) {
+	if (!Number.isSafeInteger(value) || (value ?? 0) < 1) throw new Error("Matrix durable delivery part count must be a positive integer");
+	return value;
+}
+function queuePrefix(queueId) {
+	const normalized = queueId.trim();
+	if (!normalized) throw new Error("Matrix durable delivery requires a queue id");
+	return `${createHash("sha256").update(normalized).digest("hex")}.`;
+}
+function planKey(identity) {
+	return `${queuePrefix(identity.queueId)}${requireIndex(identity.partIndex, "part index")}`;
+}
+function transactionId(identity, eventIndex) {
+	return `oc_${createHash("sha256").update(identity.queueId).update("\0").update(String(requireIndex(identity.partIndex, "part index"))).update("\0").update(String(requireIndex(eventIndex, "event index"))).digest("base64url")}`;
+}
+const RECEIPT_KINDS = /* @__PURE__ */ new Set([
+	"text",
+	"media",
+	"voice",
+	"poll",
+	"card",
+	"preview",
+	"unknown"
+]);
+function isPlan(value) {
+	if (!value || typeof value !== "object") return false;
+	const plan = value;
+	return plan.version === DELIVERY_PLAN_VERSION && typeof plan.queueId === "string" && Boolean(plan.queueId.trim()) && typeof plan.accountId === "string" && typeof plan.roomId === "string" && Boolean(plan.roomId.trim()) && (plan.wireEventType === "m.room.message" || plan.wireEventType === "m.room.encrypted") && typeof plan.endpointPrefix === "string" && Boolean(plan.endpointPrefix.trim()) && typeof plan.transactionScopeId === "string" && Boolean(plan.transactionScopeId.trim()) && Number.isSafeInteger(plan.partIndex) && (plan.partIndex ?? -1) >= 0 && Number.isSafeInteger(plan.partCount) && (plan.partCount ?? 0) > 0 && (plan.partIndex ?? -1) < (plan.partCount ?? 0) && Array.isArray(plan.events) && plan.events.length > 0 && plan.events.every((event) => event && typeof event === "object" && typeof event.transactionId === "string" && Boolean(event.transactionId.trim()) && RECEIPT_KINDS.has(event.receiptKind) && Boolean(event.content) && typeof event.content === "object");
+}
+function decodePlan(bytes) {
+	let value;
+	try {
+		value = JSON.parse(new TextDecoder().decode(bytes));
+	} catch {
+		throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan is invalid JSON");
+	}
+	if (!isPlan(value)) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan is invalid");
+	return value;
+}
+function assertPlanIdentity(plan, params) {
+	if (plan.queueId !== params.identity.queueId || plan.partIndex !== params.identity.partIndex || plan.partCount !== params.identity.partCount || plan.accountId !== (params.accountId ?? "") || plan.roomId !== params.roomId || plan.transactionScopeId !== params.transactionScopeId || plan.wireEventType !== params.wireEventType) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan no longer matches the active delivery target");
+}
+function endpointPrefix(dispatch) {
+	const encodedTransactionId = encodeURIComponent(dispatch.transactionId);
+	if (!dispatch.requestPath.endsWith(encodedTransactionId)) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery transaction does not match its request path");
+	return dispatch.requestPath.slice(0, -encodedTransactionId.length);
+}
+function createMatrixPlannedEvents(params) {
+	return params.events.map((event, index) => ({
+		...structuredClone(event),
+		transactionId: transactionId(params.identity, index)
+	}));
+}
+function resolveMatrixDurableDeliveryIdentity(params) {
+	if (params.queueId === void 0) return null;
+	if (params.partIndex === void 0 || params.partCount === void 0) throw new Error("Matrix durable delivery requires stable part topology");
+	const partIndex = requireIndex(params.partIndex, "part index");
+	const partCount = requirePartCount(params.partCount);
+	if (partIndex >= partCount) throw new Error("Matrix durable delivery part index must be below the part count");
 	return {
-		open: markers[0] ?? "",
-		close: markers[1] ?? "",
-		padding: markers[2] ?? ""
+		queueId: params.queueId,
+		partIndex,
+		partCount
+	};
+}
+async function loadMatrixDeliveryPlan(params) {
+	const entry = await createDeliveryPlanStore().lookup(planKey(params.identity));
+	if (!entry) return null;
+	const plan = decodePlan(entry.bytes);
+	if (planKey(plan) !== planKey(params.identity)) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan key is invalid");
+	assertPlanIdentity(plan, params);
+	return structuredClone(plan);
+}
+async function persistMatrixDeliveryPlan(params) {
+	if (params.events.length === 0) throw new Error("Matrix durable delivery plan must contain at least one event");
+	if (params.dispatch.roomId !== params.roomId || params.dispatch.eventType !== params.wireEventType || !params.events.some((event) => event.transactionId === params.dispatch.transactionId)) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery was dispatched to an unexpected endpoint");
+	const partCount = requirePartCount(params.identity.partCount);
+	const events = params.events.map((event, index) => {
+		if (event.transactionId !== transactionId(params.identity, index)) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan has an invalid transaction identifier");
+		return structuredClone(event);
+	});
+	const plan = {
+		version: DELIVERY_PLAN_VERSION,
+		queueId: params.identity.queueId,
+		accountId: params.accountId ?? "",
+		roomId: params.roomId,
+		wireEventType: params.wireEventType,
+		endpointPrefix: endpointPrefix(params.dispatch),
+		transactionScopeId: params.transactionScopeId,
+		partIndex: requireIndex(params.identity.partIndex, "part index"),
+		partCount,
+		events
+	};
+	const store = createDeliveryPlanStore();
+	await store.deleteExpired();
+	const bytes = new TextEncoder().encode(JSON.stringify(plan));
+	if (await store.registerIfAbsent(planKey(params.identity), bytes, {})) return plan;
+	const existing = await loadMatrixDeliveryPlan(params);
+	if (!existing || JSON.stringify(existing) !== JSON.stringify(plan)) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan no longer matches the prepared event batch");
+	return existing;
+}
+async function loadQueuePlans(queueId) {
+	const store = createDeliveryPlanStore();
+	const keys = (await store.entries()).filter((entry) => entry.key.startsWith(queuePrefix(queueId))).map((entry) => entry.key);
+	return await Promise.all(keys.map(async (key) => {
+		const entry = await store.lookup(key);
+		if (!entry) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan disappeared during reconciliation");
+		const plan = decodePlan(entry.bytes);
+		if (key !== planKey(plan)) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan key is invalid");
+		return plan;
+	}));
+}
+function assertCompletePartTopology(plans) {
+	const partCount = plans[0]?.partCount;
+	if (!partCount) throw new MatrixDeliveryPlanInvariantError("Matrix ambiguous delivery has no event plan");
+	if (plans.some((plan) => plan.partCount !== partCount)) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery plan part topology is inconsistent");
+	const storedParts = new Set(plans.map((plan) => plan.partIndex));
+	if (storedParts.size !== partCount || Array.from({ length: partCount }, (_, partIndex) => partIndex).some((partIndex) => !storedParts.has(partIndex))) throw new MatrixDeliveryPlanInvariantError("Matrix ambiguous delivery has an incomplete event plan");
+}
+function createReconciledMatrixReceipt(params) {
+	const uniqueResults = params.results.filter((result, index, results) => results.findIndex((entry) => entry.eventId === result.eventId) === index);
+	const platformMessageIds = uniqueResults.map((result) => result.eventId);
+	return {
+		...platformMessageIds[0] ? { primaryPlatformMessageId: platformMessageIds[0] } : {},
+		platformMessageIds,
+		parts: uniqueResults.map((result, index) => {
+			const part = {
+				platformMessageId: result.eventId,
+				kind: result.receiptKind,
+				index
+			};
+			if (params.replyToId) part.replyToId = params.replyToId;
+			if (params.threadId) part.threadId = params.threadId;
+			return part;
+		}),
+		...params.replyToId ? { replyToId: params.replyToId } : {},
+		...params.threadId ? { threadId: params.threadId } : {},
+		sentAt: Date.now()
+	};
+}
+async function requireTransactionScope(client) {
+	const scope = (await client.getTransactionScopeId()).trim();
+	if (!scope) throw new MatrixDeliveryPlanInvariantError("Matrix durable delivery requires a stable transaction scope");
+	return scope;
+}
+async function reconcileMatrixUnknownSend(ctx) {
+	try {
+		if (ctx.payloads.length !== 1) throw new MatrixDeliveryPlanInvariantError("Matrix reconciliation requires exactly one prepared payload");
+		const plans = await loadQueuePlans(ctx.queueId);
+		if (plans.length === 0) throw new MatrixDeliveryPlanInvariantError("Matrix ambiguous delivery has no persisted event plan");
+		assertCompletePartTopology(plans);
+		return await withResolvedMatrixSendClient({
+			cfg: ctx.cfg,
+			accountId: ctx.accountId
+		}, async (client) => {
+			const transactionScopeId = await requireTransactionScope(client);
+			const roomId = await resolveMatrixRoomId(client, ctx.to);
+			const wireEventType = await client.getMessageWireEventType(roomId);
+			const orderedPlans = [...plans].toSorted((left, right) => left.partIndex - right.partIndex);
+			const results = [];
+			for (const plan of orderedPlans) {
+				assertPlanIdentity(plan, {
+					identity: plan,
+					accountId: ctx.accountId,
+					roomId,
+					transactionScopeId,
+					wireEventType
+				});
+				for (const event of plan.events) results.push({
+					eventId: await client.sendMessage(roomId, event.content, event.transactionId, async (dispatch) => {
+						await persistMatrixDeliveryPlan({
+							identity: plan,
+							accountId: ctx.accountId,
+							roomId,
+							transactionScopeId,
+							wireEventType,
+							events: plan.events,
+							dispatch
+						});
+					}),
+					receiptKind: event.receiptKind
+				});
+			}
+			const replyToId = ctx.effectiveReplyToId !== void 0 ? ctx.effectiveReplyToId : ctx.replyToMode === "off" ? void 0 : ctx.replyToId;
+			const threadId = ctx.threadId == null ? void 0 : String(ctx.threadId);
+			const receipt = createReconciledMatrixReceipt({
+				results,
+				...replyToId ? { replyToId } : {},
+				...threadId ? { threadId } : {}
+			});
+			return {
+				status: "sent",
+				messageId: receipt.platformMessageIds.at(-1),
+				receipt
+			};
+		});
+	} catch (error) {
+		const retryable = !(error instanceof MatrixDeliveryPlanInvariantError);
+		let cleanupError;
+		if (!retryable) try {
+			await cleanupMatrixDeliveryPlans({ queueId: ctx.queueId });
+		} catch (cleanupFailure) {
+			cleanupError = cleanupFailure;
+		}
+		const errorMessage = formatErrorMessage(error instanceof Error || typeof error === "string" ? error : "unknown error");
+		return {
+			status: "unresolved",
+			error: cleanupError === void 0 ? errorMessage : `${errorMessage}; Matrix delivery-plan cleanup failed: ${formatErrorMessage(cleanupError instanceof Error || typeof cleanupError === "string" ? cleanupError : "unknown error")}`,
+			retryable
+		};
+	}
+}
+async function cleanupMatrixDeliveryPlans(ctx) {
+	const store = createDeliveryPlanStore();
+	await store.deleteExpired();
+	const keys = (await store.entries()).filter((entry) => entry.key.startsWith(queuePrefix(ctx.queueId))).map((entry) => entry.key);
+	await Promise.all(keys.map(async (key) => await store.delete(key)));
+}
+//#endregion
+//#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 (!isRecord(text)) return "";
+	return normalizeOptionalString(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);
+	if (!question) return null;
+	const rawAnswers = poll.answers;
+	const answers = (Array.isArray(rawAnswers) ? rawAnswers : []).map((answer) => ({
+		id: isRecord(answer) && typeof answer.id === "string" ? answer.id : "",
+		text: getTextContent(answer)
+	})).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({
@@ -759,937 +1344,559 @@ function mutateInlineTokensWithMentions(params) {
 		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-XsIkHNt0.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
+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);
 	}
-	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 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 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));
+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
+	};
 }
-async function readJoinedMatrixMembers(client, roomId) {
+function parseMatrixMarkdown(markdown, tableMode) {
+	const protectedSpoilers = protectMatrixSpoilerDelimiters(markdown);
+	if (tableMode === "off") md.disable("table");
 	try {
-		return normalizeJoinedMatrixMembers(await client.getJoinedRoomMembers(roomId));
-	} catch {
-		return null;
+		return md.parse(protectedSpoilers.markdown, { matrixSpoilerMarkers: protectedSpoilers.markers });
+	} finally {
+		if (tableMode === "off") md.enable("table");
 	}
 }
-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;
+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);
 }
-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);
+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 {
-		joinedMembers,
-		strict,
-		viaMemberState: memberStateFlag === true,
-		memberStateFlag
+		tokens,
+		mentions
 	};
 }
-async function isStrictDirectRoom(params) {
-	return (await inspectMatrixDirectRoomEvidence({
-		client: params.client,
-		roomId: params.roomId,
-		remoteUserId: params.remoteUserId,
-		selfUserId: params.selfUserId
-	})).strict;
+async function resolveMatrixMentionsInMarkdown(params) {
+	return (await resolveMarkdownMentionState(params)).mentions;
 }
-//#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 {};
+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
+	};
 }
-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;
+//#endregion
+//#region extensions/matrix/src/matrix/send/chunking.ts
+const getCore$2 = () => getMatrixRuntime();
+function normalizeMatrixEventLimit(limit) {
+	if (!Number.isFinite(limit) || limit <= 0) return limit;
+	return Math.max(1, Math.floor(limit));
 }
-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 resolveMatrixChunkOverflow(chunk, limit) {
+	const body = markdownToMatrixBody(chunk);
+	const renderedLength = Math.max(chunk.length, body.length);
+	if (limit === 1 && Array.from(chunk).length === 1 && Array.from(body).length === 1) return 0;
+	return Math.max(0, renderedLength - limit);
 }
-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 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 resolveDirectAccountDataWriteQueue(client) {
-	const existing = directAccountDataWriteQueues.get(client);
-	if (existing) return existing;
-	const created = new KeyedAsyncQueue();
-	directAccountDataWriteQueues.set(client, created);
-	return created;
+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("");
+	});
 }
-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
+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 changed = !hasMatrixDirectRoomMappings({
-			directContent: directContentBefore,
-			remoteUserId: params.remoteUserId,
-			roomIds: params.roomIds
+		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
 		});
-		if (changed) await params.client.setAccountData(EventType.Direct, directContentAfter);
-		return {
-			changed,
-			directContentBefore,
-			directContentAfter
-		};
+		cursor = range.end;
+	}
+	const tail = markdown.slice(cursor).replace(/^(?:[ \t]*\n)+/u, "");
+	if (tail.trim()) segments.push({
+		table: false,
+		text: tail
 	});
+	return segments;
 }
-async function classifyDirectRoomCandidate(params) {
-	const evidence = await inspectMatrixDirectRoomEvidence({
-		client: params.client,
-		roomId: params.roomId,
-		remoteUserId: params.remoteUserId,
-		selfUserId: params.selfUserId
+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 convertedText = renderMatrixMarkdownTables(trimmedText, tableMode);
+	const singleEventLimit = normalizeMatrixEventLimit(Math.min(getCore$2().channel.text.resolveTextChunkLimit(cfg, "matrix", opts.accountId), MATRIX_FORMAT_PROFILE.chunk.limit));
+	const eventTextLength = Math.max(convertedText.length, markdownToMatrixBody(convertedText).length);
 	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
+		trimmedText,
+		convertedText,
+		singleEventLimit,
+		eventTextLength,
+		fitsInSingleEvent: eventTextLength <= singleEventLimit,
+		tableMode
 	};
 }
-function buildNextDirectContent(params) {
-	const current = normalizeMappedRoomIds(params.directContent, params.remoteUserId);
-	const nextRooms = normalizeRoomIdList([...params.roomIds, ...current]);
+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) => resolveMatrixChunkOverflow(chunk, 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 {
-		...params.directContent,
-		[params.remoteUserId]: nextRooms
+		...preparedText,
+		chunks
 	};
 }
-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({
+//#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,
-		roomId: params.roomId,
-		remoteUserId,
-		selfUserId: params.selfUserId
+		tableMode: params.tableMode
 	});
-	if (!evidence.strict) return {
-		classifyAsDirect: false,
-		repaired: false,
-		reason: "not-strict"
+	return {
+		body,
+		html,
+		mentions
 	};
-	if (evidence.memberStateFlag === false) return {
-		classifyAsDirect: false,
-		repaired: false,
-		reason: "local-explicit-false"
+}
+function buildTextContent(body, relation, opts = {}) {
+	const msgtype = opts.msgtype ?? MsgType.Text;
+	return relation ? {
+		msgtype,
+		body,
+		"m.relates_to": relation
+	} : {
+		msgtype,
+		body
 	};
-	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({
+async function enrichMatrixFormattedContent(params) {
+	const { body, html, mentions } = await renderMatrixFormattedContent({
 		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);
+		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;
 	}
-	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
-	};
+	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;
 }
-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
+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;
 }
-//#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 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 normalizeThreadId(raw) {
-	return normalizeOptionalStringifiedId(raw) ?? null;
+function resolveMatrixVoiceDecision(opts) {
+	if (!opts.wantsVoice) return { useVoice: false };
+	if (isMatrixVoiceCompatibleAudio(opts)) return { useVoice: true };
+	return { useVoice: false };
 }
-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 isMatrixVoiceCompatibleAudio(opts) {
+	return isVoiceMessageCompatibleAudio({
+		contentType: opts.contentType,
+		fileName: opts.fileName
+	});
 }
-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);
+//#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;
 }
-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
+function buildMediaContent(params) {
+	const info = buildMatrixMediaInfo({
+		size: params.size,
+		mimetype: params.mimetype,
+		durationMs: params.durationMs,
+		imageInfo: params.imageInfo
 	});
-	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;
+	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 };
 	}
-	throw new Error(`No direct room found for ${trimmed} (m.direct missing)`);
+	if (params.relation) base["m.relates_to"] = params.relation;
+	return base;
 }
-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;
+const THUMBNAIL_MAX_SIDE = 800;
+const THUMBNAIL_QUALITY = 80;
+const AIFC_IMA4_BYTES_PER_CHANNEL_PACKET = 34;
+const AIFC_IMA4_FRAMES_PER_PACKET = 64;
+function resolveAifcIma4DurationSeconds(buffer, sampleRate) {
+	if (!sampleRate || !Number.isFinite(sampleRate) || buffer.length < 12 || buffer.toString("ascii", 0, 4) !== "FORM" || buffer.toString("ascii", 8, 12) !== "AIFC") return;
+	let channels;
+	let declaredFrameCount;
+	let soundDataBytes;
+	for (let offset = 12; offset + 8 <= buffer.length;) {
+		const chunkType = buffer.toString("ascii", offset, offset + 4);
+		const chunkSize = buffer.readUInt32BE(offset + 4);
+		const chunkStart = offset + 8;
+		if (chunkSize > buffer.length - chunkStart) return;
+		if (chunkType === "COMM") {
+			if (chunkSize < 22 || buffer.toString("ascii", chunkStart + 18, chunkStart + 22) !== "ima4") return;
+			channels = buffer.readUInt16BE(chunkStart);
+			declaredFrameCount = buffer.readUInt32BE(chunkStart + 2);
+		} else if (chunkType === "SSND") {
+			if (chunkSize < 8) return;
+			const soundDataOffset = buffer.readUInt32BE(chunkStart);
+			if (soundDataOffset > chunkSize - 8) return;
+			soundDataBytes = chunkSize - 8 - soundDataOffset;
+		}
+		offset = chunkStart + chunkSize + (chunkSize & 1);
 	}
-	return target;
+	if (!channels || !declaredFrameCount || !soundDataBytes) return;
+	const packetSize = channels * AIFC_IMA4_BYTES_PER_CHANNEL_PACKET;
+	if (soundDataBytes % packetSize !== 0) return;
+	const packetCount = soundDataBytes / packetSize;
+	if (packetCount !== declaredFrameCount) return;
+	return packetCount * AIFC_IMA4_FRAMES_PER_PACKET / sampleRate;
+}
+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, params.roomId, thumbBuffer, {
+			contentType: "image/jpeg",
+			filename: "thumbnail.jpg"
+		});
+		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 metadata = await parseBuffer(params.buffer, fileInfo, {
+			duration: true,
+			skipCovers: true
+		});
+		const durationSeconds = resolveAifcIma4DurationSeconds(params.buffer, metadata.format.sampleRate) ?? metadata.format.duration;
+		if (typeof durationSeconds === "number" && Number.isFinite(durationSeconds)) return Math.max(0, Math.round(durationSeconds * 1e3));
+	} catch {}
+}
+async function uploadMediaWithEncryption(client, roomId, buffer, params) {
+	if (await client.prepareRoomForMessageSend(roomId) === "m.room.encrypted") {
+		if (!client.crypto) throw new Error("Encrypted Matrix room: enable encryption before uploading media");
+		const encrypted = await client.crypto.encryptMedia(buffer);
+		const mxc = await client.uploadContent(encrypted.buffer, "application/octet-stream");
+		return {
+			url: mxc,
+			file: {
+				url: mxc,
+				...encrypted.file
+			}
+		};
+	}
+	return { url: await client.uploadContent(buffer, params.contentType, params.filename) };
 }
 //#endregion
 //#region extensions/matrix/src/matrix/send.ts
@@ -1707,16 +1914,28 @@ var send_exports = /* @__PURE__ */ __exportAll({
 	sendTypingMatrix: () => sendTypingMatrix
 });
 function createMatrixSendReceipt(params) {
-	return createMessageReceiptFromOutboundResults({
-		kind: params.kind,
-		...params.replyToId ? { replyToId: params.replyToId } : {},
+	const firstEvent = params.events[0];
+	const receipt = createMessageReceiptFromOutboundResults({
+		kind: firstEvent?.kind ?? "text",
+		...firstEvent?.replyToId ? { replyToId: firstEvent.replyToId } : {},
 		...params.threadId ? { threadId: params.threadId } : {},
-		results: params.platformMessageIds.map((messageId) => ({
+		results: params.events.map(({ messageId }) => ({
 			channel: "matrix",
 			messageId,
 			roomId: params.roomId
 		}))
 	});
+	receipt.parts = receipt.parts.map((part, index) => {
+		const event = params.events[index];
+		const actualPart = {
+			...part,
+			kind: event.kind
+		};
+		if (event.replyToId) actualPart.replyToId = event.replyToId;
+		else delete actualPart.replyToId;
+		return actualPart;
+	});
+	return receipt;
 }
 function isMatrixClient(value) {
 	return typeof value.sendEvent === "function";
@@ -1769,8 +1988,13 @@ async function resolvePreviousEditMentions(params) {
 	});
 }
 async function sendMessageMatrix(to, message, opts) {
-	const trimmedMessage = message?.trim() ?? "";
-	if (!trimmedMessage && !opts.mediaUrl) throw new Error("Matrix send requires text or media");
+	const messageText = message?.trimEnd() ?? "";
+	if (!messageText.trim() && !opts.mediaUrl) throw new Error("Matrix send requires text or media");
+	const durableIdentity = resolveMatrixDurableDeliveryIdentity({
+		queueId: opts.deliveryQueueId,
+		partIndex: opts.deliveryPartIndex,
+		partCount: opts.deliveryPartCount
+	});
 	return await withResolvedMatrixSendClient({
 		client: opts.client,
 		cfg: opts.cfg,
@@ -1778,135 +2002,174 @@ async function sendMessageMatrix(to, message, opts) {
 		accountId: opts.accountId
 	}, async (client) => {
 		const roomId = await resolveMatrixRoomId(client, to);
+		const wireEventType = await client.prepareRoomForMessageSend(roomId);
 		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);
-			const visibleContent = contentWithExtra.body ?? "";
-			if (eventId) {
-				acceptedContents.push(visibleContent);
-				await opts.onDeliveryResult?.({
-					messageId: eventId,
-					roomId,
-					primaryMessageId: eventId,
-					receipt: createMatrixSendReceipt({
-						roomId,
-						platformMessageIds: [eventId],
-						kind,
-						replyToId: opts.replyToId,
-						threadId
-					}),
-					content: visibleContent
-				});
-			}
-			return eventId;
-		};
-		const platformMessageIds = [];
-		const acceptedContents = [];
-		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 transactionScopeId = durableIdentity ? await client.getTransactionScopeId() : void 0;
+		let plannedEvents = (durableIdentity ? await loadMatrixDeliveryPlan({
+			identity: durableIdentity,
+			accountId: opts.accountId,
+			roomId,
+			transactionScopeId,
+			wireEventType
+		}) : null)?.events;
+		if (!plannedEvents) {
+			const { chunks, tableMode } = chunkMatrixText(messageText, {
+				cfg,
+				accountId: opts.accountId,
+				preserveWhitespace: true
 			});
-			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);
+			const relation = threadId ? buildThreadRelation(threadId, opts.replyToId) : buildReplyRelation(opts.replyToId);
+			let pendingExtraContent = opts.extraContent;
+			const events = [];
+			const prepareContent = (content, receiptKind) => {
+				events.push({
+					content: withMatrixExtraContentFields(content, pendingExtraContent),
+					receiptKind
+				});
+				pendingExtraContent = void 0;
+			};
+			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 uploadMediaWithEncryption(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;
+				const receiptKind = useVoice ? "voice" : "media";
+				const imageInfo = msgtype === MsgType.Image ? await prepareImageInfo({
+					buffer: media.buffer,
+					client,
+					roomId
+				}) : 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
+				});
+				prepareContent(content, receiptKind);
+				const textChunks = useVoice ? chunks : rest;
+				const followupRelation = useVoice || threadId ? relation : void 0;
+				for (const chunk of textChunks) {
+					if (!chunk.trim()) continue;
+					const followup = buildTextContent(chunk, followupRelation);
+					await enrichMatrixFormattedContent({
+						client,
+						content: followup,
+						markdown: chunk,
+						tableMode
+					});
+					prepareContent(followup, "text");
+				}
+			} else for (const chunk of chunks.length ? chunks : [""]) {
+				if (!chunk.trim()) continue;
+				const content = buildTextContent(chunk, relation);
 				await enrichMatrixFormattedContent({
 					client,
-					content: followup,
-					markdown: text,
+					content,
+					markdown: chunk,
 					tableMode
 				});
-				const followupEventId = await sendContent(followup, "text");
-				lastMessageId = followupEventId ?? lastMessageId;
-				if (followupEventId) platformMessageIds.push(followupEventId);
+				prepareContent(content, "text");
 			}
-		} 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
+			plannedEvents = durableIdentity ? createMatrixPlannedEvents({
+				identity: durableIdentity,
+				events
+			}) : events.map((event) => ({
+				content: event.content,
+				receiptKind: event.receiptKind,
+				transactionId: ""
+			}));
+		}
+		if (opts.mediaUrl) await client.prepareRoomForMessageSend(roomId, plannedEvents[0]?.content);
+		let platformDispatchStarted = false;
+		if (!durableIdentity) {
+			await opts.onPlatformSendDispatch?.();
+			platformDispatchStarted = true;
+		}
+		const acceptedEvents = [];
+		const acceptedContents = [];
+		let lastMessageId = "";
+		for (const planned of plannedEvents) {
+			const eventId = await client.sendMessage(roomId, planned.content, planned.transactionId || void 0, durableIdentity ? async (dispatch) => {
+				await persistMatrixDeliveryPlan({
+					identity: durableIdentity,
+					accountId: opts.accountId,
+					roomId,
+					transactionScopeId,
+					wireEventType: dispatch.eventType,
+					events: plannedEvents,
+					dispatch
+				});
+				if (!platformDispatchStarted) {
+					await opts.onPlatformSendDispatch?.();
+					platformDispatchStarted = true;
+				}
+			} : void 0);
+			lastMessageId = eventId || lastMessageId;
+			if (!eventId) continue;
+			const eventReplyToId = planned.content["m.relates_to"]?.["m.in_reply_to"]?.event_id;
+			const acceptedEvent = {
+				messageId: eventId,
+				kind: planned.receiptKind,
+				...eventReplyToId ? { replyToId: eventReplyToId } : {}
+			};
+			acceptedEvents.push(acceptedEvent);
+			const visibleContent = planned.content.body ?? "";
+			acceptedContents.push(visibleContent);
+			await opts.onDeliveryResult?.({
+				messageId: eventId,
+				roomId,
+				primaryMessageId: eventId,
+				receipt: createMatrixSendReceipt({
+					roomId,
+					events: [acceptedEvent],
+					threadId
+				}),
+				content: visibleContent
 			});
-			const eventId = await sendContent(content, "text");
-			lastMessageId = eventId ?? lastMessageId;
-			if (eventId) platformMessageIds.push(eventId);
 		}
 		return {
 			messageId: lastMessageId || "unknown",
 			roomId,
-			primaryMessageId: platformMessageIds[0] ?? (lastMessageId || "unknown"),
+			primaryMessageId: acceptedEvents[0]?.messageId ?? (lastMessageId || "unknown"),
 			receipt: createMatrixSendReceipt({
 				roomId,
-				platformMessageIds,
-				kind: receiptKind,
-				replyToId: opts.replyToId,
+				events: acceptedEvents,
 				threadId
 			}),
 			content: acceptedContents.join("\n")
@@ -1967,11 +2230,12 @@ async function sendReadReceiptMatrix(roomId, eventId, client) {
 	});
 }
 async function sendSingleTextMessageMatrix(roomId, text, opts) {
-	const { trimmedText, convertedText, singleEventLimit, eventTextLength, fitsInSingleEvent, tableMode } = prepareMatrixSingleText(text, {
+	const { trimmedText, convertedText, singleEventLimit, eventTextLength, fitsInSingleEvent, tableMode } = prepareMatrixSingleText(text.trimEnd(), {
 		cfg: opts.cfg,
-		accountId: opts.accountId
+		accountId: opts.accountId,
+		preserveWhitespace: true
 	});
-	if (!trimmedText) throw new Error("Matrix single-message send requires text");
+	if (!trimmedText.trim()) 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,
@@ -1991,15 +2255,18 @@ async function sendSingleTextMessageMatrix(roomId, text, opts) {
 		});
 		if (opts.live) content[MSC4357_LIVE_KEY] = {};
 		const eventId = await client.sendMessage(resolvedRoom, content);
+		const replyToId = content["m.relates_to"]?.["m.in_reply_to"]?.event_id;
 		return {
 			messageId: eventId ?? "unknown",
 			roomId: resolvedRoom,
 			primaryMessageId: eventId ?? "unknown",
 			receipt: createMatrixSendReceipt({
 				roomId: resolvedRoom,
-				platformMessageIds: eventId ? [eventId] : [],
-				kind: "text",
-				replyToId: opts.replyToId,
+				events: eventId ? [{
+					messageId: eventId,
+					kind: "text",
+					...replyToId ? { replyToId } : {}
+				}] : [],
 				threadId: normalizedThreadId
 			}),
 			content: content.body
@@ -2074,4 +2341,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, 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 };
+export { promoteMatrixDirectRoomCandidate as C, MsgType as E, direct_management_exports as S, MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY as T, parsePollStartContent as _, sendSingleTextMessageMatrix as a, reconcileMatrixUnknownSend as b, chunkMatrixText as c, buildPollResultsSummary as d, formatPollAsText as f, parsePollStart as g, isPollStartType as h, sendPollMatrix as i, prepareMatrixSingleText as l, isPollEventType as m, reactMatrixMessage as n, sendTypingMatrix as o, formatPollResultsAsText as p, sendMessageMatrix as r, send_exports as s, editMessageMatrix as t, buildPollResponseContent as u, resolvePollReferenceEventId as v, repairMatrixDirectRooms as w, resolveMatrixRoomId as x, cleanupMatrixDeliveryPlans as y };