@openclaw/signal 2026.6.11 → 2026.7.1-beta.2

package/dist/{send-CBlFUkY_.js → approval-reactions-5x1kmQEq.js}

@@ -1,16 +1,13 @@
-import { i as resolveSignalAccount } from "./accounts-hOCHbEhX.js";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { d as normalizeSignalMessagingTarget, l as looksLikeUuid } from "./identity-B6O4k8xg.js";
-import { c as getSignalApprovalApprovers, l as signalApprovalAuth, r as markdownToSignalText } from "./message-actions-Bue0g2Kc.js";
-import { a as signalRpcRequest, r as resolveSignalRpcContext } from "./reaction-runtime-api-C_PQ45D9.js";
-import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
-import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { kindFromMime, resolveOutboundAttachmentFromUrl } from "openclaw/plugin-sdk/media-runtime";
+import { i as resolveSignalTarget, n as signalApprovalAuth, t as getSignalApprovalApprovers } from "./approval-auth-DPVK9A_l.js";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildApprovalReactionHint, createApprovalReactionTargetStore, listApprovalReactionBindings, resolveApprovalReactionTarget } from "openclaw/plugin-sdk/approval-reaction-runtime";
 import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
-import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
+import { getExecApprovalReplyMetadata } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 //#region extensions/signal/src/runtime.ts
 const { setRuntime: setSignalRuntime, getRuntime: getSignalRuntime, tryGetRuntime: getOptionalSignalRuntime, clearRuntime: clearSignalRuntime } = createPluginRuntimeStore({
@@ -19,10 +16,25 @@ const { setRuntime: setSignalRuntime, getRuntime: getSignalRuntime, tryGetRuntim
 });
 //#endregion
 //#region extensions/signal/src/approval-reactions.ts
-const PERSISTENT_NAMESPACE = "signal.approval-reactions";
+var approval_reactions_exports = /* @__PURE__ */ __exportAll({
+	addSignalApprovalReactionHintToStructuredPayload: () => addSignalApprovalReactionHintToStructuredPayload,
+	addSignalApprovalReactionHintToText: () => addSignalApprovalReactionHintToText,
+	buildSignalApprovalReactionHint: () => buildSignalApprovalReactionHint,
+	clearSignalApprovalReactionTargetsForTest: () => clearSignalApprovalReactionTargetsForTest,
+	hasSignalApprovalReactionApprovers: () => hasSignalApprovalReactionApprovers,
+	listSignalApprovalReactionBindings: () => listSignalApprovalReactionBindings,
+	maybeResolveSignalApprovalReaction: () => maybeResolveSignalApprovalReaction,
+	registerSignalApprovalReactionTarget: () => registerSignalApprovalReactionTarget,
+	registerSignalApprovalReactionTargetForDeliveredPayload: () => registerSignalApprovalReactionTargetForDeliveredPayload,
+	resolveSignalApprovalConversationKey: () => resolveSignalApprovalConversationKey,
+	resolveSignalApprovalReactionTargetWithPersistence: () => resolveSignalApprovalReactionTargetWithPersistence,
+	resolveSignalApprovalTargetAuthorKeys: () => resolveSignalApprovalTargetAuthorKeys,
+	unregisterSignalApprovalReactionTarget: () => unregisterSignalApprovalReactionTarget
+});
+const PERSISTENT_NAMESPACE = "signal.approval-reactions.v2";
 const PERSISTENT_MAX_ENTRIES = 1e3;
 const DEFAULT_REACTION_TARGET_TTL_MS = 1440 * 60 * 1e3;
-let resolverRuntimePromise;
+const resolverRuntimeLoader = createLazyRuntimeModule(() => import("./approval-resolver-BR0MioAA.js"));
 const signalApprovalReactionTargets = createApprovalReactionTargetStore({
 	namespace: PERSISTENT_NAMESPACE,
 	maxEntries: PERSISTENT_MAX_ENTRIES,
@@ -31,10 +43,7 @@ const signalApprovalReactionTargets = createApprovalReactionTargetStore({
 	logPersistentError: reportPersistentApprovalReactionError,
 	readPersistedTarget
 });
-function loadApprovalResolver() {
-	resolverRuntimePromise ??= import("./approval-resolver-BR0MioAA.js");
-	return resolverRuntimePromise;
-}
+const loadApprovalResolver = resolverRuntimeLoader;
 function resolveApprovalKindFromId(approvalId) {
 	return approvalId.startsWith("plugin:") ? "plugin" : "exec";
 }
@@ -67,10 +76,25 @@ function targetAccountMatches(params) {
 	const routeAccountId = normalizeOptionalString(params.routeAccountId);
 	return Boolean(routeAccountId && normalizeAccountId(routeAccountId) === normalizeAccountId(configuredAccountId));
 }
+function resolveSignalApprovalRouteTarget(params) {
+	try {
+		return resolveSignalTarget({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			input: params.to
+		})?.to ?? normalizeSignalMessagingTarget(params.to) ?? null;
+	} catch {
+		return null;
+	}
+}
 function hasMatchingSignalApprovalReactionTarget(params) {
 	return (params.config.targets ?? []).some((target) => {
 		if (normalizeLowercaseStringOrEmpty(target.channel) !== "signal") return false;
-		const configuredTo = normalizeSignalMessagingTarget(target.to);
+		const configuredTo = resolveSignalApprovalRouteTarget({
+			cfg: params.cfg,
+			accountId: target.accountId ?? params.route.accountId,
+			to: target.to
+		});
 		if (!configuredTo || configuredTo !== params.route.to) return false;
 		return targetAccountMatches({
 			routeAccountId: params.route.accountId,
@@ -89,6 +113,7 @@ function isSignalApprovalReactionRouteStillEnabled(params) {
 		config,
 		route: params.target.route
 	}) && hasMatchingSignalApprovalReactionTarget({
+		cfg: params.cfg,
 		config,
 		route: params.target.route
 	});
@@ -101,6 +126,17 @@ function isSignalApprovalReactionRouteStillEnabled(params) {
 function resolveSignalApprovalConversationKey(to) {
 	return normalizeSignalMessagingTarget(to) ?? null;
 }
+function resolveSignalApprovalConversationKeyForDeliveredTarget(params) {
+	try {
+		return resolveSignalTarget({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			input: params.to
+		})?.to ?? resolveSignalApprovalConversationKey(params.to);
+	} catch {
+		return resolveSignalApprovalConversationKey(params.to);
+	}
+}
 function normalizeSignalApprovalTargetAuthorKey(value) {
 	const normalized = normalizeOptionalString(value);
 	if (!normalized) return null;
@@ -173,39 +209,22 @@ function insertSignalApprovalReactionHintNearHeader(params) {
 	return `${params.hint}\n\n${params.text}`;
 }
 function addSignalApprovalReactionHintToText(params) {
-	if (/(^|\n)React with:\s*(\n|$)/i.test(params.text)) return params.text;
+	if (hasSignalApprovalReactionHintText(params.text)) return params.text;
 	const hint = buildSignalApprovalReactionHint(params.allowedDecisions);
 	return hint ? insertSignalApprovalReactionHintNearHeader({
 		text: params.text,
 		hint
 	}) : params.text;
 }
-function normalizeApprovalDecision(value) {
-	const normalized = value.trim().toLowerCase();
-	if (normalized === "always") return "allow-always";
-	if (normalized === "allow-once" || normalized === "allow-always" || normalized === "deny") return normalized;
-	return null;
-}
-function extractSignalApprovalPromptBinding(text) {
-	const allowedDecisions = [];
-	let approvalId = "";
-	for (const line of text.split(/\r?\n/)) {
-		const match = line.match(/\/approve(?:@[^\s]+)?\s+([A-Za-z0-9][A-Za-z0-9._:-]*)\s+(.+)$/i);
-		if (!match) continue;
-		if (approvalId && match[1] !== approvalId) continue;
-		approvalId ||= match[1];
-		for (const decisionText of match[2].split(/[\s|,]+/)) {
-			const decision = normalizeApprovalDecision(decisionText);
-			if (decision && !allowedDecisions.includes(decision)) allowedDecisions.push(decision);
-		}
-	}
-	return approvalId && allowedDecisions.length > 0 ? {
-		approvalId,
-		allowedDecisions
-	} : null;
+function hasSignalApprovalReactionHintText(text) {
+	return /(^|\n)React with:\s*(\n|$)/i.test(text ?? "");
 }
 function buildTargetRoute(params) {
-	const to = normalizeSignalMessagingTarget(params.to);
+	const to = resolveSignalApprovalRouteTarget({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		to: params.to
+	});
 	if (!to) return null;
 	const route = {
 		deliveryMode: "target",
@@ -217,39 +236,11 @@ function buildTargetRoute(params) {
 	return isSignalApprovalReactionRouteStillEnabled({
 		cfg: params.cfg,
 		target: {
-			approvalKind: resolveApprovalKindFromId(params.approvalId),
+			approvalKind: params.approvalKind ?? resolveApprovalKindFromId(params.approvalId),
 			route
 		}
 	}) ? route : null;
 }
-function shouldAppendSignalApprovalReactionHintForOutboundMessage(params) {
-	const binding = extractSignalApprovalPromptBinding(params.text);
-	if (!binding) return false;
-	if (resolveSignalApprovalTargetAuthorKeys(params).length === 0) return false;
-	if (!hasSignalApprovalReactionApprovers({
-		cfg: params.cfg,
-		accountId: params.accountId
-	})) return false;
-	return Boolean(buildTargetRoute({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		to: params.to,
-		approvalId: binding.approvalId,
-		agentId: params.agentId,
-		sessionKey: params.sessionKey
-	}));
-}
-function appendSignalApprovalReactionHintForOutboundMessage(params) {
-	const binding = extractSignalApprovalPromptBinding(params.text);
-	if (!binding || !shouldAppendSignalApprovalReactionHintForOutboundMessage({
-		...params,
-		text: params.text
-	})) return params.text;
-	return addSignalApprovalReactionHintToText({
-		text: params.text,
-		allowedDecisions: binding.allowedDecisions
-	});
-}
 function hasSignalApprovalReactionApprovers(params) {
 	return getSignalApprovalApprovers(params).length > 0;
 }
@@ -273,7 +264,7 @@ function registerSignalApprovalReactionTarget(params) {
 	};
 	const target = {
 		approvalId,
-		approvalKind: resolveApprovalKindFromId(approvalId),
+		approvalKind: params.approvalKind ?? resolveApprovalKindFromId(approvalId),
 		allowedDecisions,
 		targetAuthorKeys,
 		route
@@ -281,31 +272,88 @@ function registerSignalApprovalReactionTarget(params) {
 	signalApprovalReactionTargets.register(key, target, { ttlMs: params.ttlMs });
 	return target;
 }
-function registerSignalApprovalReactionTargetForOutboundMessage(params) {
-	const binding = extractSignalApprovalPromptBinding(params.text);
-	if (!binding) return false;
-	const conversationKey = resolveSignalApprovalConversationKey(params.to);
-	if (!conversationKey) return false;
-	const route = buildTargetRoute({
+function addSignalApprovalReactionHintToStructuredPayload(params) {
+	const metadata = getExecApprovalReplyMetadata(params.payload);
+	if (!metadata?.allowedDecisions || metadata.allowedDecisions.length === 0) return null;
+	if (resolveSignalApprovalTargetAuthorKeys(params).length === 0) return null;
+	if (!hasSignalApprovalReactionApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	})) return null;
+	if (!buildTargetRoute({
 		cfg: params.cfg,
 		accountId: params.accountId,
 		to: params.to,
-		approvalId: binding.approvalId,
-		agentId: params.agentId,
-		sessionKey: params.sessionKey
+		approvalId: metadata.approvalId,
+		approvalKind: metadata.approvalKind,
+		agentId: metadata.agentId,
+		sessionKey: metadata.sessionKey
+	}) || !params.payload.text) return null;
+	return {
+		...params.payload,
+		text: addSignalApprovalReactionHintToText({
+			text: params.payload.text,
+			allowedDecisions: metadata.allowedDecisions
+		})
+	};
+}
+function readSignalDeliveryVisibleText(result) {
+	const meta = result.meta;
+	const visibleText = meta?.signalVisibleText ?? meta?.visibleText;
+	return typeof visibleText === "string" ? visibleText : null;
+}
+function listDeliveredSignalMessageIdsWithVisibleHint(params) {
+	const signalResults = params.results.filter((result) => !result.channel || normalizeLowercaseStringOrEmpty(result.channel) === "signal");
+	const resultsWithVisibleText = signalResults.filter((result) => readSignalDeliveryVisibleText(result) !== null);
+	const candidates = resultsWithVisibleText.length > 0 ? resultsWithVisibleText : signalResults;
+	if (resultsWithVisibleText.length === 0 && candidates.length !== 1) return [];
+	const ids = candidates.filter((result) => resultsWithVisibleText.length > 0 ? hasSignalApprovalReactionHintText(readSignalDeliveryVisibleText(result)) : hasSignalApprovalReactionHintText(params.payload.text)).map((result) => normalizeOptionalString(result.messageId)).filter((messageId) => Boolean(messageId && messageId !== "unknown"));
+	return Array.from(new Set(ids));
+}
+function registerSignalApprovalReactionTargetForDeliveredPayload(params) {
+	if (normalizeLowercaseStringOrEmpty(params.target.channel) !== "signal") return false;
+	const metadata = getExecApprovalReplyMetadata(params.payload);
+	if (!metadata?.allowedDecisions || metadata.allowedDecisions.length === 0) return false;
+	if (!hasSignalApprovalReactionHintText(params.payload.text)) return false;
+	if (!hasSignalApprovalReactionApprovers({
+		cfg: params.cfg,
+		accountId: params.target.accountId
+	})) return false;
+	const conversationKey = resolveSignalApprovalConversationKeyForDeliveredTarget({
+		cfg: params.cfg,
+		accountId: params.target.accountId,
+		to: params.target.to
+	});
+	if (!conversationKey) return false;
+	const route = buildTargetRoute({
+		cfg: params.cfg,
+		accountId: params.target.accountId,
+		to: params.target.to,
+		approvalId: metadata.approvalId,
+		approvalKind: metadata.approvalKind,
+		agentId: metadata.agentId,
+		sessionKey: metadata.sessionKey
 	});
 	if (!route) return false;
-	return Boolean(registerSignalApprovalReactionTarget({
-		accountId: params.accountId,
+	const targetAuthorKeys = resolveSignalApprovalTargetAuthorKeys(params);
+	if (targetAuthorKeys.length === 0) return false;
+	let registered = false;
+	for (const messageId of listDeliveredSignalMessageIdsWithVisibleHint({
+		payload: params.payload,
+		results: params.results
+	})) registered = Boolean(registerSignalApprovalReactionTarget({
+		accountId: normalizeAccountId(params.target.accountId ?? void 0),
 		conversationKey,
-		messageId: params.messageId,
-		approvalId: binding.approvalId,
-		allowedDecisions: binding.allowedDecisions,
-		targetAuthorKeys: resolveSignalApprovalTargetAuthorKeys(params),
+		messageId,
+		approvalId: metadata.approvalId,
+		approvalKind: metadata.approvalKind,
+		allowedDecisions: metadata.allowedDecisions,
+		targetAuthorKeys,
 		route,
 		routeAllowed: true,
 		ttlMs: params.ttlMs
-	}));
+	})) || registered;
+	return registered;
 }
 function unregisterSignalApprovalReactionTarget(params) {
 	const key = buildReactionTargetKey(params);
@@ -403,197 +451,9 @@ async function maybeResolveSignalApprovalReaction(params) {
 		return true;
 	}
 }
-//#endregion
-//#region extensions/signal/src/send.ts
-async function resolveSignalRpcAccountInfo(opts) {
-	if (opts.baseUrl?.trim() && opts.account?.trim()) return;
-	if (!opts.cfg) throw new Error("Signal RPC account resolution requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
-	return resolveSignalAccount({
-		cfg: requireRuntimeConfig(opts.cfg, "Signal RPC account resolution"),
-		accountId: opts.accountId
-	});
-}
-function parseTarget(raw) {
-	let value = raw.trim();
-	if (!value) throw new Error("Signal recipient is required");
-	if (normalizeLowercaseStringOrEmpty(value).startsWith("signal:")) value = value.slice(7).trim();
-	const normalized = normalizeLowercaseStringOrEmpty(value);
-	if (normalized.startsWith("group:")) return {
-		type: "group",
-		groupId: value.slice(6).trim()
-	};
-	if (normalized.startsWith("username:")) return {
-		type: "username",
-		username: value.slice(9).trim()
-	};
-	if (normalized.startsWith("u:")) return {
-		type: "username",
-		username: value.trim()
-	};
-	return {
-		type: "recipient",
-		recipient: value
-	};
-}
-function buildTargetParams(target, allow) {
-	if (target.type === "recipient") {
-		if (!allow.recipient) return null;
-		return { recipient: [target.recipient] };
-	}
-	if (target.type === "group") {
-		if (!allow.group) return null;
-		return { groupId: target.groupId };
-	}
-	if (target.type === "username") {
-		if (!allow.username) return null;
-		return { username: [target.username] };
-	}
-	return null;
-}
-function createSignalSendReceipt(params) {
-	const messageId = params.messageId.trim();
-	const results = messageId && messageId !== "unknown" ? [{
-		channel: "signal",
-		messageId,
-		meta: { targetType: params.target.type }
-	}] : [];
-	if (results[0]) {
-		if (params.timestamp != null) results[0].timestamp = params.timestamp;
-		if (params.target.type === "group") results[0].chatId = params.target.groupId;
-		else if (params.target.type === "recipient") results[0].toJid = params.target.recipient;
-		else results[0].toJid = params.target.username;
-	}
-	return createMessageReceiptFromOutboundResults({
-		results,
-		kind: params.kind
-	});
-}
-async function sendMessageSignal(to, text, opts) {
-	const cfg = requireRuntimeConfig(opts.cfg, "Signal send");
-	const apiMode = cfg.channels?.signal?.apiMode;
-	const accountInfo = resolveSignalAccount({
-		cfg,
-		accountId: opts.accountId
-	});
-	const { baseUrl, account } = resolveSignalRpcContext(opts, accountInfo);
-	const target = parseTarget(to);
-	const outboundText = appendSignalApprovalReactionHintForOutboundMessage({
-		cfg,
-		accountId: accountInfo.accountId,
-		to,
-		text: text ?? "",
-		targetAuthor: account
-	});
-	let message = outboundText;
-	let messageFromPlaceholder = false;
-	let textStyles = [];
-	const textMode = opts.textMode ?? "markdown";
-	const maxBytes = (() => {
-		if (typeof opts.maxBytes === "number") return opts.maxBytes;
-		if (typeof accountInfo.config.mediaMaxMb === "number") return accountInfo.config.mediaMaxMb * 1024 * 1024;
-		if (typeof cfg.agents?.defaults?.mediaMaxMb === "number") return cfg.agents.defaults.mediaMaxMb * 1024 * 1024;
-		return 8 * 1024 * 1024;
-	})();
-	let attachments;
-	if (opts.mediaUrl?.trim()) {
-		const resolved = await resolveOutboundAttachmentFromUrl(opts.mediaUrl.trim(), maxBytes, {
-			mediaAccess: opts.mediaAccess,
-			localRoots: opts.mediaLocalRoots,
-			readFile: opts.mediaReadFile
-		});
-		attachments = [resolved.path];
-		const kind = kindFromMime(resolved.contentType ?? void 0);
-		if (!message && kind) {
-			message = kind === "image" ? "<media:image>" : `<media:${kind}>`;
-			messageFromPlaceholder = true;
-		}
-	}
-	if (message.trim() && !messageFromPlaceholder) if (textMode === "plain") textStyles = opts.textStyles ?? [];
-	else {
-		const tableMode = resolveMarkdownTableMode({
-			cfg,
-			channel: "signal",
-			accountId: accountInfo.accountId
-		});
-		const formatted = markdownToSignalText(message, { tableMode });
-		message = formatted.text;
-		textStyles = formatted.styles;
-	}
-	if (!message.trim() && (!attachments || attachments.length === 0)) throw new Error("Signal send requires text or media");
-	const params = { message };
-	if (textStyles.length > 0) params["text-style"] = textStyles.map((style) => `${style.start}:${style.length}:${style.style}`);
-	if (account) params.account = account;
-	if (attachments && attachments.length > 0) params.attachments = attachments;
-	const targetParams = buildTargetParams(target, {
-		recipient: true,
-		group: true,
-		username: true
-	});
-	if (!targetParams) throw new Error("Signal recipient is required");
-	Object.assign(params, targetParams);
-	const timestamp = (await signalRpcRequest("send", params, {
-		baseUrl,
-		timeoutMs: opts.timeoutMs,
-		apiMode
-	}))?.timestamp;
-	const messageId = timestamp ? String(timestamp) : "unknown";
-	registerSignalApprovalReactionTargetForOutboundMessage({
-		cfg,
-		accountId: accountInfo.accountId,
-		to,
-		messageId,
-		text: outboundText,
-		targetAuthor: account
-	});
-	return {
-		messageId,
-		timestamp,
-		receipt: createSignalSendReceipt({
-			messageId,
-			target,
-			kind: attachments && attachments.length > 0 ? "media" : "text",
-			...timestamp != null ? { timestamp } : {}
-		})
-	};
-}
-async function sendTypingSignal(to, opts) {
-	const accountInfo = await resolveSignalRpcAccountInfo(opts);
-	const cfg = requireRuntimeConfig(opts.cfg, "Signal typing");
-	const { baseUrl, account } = resolveSignalRpcContext(opts, accountInfo);
-	const targetParams = buildTargetParams(parseTarget(to), {
-		recipient: true,
-		group: true
-	});
-	if (!targetParams) return false;
-	const params = { ...targetParams };
-	if (account) params.account = account;
-	if (opts.stop) params.stop = true;
-	await signalRpcRequest("sendTyping", params, {
-		baseUrl,
-		timeoutMs: opts.timeoutMs,
-		apiMode: cfg.channels?.signal?.apiMode
-	});
-	return true;
-}
-async function sendReadReceiptSignal(to, targetTimestamp, opts) {
-	if (!Number.isFinite(targetTimestamp) || targetTimestamp <= 0) return false;
-	const accountInfo = await resolveSignalRpcAccountInfo(opts);
-	const cfg = requireRuntimeConfig(opts.cfg, "Signal read receipt");
-	const { baseUrl, account } = resolveSignalRpcContext(opts, accountInfo);
-	const targetParams = buildTargetParams(parseTarget(to), { recipient: true });
-	if (!targetParams) return false;
-	const params = {
-		...targetParams,
-		targetTimestamp,
-		type: opts.type ?? "read"
-	};
-	if (account) params.account = account;
-	await signalRpcRequest("sendReceipt", params, {
-		baseUrl,
-		timeoutMs: opts.timeoutMs,
-		apiMode: cfg.channels?.signal?.apiMode
-	});
-	return true;
+function clearSignalApprovalReactionTargetsForTest() {
+	signalApprovalReactionTargets.clearForTest();
+	resolverRuntimeLoader.clear();
 }
 //#endregion
-export { maybeResolveSignalApprovalReaction as a, resolveSignalApprovalTargetAuthorKeys as c, hasSignalApprovalReactionApprovers as i, unregisterSignalApprovalReactionTarget as l, sendReadReceiptSignal as n, registerSignalApprovalReactionTarget as o, sendTypingSignal as r, resolveSignalApprovalConversationKey as s, sendMessageSignal as t, setSignalRuntime as u };
+export { registerSignalApprovalReactionTarget as a, resolveSignalApprovalTargetAuthorKeys as c, maybeResolveSignalApprovalReaction as i, unregisterSignalApprovalReactionTarget as l, approval_reactions_exports as n, registerSignalApprovalReactionTargetForDeliveredPayload as o, hasSignalApprovalReactionApprovers as r, resolveSignalApprovalConversationKey as s, addSignalApprovalReactionHintToStructuredPayload as t, setSignalRuntime as u };