@openclaw/matrix 2026.9.6 → 2026.9.7

package/dist/.setup/joined-room-encryption-TZoOKXgh.mjs

@@ -0,0 +1,67 @@
+import { n as LogService } from "./logger-CVv56jzH.mjs";
+import { EventType, MatrixError, MatrixEvent } from "matrix-js-sdk/lib/matrix.js";
+import { ConnectionError, HTTPError, Method } from "matrix-js-sdk/lib/http-api/index.js";
+import { RustCrypto } from "matrix-js-sdk/lib/rust-crypto/rust-crypto.js";
+//#region extensions/matrix/src/matrix/sdk/joined-room-encryption.ts
+const ROOM_CONCURRENCY = 4;
+async function reconcileJoinedRoomEncryption(client, signal, assertCurrent) {
+	const crypto = client.getCrypto();
+	if (!crypto) return;
+	if (!(crypto instanceof RustCrypto)) throw new Error("Matrix room encryption recovery requires the Rust crypto backend");
+	const checkActive = () => {
+		signal.throwIfAborted();
+		assertCurrent();
+	};
+	checkActive();
+	let joinedRooms;
+	try {
+		({joined_rooms: joinedRooms} = await client.http.authedRequest(Method.Get, "/joined_rooms", void 0, void 0, { abortSignal: signal }));
+	} catch (error) {
+		checkActive();
+		if (error instanceof ConnectionError || error instanceof HTTPError && (error.httpStatus === 408 || error.httpStatus === 429 || (error.httpStatus ?? 0) >= 500)) {
+			LogService.warn("MatrixClientLite", "Skipping room encryption recovery: joined-room discovery failed", error);
+			return;
+		}
+		throw error;
+	}
+	checkActive();
+	if (!Array.isArray(joinedRooms) || !joinedRooms.every((room) => typeof room === "string")) throw new Error("Matrix homeserver returned invalid joined rooms");
+	const rooms = [...new Set(joinedRooms)];
+	let next = 0;
+	const worker = async () => {
+		while (next < rooms.length) {
+			checkActive();
+			const roomId = rooms[next++];
+			if (!roomId) continue;
+			const room = client.getRoom(roomId);
+			if (!room || room.getMyMembership() !== "join") continue;
+			try {
+				let event = room.currentState.getStateEvents(EventType.RoomEncryption, "");
+				if (!event) {
+					const content = await client.http.authedRequest(Method.Get, `/rooms/${encodeURIComponent(roomId)}/state/m.room.encryption/`, void 0, void 0, { abortSignal: signal });
+					checkActive();
+					event = new MatrixEvent({
+						room_id: roomId,
+						type: EventType.RoomEncryption,
+						state_key: "",
+						content
+					});
+				}
+				checkActive();
+				if (client.getRoom(roomId) !== room || room.getMyMembership() !== "join") continue;
+				await crypto.onCryptoEvent(room, event);
+				checkActive();
+				if (client.getRoom(roomId) === room && room.getMyMembership() === "join") room.currentState.setStateEvents([event]);
+			} catch (error) {
+				checkActive();
+				if (error instanceof MatrixError && error.httpStatus === 404 && error.errcode === "M_NOT_FOUND") continue;
+				LogService.warn("MatrixClientLite", `Failed to recover encryption for ${roomId}:`, error);
+			}
+		}
+	};
+	const results = await Promise.allSettled(Array.from({ length: Math.min(ROOM_CONCURRENCY, rooms.length) }, worker));
+	checkActive();
+	for (const result of results) if (result.status === "rejected") throw result.reason;
+}
+//#endregion
+export { reconcileJoinedRoomEncryption };

package/dist/.setup/logger-CVv56jzH.mjs

@@ -0,0 +1,74 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { format } from "node:util";
+import { redactSensitiveText } from "openclaw/plugin-sdk/security-runtime";
+//#region extensions/matrix/src/matrix/sdk/logger.ts
+function noop() {}
+let forceConsoleLogging = false;
+function setMatrixConsoleLogging(enabled) {
+	forceConsoleLogging = enabled;
+}
+function resolveRuntimeLogger(module) {
+	if (forceConsoleLogging) return null;
+	try {
+		return getMatrixRuntime().logging.getChildLogger({ module: `matrix:${module}` });
+	} catch {
+		return null;
+	}
+}
+function formatMessage(module, messageOrObject) {
+	if (messageOrObject.length === 0) return `[${module}]`;
+	return redactSensitiveText(`[${module}] ${format(...messageOrObject)}`);
+}
+var ConsoleLogger = class {
+	emit(level, module, ...messageOrObject) {
+		const runtimeLogger = resolveRuntimeLogger(module);
+		const message = formatMessage(module, messageOrObject);
+		if (runtimeLogger) {
+			if (level === "debug") {
+				runtimeLogger.debug?.(message);
+				return;
+			}
+			runtimeLogger[level](message);
+			return;
+		}
+		console[level](message);
+	}
+	trace(module, ...messageOrObject) {
+		this.emit("debug", module, ...messageOrObject);
+	}
+	debug(module, ...messageOrObject) {
+		this.emit("debug", module, ...messageOrObject);
+	}
+	info(module, ...messageOrObject) {
+		this.emit("info", module, ...messageOrObject);
+	}
+	warn(module, ...messageOrObject) {
+		this.emit("warn", module, ...messageOrObject);
+	}
+	error(module, ...messageOrObject) {
+		this.emit("error", module, ...messageOrObject);
+	}
+};
+let activeLogger = new ConsoleLogger();
+const LogService = {
+	setLogger(logger) {
+		activeLogger = logger;
+	},
+	trace(module, ...messageOrObject) {
+		activeLogger.trace(module, ...messageOrObject);
+	},
+	debug(module, ...messageOrObject) {
+		activeLogger.debug(module, ...messageOrObject);
+	},
+	info(module, ...messageOrObject) {
+		activeLogger.info(module, ...messageOrObject);
+	},
+	warn(module, ...messageOrObject) {
+		activeLogger.warn(module, ...messageOrObject);
+	},
+	error(module, ...messageOrObject) {
+		activeLogger.error(module, ...messageOrObject);
+	}
+};
+//#endregion
+export { setMatrixConsoleLogging as i, LogService as n, noop as r, ConsoleLogger as t };

package/dist/.setup/logging-mhnFQGzB.mjs

@@ -0,0 +1,96 @@
+import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { i as setMatrixConsoleLogging, n as LogService, t as ConsoleLogger } from "./logger-CVv56jzH.mjs";
+import { logger } from "matrix-js-sdk/lib/logger.js";
+//#region extensions/matrix/src/matrix/client/logging.ts
+var logging_exports = /* @__PURE__ */ __exportAll({
+	createMatrixJsSdkClientLogger: () => createMatrixJsSdkClientLogger,
+	ensureMatrixSdkLoggingConfigured: () => ensureMatrixSdkLoggingConfigured,
+	setMatrixSdkConsoleLogging: () => setMatrixSdkConsoleLogging,
+	setMatrixSdkLogMode: () => setMatrixSdkLogMode
+});
+let matrixSdkLoggingConfigured = false;
+let matrixSdkLogMode = "default";
+const matrixSdkBaseLogger = new ConsoleLogger();
+let matrixJsSdkRootLoggerSnapshot = null;
+function shouldSuppressMatrixHttpNotFound(module, messageOrObject) {
+	if (!module.includes("MatrixHttpClient")) return false;
+	return messageOrObject.some((entry) => {
+		if (!entry || typeof entry !== "object") return false;
+		return entry.errcode === "M_NOT_FOUND";
+	});
+}
+function ensureMatrixSdkLoggingConfigured() {
+	matrixSdkLoggingConfigured = true;
+	applyMatrixSdkLogger();
+}
+function setMatrixSdkLogMode(mode) {
+	matrixSdkLogMode = mode;
+	if (!matrixSdkLoggingConfigured) return;
+	applyMatrixSdkLogger();
+}
+function setMatrixSdkConsoleLogging(enabled) {
+	setMatrixConsoleLogging(enabled);
+}
+function applyMatrixSdkLogger() {
+	if (matrixSdkLogMode === "quiet") {
+		setMatrixJsSdkRootLoggerLevel("silent");
+		LogService.setLogger({
+			trace: () => {},
+			debug: () => {},
+			info: () => {},
+			warn: () => {},
+			error: () => {}
+		});
+		return;
+	}
+	setMatrixJsSdkRootLoggerLevel("debug");
+	LogService.setLogger({
+		trace: (module, ...messageOrObject) => matrixSdkBaseLogger.trace(module, ...messageOrObject),
+		debug: (module, ...messageOrObject) => matrixSdkBaseLogger.debug(module, ...messageOrObject),
+		info: (module, ...messageOrObject) => matrixSdkBaseLogger.info(module, ...messageOrObject),
+		warn: (module, ...messageOrObject) => matrixSdkBaseLogger.warn(module, ...messageOrObject),
+		error: (module, ...messageOrObject) => {
+			if (shouldSuppressMatrixHttpNotFound(module, messageOrObject)) return;
+			matrixSdkBaseLogger.error(module, ...messageOrObject);
+		}
+	});
+}
+function setMatrixJsSdkRootLoggerLevel(level) {
+	const logger$1 = logger;
+	matrixJsSdkRootLoggerSnapshot ??= {
+		level: logger$1.getLevel?.(),
+		methodFactory: logger$1.methodFactory
+	};
+	if (level === "silent") {
+		logger$1.methodFactory = () => () => void 0;
+		logger$1.setLevel?.("silent", false);
+		logger$1.rebuild?.();
+		return;
+	}
+	logger$1.methodFactory = matrixJsSdkRootLoggerSnapshot.methodFactory;
+	const previousLevel = matrixJsSdkRootLoggerSnapshot.level;
+	if (typeof previousLevel === "string" || typeof previousLevel === "number") logger$1.setLevel?.(previousLevel, false);
+	logger$1.rebuild?.();
+}
+function createMatrixJsSdkClientLogger(prefix = "matrix") {
+	const log = (method, ...messageOrObject) => {
+		if (matrixSdkLogMode === "quiet") return;
+		matrixSdkBaseLogger[method](prefix, ...messageOrObject);
+	};
+	return {
+		trace: (...messageOrObject) => log("trace", ...messageOrObject),
+		debug: (...messageOrObject) => log("debug", ...messageOrObject),
+		info: (...messageOrObject) => log("info", ...messageOrObject),
+		warn: (...messageOrObject) => log("warn", ...messageOrObject),
+		error: (...messageOrObject) => {
+			if (shouldSuppressMatrixHttpNotFound(prefix, messageOrObject)) return;
+			log("error", ...messageOrObject);
+		},
+		getChild: (namespace) => {
+			const nextNamespace = namespace.trim();
+			return createMatrixJsSdkClientLogger(nextNamespace ? `${prefix}.${nextNamespace}` : prefix);
+		}
+	};
+}
+//#endregion
+export { setMatrixSdkLogMode as i, logging_exports as n, setMatrixSdkConsoleLogging as r, createMatrixJsSdkClientLogger as t };

package/dist/.setup/messages-Buz27pi5.mjs

@@ -0,0 +1,324 @@
+import { a as MATRIX_REACTION_EVENT_TYPE } from "./send-currentness-C2rMVVIQ.mjs";
+import { C as resolvePollReferenceEventId, S as parsePollStartContent, _ as formatPollAsText, b as isPollStartType, f as resolveMatrixMessageAttachment, g as buildPollResultsSummary, p as resolveMatrixReplacementContent, r as sendMessageMatrix, t as editMessageMatrix, v as formatPollResultsAsText, y as isPollEventType } from "./send-GOF64QRc.mjs";
+import { r as withResolvedRoomAction } from "./client-BXATebyo.mjs";
+import { n as isMatrixNotFoundError } from "./errors-DKVS3_DO.mjs";
+import { asNullableObjectRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/poll-summary.ts
+function resolveMatrixPollRootEventId(event) {
+	if (isPollStartType(event.type)) {
+		const eventId = event.event_id?.trim();
+		return eventId ? eventId : null;
+	}
+	return resolvePollReferenceEventId(event.content);
+}
+async function readAllPollRelations(client, roomId, pollEventId) {
+	const relationEvents = [];
+	const seenCursors = /* @__PURE__ */ new Set();
+	let nextBatch;
+	do {
+		const page = await client.getRelations(roomId, pollEventId, "m.reference", void 0, { from: nextBatch });
+		relationEvents.push(...page.events);
+		nextBatch = page.nextBatch ?? void 0;
+		if (nextBatch && seenCursors.has(nextBatch)) throw new Error("Matrix poll pagination returned a repeated cursor");
+		if (nextBatch) seenCursors.add(nextBatch);
+	} while (nextBatch);
+	return relationEvents;
+}
+async function fetchMatrixPollSnapshot(client, roomId, event) {
+	if (!isPollEventType(event.type)) return null;
+	const pollEventId = resolveMatrixPollRootEventId(event);
+	if (!pollEventId) return null;
+	const rootEvent = isPollStartType(event.type) ? event : await client.getEvent(roomId, pollEventId);
+	if (!isPollStartType(rootEvent.type)) return null;
+	const pollStartContent = rootEvent.content;
+	const pollSummary = parsePollStartContent(pollStartContent);
+	if (!pollSummary) return null;
+	const relationEvents = await readAllPollRelations(client, roomId, pollEventId);
+	const pollResults = buildPollResultsSummary({
+		pollEventId,
+		roomId,
+		sender: rootEvent.sender,
+		senderName: rootEvent.sender,
+		content: pollStartContent,
+		relationEvents
+	});
+	return {
+		pollEventId,
+		triggerEvent: event,
+		rootEvent,
+		text: pollResults ? formatPollResultsAsText(pollResults) : formatPollAsText(pollSummary)
+	};
+}
+async function fetchMatrixPollMessageSummary(client, roomId, event) {
+	const snapshot = await fetchMatrixPollSnapshot(client, roomId, event);
+	if (!snapshot) return null;
+	return {
+		eventId: snapshot.pollEventId,
+		sender: snapshot.rootEvent.sender,
+		body: snapshot.text,
+		msgtype: "m.text",
+		timestamp: snapshot.triggerEvent.origin_server_ts || snapshot.rootEvent.origin_server_ts
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/actions/limits.ts
+function resolveMatrixActionLimit(raw, fallback) {
+	return Math.max(1, Math.floor(raw !== void 0 && Number.isFinite(raw) ? raw : fallback));
+}
+//#endregion
+//#region extensions/matrix/src/matrix/actions/types.ts
+const EventType = {
+	RoomMessage: "m.room.message",
+	RoomPinnedEvents: "m.room.pinned_events",
+	RoomTopic: "m.room.topic",
+	Reaction: MATRIX_REACTION_EVENT_TYPE
+};
+//#endregion
+//#region extensions/matrix/src/matrix/actions/summary.ts
+function parseMatrixRawEvent(value) {
+	const event = asNullableObjectRecord(value);
+	const content = asNullableObjectRecord(event?.content);
+	if (!event || typeof event.event_id !== "string" || typeof event.sender !== "string" || typeof event.type !== "string" || typeof event.origin_server_ts !== "number" || !content) return null;
+	const unsigned = asNullableObjectRecord(event.unsigned);
+	const relations = asNullableObjectRecord(unsigned?.["m.relations"]);
+	return {
+		event_id: event.event_id,
+		sender: event.sender,
+		type: event.type,
+		origin_server_ts: event.origin_server_ts,
+		content,
+		...unsigned ? { unsigned: {
+			...typeof unsigned.age === "number" ? { age: unsigned.age } : {},
+			...relations ? { "m.relations": relations } : {},
+			...unsigned.redacted_because !== void 0 ? { redacted_because: unsigned.redacted_because } : {}
+		} } : {},
+		...typeof event.state_key === "string" ? { state_key: event.state_key } : {}
+	};
+}
+function summarizeMatrixRawEvent(event) {
+	const content = event.content;
+	const relates = content["m.relates_to"];
+	const displayContent = relates?.rel_type === "m.replace" ? content["m.new_content"] ?? content : resolveMatrixReplacementContent(event) ?? content;
+	let relType;
+	let eventId;
+	if (relates) {
+		if ("rel_type" in relates) {
+			relType = relates.rel_type;
+			eventId = relates.event_id;
+		} else if ("m.in_reply_to" in relates) eventId = relates["m.in_reply_to"]?.event_id;
+	}
+	const relatesTo = relType || eventId ? {
+		relType,
+		eventId
+	} : void 0;
+	const attachment = resolveMatrixMessageAttachment({
+		body: displayContent.body,
+		filename: displayContent.filename,
+		msgtype: displayContent.msgtype
+	});
+	return {
+		eventId: event.event_id,
+		sender: event.sender,
+		body: attachment ? attachment.caption : displayContent.body?.trim() || void 0,
+		msgtype: displayContent.msgtype,
+		attachment,
+		timestamp: event.origin_server_ts,
+		relatesTo
+	};
+}
+async function readPinnedEvents(client, roomId) {
+	try {
+		return (await client.getRoomStateEvent(roomId, EventType.RoomPinnedEvents, "")).pinned.filter((id) => id.trim().length > 0);
+	} catch (err) {
+		if (isMatrixNotFoundError(err)) return [];
+		throw err;
+	}
+}
+async function fetchEventSummary(client, roomId, eventId) {
+	try {
+		const raw = parseMatrixRawEvent(await client.getEvent(roomId, eventId));
+		if (!raw) return null;
+		if (raw.unsigned?.redacted_because) return null;
+		const pollSummary = await fetchMatrixPollMessageSummary(client, roomId, raw);
+		if (pollSummary) return pollSummary;
+		return summarizeMatrixRawEvent(raw);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region extensions/matrix/src/matrix/actions/messages.ts
+const MATRIX_THREAD_RELATIONS_START_CURSOR_PREFIX = "openclaw.matrix.thread-relations-start:";
+function resolveMatrixReplacementTarget(event) {
+	const relation = event.content["m.relates_to"];
+	if (!relation || typeof relation !== "object") return;
+	const replacement = relation;
+	return replacement.rel_type === "m.replace" && typeof replacement.event_id === "string" ? replacement.event_id : void 0;
+}
+function resolveLatestMatrixReplacements(events) {
+	const pageEventIds = new Set(events.map((event) => event.event_id));
+	const originals = new Map(events.filter((event) => event.type === EventType.RoomMessage && !event.unsigned?.redacted_because && event.state_key === void 0 && !resolveMatrixReplacementTarget(event)).map((event) => [event.event_id, event]));
+	const replacements = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const targetId = resolveMatrixReplacementTarget(event);
+		const original = targetId ? originals.get(targetId) : void 0;
+		if (!targetId || !original || !resolveMatrixReplacementContent(original, event)) continue;
+		const latest = replacements.get(targetId);
+		if (!latest || event.origin_server_ts > latest.origin_server_ts || event.origin_server_ts === latest.origin_server_ts && event.event_id > latest.event_id) replacements.set(targetId, event);
+	}
+	return {
+		pageEventIds,
+		replacements
+	};
+}
+async function sendMatrixMessage(to, content, opts = {}) {
+	if (!opts.cfg) throw new Error("Matrix message actions require a resolved runtime config.");
+	return await sendMessageMatrix(to, content, {
+		cfg: opts.cfg,
+		mediaUrl: opts.mediaUrl,
+		...opts.mediaAccess ? { mediaAccess: opts.mediaAccess } : {},
+		mediaLocalRoots: opts.mediaLocalRoots,
+		replyToId: opts.replyToId,
+		threadId: opts.threadId,
+		audioAsVoice: opts.audioAsVoice,
+		accountId: opts.accountId ?? void 0,
+		client: opts.client,
+		timeoutMs: opts.timeoutMs
+	});
+}
+async function editMatrixMessage(roomId, messageId, content, opts = {}) {
+	if (!opts.cfg) throw new Error("Matrix message actions require a resolved runtime config.");
+	if (!content.trim()) throw new Error("Matrix edit requires content");
+	return { eventId: await editMessageMatrix(roomId, messageId, content.trimEnd(), {
+		cfg: opts.cfg,
+		accountId: opts.accountId ?? void 0,
+		client: opts.client,
+		timeoutMs: opts.timeoutMs
+	}) || null };
+}
+async function deleteMatrixMessage(roomId, messageId, opts = {}) {
+	await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		await client.redactEvent(resolvedRoom, messageId, opts.reason);
+	});
+}
+async function readMatrixMessage(roomId, eventId, opts = {}) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		const message = await fetchEventSummary(client, resolvedRoom, eventId);
+		if (!message) throw new Error(`Matrix message ${eventId} was not found in room ${resolvedRoom}.`);
+		return message;
+	});
+}
+async function readMatrixMessages(roomId, opts = {}) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		const limit = resolveMatrixActionLimit(opts.limit, 20);
+		const rawBefore = normalizeOptionalString(opts.before);
+		const rawAfter = normalizeOptionalString(opts.after);
+		const dir = opts.after ? "f" : "b";
+		const threadId = normalizeOptionalString(opts.threadId);
+		const isThreadRelationsStartCursor = threadId ? isMatrixThreadRelationsStartCursor(rawBefore, threadId) : false;
+		const token = isThreadRelationsStartCursor ? void 0 : rawBefore ?? rawAfter;
+		const threadRootSummary = threadId !== void 0 && !token && !isThreadRelationsStartCursor && threadId ? await fetchDisplayableThreadRootSummary(client, resolvedRoom, threadId) : void 0;
+		const rootCountsTowardLimit = threadRootSummary !== void 0;
+		const rootFillsThreadPage = rootCountsTowardLimit && limit === 1;
+		const relationLimit = rootCountsTowardLimit ? Math.max(limit - 1, 1) : limit;
+		const seenPollRoots = /* @__PURE__ */ new Set();
+		const threadRootEventId = normalizeOptionalString(threadRootSummary?.eventId);
+		if (threadRootEventId) seenPollRoots.add(threadRootEventId);
+		const relationPage = threadId && relationLimit > 0 ? await client.getRelations(resolvedRoom, threadId, "m.thread", void 0, {
+			dir,
+			from: token,
+			limit: relationLimit
+		}) : null;
+		const flatPage = threadId ? null : await client.doRequest("GET", `/_matrix/client/v3/rooms/${encodeURIComponent(resolvedRoom)}/messages`, {
+			dir,
+			limit,
+			from: token
+		});
+		const hydratedChunk = await client.hydrateEvents(resolvedRoom, relationPage ? rootFillsThreadPage ? [] : relationPage.events : flatPage?.chunk ?? []);
+		const { pageEventIds, replacements } = resolveLatestMatrixReplacements(hydratedChunk);
+		const messages = [];
+		if (threadRootSummary) messages.push(threadRootSummary);
+		for (const event of hydratedChunk) {
+			if (event.unsigned?.redacted_because) continue;
+			if (!threadId && isMatrixThreadEvent(event)) continue;
+			if (event.type === EventType.RoomMessage) {
+				if (threadId && event.event_id === threadId) continue;
+				const replacementTarget = resolveMatrixReplacementTarget(event);
+				if (replacementTarget) {
+					const newContent = event.content["m.new_content"];
+					if (pageEventIds.has(replacementTarget) || !newContent || typeof newContent !== "object" || Array.isArray(newContent)) continue;
+					messages.push(summarizeMatrixRawEvent(event));
+					continue;
+				}
+				const replacement = replacements.get(event.event_id);
+				const originalRelation = event.content["m.relates_to"];
+				messages.push(summarizeMatrixRawEvent(replacement ? {
+					...event,
+					content: {
+						...replacement.content["m.new_content"],
+						"m.relates_to": originalRelation
+					}
+				} : event));
+				continue;
+			}
+			if (!isPollEventType(event.type)) continue;
+			const pollRootId = resolveMatrixPollRootEventId(event);
+			if (!pollRootId || seenPollRoots.has(pollRootId)) continue;
+			if (!threadId && await isMatrixPollRootThreaded({
+				client,
+				event,
+				pollRootId,
+				resolvedRoom
+			})) continue;
+			seenPollRoots.add(pollRootId);
+			const pollSummary = await fetchMatrixPollMessageSummary(client, resolvedRoom, event);
+			if (pollSummary) messages.push(pollSummary);
+		}
+		return {
+			messages,
+			nextBatch: rootFillsThreadPage && threadId && relationPage?.events.length ? encodeMatrixThreadRelationsStartCursor(threadId) : relationPage?.nextBatch ?? flatPage?.end ?? null,
+			prevBatch: relationPage?.prevBatch ?? flatPage?.start ?? null
+		};
+	});
+}
+function encodeMatrixThreadRelationsStartCursor(threadId) {
+	const payload = Buffer.from(JSON.stringify({
+		v: 1,
+		threadId
+	}), "utf8").toString("base64url");
+	return `${MATRIX_THREAD_RELATIONS_START_CURSOR_PREFIX}${payload}`;
+}
+function isMatrixThreadRelationsStartCursor(raw, threadId) {
+	if (!raw?.startsWith(MATRIX_THREAD_RELATIONS_START_CURSOR_PREFIX)) return false;
+	const encoded = raw.slice(39);
+	try {
+		const bytes = Buffer.from(encoded, "base64url");
+		if (bytes.toString("base64url") !== encoded) return false;
+		const decoded = JSON.parse(bytes.toString("utf8"));
+		return decoded.v === 1 && decoded.threadId === threadId && encodeMatrixThreadRelationsStartCursor(decoded.threadId) === raw;
+	} catch {
+		return false;
+	}
+}
+async function fetchDisplayableThreadRootSummary(client, resolvedRoom, threadId) {
+	const rawRootEvent = await client.getEvent(resolvedRoom, threadId).catch(() => null);
+	if (!rawRootEvent) return;
+	const rootEvent = (await client.hydrateEvents(resolvedRoom, [rawRootEvent]))[0];
+	if (!rootEvent || rootEvent.unsigned?.redacted_because) return;
+	if (rootEvent.type === EventType.RoomMessage) return summarizeMatrixRawEvent(rootEvent);
+	if (isPollStartType(rootEvent.type)) return await fetchMatrixPollMessageSummary(client, resolvedRoom, rootEvent) ?? void 0;
+}
+function isMatrixThreadEvent(event) {
+	const relates = event.content?.["m.relates_to"];
+	if (!relates || typeof relates !== "object") return false;
+	return relates.rel_type === "m.thread";
+}
+async function isMatrixPollRootThreaded(params) {
+	if (isMatrixThreadEvent(params.event)) return true;
+	const rootEvent = await params.client.getEvent(params.resolvedRoom, params.pollRootId).catch(() => null);
+	if (!rootEvent) return false;
+	const hydratedRoot = (await params.client.hydrateEvents(params.resolvedRoom, [rootEvent]))[0];
+	return hydratedRoot ? isMatrixThreadEvent(hydratedRoot) : false;
+}
+//#endregion
+export { sendMatrixMessage as a, EventType as c, readMatrixMessages as i, resolveMatrixActionLimit as l, editMatrixMessage as n, fetchEventSummary as o, readMatrixMessage as r, readPinnedEvents as s, deleteMatrixMessage as t, fetchMatrixPollSnapshot as u };