@openclaw/matrix 2026.3.12 → 2026.5.9-beta.1

package/dist/directory-live-DmOtMhyr.js

@@ -0,0 +1,150 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-80nQ2gql.js";
+import { t as MatrixAuthedHttpClient } from "./http-client-C7AeVJay.js";
+import { n as resolveMatrixAuth } from "./config--5-S2Akv.js";
+import "./client-_hckQNGW.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/directory-live.ts
+var directory_live_exports = /* @__PURE__ */ __exportAll({
+	listMatrixDirectoryGroupsLive: () => listMatrixDirectoryGroupsLive,
+	listMatrixDirectoryPeersLive: () => listMatrixDirectoryPeersLive
+});
+const MATRIX_DIRECTORY_TIMEOUT_MS = 1e4;
+function resolveMatrixDirectoryLimit(limit) {
+	return typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? Math.max(1, Math.floor(limit)) : 20;
+}
+function createMatrixDirectoryClient(auth) {
+	return new MatrixAuthedHttpClient({
+		homeserver: auth.homeserver,
+		accessToken: auth.accessToken,
+		ssrfPolicy: auth.ssrfPolicy,
+		dispatcherPolicy: auth.dispatcherPolicy
+	});
+}
+async function resolveMatrixDirectoryContext(params) {
+	const query = normalizeOptionalString(params.query) ?? "";
+	if (!query) return null;
+	const auth = await resolveMatrixAuth({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return {
+		auth,
+		client: createMatrixDirectoryClient(auth),
+		query,
+		queryLower: normalizeLowercaseStringOrEmpty(query)
+	};
+}
+function createGroupDirectoryEntry(params) {
+	return {
+		kind: "group",
+		id: params.id,
+		name: params.name,
+		handle: params.handle
+	};
+}
+async function requestMatrixJson(client, params) {
+	return await client.requestJson({
+		method: params.method,
+		endpoint: params.endpoint,
+		body: params.body,
+		timeoutMs: MATRIX_DIRECTORY_TIMEOUT_MS
+	});
+}
+async function listMatrixDirectoryPeersLive(params) {
+	const query = normalizeOptionalString(params.query) ?? "";
+	if (!query) return [];
+	const directUserId = normalizeMatrixMessagingTarget(query);
+	if (directUserId && isMatrixQualifiedUserId(directUserId)) return [{
+		kind: "user",
+		id: directUserId
+	}];
+	const context = await resolveMatrixDirectoryContext({
+		...params,
+		query
+	});
+	if (!context) return [];
+	return ((await requestMatrixJson(context.client, {
+		method: "POST",
+		endpoint: "/_matrix/client/v3/user_directory/search",
+		body: {
+			search_term: context.query,
+			limit: resolveMatrixDirectoryLimit(params.limit)
+		}
+	})).results ?? []).map((entry) => {
+		const userId = normalizeOptionalString(entry.user_id);
+		if (!userId) return null;
+		const displayName = normalizeOptionalString(entry.display_name);
+		return {
+			kind: "user",
+			id: userId,
+			name: displayName,
+			handle: displayName ? `@${displayName}` : void 0,
+			raw: entry
+		};
+	}).filter(Boolean);
+}
+async function resolveMatrixRoomAlias(client, alias) {
+	try {
+		return normalizeOptionalString((await requestMatrixJson(client, {
+			method: "GET",
+			endpoint: `/_matrix/client/v3/directory/room/${encodeURIComponent(alias)}`
+		})).room_id) ?? null;
+	} catch {
+		return null;
+	}
+}
+async function fetchMatrixRoomName(client, roomId) {
+	try {
+		return normalizeOptionalString((await requestMatrixJson(client, {
+			method: "GET",
+			endpoint: `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state/m.room.name`
+		})).name) ?? null;
+	} catch {
+		return null;
+	}
+}
+async function listMatrixDirectoryGroupsLive(params) {
+	const query = normalizeOptionalString(params.query) ?? "";
+	if (!query) return [];
+	const directTarget = normalizeMatrixMessagingTarget(query);
+	if (directTarget?.startsWith("!")) return [createGroupDirectoryEntry({
+		id: directTarget,
+		name: directTarget
+	})];
+	const context = await resolveMatrixDirectoryContext({
+		...params,
+		query
+	});
+	if (!context) return [];
+	const { client, queryLower } = context;
+	const limit = resolveMatrixDirectoryLimit(params.limit);
+	if (directTarget?.startsWith("#")) {
+		const roomId = await resolveMatrixRoomAlias(client, directTarget);
+		if (!roomId) return [];
+		return [createGroupDirectoryEntry({
+			id: roomId,
+			name: directTarget,
+			handle: directTarget
+		})];
+	}
+	const rooms = ((await requestMatrixJson(client, {
+		method: "GET",
+		endpoint: "/_matrix/client/v3/joined_rooms"
+	})).joined_rooms ?? []).map((roomId) => normalizeOptionalString(roomId)).filter((roomId) => Boolean(roomId));
+	const results = [];
+	for (const roomId of rooms) {
+		const name = await fetchMatrixRoomName(client, roomId);
+		if (!name || !normalizeLowercaseStringOrEmpty(name).includes(queryLower)) continue;
+		results.push({
+			kind: "group",
+			id: roomId,
+			name,
+			handle: `#${name}`
+		});
+		if (results.length >= limit) break;
+	}
+	return results;
+}
+//#endregion
+export { listMatrixDirectoryGroupsLive as n, listMatrixDirectoryPeersLive as r, directory_live_exports as t };

package/dist/doctor-C4__7c-U.js

@@ -0,0 +1,153 @@
+import { t as isRecord } from "./record-shared-CHWJCTWf.js";
+import "./doctor-contract-D4-64QuJ.js";
+import { i as autoPrepareLegacyMatrixCrypto, o as autoMigrateLegacyMatrixState, r as resolveMatrixMigrationStatus } from "./matrix-migration.runtime-WY6ffcrf.js";
+import { t as maybeCreateMatrixMigrationSnapshot } from "./migration-snapshot-backup-DaCHTp8C.js";
+import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "openclaw/plugin-sdk/runtime-doctor";
+//#region extensions/matrix/src/doctor.ts
+function hasConfiguredMatrixChannel(cfg) {
+	const channels = cfg.channels;
+	return isRecord(channels?.matrix);
+}
+function hasConfiguredMatrixPluginSurface(cfg) {
+	return Boolean(cfg.plugins?.installs?.matrix || cfg.plugins?.entries?.matrix || cfg.plugins?.allow?.includes("matrix") || cfg.plugins?.deny?.includes("matrix"));
+}
+function hasConfiguredMatrixEnv(env) {
+	return Object.entries(env).some(([key, value]) => key.startsWith("MATRIX_") && typeof value === "string" && value.trim());
+}
+function configMayNeedMatrixDoctorSequence(cfg, env) {
+	return hasConfiguredMatrixChannel(cfg) || hasConfiguredMatrixPluginSurface(cfg) || hasConfiguredMatrixEnv(env);
+}
+function formatMatrixLegacyStatePreview(detection) {
+	return [
+		"- Matrix plugin upgraded in place.",
+		`- Legacy sync store: ${detection.legacyStoragePath} -> ${detection.targetStoragePath}`,
+		`- Legacy crypto store: ${detection.legacyCryptoPath} -> ${detection.targetCryptoPath}`,
+		...detection.selectionNote ? [`- ${detection.selectionNote}`] : [],
+		"- Run \"openclaw doctor --fix\" to migrate this Matrix state now."
+	].join("\n");
+}
+function formatMatrixLegacyCryptoPreview(detection) {
+	const notes = [];
+	for (const warning of detection.warnings) notes.push(`- ${warning}`);
+	for (const plan of detection.plans) notes.push([
+		`- Matrix encrypted-state migration is pending for account "${plan.accountId}".`,
+		`- Legacy crypto store: ${plan.legacyCryptoPath}`,
+		`- New recovery key file: ${plan.recoveryKeyPath}`,
+		`- Migration state file: ${plan.statePath}`,
+		"- Run \"openclaw doctor --fix\" to extract any saved backup key now. Backed-up room keys will restore automatically on next gateway start."
+	].join("\n"));
+	return notes;
+}
+async function collectMatrixInstallPathWarnings(cfg) {
+	const issue = await detectPluginInstallPathIssue({
+		pluginId: "matrix",
+		install: cfg.plugins?.installs?.matrix
+	});
+	if (!issue) return [];
+	return formatPluginInstallPathIssue({
+		issue,
+		pluginLabel: "Matrix",
+		defaultInstallCommand: "openclaw plugins install @openclaw/matrix"
+	}).map((entry) => `- ${entry}`);
+}
+async function cleanStaleMatrixPluginConfig(cfg) {
+	const issue = await detectPluginInstallPathIssue({
+		pluginId: "matrix",
+		install: cfg.plugins?.installs?.matrix
+	});
+	if (!issue || issue.kind !== "missing-path") return {
+		config: cfg,
+		changes: []
+	};
+	const { config, actions } = removePluginFromConfig(cfg, "matrix");
+	const removed = [];
+	if (actions.install) removed.push("install record");
+	if (actions.loadPath) removed.push("load path");
+	if (actions.entry) removed.push("plugin entry");
+	if (actions.allowlist) removed.push("allowlist entry");
+	if (removed.length === 0) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config,
+		changes: [`Removed stale Matrix plugin references (${removed.join(", ")}). The previous install path no longer exists: ${issue.path}`]
+	};
+}
+async function applyMatrixDoctorRepair(params) {
+	const changes = [];
+	const warnings = [];
+	const migrationStatus = resolveMatrixMigrationStatus({
+		cfg: params.cfg,
+		env: params.env
+	});
+	let matrixSnapshotReady = true;
+	if (migrationStatus.actionable) try {
+		const snapshot = await maybeCreateMatrixMigrationSnapshot({
+			trigger: "doctor-fix",
+			env: params.env
+		});
+		changes.push(`Matrix migration snapshot ${snapshot.created ? "created" : "reused"} before applying Matrix upgrades.\n- ${snapshot.archivePath}`);
+	} catch (error) {
+		matrixSnapshotReady = false;
+		warnings.push(`- Failed creating a Matrix migration snapshot before repair: ${String(error)}`);
+		warnings.push("- Skipping Matrix migration changes for now. Resolve the snapshot failure, then rerun \"openclaw doctor --fix\".");
+	}
+	else if (migrationStatus.pending) warnings.push("- Matrix migration warnings are present, but no on-disk Matrix mutation is actionable yet. No pre-migration snapshot was needed.");
+	if (!matrixSnapshotReady) return {
+		changes,
+		warnings
+	};
+	const matrixStateRepair = await autoMigrateLegacyMatrixState({
+		cfg: params.cfg,
+		env: params.env
+	});
+	if (matrixStateRepair.changes.length > 0) changes.push([
+		"Matrix plugin upgraded in place.",
+		...matrixStateRepair.changes.map((entry) => `- ${entry}`),
+		"- No user action required."
+	].join("\n"));
+	if (matrixStateRepair.warnings.length > 0) warnings.push(matrixStateRepair.warnings.map((entry) => `- ${entry}`).join("\n"));
+	const matrixCryptoRepair = await autoPrepareLegacyMatrixCrypto({
+		cfg: params.cfg,
+		env: params.env
+	});
+	if (matrixCryptoRepair.changes.length > 0) changes.push(["Matrix encrypted-state migration prepared.", ...matrixCryptoRepair.changes.map((entry) => `- ${entry}`)].join("\n"));
+	if (matrixCryptoRepair.warnings.length > 0) warnings.push(matrixCryptoRepair.warnings.map((entry) => `- ${entry}`).join("\n"));
+	return {
+		changes,
+		warnings
+	};
+}
+async function runMatrixDoctorSequence(params) {
+	const warningNotes = [];
+	const changeNotes = [];
+	const installWarnings = await collectMatrixInstallPathWarnings(params.cfg);
+	if (installWarnings.length > 0) warningNotes.push(installWarnings.join("\n"));
+	if (!configMayNeedMatrixDoctorSequence(params.cfg, params.env)) return {
+		changeNotes,
+		warningNotes
+	};
+	if (params.shouldRepair) {
+		const repair = await applyMatrixDoctorRepair({
+			cfg: params.cfg,
+			env: params.env
+		});
+		changeNotes.push(...repair.changes);
+		warningNotes.push(...repair.warnings);
+	} else {
+		const migrationStatus = resolveMatrixMigrationStatus({
+			cfg: params.cfg,
+			env: params.env
+		});
+		if (migrationStatus.legacyState) if ("warning" in migrationStatus.legacyState) warningNotes.push(`- ${migrationStatus.legacyState.warning}`);
+		else warningNotes.push(formatMatrixLegacyStatePreview(migrationStatus.legacyState));
+		if (migrationStatus.legacyCrypto.warnings.length > 0 || migrationStatus.legacyCrypto.plans.length > 0) warningNotes.push(...formatMatrixLegacyCryptoPreview(migrationStatus.legacyCrypto));
+	}
+	return {
+		changeNotes,
+		warningNotes
+	};
+}
+//#endregion
+export { cleanStaleMatrixPluginConfig, runMatrixDoctorSequence };

package/dist/doctor-contract-D4-64QuJ.js

@@ -0,0 +1,246 @@
+import { t as isRecord } from "./record-shared-CHWJCTWf.js";
+import { hasLegacyFlatAllowPrivateNetworkAlias, migrateLegacyFlatAllowPrivateNetworkAlias } from "openclaw/plugin-sdk/ssrf-runtime";
+//#region extensions/matrix/src/doctor-contract.ts
+function hasLegacyMatrixRoomAllowAlias(value) {
+	const room = isRecord(value) ? value : null;
+	return Boolean(room && typeof room.allow === "boolean");
+}
+function hasLegacyMatrixRoomMapAllowAliases(value) {
+	const rooms = isRecord(value) ? value : null;
+	return Boolean(rooms && Object.values(rooms).some((room) => hasLegacyMatrixRoomAllowAlias(room)));
+}
+function hasLegacyMatrixAccountRoomAllowAliases(value) {
+	const accounts = isRecord(value) ? value : null;
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => {
+		if (!isRecord(account)) return false;
+		return hasLegacyMatrixRoomMapAllowAliases(account.groups) || hasLegacyMatrixRoomMapAllowAliases(account.rooms);
+	});
+}
+function hasLegacyMatrixAccountPrivateNetworkAliases(value) {
+	const accounts = isRecord(value) ? value : null;
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => hasLegacyFlatAllowPrivateNetworkAlias(isRecord(account) ? account : {}));
+}
+function hasLegacyTrustedDmPolicy(value) {
+	const root = isRecord(value) ? value : null;
+	if (!root) return false;
+	return (isRecord(root.dm) ? root.dm : null)?.policy === "trusted";
+}
+function hasLegacyMatrixAccountTrustedDmPolicies(value) {
+	const accounts = isRecord(value) ? value : null;
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => hasLegacyTrustedDmPolicy(account));
+}
+function migrateLegacyTrustedDmPolicy(params) {
+	const dm = isRecord(params.entry.dm) ? params.entry.dm : null;
+	if (!dm || dm.policy !== "trusted") return {
+		entry: params.entry,
+		changed: false
+	};
+	const allowFromRaw = dm.allowFrom;
+	const allowFromEntries = Array.isArray(allowFromRaw) ? allowFromRaw.filter((entry) => typeof entry === "string" && entry.trim().length > 0).length : 0;
+	const nextPolicy = allowFromEntries > 0 ? "allowlist" : "pairing";
+	const nextDm = {
+		...dm,
+		policy: nextPolicy
+	};
+	params.changes.push(`Migrated ${params.pathPrefix}.dm.policy "trusted" → "${nextPolicy}" (legacy alias removed; ${allowFromEntries > 0 ? `preserved ${allowFromEntries} ${params.pathPrefix}.dm.allowFrom ${allowFromEntries === 1 ? "entry" : "entries"}` : "no allowFrom entries present, defaulting to pairing for safety"}).`);
+	return {
+		entry: {
+			...params.entry,
+			dm: nextDm
+		},
+		changed: true
+	};
+}
+function normalizeMatrixRoomAllowAliases(params) {
+	let changed = false;
+	const nextRooms = { ...params.rooms };
+	for (const [roomId, roomValue] of Object.entries(params.rooms)) {
+		const room = isRecord(roomValue) ? roomValue : null;
+		if (!room || typeof room.allow !== "boolean") continue;
+		const nextRoom = { ...room };
+		if (typeof nextRoom.enabled !== "boolean") nextRoom.enabled = room.allow;
+		delete nextRoom.allow;
+		nextRooms[roomId] = nextRoom;
+		changed = true;
+		params.changes.push(`Moved ${params.pathPrefix}.${roomId}.allow → ${params.pathPrefix}.${roomId}.enabled (${String(nextRoom.enabled)}).`);
+	}
+	return {
+		rooms: nextRooms,
+		changed
+	};
+}
+const legacyConfigRules = [
+	{
+		path: ["channels", "matrix"],
+		message: "channels.matrix.allowPrivateNetwork is legacy; use channels.matrix.network.dangerouslyAllowPrivateNetwork instead. Run \"openclaw doctor --fix\".",
+		match: (value) => hasLegacyFlatAllowPrivateNetworkAlias(isRecord(value) ? value : {})
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.allowPrivateNetwork is legacy; use channels.matrix.accounts.<id>.network.dangerouslyAllowPrivateNetwork instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyMatrixAccountPrivateNetworkAliases
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"groups"
+		],
+		message: "channels.matrix.groups.<room>.allow is legacy; use channels.matrix.groups.<room>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyMatrixRoomMapAllowAliases
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"rooms"
+		],
+		message: "channels.matrix.rooms.<room>.allow is legacy; use channels.matrix.rooms.<room>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyMatrixRoomMapAllowAliases
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.{groups,rooms}.<room>.allow is legacy; use channels.matrix.accounts.<id>.{groups,rooms}.<room>.enabled instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyMatrixAccountRoomAllowAliases
+	},
+	{
+		path: ["channels", "matrix"],
+		message: "channels.matrix.dm.policy \"trusted\" is legacy; use \"allowlist\" (with allowFrom entries) or \"pairing\" instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyTrustedDmPolicy
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.dm.policy \"trusted\" is legacy; use \"allowlist\" (with allowFrom entries) or \"pairing\" instead. Run \"openclaw doctor --fix\".",
+		match: hasLegacyMatrixAccountTrustedDmPolicies
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const channels = isRecord(cfg.channels) ? cfg.channels : null;
+	const matrix = isRecord(channels?.matrix) ? channels.matrix : null;
+	if (!matrix) return {
+		config: cfg,
+		changes: []
+	};
+	const changes = [];
+	let updatedMatrix = matrix;
+	let changed = false;
+	const topLevelPrivateNetwork = migrateLegacyFlatAllowPrivateNetworkAlias({
+		entry: updatedMatrix,
+		pathPrefix: "channels.matrix",
+		changes
+	});
+	updatedMatrix = topLevelPrivateNetwork.entry;
+	changed = changed || topLevelPrivateNetwork.changed;
+	const topLevelTrustedDmPolicy = migrateLegacyTrustedDmPolicy({
+		entry: updatedMatrix,
+		pathPrefix: "channels.matrix",
+		changes
+	});
+	updatedMatrix = topLevelTrustedDmPolicy.entry;
+	changed = changed || topLevelTrustedDmPolicy.changed;
+	const normalizeTopLevelRoomScope = (key) => {
+		const rooms = isRecord(updatedMatrix[key]) ? updatedMatrix[key] : null;
+		if (!rooms) return;
+		const normalized = normalizeMatrixRoomAllowAliases({
+			rooms,
+			pathPrefix: `channels.matrix.${key}`,
+			changes
+		});
+		if (normalized.changed) {
+			updatedMatrix = {
+				...updatedMatrix,
+				[key]: normalized.rooms
+			};
+			changed = true;
+		}
+	};
+	normalizeTopLevelRoomScope("groups");
+	normalizeTopLevelRoomScope("rooms");
+	const accounts = isRecord(updatedMatrix.accounts) ? updatedMatrix.accounts : null;
+	if (accounts) {
+		let accountsChanged = false;
+		const nextAccounts = { ...accounts };
+		for (const [accountId, accountValue] of Object.entries(accounts)) {
+			const account = isRecord(accountValue) ? accountValue : null;
+			if (!account) continue;
+			let nextAccount = account;
+			let accountChanged = false;
+			const privateNetworkMigration = migrateLegacyFlatAllowPrivateNetworkAlias({
+				entry: nextAccount,
+				pathPrefix: `channels.matrix.accounts.${accountId}`,
+				changes
+			});
+			if (privateNetworkMigration.changed) {
+				nextAccount = privateNetworkMigration.entry;
+				accountChanged = true;
+			}
+			const accountTrustedDmPolicy = migrateLegacyTrustedDmPolicy({
+				entry: nextAccount,
+				pathPrefix: `channels.matrix.accounts.${accountId}`,
+				changes
+			});
+			if (accountTrustedDmPolicy.changed) {
+				nextAccount = accountTrustedDmPolicy.entry;
+				accountChanged = true;
+			}
+			for (const key of ["groups", "rooms"]) {
+				const rooms = isRecord(nextAccount[key]) ? nextAccount[key] : null;
+				if (!rooms) continue;
+				const normalized = normalizeMatrixRoomAllowAliases({
+					rooms,
+					pathPrefix: `channels.matrix.accounts.${accountId}.${key}`,
+					changes
+				});
+				if (normalized.changed) {
+					nextAccount = {
+						...nextAccount,
+						[key]: normalized.rooms
+					};
+					accountChanged = true;
+				}
+			}
+			if (accountChanged) {
+				nextAccounts[accountId] = nextAccount;
+				accountsChanged = true;
+			}
+		}
+		if (accountsChanged) {
+			updatedMatrix = {
+				...updatedMatrix,
+				accounts: nextAccounts
+			};
+			changed = true;
+		}
+	}
+	if (!changed) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				matrix: updatedMatrix
+			}
+		},
+		changes
+	};
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

@@ -0,0 +1,2 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-D4-64QuJ.js";
+export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/draft-stream-BE2QevQQ.js

@@ -0,0 +1,144 @@
+import { n as editMessageMatrix, r as prepareMatrixSingleText, s as sendSingleTextMessageMatrix } from "./send-Bo0DU1ca.js";
+import { l as MsgType } from "./direct-management-DMMMgtTB.js";
+import { createDraftStreamLoop } from "openclaw/plugin-sdk/channel-lifecycle";
+//#region extensions/matrix/src/matrix/draft-stream.ts
+const DEFAULT_THROTTLE_MS = 1e3;
+function resolveDraftPreviewOptions(mode) {
+	if (mode === "quiet") return {
+		msgtype: MsgType.Notice,
+		includeMentions: false
+	};
+	return { msgtype: MsgType.Text };
+}
+function createMatrixDraftStream(params) {
+	const { roomId, client, cfg, threadId, accountId, log } = params;
+	const preview = resolveDraftPreviewOptions(params.mode ?? "partial");
+	const useLive = params.mode !== "quiet";
+	let currentEventId;
+	let lastSentText = "";
+	let stopped = false;
+	let sendFailed = false;
+	let finalizeInPlaceBlocked = false;
+	let liveFinalized = false;
+	let replyToId = params.replyToId;
+	const sendOrEdit = async (text) => {
+		const trimmed = text.trimEnd();
+		if (!trimmed) return false;
+		const preparedText = prepareMatrixSingleText(trimmed, {
+			cfg,
+			accountId
+		});
+		if (!preparedText.fitsInSingleEvent) {
+			finalizeInPlaceBlocked = true;
+			if (!currentEventId) sendFailed = true;
+			stopped = true;
+			log?.(`draft-stream: preview exceeded single-event limit (${preparedText.convertedText.length} > ${preparedText.singleEventLimit})`);
+			return false;
+		}
+		if (sendFailed) return false;
+		if (preparedText.trimmedText === lastSentText) return true;
+		try {
+			if (!currentEventId) {
+				currentEventId = (await sendSingleTextMessageMatrix(roomId, preparedText.trimmedText, {
+					client,
+					cfg,
+					replyToId,
+					threadId,
+					accountId,
+					msgtype: preview.msgtype,
+					includeMentions: preview.includeMentions,
+					live: useLive
+				})).messageId;
+				lastSentText = preparedText.trimmedText;
+				log?.(`draft-stream: created message ${currentEventId}${useLive ? " (MSC4357 live)" : ""}`);
+			} else {
+				await editMessageMatrix(roomId, currentEventId, preparedText.trimmedText, {
+					client,
+					cfg,
+					threadId,
+					accountId,
+					msgtype: preview.msgtype,
+					includeMentions: preview.includeMentions,
+					live: useLive
+				});
+				lastSentText = preparedText.trimmedText;
+			}
+			return true;
+		} catch (err) {
+			log?.(`draft-stream: send/edit failed: ${String(err)}`);
+			if (err instanceof Error && err.message.startsWith("Matrix single-message text exceeds limit")) finalizeInPlaceBlocked = true;
+			if (!currentEventId) sendFailed = true;
+			stopped = true;
+			return false;
+		}
+	};
+	const loop = createDraftStreamLoop({
+		throttleMs: DEFAULT_THROTTLE_MS,
+		isStopped: () => stopped,
+		sendOrEditStreamMessage: sendOrEdit
+	});
+	log?.(`draft-stream: ready (throttleMs=${DEFAULT_THROTTLE_MS})`);
+	const finalizeLive = async () => {
+		if (useLive && !liveFinalized && currentEventId && lastSentText) {
+			liveFinalized = true;
+			try {
+				await editMessageMatrix(roomId, currentEventId, lastSentText, {
+					client,
+					cfg,
+					threadId,
+					accountId,
+					msgtype: preview.msgtype,
+					includeMentions: preview.includeMentions,
+					live: false
+				});
+				log?.(`draft-stream: finalized ${currentEventId} (MSC4357 stream ended)`);
+				return true;
+			} catch (err) {
+				log?.(`draft-stream: finalize edit failed: ${String(err)}`);
+				finalizeInPlaceBlocked = true;
+				return false;
+			}
+		}
+		return true;
+	};
+	const stop = async () => {
+		await loop.flush();
+		stopped = true;
+		return currentEventId;
+	};
+	const discardPending = async () => {
+		stopped = true;
+		loop.stop();
+		await loop.waitForInFlight();
+	};
+	const reset = () => {
+		replyToId = params.preserveReplyId ? params.replyToId : void 0;
+		currentEventId = void 0;
+		lastSentText = "";
+		stopped = false;
+		sendFailed = false;
+		finalizeInPlaceBlocked = false;
+		liveFinalized = false;
+		loop.resetPending();
+		loop.resetThrottleWindow();
+	};
+	return {
+		update: (text) => {
+			if (stopped) return;
+			loop.update(text);
+		},
+		flush: loop.flush,
+		stop,
+		discardPending,
+		finalizeLive,
+		reset,
+		eventId: () => currentEventId,
+		matchesPreparedText: (text) => prepareMatrixSingleText(text, {
+			cfg,
+			accountId
+		}).trimmedText === lastSentText,
+		mustDeliverFinalNormally: () => sendFailed || finalizeInPlaceBlocked
+	};
+}
+//#endregion
+export { createMatrixDraftStream };