@openclaw/matrix 2026.9.6 → 2026.9.8

package/dist/.setup/approval-handler.runtime-C-pw3NvY.mjs

@@ -0,0 +1,408 @@
+import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { c as shouldHandleMatrixApprovalRequest, r as isMatrixAnyApprovalClientEnabled } from "./exec-approvals-fsiMQ1ce.mjs";
+import { o as resolveMatrixTargetIdentity } from "./target-ids-Nwx7cMVE.mjs";
+import { a as repairMatrixDirectRooms } from "./direct-management-Cn2t8n1V.mjs";
+import { a as sendSingleTextMessageMatrix, n as reactMatrixMessage, r as sendMessageMatrix } from "./send-GOF64QRc.mjs";
+import { a as unregisterMatrixApprovalReactionTarget, n as listMatrixApprovalReactionBindings, r as registerMatrixApprovalReactionTarget, t as buildMatrixApprovalReactionHint } from "./approval-reactions-BrS5ECU0.mjs";
+import { n as editMatrixMessage, t as deleteMatrixMessage } from "./messages-Buz27pi5.mjs";
+import { listMessageReceiptPlatformIds, resolveMessageReceiptPrimaryId } from "openclaw/plugin-sdk/channel-outbound";
+import { normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { buildExecApprovalPendingReplyPayload, buildPluginApprovalPendingReplyPayload } from "openclaw/plugin-sdk/approval-reply-runtime";
+import { buildApprovalPendingReplyPayload, buildPluginApprovalResolvedReplyPayload, formatChannelApprovalResolvedLabel } from "openclaw/plugin-sdk/approval-runtime";
+import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
+//#region extensions/matrix/src/approval-handler.runtime.ts
+const MATRIX_APPROVAL_METADATA_KEY = "com.openclaw.approval";
+const MATRIX_APPROVAL_DELIVERY_ATTEMPTS = 3;
+const MATRIX_APPROVAL_DELIVERY_RETRY_DELAY_MS = 250;
+function resolveHandlerContext(params) {
+	const context = params.context;
+	const accountId = params.accountId?.trim() || "";
+	if (!context?.client || !accountId) return null;
+	return {
+		accountId,
+		context
+	};
+}
+function normalizeReactionTargetRef(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const roomId = params.roomId.trim();
+	const eventId = params.eventId.trim();
+	if (!accountId || !roomId || !eventId) return null;
+	return {
+		accountId,
+		roomId,
+		eventId
+	};
+}
+function normalizeThreadId(value) {
+	return (value == null ? "" : String(value).trim()) || void 0;
+}
+function isSingleMatrixMessageLimitError(error) {
+	return error instanceof Error && error.message.includes("Matrix single-message text exceeds limit");
+}
+async function retryMatrixApprovalDelivery(operation, params = {}) {
+	return await retryAsync(operation, {
+		attempts: MATRIX_APPROVAL_DELIVERY_ATTEMPTS,
+		minDelayMs: MATRIX_APPROVAL_DELIVERY_RETRY_DELAY_MS,
+		shouldRetry: (error) => params.shouldRetry?.(error) !== false
+	});
+}
+async function prepareTarget(params) {
+	const resolved = resolveHandlerContext(params);
+	if (!resolved) return null;
+	const target = resolveMatrixTargetIdentity(params.rawTarget.to);
+	if (!target) return null;
+	const threadId = normalizeThreadId(params.rawTarget.threadId);
+	if (target.kind === "user") {
+		const accountConfig = resolveMatrixAccountConfig({
+			cfg: params.cfg,
+			accountId: resolved.accountId
+		});
+		const repairDirectRooms = resolved.context.deps?.repairDirectRooms ?? repairMatrixDirectRooms;
+		const repaired = await retryMatrixApprovalDelivery(async () => await repairDirectRooms({
+			client: resolved.context.client,
+			remoteUserId: target.id,
+			encrypted: accountConfig.encryption === true
+		}));
+		if (!repaired.activeRoomId) return null;
+		return {
+			to: `room:${repaired.activeRoomId}`,
+			roomId: repaired.activeRoomId,
+			threadId
+		};
+	}
+	return {
+		to: `room:${target.id}`,
+		roomId: target.id,
+		threadId
+	};
+}
+function buildMatrixApprovalMetadata(params) {
+	const base = {
+		version: 1,
+		type: "approval.request",
+		id: params.view.approvalId,
+		state: "pending",
+		kind: params.view.approvalKind,
+		phase: params.view.phase,
+		title: params.view.title,
+		expiresAtMs: params.view.expiresAtMs,
+		metadata: params.view.metadata,
+		allowedDecisions: Array.from(params.allowedDecisions),
+		actions: params.view.actions.map((action) => ({
+			decision: action.decision,
+			label: action.label,
+			style: action.style,
+			command: action.command
+		})),
+		...params.view.description != null ? { description: params.view.description } : {}
+	};
+	if (params.view.approvalKind === "plugin") return {
+		...base,
+		kind: "plugin",
+		severity: params.view.severity,
+		...params.view.agentId != null ? { agentId: params.view.agentId } : {},
+		...params.view.pluginId != null ? { pluginId: params.view.pluginId } : {},
+		...params.view.toolName != null ? { toolName: params.view.toolName } : {}
+	};
+	if (params.view.approvalKind === "system-agent") return {
+		...base,
+		kind: "system-agent",
+		commandText: params.view.commandText,
+		operationSummary: params.view.operationSummary,
+		...params.view.agentId != null ? { agentId: params.view.agentId } : {}
+	};
+	return {
+		...base,
+		kind: "exec",
+		commandText: params.view.commandText,
+		...params.view.ask != null ? { ask: params.view.ask } : {},
+		...params.view.agentId != null ? { agentId: params.view.agentId } : {},
+		...params.view.commandPreview != null ? { commandPreview: params.view.commandPreview } : {},
+		...params.view.cwd != null ? { cwd: params.view.cwd } : {},
+		...params.view.envKeys != null ? { envKeys: params.view.envKeys } : {},
+		...params.view.host != null ? { host: params.view.host } : {},
+		...params.view.nodeId != null ? { nodeId: params.view.nodeId } : {},
+		...params.view.sessionKey != null ? { sessionKey: params.view.sessionKey } : {}
+	};
+}
+function buildPendingApprovalContent(params) {
+	const allowedDecisions = params.view.actions.map((action) => action.decision);
+	let payload;
+	if (params.view.approvalKind === "plugin") payload = buildPluginApprovalPendingReplyPayload({
+		request: {
+			approvalKind: "plugin",
+			id: params.view.approvalId,
+			request: {
+				title: params.view.title,
+				description: params.view.description ?? "",
+				severity: params.view.severity,
+				toolName: params.view.toolName ?? void 0,
+				pluginId: params.view.pluginId ?? void 0,
+				agentId: params.view.agentId ?? void 0,
+				scope: params.view.scope ?? void 0
+			},
+			createdAtMs: 0,
+			expiresAtMs: params.view.expiresAtMs
+		},
+		nowMs: params.nowMs,
+		allowedDecisions
+	});
+	else if (params.view.approvalKind === "system-agent") payload = buildApprovalPendingReplyPayload({
+		approvalKind: "system-agent",
+		approvalId: params.view.approvalId,
+		approvalSlug: params.view.approvalId.slice(0, 8),
+		text: `OpenClaw change requires approval:\n${params.view.operationSummary}`,
+		agentId: params.view.agentId,
+		allowedDecisions,
+		sessionKey: params.view.sessionKey
+	});
+	else payload = buildExecApprovalPendingReplyPayload({
+		approvalId: params.view.approvalId,
+		approvalSlug: params.view.approvalId.slice(0, 8),
+		approvalCommandId: params.view.approvalId,
+		ask: params.view.ask ?? void 0,
+		agentId: params.view.agentId ?? void 0,
+		allowedDecisions,
+		command: params.view.commandText,
+		cwd: params.view.cwd ?? void 0,
+		host: params.view.host === "node" ? "node" : "gateway",
+		nodeId: params.view.nodeId ?? void 0,
+		scope: params.view.scope ?? void 0,
+		sessionKey: params.view.sessionKey ?? void 0,
+		expiresAtMs: params.view.expiresAtMs,
+		nowMs: params.nowMs
+	});
+	const hint = buildMatrixApprovalReactionHint(allowedDecisions);
+	const text = payload.text ?? "";
+	return {
+		approvalId: params.view.approvalId,
+		text: hint ? text ? `${hint}\n\n${text}` : hint : text,
+		allowedDecisions,
+		extraContent: { [MATRIX_APPROVAL_METADATA_KEY]: buildMatrixApprovalMetadata({
+			view: params.view,
+			allowedDecisions
+		}) }
+	};
+}
+function buildResolvedApprovalText(view) {
+	if (view.approvalKind === "plugin") return buildPluginApprovalResolvedReplyPayload({ resolved: {
+		id: view.approvalId,
+		decision: view.decision,
+		resolvedBy: view.resolvedBy ?? void 0,
+		ts: 0
+	} }).text ?? "";
+	const decisionLabel = formatChannelApprovalResolvedLabel(view);
+	return [
+		`${view.approvalKind === "system-agent" ? "OpenClaw change" : "Exec approval"}: ${decisionLabel}`,
+		"",
+		view.approvalKind === "system-agent" ? "Change" : "Command",
+		buildMarkdownCodeBlock(view.commandText)
+	].join("\n");
+}
+function buildMarkdownCodeBlock(text) {
+	const longestFence = Math.max(...Array.from(text.matchAll(/`+/g), (match) => match[0].length), 0);
+	const fence = "`".repeat(Math.max(3, longestFence + 1));
+	return [
+		fence,
+		text,
+		fence
+	].join("\n");
+}
+const matrixApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+	eventKinds: [
+		"exec",
+		"plugin",
+		"system-agent"
+	],
+	availability: {
+		isConfigured: ({ cfg, accountId, context }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return false;
+			return isMatrixAnyApprovalClientEnabled({
+				cfg,
+				accountId: resolved.accountId
+			});
+		},
+		shouldHandle: ({ cfg, accountId, approvalKind, request, context }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return false;
+			return shouldHandleMatrixApprovalRequest({
+				cfg,
+				accountId: resolved.accountId,
+				approvalKind,
+				request
+			});
+		}
+	},
+	presentation: {
+		buildPendingPayload: buildPendingApprovalContent,
+		buildResolvedResult: ({ view }) => ({
+			kind: "update",
+			payload: buildResolvedApprovalText(view)
+		}),
+		buildExpiredResult: () => ({ kind: "delete" })
+	},
+	transport: {
+		prepareTarget: ({ cfg, accountId, context, plannedTarget }) => {
+			return prepareTarget({
+				cfg,
+				accountId,
+				context,
+				rawTarget: plannedTarget.target
+			}).then((preparedTarget) => preparedTarget ? {
+				dedupeKey: buildChannelApprovalNativeTargetKey({
+					to: preparedTarget.roomId,
+					threadId: preparedTarget.threadId
+				}),
+				target: preparedTarget
+			} : null);
+		},
+		deliverPending: async ({ cfg, accountId, context, preparedTarget, pendingPayload, view }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return null;
+			const sendSingleTextMessage = resolved.context.deps?.sendSingleTextMessage ?? sendSingleTextMessageMatrix;
+			const reactMessage = resolved.context.deps?.reactMessage ?? reactMatrixMessage;
+			let result;
+			try {
+				result = await retryMatrixApprovalDelivery(async () => await sendSingleTextMessage(preparedTarget.to, pendingPayload.text, {
+					cfg,
+					accountId: resolved.accountId,
+					client: resolved.context.client,
+					threadId: preparedTarget.threadId,
+					extraContent: pendingPayload.extraContent
+				}), { shouldRetry: (error) => !isSingleMatrixMessageLimitError(error) });
+			} catch (error) {
+				if (!isSingleMatrixMessageLimitError(error)) throw error;
+				const sendMessage = resolved.context.deps?.sendMessage ?? sendMessageMatrix;
+				result = await retryMatrixApprovalDelivery(async () => await sendMessage(preparedTarget.to, pendingPayload.text, {
+					cfg,
+					accountId: resolved.accountId,
+					client: resolved.context.client,
+					threadId: preparedTarget.threadId,
+					extraContent: pendingPayload.extraContent
+				}));
+			}
+			const receiptMessageIds = listMessageReceiptPlatformIds(result.receipt);
+			const platformMessageIds = receiptMessageIds.length ? receiptMessageIds : [result.messageId.trim()].filter(Boolean);
+			const reactionEventId = resolveMessageReceiptPrimaryId(result.receipt) || result.primaryMessageId?.trim() || platformMessageIds[0] || result.messageId.trim();
+			await registerMatrixApprovalReactionTarget({
+				accountId: resolved.accountId,
+				roomId: result.roomId,
+				eventId: reactionEventId,
+				approvalId: pendingPayload.approvalId,
+				approvalKind: view.approvalKind,
+				allowedDecisions: pendingPayload.allowedDecisions,
+				ttlMs: view.expiresAtMs - Date.now()
+			});
+			await Promise.allSettled(listMatrixApprovalReactionBindings(pendingPayload.allowedDecisions).map(async ({ emoji }) => {
+				await reactMessage(result.roomId, reactionEventId, emoji, {
+					cfg,
+					accountId: resolved.accountId,
+					client: resolved.context.client
+				});
+			}));
+			return {
+				roomId: result.roomId,
+				platformMessageIds,
+				reactionEventId
+			};
+		},
+		updateEntry: async ({ cfg, accountId, context, entry, payload }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return;
+			const editMessage = resolved.context.deps?.editMessage ?? editMatrixMessage;
+			const deleteMessage = resolved.context.deps?.deleteMessage ?? deleteMatrixMessage;
+			const [primaryMessageId, ...staleMessageIds] = normalizeUniqueStringEntries(entry.platformMessageIds);
+			if (!primaryMessageId) return;
+			await Promise.allSettled([editMessage(entry.roomId, primaryMessageId, payload, {
+				cfg,
+				accountId: resolved.accountId,
+				client: resolved.context.client
+			}), ...staleMessageIds.map(async (messageId) => {
+				await deleteMessage(entry.roomId, messageId, {
+					cfg,
+					accountId: resolved.accountId,
+					client: resolved.context.client,
+					reason: "approval resolved"
+				});
+			})]);
+		},
+		deleteEntry: async ({ cfg, accountId, context, entry, phase }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return;
+			const deleteMessage = resolved.context.deps?.deleteMessage ?? deleteMatrixMessage;
+			await Promise.allSettled(normalizeUniqueStringEntries(entry.platformMessageIds).map(async (messageId) => {
+				await deleteMessage(entry.roomId, messageId, {
+					cfg,
+					accountId: resolved.accountId,
+					client: resolved.context.client,
+					reason: phase === "expired" ? "approval expired" : "approval resolved"
+				});
+			}));
+		}
+	},
+	interactions: {
+		bindPending: async (params) => {
+			const accountId = params.accountId?.trim();
+			if (!accountId) return null;
+			const target = normalizeReactionTargetRef({
+				accountId,
+				roomId: params.entry.roomId,
+				eventId: params.entry.reactionEventId
+			});
+			if (!target) return null;
+			await registerMatrixApprovalReactionTarget({
+				accountId: target.accountId,
+				roomId: target.roomId,
+				eventId: target.eventId,
+				approvalId: params.pendingPayload.approvalId,
+				approvalKind: params.view.approvalKind,
+				allowedDecisions: params.pendingPayload.allowedDecisions,
+				ttlMs: params.view.expiresAtMs - Date.now()
+			});
+			return target;
+		},
+		unbindPending: async (params) => {
+			const target = normalizeReactionTargetRef(params.binding);
+			if (!target) return;
+			await unregisterMatrixApprovalReactionTarget(target);
+		},
+		cancelDelivered: async (params) => {
+			const accountId = params.accountId?.trim();
+			if (!accountId) return;
+			const target = normalizeReactionTargetRef({
+				accountId,
+				roomId: params.entry.roomId,
+				eventId: params.entry.reactionEventId
+			});
+			if (!target) return;
+			await unregisterMatrixApprovalReactionTarget(target);
+		}
+	}
+});
+//#endregion
+export { matrixApprovalNativeRuntime };

package/dist/.setup/approval-reactions-BrS5ECU0.mjs

@@ -0,0 +1,196 @@
+import { r as getOptionalMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/routing";
+import { createApprovalReactionTargetStore } from "openclaw/plugin-sdk/approval-reaction-runtime";
+import { createPluginStateErrorReporter } from "openclaw/plugin-sdk/plugin-state-runtime";
+//#region extensions/matrix/src/approval-reactions.ts
+const MATRIX_APPROVAL_REACTION_META = {
+	"allow-once": {
+		emoji: "✅",
+		label: "Allow once"
+	},
+	"allow-always": {
+		emoji: "♾️",
+		label: "Allow always"
+	},
+	deny: {
+		emoji: "❌",
+		label: "Deny"
+	}
+};
+const MATRIX_APPROVAL_REACTION_ORDER = [
+	"allow-once",
+	"allow-always",
+	"deny"
+];
+const PERSISTENT_NAMESPACE = "matrix.approval-reactions";
+const PERSISTENT_MAX_ENTRIES = 1e3;
+const DEFAULT_REACTION_TARGET_TTL_MS = 864e5;
+const reportPersistentApprovalReactionError = createPluginStateErrorReporter(getOptionalMatrixRuntime, "matrix", "approval-reaction-state", "Matrix persistent approval reaction state failed");
+function readPersistedTarget(target) {
+	const value = target;
+	const accountId = typeof value?.accountId === "string" ? normalizeOptionalAccountId(value.accountId) : void 0;
+	const approvalId = typeof value?.approvalId === "string" ? value.approvalId.trim() : "";
+	const roomId = typeof value?.roomId === "string" ? value.roomId.trim() : "";
+	const eventId = typeof value?.eventId === "string" ? value.eventId.trim() : "";
+	if (!value || !accountId || !approvalId || !Array.isArray(value.allowedDecisions) || !roomId || !eventId || value.approvalKind !== "exec" && value.approvalKind !== "plugin" && value.approvalKind !== "system-agent") return null;
+	return {
+		accountId,
+		approvalId,
+		approvalKind: value.approvalKind,
+		roomId,
+		eventId,
+		allowedDecisions: value.allowedDecisions
+	};
+}
+function openPersistentMatrixApprovalReactionStore() {
+	return getOptionalMatrixRuntime()?.state.openKeyedStore({
+		namespace: PERSISTENT_NAMESPACE,
+		maxEntries: PERSISTENT_MAX_ENTRIES,
+		defaultTtlMs: DEFAULT_REACTION_TARGET_TTL_MS
+	});
+}
+const matrixApprovalReactionTargets = createApprovalReactionTargetStore({
+	namespace: PERSISTENT_NAMESPACE,
+	maxEntries: PERSISTENT_MAX_ENTRIES,
+	defaultTtlMs: DEFAULT_REACTION_TARGET_TTL_MS,
+	openStore: openPersistentMatrixApprovalReactionStore,
+	logPersistentError: reportPersistentApprovalReactionError,
+	readPersistedTarget
+});
+const matrixApprovalReactionTargetIndex = /* @__PURE__ */ new Map();
+function pruneMatrixApprovalReactionTargetIndex() {
+	const nowMs = Date.now();
+	for (const [key, entry] of matrixApprovalReactionTargetIndex) if (entry.expiresAtMs <= nowMs) matrixApprovalReactionTargetIndex.delete(key);
+	while (matrixApprovalReactionTargetIndex.size > PERSISTENT_MAX_ENTRIES) {
+		const oldestKey = matrixApprovalReactionTargetIndex.keys().next().value;
+		if (!oldestKey) return;
+		matrixApprovalReactionTargetIndex.delete(oldestKey);
+	}
+}
+function buildReactionTargetKey(accountId, roomId, eventId) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const normalizedRoomId = roomId.trim();
+	const normalizedEventId = eventId.trim();
+	if (!normalizedAccountId || !normalizedRoomId || !normalizedEventId) return null;
+	return JSON.stringify([
+		normalizedAccountId,
+		normalizedRoomId,
+		normalizedEventId
+	]);
+}
+function listMatrixApprovalReactionBindings(allowedDecisions) {
+	const allowed = new Set(allowedDecisions);
+	return MATRIX_APPROVAL_REACTION_ORDER.filter((decision) => allowed.has(decision)).map((decision) => ({
+		decision,
+		emoji: MATRIX_APPROVAL_REACTION_META[decision].emoji,
+		label: MATRIX_APPROVAL_REACTION_META[decision].label
+	}));
+}
+function buildMatrixApprovalReactionHint(allowedDecisions) {
+	const bindings = listMatrixApprovalReactionBindings(allowedDecisions);
+	if (bindings.length === 0) return null;
+	return `React here: ${bindings.map((binding) => `${binding.emoji} ${binding.label}`).join(", ")}`;
+}
+function resolveMatrixApprovalReactionDecision(reactionKey, allowedDecisions) {
+	const normalizedReaction = reactionKey.trim();
+	if (!normalizedReaction) return null;
+	const allowed = new Set(allowedDecisions);
+	for (const decision of MATRIX_APPROVAL_REACTION_ORDER) {
+		if (!allowed.has(decision)) continue;
+		if (MATRIX_APPROVAL_REACTION_META[decision].emoji === normalizedReaction) return decision;
+	}
+	return null;
+}
+async function registerMatrixApprovalReactionTarget(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const key = buildReactionTargetKey(accountId, params.roomId, params.eventId);
+	const approvalId = params.approvalId.trim();
+	const allowedDecisions = Array.from(new Set(params.allowedDecisions.filter((decision) => decision === "allow-once" || decision === "allow-always" || decision === "deny")));
+	if (!key || !approvalId || params.approvalKind !== "exec" && params.approvalKind !== "plugin" && params.approvalKind !== "system-agent" || allowedDecisions.length === 0) return;
+	const ttlMs = Math.max(1, params.ttlMs ?? DEFAULT_REACTION_TARGET_TTL_MS);
+	const target = {
+		accountId,
+		approvalId,
+		approvalKind: params.approvalKind,
+		roomId: params.roomId.trim(),
+		eventId: params.eventId.trim(),
+		allowedDecisions
+	};
+	matrixApprovalReactionTargetIndex.delete(key);
+	matrixApprovalReactionTargetIndex.set(key, {
+		target,
+		expiresAtMs: Date.now() + ttlMs
+	});
+	pruneMatrixApprovalReactionTargetIndex();
+	await matrixApprovalReactionTargets.register(key, target, { ttlMs });
+}
+async function unregisterMatrixApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params.accountId, params.roomId, params.eventId);
+	if (!key) return;
+	matrixApprovalReactionTargetIndex.delete(key);
+	await matrixApprovalReactionTargets.delete(key);
+}
+/** Retires every Matrix reaction anchor bound to one canonical approval. */
+async function unregisterMatrixApprovalReactionTargetsForApproval(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const approvalId = params.approvalId.trim();
+	if (!approvalId) return [];
+	pruneMatrixApprovalReactionTargetIndex();
+	const matches = /* @__PURE__ */ new Map();
+	for (const [key, entry] of matrixApprovalReactionTargetIndex) if (entry.target.approvalId === approvalId && entry.target.accountId === accountId && entry.target.approvalKind === params.approvalKind) matches.set(key, entry.target);
+	let persistentStore = void 0;
+	try {
+		persistentStore = openPersistentMatrixApprovalReactionStore();
+		for (const entry of await persistentStore?.entries() ?? []) {
+			if (entry.value.version !== 1) continue;
+			const target = readPersistedTarget(entry.value.target);
+			if (target?.approvalId === approvalId && target.accountId === accountId && target.approvalKind === params.approvalKind && buildReactionTargetKey(target.accountId, target.roomId, target.eventId) === entry.key) matches.set(entry.key, target);
+		}
+	} catch (error) {
+		reportPersistentApprovalReactionError(error);
+	}
+	const persistentDeletes = [];
+	for (const [key] of matches) {
+		matrixApprovalReactionTargetIndex.delete(key);
+		persistentDeletes.push(matrixApprovalReactionTargets.delete(key));
+		if (persistentStore) persistentDeletes.push(persistentStore.delete(key));
+	}
+	await Promise.allSettled(persistentDeletes);
+	return Array.from(matches.values(), ({ accountId: ownerAccountId, roomId, eventId }) => ({
+		accountId: ownerAccountId,
+		roomId,
+		eventId
+	}));
+}
+function resolveTarget(params) {
+	const target = params.target;
+	if (!target) return null;
+	const decision = resolveMatrixApprovalReactionDecision(params.reactionKey, target.allowedDecisions);
+	if (!decision) return null;
+	return {
+		approvalId: target.approvalId,
+		approvalKind: target.approvalKind,
+		decision
+	};
+}
+async function resolveMatrixApprovalReactionTargetWithPersistence(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const key = buildReactionTargetKey(accountId, params.roomId, params.eventId);
+	if (!key) return null;
+	const target = await matrixApprovalReactionTargets.lookup(key);
+	if (target && (target.accountId !== accountId || buildReactionTargetKey(target.accountId, target.roomId, target.eventId) !== key)) return null;
+	if (target) {
+		matrixApprovalReactionTargetIndex.delete(key);
+		matrixApprovalReactionTargetIndex.set(key, {
+			target,
+			expiresAtMs: Date.now() + DEFAULT_REACTION_TARGET_TTL_MS
+		});
+		pruneMatrixApprovalReactionTargetIndex();
+	}
+	return resolveTarget({
+		target,
+		reactionKey: params.reactionKey
+	});
+}
+//#endregion
+export { unregisterMatrixApprovalReactionTarget as a, resolveMatrixApprovalReactionTargetWithPersistence as i, listMatrixApprovalReactionBindings as n, unregisterMatrixApprovalReactionTargetsForApproval as o, registerMatrixApprovalReactionTarget as r, buildMatrixApprovalReactionHint as t };