@openclaw/whatsapp 2026.7.2-beta.4 → 2026.7.2-beta.7

package/dist/api.js

@@ -1,25 +1,19 @@
-import { a as resolveWhatsAppAccount, i as listWhatsAppAuthDirs, n as hasAnyWhatsAppAuth, o as resolveWhatsAppAuthDir, r as listEnabledWhatsAppAccounts, s as resolveWhatsAppMediaMaxBytes, t as DEFAULT_WHATSAPP_MEDIA_MAX_MB } from "./accounts-CxPuEFi-.js";
+import { a as resolveWhatsAppAccount, i as listWhatsAppAuthDirs, n as hasAnyWhatsAppAuth, o as resolveWhatsAppAuthDir, r as listEnabledWhatsAppAccounts, s as resolveWhatsAppMediaMaxBytes, t as DEFAULT_WHATSAPP_MEDIA_MAX_MB } from "./accounts-CSqLvCY5.js";
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as normalizeWhatsAppAllowFromEntries, c as normalizeWhatsAppTarget, i as looksLikeWhatsAppTargetId, r as isWhatsAppUserTarget, s as normalizeWhatsAppMessagingTarget, t as isWhatsAppGroupJid } from "./normalize-target-DSZnHkKF.js";
-import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-BR97fAbB.js";
-import "./send-DhJVN30g.js";
-import { c as toWhatsappJid, i as markdownToWhatsApp, l as toWhatsappJidWithLid, n as isSelfChatMode, r as jidToE164, s as resolveJidToE164, t as assertWebChannel } from "./targets-runtime-CKFrhoX4.js";
-import { n as resolveUserPath, t as normalizeE164 } from "./text-runtime-CU_IlbK5.js";
-import { n as resolveWhatsAppGroupIntroHint, r as WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, t as whatsappPlugin } from "./channel-B9xjrOGG.js";
-import { a as resolveWhatsAppGroupRequireMention, o as resolveWhatsAppGroupToolPolicy } from "./shared-CuqHFnKd.js";
+import { a as normalizeWhatsAppAllowFromEntries, c as normalizeWhatsAppTarget, i as looksLikeWhatsAppTargetId, r as isWhatsAppUserTarget, s as normalizeWhatsAppMessagingTarget, t as isWhatsAppGroupJid } from "./normalize-target-CugRyONv.js";
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-1GqbT1uX.js";
+import { c as toWhatsappJid, i as markdownToWhatsApp, l as toWhatsappJidWithLid, n as isSelfChatMode, r as jidToE164, s as resolveJidToE164, t as assertWebChannel } from "./targets-runtime-TMk0lGuy.js";
+import { n as resolveUserPath, t as normalizeE164 } from "./text-runtime-CaKLhowd.js";
+import { n as WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, t as whatsappPlugin } from "./channel-Dg62olhy.js";
+import { a as resolveWhatsAppGroupRequireMention, o as resolveWhatsAppGroupToolPolicy } from "./shared-CAxd15bp.js";
 import { t as whatsappCommandPolicy } from "./command-policy-BIOSHySD.js";
-import "./config-schema-C6IeKIC0.js";
-import { t as whatsappSetupPlugin } from "./channel.setup-DXUCPHel.js";
+import { t as whatsappSetupPlugin } from "./channel.setup-pMwNVkCA.js";
 import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-HU41RHGI.js";
-import { a as waitForWaConnection, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, s as createWhatsAppSocketOperationTimeoutAdapter } from "./socket-close-BoSHhQNJ.js";
+import { a as waitForWaConnection, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, s as createWhatsAppSocketOperationTimeoutAdapter } from "./socket-close-DridEuzz.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
-import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-BTbJkV1W.js";
-import { n as testing } from "./access-control-CRz_v6bR.js";
-import { d as normalizeMessageContent, f as describeReplyContext, g as extractLocationData, m as extractContextInfo, t as createWebSendApi, x as resolveInboundMediaMimetype, y as extractText } from "./send-api-CpHwbor_.js";
-import "openclaw/plugin-sdk/channel-actions";
-import "openclaw/plugin-sdk/account-resolution";
-import "openclaw/plugin-sdk/core";
-import "openclaw/plugin-sdk/account-id";
+import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-DalGrfGN.js";
+import { n as testing } from "./access-control-pZcxTmd5.js";
+import { d as normalizeMessageContent, f as describeReplyContext, g as extractLocationData, m as extractContextInfo, t as createWebSendApi, x as resolveInboundMediaMimetype, y as extractText } from "./send-api-7wk6eQyW.js";
 import { formatLocationText } from "openclaw/plugin-sdk/channel-inbound";
 //#region extensions/whatsapp/src/qa-driver.runtime.ts
 function isRecord(value) {
@@ -309,4 +303,4 @@ async function startWhatsAppQaDriverSession(params) {
 	};
 }
 //#endregion
-export { DEFAULT_WEB_MEDIA_BYTES, DEFAULT_WHATSAPP_MEDIA_MAX_MB, WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, assertWebChannel, hasAnyWhatsAppAuth, isSelfChatMode, isWhatsAppGroupJid, isWhatsAppUserTarget, jidToE164, listEnabledWhatsAppAccounts, listAccountIds as listWhatsAppAccountIds, listWhatsAppAuthDirs, listWhatsAppDirectoryGroupsFromConfig, listWhatsAppDirectoryPeersFromConfig, looksLikeWhatsAppTargetId, markdownToWhatsApp, normalizeE164, normalizeWhatsAppAllowFromEntries, normalizeWhatsAppMessagingTarget, normalizeWhatsAppTarget, resolveDefaultWhatsAppAccountId, resolveJidToE164, resolveUserPath, resolveWhatsAppAccount, resolveWhatsAppAuthDir, resolveWhatsAppGroupIntroHint, resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, resolveWhatsAppMediaMaxBytes, resolveWhatsAppOutboundTarget, startWhatsAppQaDriverSession, toWhatsappJid, toWhatsappJidWithLid, testing as whatsappAccessControlTesting, whatsappCommandPolicy, whatsappPlugin, whatsappSetupPlugin };
+export { DEFAULT_WEB_MEDIA_BYTES, DEFAULT_WHATSAPP_MEDIA_MAX_MB, WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, assertWebChannel, hasAnyWhatsAppAuth, isSelfChatMode, isWhatsAppGroupJid, isWhatsAppUserTarget, jidToE164, listEnabledWhatsAppAccounts, listAccountIds as listWhatsAppAccountIds, listWhatsAppAuthDirs, listWhatsAppDirectoryGroupsFromConfig, listWhatsAppDirectoryPeersFromConfig, looksLikeWhatsAppTargetId, markdownToWhatsApp, normalizeE164, normalizeWhatsAppAllowFromEntries, normalizeWhatsAppMessagingTarget, normalizeWhatsAppTarget, resolveDefaultWhatsAppAccountId, resolveJidToE164, resolveUserPath, resolveWhatsAppAccount, resolveWhatsAppAuthDir, resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, resolveWhatsAppMediaMaxBytes, resolveWhatsAppOutboundTarget, startWhatsAppQaDriverSession, toWhatsappJid, toWhatsappJidWithLid, testing as whatsappAccessControlTesting, whatsappCommandPolicy, whatsappPlugin, whatsappSetupPlugin };

package/dist/approval-handler.runtime-DrA59QSA.js

@@ -0,0 +1,128 @@
+import "./accounts-CSqLvCY5.js";
+import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
+import { s as normalizeWhatsAppMessagingTarget } from "./normalize-target-CugRyONv.js";
+import { i as sendTypingWhatsApp, t as sendMessageWhatsApp } from "./send-D37ddk22.js";
+import { i as getWhatsAppRuntime } from "./runtime-BLlToOi6.js";
+import "./normalize-C7Hkc_vE.js";
+import { i as unregisterWhatsAppApprovalReactionTarget, r as registerWhatsAppApprovalReactionTarget } from "./approval-reactions-Cu66aYdq.js";
+import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildApprovalReactionPendingContent } from "openclaw/plugin-sdk/approval-reaction-runtime";
+import { buildChannelApprovalExpiredText, buildChannelApprovalResolvedText, createChannelApprovalNativeRuntimeAdapter, resolvePreparedApprovalAccountId } from "openclaw/plugin-sdk/approval-handler-runtime";
+//#region extensions/whatsapp/src/approval-handler.runtime.ts
+const log = createSubsystemLogger("whatsapp/approvals");
+function buildPendingPayload(params) {
+	return buildApprovalReactionPendingContent(params);
+}
+const whatsappApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+	eventKinds: ["exec", "plugin"],
+	availability: {
+		isConfigured: ({ context }) => Boolean(context),
+		shouldHandle: ({ context }) => Boolean(context)
+	},
+	presentation: {
+		buildPendingPayload: ({ request, nowMs, view }) => buildPendingPayload({
+			request,
+			view,
+			nowMs
+		}),
+		buildResolvedResult: ({ request, resolved, view }) => ({
+			kind: "update",
+			payload: { text: buildChannelApprovalResolvedText({
+				request,
+				resolved,
+				view
+			}) }
+		}),
+		buildExpiredResult: ({ request, view }) => ({
+			kind: "update",
+			payload: { text: buildChannelApprovalExpiredText({
+				request,
+				view
+			}) }
+		})
+	},
+	transport: {
+		prepareTarget: ({ cfg, plannedTarget, accountId }) => {
+			const to = normalizeWhatsAppMessagingTarget(plannedTarget.target.to);
+			if (!to) return null;
+			const prepared = {
+				to,
+				accountId: resolvePreparedApprovalAccountId({
+					plannedAccountId: plannedTarget.target.accountId,
+					contextAccountId: accountId,
+					fallbackAccountId: cfg ? resolveDefaultWhatsAppAccountId(cfg) : DEFAULT_ACCOUNT_ID
+				})
+			};
+			return {
+				dedupeKey: `${prepared.accountId ?? ""}:${buildChannelApprovalNativeTargetKey({ to: prepared.to })}`,
+				target: prepared
+			};
+		},
+		deliverPending: async ({ cfg, preparedTarget, pendingPayload }) => {
+			const verbose = getWhatsAppRuntime().logging.shouldLogVerbose();
+			await sendTypingWhatsApp(preparedTarget.to, {
+				cfg,
+				accountId: preparedTarget.accountId
+			}).catch(() => {});
+			const result = await sendMessageWhatsApp(preparedTarget.to, pendingPayload.reactionPayload.text ?? "", {
+				cfg,
+				verbose,
+				accountId: preparedTarget.accountId,
+				preserveLeadingWhitespace: true
+			});
+			if (!result.messageId) return null;
+			return {
+				accountId: preparedTarget.accountId,
+				to: preparedTarget.to,
+				remoteJid: result.toJid,
+				messageId: result.messageId
+			};
+		},
+		updateEntry: async ({ cfg, entry, payload }) => {
+			const verbose = getWhatsAppRuntime().logging.shouldLogVerbose();
+			await sendMessageWhatsApp(entry.to, payload.text, {
+				cfg,
+				verbose,
+				accountId: entry.accountId,
+				preserveLeadingWhitespace: true,
+				quotedMessageKey: {
+					id: entry.messageId,
+					remoteJid: entry.remoteJid,
+					fromMe: true
+				}
+			});
+		}
+	},
+	interactions: {
+		bindPending: ({ entry, request, view, pendingPayload }) => registerWhatsAppApprovalReactionTarget({
+			accountId: entry.accountId,
+			remoteJid: entry.remoteJid,
+			messageId: entry.messageId,
+			approvalId: request.id,
+			approvalKind: view.approvalKind,
+			allowedDecisions: pendingPayload.reactionPayload.allowedDecisions,
+			ttlMs: Math.max(1, view.expiresAtMs - Date.now())
+		}) ? true : null,
+		unbindPending: ({ entry }) => {
+			unregisterWhatsAppApprovalReactionTarget({
+				accountId: entry.accountId,
+				remoteJid: entry.remoteJid,
+				messageId: entry.messageId
+			});
+		},
+		cancelDelivered: ({ entry }) => {
+			unregisterWhatsAppApprovalReactionTarget({
+				accountId: entry.accountId,
+				remoteJid: entry.remoteJid,
+				messageId: entry.messageId
+			});
+		}
+	},
+	observe: { onDeliveryError: ({ error, request }) => {
+		log.error(`whatsapp approvals: failed to send request ${request.id}: ${String(error)}`);
+	} }
+});
+//#endregion
+export { whatsappApprovalNativeRuntime };

package/dist/approval-reactions-Cu66aYdq.js

@@ -0,0 +1,373 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.js";
+import { n as getOptionalWhatsAppRuntime } from "./runtime-BLlToOi6.js";
+import { c as getWhatsAppApprovalApprovers, l as whatsappApprovalAuth } from "./group-session-key-DVMZlO3x.js";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { createApprovalReactionTargetStore, listApprovalReactionBindings, resolveTypedApprovalReactionTarget } from "openclaw/plugin-sdk/approval-reaction-runtime";
+//#region extensions/whatsapp/src/approval-reactions.ts
+var approval_reactions_exports = /* @__PURE__ */ __exportAll({
+	clearWhatsAppApprovalReactionTargetsForTest: () => clearWhatsAppApprovalReactionTargetsForTest,
+	maybeResolveWhatsAppApprovalReaction: () => maybeResolveWhatsAppApprovalReaction,
+	prepareWhatsAppApprovalPayloadForDelivery: () => prepareWhatsAppApprovalPayloadForDelivery,
+	registerWhatsAppApprovalReactionTarget: () => registerWhatsAppApprovalReactionTarget,
+	registerWhatsAppApprovalReactionTargetForDeliveredPayload: () => registerWhatsAppApprovalReactionTargetForDeliveredPayload,
+	resolveWhatsAppApprovalReactionTargetWithPersistence: () => resolveWhatsAppApprovalReactionTargetWithPersistence,
+	unregisterWhatsAppApprovalReactionTarget: () => unregisterWhatsAppApprovalReactionTarget
+});
+const PERSISTENT_NAMESPACE = "whatsapp.approval-reactions";
+const PERSISTENT_MAX_ENTRIES = 1e3;
+const DEFAULT_REACTION_TARGET_TTL_MS = 1440 * 60 * 1e3;
+const DELIVERY_BINDING_CHANNEL_DATA_KEY = "whatsappApprovalReactionBindingV1";
+const resolverRuntimeLoader = createLazyRuntimeModule(() => import("./approval-resolver-DoeBBt22.js"));
+const whatsappApprovalReactionTargets = createApprovalReactionTargetStore({
+	namespace: PERSISTENT_NAMESPACE,
+	maxEntries: PERSISTENT_MAX_ENTRIES,
+	defaultTtlMs: DEFAULT_REACTION_TARGET_TTL_MS,
+	openStore: (storeParams) => getOptionalWhatsAppRuntime()?.state.openKeyedStore(storeParams),
+	logPersistentError: reportPersistentApprovalReactionError,
+	readPersistedTarget
+});
+const loadApprovalResolver = resolverRuntimeLoader;
+function buildReactionTargetKey(params) {
+	const accountId = params.accountId.trim();
+	const remoteJid = params.remoteJid.trim();
+	const messageId = params.messageId.trim();
+	if (!accountId || !remoteJid || !messageId) return null;
+	return `${accountId}:${remoteJid}:${messageId}`;
+}
+function addCandidateRemoteJid(target, value) {
+	const remoteJid = value?.trim();
+	if (remoteJid && !target.includes(remoteJid)) target.push(remoteJid);
+}
+function reportPersistentApprovalReactionError(error) {
+	try {
+		getOptionalWhatsAppRuntime()?.logging.getChildLogger({
+			plugin: "whatsapp",
+			feature: "approval-reaction-state"
+		}).warn("WhatsApp persistent approval reaction state failed", { error: String(error) });
+	} catch {}
+}
+function reportApprovalBindingCorrelationMismatch(binding) {
+	try {
+		getOptionalWhatsAppRuntime()?.logging.getChildLogger({
+			plugin: "whatsapp",
+			feature: "approval-reaction-state"
+		}).warn("WhatsApp approval prompt text failed binding correlation; reactions disabled", {
+			approvalId: binding.approvalId,
+			approvalKind: binding.approvalKind
+		});
+	} catch {}
+}
+function readPersistedTarget(target) {
+	const value = target;
+	if (!value || typeof value.approvalId !== "string" || !Array.isArray(value.allowedDecisions) || value.approvalKind !== "exec" && value.approvalKind !== "plugin") return null;
+	return {
+		approvalId: value.approvalId,
+		approvalKind: value.approvalKind,
+		allowedDecisions: value.allowedDecisions
+	};
+}
+function listWhatsAppApprovalReactionBindings(allowedDecisions) {
+	return listApprovalReactionBindings({ allowedDecisions });
+}
+const APPROVAL_ID_LINE_RE = /^\s*ID:\s*(\S(?:.*\S)?)\s*$/i;
+const APPROVAL_KIND_LINE_RE = /^\s*(?:\S+\s+)?(Exec|Plugin) approval required\s*$/i;
+function isApprovalDecision(value) {
+	return value === "allow-once" || value === "allow-always" || value === "deny";
+}
+function readStrictDecisionList(value) {
+	if (!Array.isArray(value) || value.length === 0 || !value.every(isApprovalDecision)) return null;
+	return new Set(value).size === value.length ? [...value] : null;
+}
+function readStrictApprovalMetadata(payload) {
+	const value = payload.channelData?.execApproval;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const approvalId = record.approvalId;
+	const approvalKind = record.approvalKind;
+	const allowedDecisions = readStrictDecisionList(record.allowedDecisions);
+	if (typeof approvalId !== "string" || !approvalId || approvalId !== approvalId.trim() || approvalKind !== "exec" && approvalKind !== "plugin" || !allowedDecisions) return null;
+	return {
+		version: 1,
+		approvalId,
+		approvalKind,
+		allowedDecisions
+	};
+}
+function listTypedApprovalActions(presentation) {
+	return presentation.blocks.flatMap((block) => {
+		if (block.type === "buttons") return block.buttons.flatMap((button) => button.action?.type === "approval" ? [button.action] : []);
+		return [];
+	});
+}
+function decisionSetsMatch(left, right) {
+	return left.length === right.length && left.every((decision) => right.includes(decision));
+}
+function readTypedApprovalDeliveryBinding(params) {
+	const metadata = readStrictApprovalMetadata(params.payload);
+	if (!metadata) return null;
+	const actions = listTypedApprovalActions(params.presentation);
+	if (actions.length === 0 || actions.some((action) => action.approvalId !== metadata.approvalId || action.approvalKind !== metadata.approvalKind)) return null;
+	const actionDecisions = actions.map((action) => action.decision);
+	if (new Set(actionDecisions).size !== actionDecisions.length || !decisionSetsMatch(metadata.allowedDecisions, actionDecisions)) return null;
+	return metadata;
+}
+function visibleApprovalBindingMatches(text, binding) {
+	const lines = (text ?? "").split(/\r?\n/).map((line) => line.replace(/\*\*/g, ""));
+	const kindMatches = lines.map((line) => line.match(APPROVAL_KIND_LINE_RE)).filter((match) => Boolean(match));
+	const idMatches = lines.map((line) => line.match(APPROVAL_ID_LINE_RE)).filter((match) => Boolean(match));
+	const visibleKind = kindMatches[0]?.[1]?.toLowerCase();
+	if (kindMatches.length !== 1 || idMatches.length !== 1 || visibleKind !== binding.approvalKind || idMatches[0]?.[1] !== binding.approvalId) return false;
+	const hintIndices = lines.flatMap((line, index) => line.trim().toLowerCase() === "react with:" ? [index] : []);
+	if (hintIndices.length !== 1) return false;
+	const hintIndex = hintIndices[0];
+	if (hintIndex === void 0) return false;
+	let cursor = hintIndex + 1;
+	while (cursor < lines.length && !lines[cursor]?.trim()) cursor += 1;
+	const decisionLines = [];
+	while (cursor < lines.length) {
+		const decisionLine = lines[cursor]?.trim();
+		if (!decisionLine) break;
+		decisionLines.push(decisionLine);
+		cursor += 1;
+	}
+	const knownBindings = listWhatsAppApprovalReactionBindings([
+		"allow-once",
+		"allow-always",
+		"deny"
+	]);
+	const visibleDecisions = decisionLines.map((line) => knownBindings.find((entry) => `${entry.emoji} ${entry.label}` === line)?.decision);
+	if (!visibleDecisions.every(isApprovalDecision)) return false;
+	return new Set(visibleDecisions).size === visibleDecisions.length && decisionSetsMatch(binding.allowedDecisions, visibleDecisions);
+}
+function readDeliveredApprovalBinding(payload) {
+	const metadata = readStrictApprovalMetadata(payload);
+	const value = payload.channelData?.[DELIVERY_BINDING_CHANNEL_DATA_KEY];
+	if (!metadata || !value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const allowedDecisions = readStrictDecisionList(record.allowedDecisions);
+	if (record.version !== 1 || record.approvalId !== metadata.approvalId || record.approvalKind !== metadata.approvalKind || !allowedDecisions || !decisionSetsMatch(metadata.allowedDecisions, allowedDecisions)) return null;
+	return metadata;
+}
+/** Preserve a validated typed approval binding until the platform message id is known. */
+function prepareWhatsAppApprovalPayloadForDelivery(params) {
+	const binding = readTypedApprovalDeliveryBinding(params);
+	if (!binding) return null;
+	if (!visibleApprovalBindingMatches(params.payload.text, binding)) {
+		reportApprovalBindingCorrelationMismatch(binding);
+		return null;
+	}
+	return {
+		...params.payload,
+		channelData: {
+			...params.payload.channelData,
+			[DELIVERY_BINDING_CHANNEL_DATA_KEY]: binding
+		}
+	};
+}
+function registerWhatsAppApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params);
+	const approvalId = params.approvalId.trim();
+	const allowedDecisions = listWhatsAppApprovalReactionBindings(params.allowedDecisions).map((binding) => binding.decision);
+	if (!key || !approvalId || params.approvalKind !== "exec" && params.approvalKind !== "plugin" || allowedDecisions.length === 0) return null;
+	const target = {
+		approvalId,
+		approvalKind: params.approvalKind,
+		allowedDecisions
+	};
+	whatsappApprovalReactionTargets.register(key, target, { ttlMs: params.ttlMs });
+	return target;
+}
+function listWhatsAppDeliveredMessageIdentities(results) {
+	const identities = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (params) => {
+		if (params.channel && params.channel !== "whatsapp") return;
+		const messageId = params.messageId?.trim() ?? "";
+		const remoteJid = params.toJid?.trim() ?? "";
+		const key = `${remoteJid}:${messageId}`;
+		if (!messageId || messageId === "unknown" || !remoteJid || seen.has(key)) return;
+		seen.add(key);
+		identities.push({
+			messageId,
+			remoteJid
+		});
+	};
+	for (const result of results) {
+		if (result.channel !== "whatsapp") continue;
+		add(result);
+		for (const raw of result.receipt?.raw ?? []) add(raw);
+		for (const part of result.receipt?.parts ?? []) add({
+			channel: part.raw?.channel,
+			messageId: part.raw?.messageId ?? part.platformMessageId,
+			toJid: part.raw?.toJid
+		});
+	}
+	return identities;
+}
+/** Bind generic forwarded approvals to the exact WhatsApp messages accepted by Baileys. */
+function registerWhatsAppApprovalReactionTargetForDeliveredPayload(params) {
+	if (params.target.channel.trim().toLowerCase() !== "whatsapp") return false;
+	const binding = readDeliveredApprovalBinding(params.payload);
+	if (!binding) return false;
+	if (!visibleApprovalBindingMatches(params.payload.text, binding)) {
+		reportApprovalBindingCorrelationMismatch(binding);
+		return false;
+	}
+	const accountId = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.target.accountId
+	}).accountId;
+	let registered = false;
+	for (const { messageId, remoteJid } of listWhatsAppDeliveredMessageIdentities(params.results)) registered = Boolean(registerWhatsAppApprovalReactionTarget({
+		accountId,
+		remoteJid,
+		messageId,
+		approvalId: binding.approvalId,
+		approvalKind: binding.approvalKind,
+		allowedDecisions: binding.allowedDecisions,
+		ttlMs: params.ttlMs
+	})) || registered;
+	return registered;
+}
+function unregisterWhatsAppApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params);
+	if (!key) return;
+	whatsappApprovalReactionTargets.delete(key);
+}
+function resolveTarget(params) {
+	const resolved = resolveTypedApprovalReactionTarget({
+		target: params.target,
+		reactionKey: params.reactionKey
+	});
+	return resolved ? {
+		approvalId: resolved.approvalId,
+		approvalKind: resolved.approvalKind,
+		decision: resolved.decision
+	} : null;
+}
+async function resolveWhatsAppApprovalReactionTargetWithPersistence(params) {
+	const key = buildReactionTargetKey(params);
+	if (!key) return null;
+	return resolveTarget({
+		target: await whatsappApprovalReactionTargets.lookup(key),
+		reactionKey: params.reactionKey
+	});
+}
+async function resolveWhatsAppApprovalReactionTargetFromCandidates(params) {
+	const candidateRemoteJids = [];
+	for (const observedRemoteJid of params.observedRemoteJids) {
+		addCandidateRemoteJid(candidateRemoteJids, observedRemoteJid);
+		try {
+			for (const candidate of await params.resolveReactionTargetJids?.(observedRemoteJid) ?? []) addCandidateRemoteJid(candidateRemoteJids, candidate);
+		} catch (error) {
+			params.logVerboseMessage?.(`whatsapp: approval reaction target JID mapping failed for ${observedRemoteJid}: ${String(error)}`);
+		}
+	}
+	for (const remoteJid of candidateRemoteJids) {
+		const target = await resolveWhatsAppApprovalReactionTargetWithPersistence({
+			accountId: params.accountId,
+			remoteJid,
+			messageId: params.messageId,
+			reactionKey: params.reactionKey
+		});
+		if (target) return {
+			...target,
+			remoteJid
+		};
+	}
+	return null;
+}
+function readWhatsAppApprovalReactionEvent(params) {
+	const msg = params.msg;
+	const reaction = msg.message?.reactionMessage;
+	const reactionKey = reaction?.text?.trim() ?? "";
+	const messageId = reaction?.key?.id?.trim() ?? "";
+	const remoteJids = [];
+	addCandidateRemoteJid(remoteJids, reaction?.key?.remoteJid);
+	addCandidateRemoteJid(remoteJids, msg.key?.remoteJid);
+	const actorJid = msg.key?.participant?.trim() || (msg.key?.fromMe ? params.selfLid?.trim() ?? params.selfJid?.trim() ?? "" : msg.key?.remoteJid?.trim() ?? "");
+	if (!reactionKey || !messageId || remoteJids.length === 0 || !actorJid) return null;
+	return {
+		remoteJids,
+		messageId,
+		actorJid,
+		reactionKey
+	};
+}
+async function maybeResolveWhatsAppApprovalReaction(params) {
+	const event = readWhatsAppApprovalReactionEvent({
+		msg: params.msg,
+		selfJid: params.selfJid,
+		selfLid: params.selfLid
+	});
+	if (!event) return false;
+	const target = await resolveWhatsAppApprovalReactionTargetFromCandidates({
+		accountId: params.accountId,
+		observedRemoteJids: event.remoteJids,
+		messageId: event.messageId,
+		reactionKey: event.reactionKey,
+		resolveReactionTargetJids: params.resolveReactionTargetJids,
+		logVerboseMessage: params.logVerboseMessage
+	});
+	if (!target) return false;
+	const actorId = await params.resolveInboundJid(event.actorJid);
+	if (!actorId) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction ignored for ${target.approvalId}; missing actor identity`);
+		return true;
+	}
+	if (getWhatsAppApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).length === 0) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction denied id=${target.approvalId}; reactions require explicit approvers`);
+		return true;
+	}
+	if (!whatsappApprovalAuth.authorizeActorAction({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		senderId: actorId,
+		action: "approve",
+		approvalKind: target.approvalKind
+	}).authorized) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction denied id=${target.approvalId} sender=${actorId}`);
+		return true;
+	}
+	const { isApprovalNotFoundError, resolveWhatsAppApproval } = await loadApprovalResolver();
+	try {
+		const result = await resolveWhatsAppApproval({
+			cfg: params.cfg,
+			approvalId: target.approvalId,
+			approvalKind: target.approvalKind,
+			decision: target.decision,
+			senderId: actorId,
+			gatewayUrl: params.gatewayUrl
+		});
+		unregisterWhatsAppApprovalReactionTarget({
+			accountId: params.accountId,
+			remoteJid: target.remoteJid,
+			messageId: event.messageId
+		});
+		const canonicalDecision = "decision" in result.approval ? ` decision=${result.approval.decision}` : "";
+		params.logVerboseMessage?.(result.applied ? `whatsapp: approval reaction applied id=${target.approvalId} sender=${actorId} status=${result.approval.status}${canonicalDecision}` : `whatsapp: approval reaction already resolved id=${target.approvalId} sender=${actorId} status=${result.approval.status}${canonicalDecision}`);
+		return true;
+	} catch (error) {
+		if (isApprovalNotFoundError(error)) {
+			unregisterWhatsAppApprovalReactionTarget({
+				accountId: params.accountId,
+				remoteJid: target.remoteJid,
+				messageId: event.messageId
+			});
+			params.logVerboseMessage?.(`whatsapp: approval reaction ignored for expired approval id=${target.approvalId} sender=${actorId}`);
+			return true;
+		}
+		params.logVerboseMessage?.(`whatsapp: approval reaction failed id=${target.approvalId} sender=${actorId}: ${String(error)}`);
+		return true;
+	}
+}
+function clearWhatsAppApprovalReactionTargetsForTest() {
+	whatsappApprovalReactionTargets.clearForTest();
+	resolverRuntimeLoader.clear();
+}
+//#endregion
+export { unregisterWhatsAppApprovalReactionTarget as i, maybeResolveWhatsAppApprovalReaction as n, registerWhatsAppApprovalReactionTarget as r, approval_reactions_exports as t };