@openclaw/matrix 2026.9.4 → 2026.9.6

package/dist/{send-UWLIQ0bG.js → .setup/send-aVdC5NJO.mjs}

@@ -1,29 +1,29 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.js";
-import { t as getMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { i as normalizeMatrixResolvableTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.js";
-import { a as isStrictDirectRoom, r as inspectMatrixDirectRoomEvidence } from "./direct-room-RinHjtqX.js";
-import { r as buildMatrixReactionContent } from "./reaction-common-DkrQdBSZ.js";
-import { a as RelationType, i as MsgType, r as MSC4357_LIVE_KEY, t as EventType } from "./types-DzSc7Sqm.js";
-import { n as getMatrixEventProjection } from "./event-helpers-CspuhE9k.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { i as normalizeMatrixResolvableTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
+import { n as withMatrixSendCurrentness, o as buildMatrixReactionContent, t as captureMatrixSendCurrentness } from "./send-currentness-BrGXL7b8.mjs";
+import { _ as MsgType, d as buildMatrixMessageRelation, f as resolveMatrixReplyToEventId, g as MSC4357_LIVE_KEY, l as isStrictDirectRoom, m as EventType, n as inspectMatrixDirectRooms, p as resolveMatrixThreadRootId, r as persistMatrixDirectRoomMapping, v as RelationType } from "./direct-management-B2Bno2xL.mjs";
+import { n as getMatrixEventProjection } from "./event-helpers-CspuhE9k.mjs";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
-import { asNullableObjectRecord, asNullableRecord, asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asFiniteNumber, asNullableObjectRecord, asNullableRecord, 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 path from "node:path";
 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 { M_POLL_KIND_DISCLOSED } from "matrix-js-sdk/lib/@types/polls.js";
 import { normalizePollInput } from "openclaw/plugin-sdk/poll-runtime";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
 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";
 //#region extensions/matrix/src/matrix/send/client.ts
-const loadMatrixSendClientRuntime = createLazyRuntimeModule(() => import("./client-bootstrap-DLN-K8Xb.js").then((n) => n.t));
+const loadMatrixSendClientRuntime = createLazyRuntimeModule(() => import("./client-bootstrap-BSnUAoz1.mjs"));
 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 resolvedCfg = requireRuntimeConfig(cfg, "Matrix media limits");
@@ -37,7 +37,14 @@ async function withResolvedMatrixSendClient(opts, run) {
 	return await withResolvedMatrixClient({
 		...opts,
 		readiness: "started"
-	}, run, "persist");
+	}, (client, abortSignal) => {
+		if (!opts.signal && !opts.assertDirectAdapterHandoff) return run(client, abortSignal);
+		return withMatrixSendCurrentness(client, () => {
+			opts.assertDirectAdapterHandoff?.();
+			opts.signal?.throwIfAborted();
+			abortSignal?.throwIfAborted();
+		}, () => run(client, abortSignal));
+	}, "persist");
 }
 async function withResolvedMatrixControlClient(opts, run) {
 	return await withResolvedMatrixClient({
@@ -51,218 +58,30 @@ async function withResolvedMatrixClient(opts, run, shutdownBehavior) {
 	return await withResolvedRuntimeMatrixClient(opts, run, shutdownBehavior);
 }
 //#endregion
-//#region extensions/matrix/src/matrix/direct-management.ts
-var direct_management_exports = /* @__PURE__ */ __exportAll({
-	inspectMatrixDirectRooms: () => inspectMatrixDirectRooms,
-	persistMatrixDirectRoomMapping: () => persistMatrixDirectRoomMapping,
-	promoteMatrixDirectRoomCandidate: () => promoteMatrixDirectRoomCandidate,
-	repairMatrixDirectRooms: () => repairMatrixDirectRooms
-});
-const DIRECT_ACCOUNT_DATA_QUEUE_KEY = EventType.Direct;
-const directAccountDataWriteQueues = /* @__PURE__ */ new WeakMap();
-async function readMatrixDirectAccountData(client) {
-	try {
-		const direct = await client.getAccountData(EventType.Direct);
-		return direct && typeof direct === "object" && !Array.isArray(direct) ? direct : {};
-	} catch {
-		return {};
-	}
-}
-function normalizeRemoteUserId(remoteUserId) {
-	const normalized = normalizeOptionalString(remoteUserId) ?? "";
-	if (!isMatrixQualifiedUserId(normalized)) throw new Error(`Matrix user IDs must be fully qualified (got "${remoteUserId}")`);
-	return normalized;
-}
-function normalizeMappedRoomIds(direct, remoteUserId) {
-	const current = direct[remoteUserId];
-	if (!Array.isArray(current)) return [];
-	const seen = /* @__PURE__ */ new Set();
-	const normalized = [];
-	for (const value of current) {
-		const roomId = normalizeOptionalString(value) ?? "";
-		if (!roomId || seen.has(roomId)) continue;
-		seen.add(roomId);
-		normalized.push(roomId);
-	}
-	return normalized;
-}
-function normalizeRoomIdList(values) {
-	const seen = /* @__PURE__ */ new Set();
-	const normalized = [];
-	for (const value of values) {
-		const roomId = value.trim();
-		if (!roomId || seen.has(roomId)) continue;
-		seen.add(roomId);
-		normalized.push(roomId);
-	}
-	return normalized;
-}
-function hasMatrixDirectRoomMappings(params) {
-	const current = normalizeMappedRoomIds(params.directContent, params.remoteUserId);
-	const next = normalizeRoomIdList([...params.roomIds, ...current]);
-	return current.length === next.length && current.every((roomId, index) => roomId === next[index]);
-}
-function resolveDirectAccountDataWriteQueue(client) {
-	const existing = directAccountDataWriteQueues.get(client);
-	if (existing) return existing;
-	const created = new KeyedAsyncQueue();
-	directAccountDataWriteQueues.set(client, created);
-	return created;
-}
-async function writeMatrixDirectRoomMappings(params) {
-	return await resolveDirectAccountDataWriteQueue(params.client).enqueue(DIRECT_ACCOUNT_DATA_QUEUE_KEY, async () => {
-		const directContentBefore = await readMatrixDirectAccountData(params.client);
-		const directContentAfter = buildNextDirectContent({
-			directContent: directContentBefore,
-			remoteUserId: params.remoteUserId,
-			roomIds: params.roomIds
-		});
-		const changed = !hasMatrixDirectRoomMappings({
-			directContent: directContentBefore,
-			remoteUserId: params.remoteUserId,
-			roomIds: params.roomIds
-		});
-		if (changed) await params.client.setAccountData(EventType.Direct, directContentAfter);
-		return {
-			changed,
-			directContentBefore,
-			directContentAfter
-		};
-	});
-}
-async function classifyDirectRoomCandidate(params) {
-	const evidence = await inspectMatrixDirectRoomEvidence({
-		client: params.client,
-		roomId: params.roomId,
-		remoteUserId: params.remoteUserId,
-		selfUserId: params.selfUserId
-	});
-	return {
-		roomId: params.roomId,
-		joinedMembers: evidence.joinedMembers,
-		strict: evidence.strict && (params.source === "account-data" || evidence.memberStateFlag !== false),
-		explicit: evidence.strict && (params.source === "account-data" || evidence.memberStateFlag !== false) && (params.source === "account-data" || evidence.viaMemberState),
-		source: params.source
-	};
-}
-function buildNextDirectContent(params) {
-	const current = normalizeMappedRoomIds(params.directContent, params.remoteUserId);
-	const nextRooms = normalizeRoomIdList([...params.roomIds, ...current]);
-	return {
-		...params.directContent,
-		[params.remoteUserId]: nextRooms
-	};
-}
-async function persistMatrixDirectRoomMapping(params) {
-	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
-	return (await writeMatrixDirectRoomMappings({
-		client: params.client,
-		remoteUserId,
-		roomIds: [params.roomId]
-	})).changed;
-}
-async function promoteMatrixDirectRoomCandidate(params) {
-	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
-	const evidence = await inspectMatrixDirectRoomEvidence({
-		client: params.client,
-		roomId: params.roomId,
-		remoteUserId,
-		selfUserId: params.selfUserId
-	});
-	if (!evidence.strict) return {
-		classifyAsDirect: false,
-		repaired: false,
-		reason: "not-strict"
-	};
-	if (evidence.memberStateFlag === false) return {
-		classifyAsDirect: false,
-		repaired: false,
-		reason: "local-explicit-false"
-	};
-	try {
-		const repaired = await persistMatrixDirectRoomMapping({
-			client: params.client,
-			remoteUserId,
+//#region extensions/matrix/src/matrix/send/receipt.ts
+function createMatrixSendReceipt(params) {
+	const firstEvent = params.events[0];
+	const receipt = createMessageReceiptFromOutboundResults({
+		kind: firstEvent?.kind ?? "text",
+		...firstEvent?.replyToId ? { replyToId: firstEvent.replyToId } : {},
+		...params.threadId ? { threadId: params.threadId } : {},
+		results: params.events.map(({ messageId }) => ({
+			channel: "matrix",
+			messageId,
 			roomId: params.roomId
-		});
-		return {
-			classifyAsDirect: true,
-			repaired,
-			roomId: params.roomId,
-			reason: repaired ? "promoted" : "already-mapped"
-		};
-	} catch {
-		return {
-			classifyAsDirect: true,
-			repaired: false,
-			roomId: params.roomId,
-			reason: "repair-failed"
-		};
-	}
-}
-async function inspectMatrixDirectRooms(params) {
-	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
-	const selfUserId = normalizeOptionalString(await params.client.getUserId().catch(() => null)) ?? null;
-	const mappedRoomIds = normalizeMappedRoomIds(await readMatrixDirectAccountData(params.client), remoteUserId);
-	const mappedRooms = await Promise.all(mappedRoomIds.map(async (roomId) => await classifyDirectRoomCandidate({
-		client: params.client,
-		roomId,
-		remoteUserId,
-		selfUserId,
-		source: "account-data"
-	})));
-	const mappedStrict = mappedRooms.find((room) => room.strict);
-	let joinedRooms = [];
-	if (typeof params.client.getJoinedRooms === "function") try {
-		const resolved = await params.client.getJoinedRooms();
-		joinedRooms = Array.isArray(resolved) ? resolved : [];
-	} catch {
-		joinedRooms = [];
-	}
-	const discoveredStrictRooms = [];
-	for (const roomId of normalizeRoomIdList(joinedRooms)) {
-		if (mappedRoomIds.includes(roomId)) continue;
-		const candidate = await classifyDirectRoomCandidate({
-			client: params.client,
-			roomId,
-			remoteUserId,
-			selfUserId,
-			source: "joined"
-		});
-		if (candidate.strict) discoveredStrictRooms.push(candidate);
-	}
-	const discoveredStrictRoomIds = discoveredStrictRooms.map((room) => room.roomId);
-	const discoveredExplicit = discoveredStrictRooms.find((room) => room.explicit);
-	return {
-		selfUserId,
-		remoteUserId,
-		mappedRoomIds,
-		mappedRooms,
-		discoveredStrictRoomIds,
-		activeRoomId: mappedStrict?.roomId ?? discoveredExplicit?.roomId ?? discoveredStrictRoomIds[0] ?? null
-	};
-}
-async function repairMatrixDirectRooms(params) {
-	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
-	const inspected = await inspectMatrixDirectRooms({
-		client: params.client,
-		remoteUserId
+		}))
 	});
-	const activeRoomId = inspected.activeRoomId ?? await params.client.createDirectRoom(remoteUserId, { encrypted: params.encrypted === true });
-	const createdRoomId = inspected.activeRoomId ? null : activeRoomId;
-	const mappingWrite = await writeMatrixDirectRoomMappings({
-		client: params.client,
-		remoteUserId,
-		roomIds: [activeRoomId, ...inspected.discoveredStrictRoomIds]
+	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 {
-		...inspected,
-		activeRoomId,
-		createdRoomId,
-		changed: mappingWrite.changed,
-		directContentBefore: mappingWrite.directContentBefore,
-		directContentAfter: mappingWrite.directContentAfter
-	};
+	return receipt;
 }
 //#endregion
 //#region extensions/matrix/src/matrix/send/targets.ts
@@ -291,38 +110,41 @@ function setDirectRoomCached(client, key, value) {
 		if (oldest !== void 0) directRoomCache.delete(oldest);
 	}
 }
-async function resolveDirectRoomId(client, userId) {
+async function resolveDirectRoomId(client, userId, persistDirectMapping) {
 	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);
+	const cacheKey = persistDirectMapping ? trimmed : `read:${trimmed}`;
+	const cached = directRoomCache.get(cacheKey);
 	if (cached && await isStrictDirectRoom({
 		client,
 		roomId: cached,
 		remoteUserId: trimmed,
 		selfUserId
 	})) return cached;
-	if (cached) directRoomCache.delete(trimmed);
+	if (cached) directRoomCache.delete(cacheKey);
 	const inspection = await inspectMatrixDirectRooms({
 		client,
 		remoteUserId: trimmed
 	});
 	if (inspection.activeRoomId) {
-		setDirectRoomCached(client, trimmed, inspection.activeRoomId);
-		if (inspection.mappedRoomIds[0] !== inspection.activeRoomId) await persistMatrixDirectRoomMapping({
+		if (persistDirectMapping && inspection.mappedRoomIds[0] !== inspection.activeRoomId) await persistMatrixDirectRoomMapping({
 			client,
 			remoteUserId: trimmed,
 			roomId: inspection.activeRoomId
-		}).catch(() => {});
+		}).catch(() => {
+			captureMatrixSendCurrentness(client)?.();
+		});
+		setDirectRoomCached(client, cacheKey, inspection.activeRoomId);
 		return inspection.activeRoomId;
 	}
 	throw new Error(`No direct room found for ${trimmed} (m.direct missing)`);
 }
-async function resolveMatrixRoomId(client, raw) {
+async function resolveMatrixRoomId(client, raw, opts = {}) {
 	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 (normalizeLowercaseStringOrEmpty(target).startsWith("user:")) return await resolveDirectRoomId(client, target.slice(5), opts.persistDirectMapping ?? true);
+	if (isMatrixQualifiedUserId(target)) return await resolveDirectRoomId(client, target, opts.persistDirectMapping ?? true);
 	if (target.startsWith("#")) {
 		const resolved = await client.resolveRoom(target);
 		if (!resolved) throw new Error(`Matrix alias ${target} could not be resolved`);
@@ -458,14 +280,18 @@ async function persistMatrixDeliveryPlan(params) {
 }
 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 entries = await store.entries();
+	const prefix = entries.length > 0 ? queuePrefix(queueId) : "";
+	const keys = entries.filter((entry) => entry.key.startsWith(prefix)).map((entry) => entry.key);
+	const plans = [];
+	for (const key of keys) {
 		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;
-	}));
+		plans.push(plan);
+	}
+	return plans;
 }
 function assertCompletePartTopology(plans) {
 	const partCount = plans[0]?.partCount;
@@ -474,27 +300,6 @@ function assertCompletePartTopology(plans) {
 	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");
@@ -514,7 +319,7 @@ async function reconcileMatrixUnknownSend(ctx) {
 			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 = [];
+			const results = /* @__PURE__ */ new Map();
 			for (const plan of orderedPlans) {
 				assertPlanIdentity(plan, {
 					identity: plan,
@@ -523,8 +328,8 @@ async function reconcileMatrixUnknownSend(ctx) {
 					transactionScopeId,
 					wireEventType
 				});
-				for (const event of plan.events) results.push({
-					eventId: await client.sendMessage(roomId, event.content, event.transactionId, async (dispatch) => {
+				for (const event of plan.events) {
+					const messageId = await client.sendMessage(roomId, event.content, event.transactionId, async (dispatch) => {
 						await persistMatrixDeliveryPlan({
 							identity: plan,
 							accountId: ctx.accountId,
@@ -534,16 +339,21 @@ async function reconcileMatrixUnknownSend(ctx) {
 							events: plan.events,
 							dispatch
 						});
-					}),
-					receiptKind: event.receiptKind
-				});
+					});
+					if (!results.has(messageId)) {
+						const replyToId = resolveMatrixReplyToEventId(event.content);
+						results.set(messageId, {
+							messageId,
+							kind: event.receiptKind,
+							...replyToId ? { replyToId } : {}
+						});
+					}
+				}
 			}
-			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 } : {}
+			const receipt = createMatrixSendReceipt({
+				roomId,
+				events: [...results.values()],
+				threadId: resolveMatrixThreadRootId(orderedPlans[0].events[0].content)
 			});
 			return {
 				status: "sent",
@@ -570,8 +380,10 @@ async function reconcileMatrixUnknownSend(ctx) {
 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)));
+	const entries = await store.entries();
+	const prefix = entries.length > 0 ? queuePrefix(ctx.queueId) : "";
+	const keys = entries.filter((entry) => entry.key.startsWith(prefix)).map((entry) => entry.key);
+	for (const key of keys) await store.delete(key);
 }
 //#endregion
 //#region extensions/matrix/src/matrix/poll-types.ts
@@ -680,14 +492,14 @@ function buildPollResultsSummary(params) {
 		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;
+		const ts = asFiniteNumber(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;
+		const leftTs = asFiniteNumber(left.origin_server_ts) ?? Number.POSITIVE_INFINITY;
+		const rightTs = asFiniteNumber(right.origin_server_ts) ?? Number.POSITIVE_INFINITY;
 		if (leftTs !== rightTs) return leftTs - rightTs;
 		return (left.event_id ?? "").localeCompare(right.event_id ?? "");
 	});
@@ -696,7 +508,7 @@ function buildPollResultsSummary(params) {
 		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;
+		const eventTs = asFiniteNumber(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)));
@@ -790,34 +602,6 @@ function buildPollResponseContent(pollEventId, answerIds) {
 	};
 }
 //#endregion
-//#region extensions/matrix/src/matrix/relations.ts
-function relatedReplyEventId(relation) {
-	const reply = asOptionalRecord(relation?.["m.in_reply_to"]);
-	return typeof reply?.event_id === "string" ? reply.event_id : void 0;
-}
-function buildMatrixMessageRelation(params) {
-	const threadId = params.threadId?.trim();
-	const replyToId = params.replyToId?.trim();
-	const relatedId = replyToId || (threadId ? params.fallbackReplyToId?.trim() : void 0);
-	const reply = relatedId ? { "m.in_reply_to": { event_id: relatedId } } : void 0;
-	if (!threadId) return reply;
-	return {
-		rel_type: RelationType.Thread,
-		event_id: threadId,
-		...reply,
-		...relatedId && !replyToId ? { is_falling_back: true } : {}
-	};
-}
-function resolveMatrixReplyToEventId(content) {
-	const relation = asOptionalRecord(content["m.relates_to"]);
-	return relation?.rel_type === RelationType.Thread && relation.is_falling_back === true ? void 0 : relatedReplyEventId(relation);
-}
-function resolveMatrixThreadRootId(content) {
-	const relation = asOptionalRecord(content["m.relates_to"]);
-	if (relation?.rel_type !== RelationType.Thread) return;
-	return typeof relation.event_id === "string" ? relation.event_id : relatedReplyEventId(relation);
-}
-//#endregion
 //#region extensions/matrix/src/matrix/format-profile.ts
 function createMatrixPrivateMarkers(markdown, exhaustedMessage) {
 	const used = new Set(Array.from(markdown, (character) => character.charCodeAt(0)));
@@ -872,11 +656,14 @@ function findMatrixTableSourceRanges(markdown) {
 	const lineStarts = [0];
 	for (let index = 0; index < markdown.length; index += 1) if (markdown[index] === "\n") lineStarts.push(index + 1);
 	lineStarts.push(markdown.length);
-	return tableParser.parse(markdown, {}).flatMap((token) => {
+	return matrixTableSourceRangesFromTokens(tableParser.parse(markdown, {}), lineStarts, markdown.length);
+}
+function matrixTableSourceRangesFromTokens(tokens, lineStarts, sourceLength) {
+	return tokens.flatMap((token) => {
 		if (token.type !== "table_open" || !token.map) return [];
 		return [{
 			start: lineStarts[token.map[0]] ?? 0,
-			end: lineStarts[token.map[1]] ?? markdown.length
+			end: lineStarts[token.map[1]] ?? sourceLength
 		}];
 	});
 }
@@ -893,8 +680,14 @@ function findInlineMetadataRanges(markdown, references) {
 	const labelStack = [];
 	const codeRegions = findCodeRegions(markdown);
 	const underlineTags = [...tokenizeHtmlTags(markdown)].filter((tag) => tag.name === "u" || tag.name === "ins");
+	let underlineIndex = 0;
 	for (let index = 0; index < markdown.length - 1; index += 1) {
-		const underlineTag = underlineTags.find((tag) => tag.start === index);
+		let nextUnderlineTag = underlineTags[underlineIndex];
+		while (nextUnderlineTag && nextUnderlineTag.start < index) {
+			underlineIndex += 1;
+			nextUnderlineTag = underlineTags[underlineIndex];
+		}
+		const underlineTag = nextUnderlineTag?.start === index ? nextUnderlineTag : void 0;
 		if (underlineTag) {
 			index = underlineTag.end - 1;
 			continue;
@@ -945,42 +738,46 @@ function findInlineMetadataRanges(markdown, references) {
 			continue;
 		}
 		if (markdown[index] === "]" && !isMarkdownEscaped(markdown, index)) labelStack.pop();
-		const autolink = /^<[A-Za-z][A-Za-z0-9+.-]{1,31}:[^<>\s]*>/u.exec(markdown.slice(index));
-		if (autolink && !isMarkdownEscaped(markdown, index)) {
-			ranges.push({
-				start: index,
-				end: index + autolink[0].length
-			});
-			index += autolink[0].length - 1;
-			continue;
-		}
-		const emailAutolink = /^<[^<>\s@]+@[^<>\s@]+>/u.exec(markdown.slice(index));
-		if (emailAutolink && !isMarkdownEscaped(markdown, index)) {
-			ranges.push({
-				start: index,
-				end: index + emailAutolink[0].length
-			});
-			index += emailAutolink[0].length - 1;
+		if (markdown[index] === "<") {
+			const autolink = /^<[A-Za-z][A-Za-z0-9+.-]{1,31}:[^<>\s]*>/u.exec(markdown.slice(index));
+			if (autolink && !isMarkdownEscaped(markdown, index)) {
+				ranges.push({
+					start: index,
+					end: index + autolink[0].length
+				});
+				index += autolink[0].length - 1;
+				continue;
+			}
+			const emailAutolink = /^<[^<>\s@]+@[^<>\s@]+>/u.exec(markdown.slice(index));
+			if (emailAutolink && !isMarkdownEscaped(markdown, index)) {
+				ranges.push({
+					start: index,
+					end: index + emailAutolink[0].length
+				});
+				index += emailAutolink[0].length - 1;
+			}
 		}
 	}
 	return ranges;
 }
-function findMatrixMarkdownMetadataRanges(markdown) {
+function prepareMatrixMarkdownSource(markdown) {
 	const env = {};
 	const tokens = spoilerParser.parse(markdown, env);
 	const references = new Set(Object.keys(env.references ?? {}));
 	const lineStarts = [0];
 	for (let index = 0; index < markdown.length; index += 1) if (markdown[index] === "\n") lineStarts.push(index + 1);
 	lineStarts.push(markdown.length);
-	const ranges = tokens.flatMap((token) => {
+	const inlineRanges = tokens.flatMap((token) => {
 		if (token.type !== "inline" || !token.map) return [];
-		const start = lineStarts[token.map[0]] ?? 0;
-		const end = lineStarts[token.map[1]] ?? markdown.length;
-		return findInlineMetadataRanges(markdown.slice(start, end), references).map((range) => ({
-			start: start + range.start,
-			end: start + range.end
-		}));
+		return [{
+			start: lineStarts[token.map[0]] ?? 0,
+			end: lineStarts[token.map[1]] ?? markdown.length
+		}];
 	});
+	const ranges = inlineRanges.flatMap(({ start, end }) => findInlineMetadataRanges(markdown.slice(start, end), references).map((range) => ({
+		start: start + range.start,
+		end: start + range.end
+	})));
 	for (const match of markdown.matchAll(/^\s*\[[^\]\n]+\]:\s*.+$/gmu)) {
 		const start = match.index ?? 0;
 		const labelEnd = match[0].indexOf("]:");
@@ -1000,33 +797,29 @@ function findMatrixMarkdownMetadataRanges(markdown) {
 		start: match.index,
 		end: match.lastIndex
 	});
-	return ranges;
+	return {
+		markdown,
+		inlineRanges,
+		tableRanges: matrixTableSourceRangesFromTokens(tokens, lineStarts, markdown.length),
+		metadataRanges: ranges,
+		codeRegions,
+		underlineTags: [...tokenizeHtmlTags(markdown)].filter((tag) => tag.name === "u" || tag.name === "ins")
+	};
 }
-function findMatrixSpoilerDelimiterOffsets(markdown) {
-	const projected = projectMatrixMarkdown(markdown);
-	if (!projected.includes("||")) return [];
-	const tokens = spoilerParser.parse(projected, {});
-	const lineStarts = [0];
-	for (let index = 0; index < projected.length; index += 1) if (projected[index] === "\n") lineStarts.push(index + 1);
-	lineStarts.push(projected.length);
+function findMatrixSpoilerDelimiterOffsets(source) {
+	const { markdown, inlineRanges, codeRegions, metadataRanges, underlineTags } = source;
 	const excludedRanges = [
-		...findCodeRegions(projected),
-		...findMatrixMarkdownMetadataRanges(projected),
-		...[...tokenizeHtmlTags(projected)].flatMap((tag) => tag.name === "u" || tag.name === "ins" ? [{
-			start: tag.start,
-			end: tag.end
-		}] : [])
+		...codeRegions,
+		...metadataRanges,
+		...underlineTags
 	];
 	const offsets = [];
-	for (const token of tokens) {
-		if (token.type !== "inline" || !token.map) continue;
-		const start = lineStarts[token.map[0]] ?? 0;
-		const end = lineStarts[token.map[1]] ?? projected.length;
+	for (const { start, end } of inlineRanges) {
 		const candidates = [];
 		for (let index = start; index < end - 1; index += 1) {
-			if (projected[index] !== "|" || projected[index + 1] !== "|") continue;
+			if (markdown[index] !== "|" || markdown[index + 1] !== "|") continue;
 			const excluded = excludedRanges.some((range) => index >= range.start && index < range.end);
-			if (isMarkdownEscaped(projected, index) || excluded) continue;
+			if (isMarkdownEscaped(markdown, index) || excluded) continue;
 			candidates.push(index);
 			index += 1;
 		}
@@ -1035,20 +828,34 @@ function findMatrixSpoilerDelimiterOffsets(markdown) {
 	}
 	return [...new Set(offsets)].toSorted((left, right) => left - right);
 }
-function hasMatrixSpoilerMetadataCollision(markdown) {
-	const projected = projectMatrixMarkdown(markdown);
-	if (!projected.includes("||")) return false;
-	const ordinary = new Set(findMatrixSpoilerDelimiterOffsets(projected));
-	const underlineTags = [...tokenizeHtmlTags(projected)].filter((tag) => (tag.name === "u" || tag.name === "ins") && !isMarkdownEscaped(projected, tag.start));
-	const literalRanges = [...findMatrixTableSourceRanges(projected), ...findCodeRegions(projected).filter((code) => !underlineTags.some((tag) => code.start > tag.start && code.start < tag.end))];
-	for (let index = 0; index < projected.length - 1; index += 1) {
-		if (projected[index] !== "|" || projected[index + 1] !== "|") continue;
-		if (ordinary.has(index) || isMarkdownEscaped(projected, index)) continue;
+function hasMatrixSpoilerMetadataCollision(source, offsets) {
+	const { markdown, codeRegions } = source;
+	const ordinary = new Set(offsets);
+	const underlineTags = source.underlineTags.filter((tag) => !isMarkdownEscaped(markdown, tag.start));
+	const literalRanges = [...source.tableRanges, ...codeRegions.filter((code) => !underlineTags.some((tag) => code.start > tag.start && code.start < tag.end))];
+	for (let index = 0; index < markdown.length - 1; index += 1) {
+		if (markdown[index] !== "|" || markdown[index + 1] !== "|") continue;
+		if (ordinary.has(index) || isMarkdownEscaped(markdown, index)) continue;
 		if (literalRanges.some((range) => index >= range.start && index < range.end)) continue;
 		return true;
 	}
 	return false;
 }
+function analyzeMatrixSpoilers(markdown) {
+	const projected = projectMatrixMarkdown(markdown);
+	if (!projected.includes("||")) return {
+		markdown: projected,
+		delimiterOffsets: [],
+		metadataCollision: false
+	};
+	const source = prepareMatrixMarkdownSource(projected);
+	const delimiterOffsets = findMatrixSpoilerDelimiterOffsets(source);
+	return {
+		markdown: projected,
+		delimiterOffsets,
+		metadataCollision: hasMatrixSpoilerMetadataCollision(source, delimiterOffsets)
+	};
+}
 //#endregion
 //#region extensions/matrix/src/matrix/format.ts
 const MATRIX_STYLE_MARKERS = {
@@ -1350,13 +1157,14 @@ function compactLooseListTokens(tokens) {
 	}
 }
 function markdownToMatrixHtml(markdown, options = {}) {
-	if (hasMatrixSpoilerMetadataCollision(markdown)) return renderMatrixFallbackHtml(markdown);
-	const tokens = parseMatrixMarkdown(projectMatrixMarkdown(markdown), options.tableMode);
+	const analysis = analyzeMatrixSpoilers(markdown);
+	if (analysis.metadataCollision) return renderMatrixFallbackHtml(analysis);
+	const tokens = parseMatrixMarkdown(analysis, options.tableMode);
 	compactLooseListTokens(tokens);
 	return md.renderer.render(tokens, md.options, {}).trimEnd();
 }
-function protectMatrixSpoilerDelimiters(markdown) {
-	const offsets = findMatrixSpoilerDelimiterOffsets(markdown);
+function protectMatrixSpoilerDelimiters(analysis) {
+	const { markdown, delimiterOffsets: offsets } = analysis;
 	if (offsets.length === 0) return { markdown };
 	const markers = createMatrixPrivateMarkers(markdown, "Matrix spoiler formatting exhausted its private marker pool");
 	let protectedMarkdown = "";
@@ -1372,8 +1180,8 @@ function protectMatrixSpoilerDelimiters(markdown) {
 		markers
 	};
 }
-function parseMatrixMarkdown(markdown, tableMode) {
-	const protectedSpoilers = protectMatrixSpoilerDelimiters(markdown);
+function parseMatrixMarkdown(analysis, tableMode) {
+	const protectedSpoilers = protectMatrixSpoilerDelimiters(analysis);
 	if (tableMode === "off") md.disable("table");
 	try {
 		return md.parse(protectedSpoilers.markdown, { matrixSpoilerMarkers: protectedSpoilers.markers });
@@ -1382,9 +1190,10 @@ function parseMatrixMarkdown(markdown, tableMode) {
 	}
 }
 function markdownToMatrixBody(markdown) {
-	const projected = projectMatrixMarkdown(markdown);
-	const offsets = findMatrixSpoilerDelimiterOffsets(projected);
-	const metadataCollision = hasMatrixSpoilerMetadataCollision(projected);
+	return renderMatrixBody(analyzeMatrixSpoilers(markdown));
+}
+function renderMatrixBody(analysis) {
+	const { markdown: projected, delimiterOffsets: offsets, metadataCollision } = analysis;
 	if (offsets.length === 0 && !metadataCollision) return projected;
 	let body = projected;
 	if (metadataCollision) body = "[Spoiler]";
@@ -1403,11 +1212,11 @@ function markdownToMatrixBody(markdown) {
 		escapeText: (text) => text
 	}, MATRIX_FORMAT_PROFILE);
 }
-function renderMatrixFallbackHtml(markdown) {
-	return `<p>${escapeHtml(markdownToMatrixBody(markdown)).replaceAll("\n", "<br>\n")}</p>`;
+function renderMatrixFallbackHtml(analysis) {
+	return `<p>${escapeHtml(renderMatrixBody(analysis)).replaceAll("\n", "<br>\n")}</p>`;
 }
 async function resolveMarkdownMentionState(params) {
-	const tokens = parseMatrixMarkdown(projectMatrixMarkdown(params.markdown), params.tableMode);
+	const tokens = parseMatrixMarkdown(params.analysis, params.tableMode);
 	const selfUserId = await resolveMatrixSelfUserId(params.client);
 	const userIds = [];
 	const seenUserIds = /* @__PURE__ */ new Set();
@@ -1432,18 +1241,25 @@ async function resolveMarkdownMentionState(params) {
 	};
 }
 async function resolveMatrixMentionsInMarkdown(params) {
-	return (await resolveMarkdownMentionState(params)).mentions;
+	return (await resolveMarkdownMentionState({
+		analysis: analyzeMatrixSpoilers(params.markdown),
+		client: params.client
+	})).mentions;
 }
 async function renderMarkdownToMatrixHtmlWithMentions(params) {
-	const state = await resolveMarkdownMentionState(params);
-	if (hasMatrixSpoilerMetadataCollision(params.markdown)) {
-		const redacted = markdownToMatrixBody(params.markdown);
+	const analysis = analyzeMatrixSpoilers(params.markdown);
+	const state = await resolveMarkdownMentionState({
+		...params,
+		analysis
+	});
+	if (analysis.metadataCollision) {
+		const redacted = renderMatrixBody(analysis);
 		const redactedState = await resolveMarkdownMentionState({
 			...params,
-			markdown: redacted
+			analysis: analyzeMatrixSpoilers(redacted)
 		});
 		return {
-			html: renderMatrixFallbackHtml(params.markdown),
+			html: renderMatrixFallbackHtml(analysis),
 			mentions: redactedState.mentions
 		};
 	}
@@ -1466,9 +1282,8 @@ function resolveMatrixChunkOverflow(chunk, limit) {
 	return Math.max(0, renderedLength - limit);
 }
 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));
+	const { codeRegions, metadataRanges, underlineTags } = prepareMatrixMarkdownSource(markdown);
+	const tags = underlineTags.filter((tag) => !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;
@@ -1495,24 +1310,23 @@ function protectMatrixUnderlineTags(markdown) {
 	};
 }
 function restoreMatrixStyleChunks(chunks, spoiler, underline) {
+	if (!spoiler && !underline) return chunks;
 	const stack = [];
 	const syntax = {
 		spoiler: {
 			open: "||",
-			close: "||",
-			markers: spoiler
+			close: "||"
 		},
 		underline: {
 			open: "<u>",
-			close: "</u>",
-			markers: underline
+			close: "</u>"
 		}
 	};
 	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);
+			const opening = character === spoiler?.open ? "spoiler" : character === underline?.open ? "underline" : void 0;
+			const closing = character === spoiler?.close ? "spoiler" : character === underline?.close ? "underline" : void 0;
 			if (opening) {
 				stack.push(opening);
 				restored += syntax[opening].open;
@@ -1559,14 +1373,14 @@ 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 ?? getMatrixRuntime().channel.text.resolveMarkdownTableMode({
+	const tableMode = opts.tableMode ?? resolveMarkdownTableMode({
 		cfg,
 		channel: "matrix",
 		accountId: opts.accountId,
 		supportsBlockTables: MATRIX_FORMAT_PROFILE.constructs.table === "native"
 	});
 	const convertedText = renderMatrixMarkdownTables(trimmedText, tableMode);
-	const singleEventLimit = normalizeMatrixEventLimit(Math.min(getMatrixRuntime().channel.text.resolveTextChunkLimit(cfg, "matrix", opts.accountId), MATRIX_FORMAT_PROFILE.chunk.limit));
+	const singleEventLimit = normalizeMatrixEventLimit(Math.min(resolveTextChunkLimit(cfg, "matrix", opts.accountId), MATRIX_FORMAT_PROFILE.chunk.limit));
 	const preparedBody = markdownToMatrixBody(convertedText);
 	const eventTextLength = Math.max(convertedText.length, preparedBody.length);
 	return {
@@ -1587,10 +1401,12 @@ function chunkMatrixText(text, opts) {
 	};
 	const cfg = requireRuntimeConfig(opts.cfg, "Matrix text chunking");
 	const chunkMode = getMatrixRuntime().channel.text.resolveChunkMode(cfg, "matrix", opts.accountId);
-	const collisionRedacted = hasMatrixSpoilerMetadataCollision(preparedText.convertedText) ? markdownToMatrixBody(preparedText.convertedText) : void 0;
+	const analysis = analyzeMatrixSpoilers(preparedText.convertedText);
+	const collisionRedacted = analysis.metadataCollision ? renderMatrixBody(analysis) : void 0;
 	const chunkSegment = (segmentText) => {
-		const protectedUnderline = protectMatrixUnderlineTags(hasMatrixSpoilerMetadataCollision(segmentText) ? markdownToMatrixBody(segmentText) : segmentText);
-		const protectedSpoilers = protectMatrixSpoilerDelimiters(protectedUnderline.markdown);
+		const segmentAnalysis = analyzeMatrixSpoilers(segmentText);
+		const protectedUnderline = protectMatrixUnderlineTags(segmentAnalysis.metadataCollision ? renderMatrixBody(segmentAnalysis) : segmentText);
+		const protectedSpoilers = protectMatrixSpoilerDelimiters(analyzeMatrixSpoilers(protectedUnderline.markdown));
 		const wrapperReserve = (protectedSpoilers.markers ? 4 : 0) + (protectedUnderline.markers ? 7 : 0);
 		const privateMarkers = [protectedSpoilers.markers, protectedUnderline.markers].flatMap((markers) => markers ? [
 			markers.open,
@@ -1859,23 +1675,16 @@ 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 {
+	const info = params.imageInfo ? {
 		...base,
+		...params.imageInfo
+	} : base;
+	if (typeof params.durationMs === "number") return {
+		...info,
 		duration: params.durationMs
 	};
-	if (Object.keys(base).length === 0) return;
-	return base;
+	if (!params.imageInfo && Object.keys(info).length === 0) return;
+	return info;
 }
 function buildMediaContent(params) {
 	const info = buildMatrixMediaInfo({
@@ -2008,30 +1817,6 @@ var send_exports = /* @__PURE__ */ __exportAll({
 	sendSingleTextMessageMatrix: () => sendSingleTextMessageMatrix,
 	sendTypingMatrix: () => sendTypingMatrix
 });
-function createMatrixSendReceipt(params) {
-	const firstEvent = params.events[0];
-	const receipt = createMessageReceiptFromOutboundResults({
-		kind: firstEvent?.kind ?? "text",
-		...firstEvent?.replyToId ? { replyToId: firstEvent.replyToId } : {},
-		...params.threadId ? { threadId: params.threadId } : {},
-		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";
 }
@@ -2084,7 +1869,9 @@ async function sendMessageMatrix(to, message, opts) {
 		client: opts.client,
 		cfg: opts.cfg,
 		timeoutMs: opts.timeoutMs,
-		accountId: opts.accountId
+		accountId: opts.accountId,
+		signal: opts.signal,
+		assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff
 	}, async (client) => {
 		const roomId = await resolveMatrixRoomId(client, to);
 		const wireEventType = await client.prepareRoomForMessageSend(roomId);
@@ -2208,11 +1995,6 @@ async function sendMessageMatrix(to, message, opts) {
 			}));
 		}
 		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 = "";
@@ -2227,11 +2009,8 @@ async function sendMessageMatrix(to, message, opts) {
 					events: plannedEvents,
 					dispatch
 				});
-				if (!platformDispatchStarted) {
-					await opts.onPlatformSendDispatch?.();
-					platformDispatchStarted = true;
-				}
-			} : void 0);
+				await opts.onPlatformSendDispatch?.();
+			} : opts.onPlatformSendDispatch);
 			lastMessageId = eventId || lastMessageId;
 			if (!eventId) continue;
 			const eventReplyToId = resolveMatrixReplyToEventId(planned.content);
@@ -2434,4 +2213,4 @@ async function reactMatrixMessage(roomId, messageId, emoji, opts) {
 	});
 }
 //#endregion
-export { promoteMatrixDirectRoomCandidate as A, parsePollStart as C, reconcileMatrixUnknownSend as D, cleanupMatrixDeliveryPlans as E, resolveMatrixRoomId as O, isPollStartType as S, resolvePollReferenceEventId as T, buildPollResponseContent as _, sendSingleTextMessageMatrix as a, formatPollResultsAsText as b, formatMatrixMediaTooLargeText as c, isLikelyBareFilename as d, resolveMatrixMessageAttachment as f, resolveMatrixThreadRootId as g, resolveMatrixReplyToEventId as h, sendPollMatrix as i, repairMatrixDirectRooms as j, direct_management_exports as k, formatMatrixMediaUnavailableText as l, prepareMatrixSingleText as m, reactMatrixMessage as n, sendTypingMatrix as o, resolveMatrixReplacementContent as p, sendMessageMatrix as r, send_exports as s, editMessageMatrix as t, formatMatrixMessageText as u, buildPollResultsSummary as v, parsePollStartContent as w, isPollEventType as x, formatPollAsText as y };
+export { resolvePollReferenceEventId as C, resolveMatrixRoomId as E, parsePollStartContent as S, reconcileMatrixUnknownSend as T, formatPollAsText as _, sendSingleTextMessageMatrix as a, isPollStartType as b, formatMatrixMediaTooLargeText as c, isLikelyBareFilename as d, resolveMatrixMessageAttachment as f, buildPollResultsSummary as g, buildPollResponseContent as h, sendPollMatrix as i, formatMatrixMediaUnavailableText as l, prepareMatrixSingleText as m, reactMatrixMessage as n, sendTypingMatrix as o, resolveMatrixReplacementContent as p, sendMessageMatrix as r, send_exports as s, editMessageMatrix as t, formatMatrixMessageText as u, formatPollResultsAsText as v, cleanupMatrixDeliveryPlans as w, parsePollStart as x, isPollEventType as y };