@openclaw/whatsapp 2026.7.2-beta.7 → 2026.7.33

package/dist/question-reactions-CRsnyoMK.js

@@ -1,142 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.js";
-import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
-//#region extensions/whatsapp/src/question-reactions.ts
-var question_reactions_exports = /* @__PURE__ */ __exportAll({
-	clearWhatsAppQuestionReactionTargetsForTest: () => clearWhatsAppQuestionReactionTargetsForTest,
-	maybeResolveWhatsAppQuestionReaction: () => maybeResolveWhatsAppQuestionReaction,
-	registerWhatsAppQuestionReactionTargetForDeliveredPayload: () => registerWhatsAppQuestionReactionTargetForDeliveredPayload
-});
-const TARGET_TTL_MS = 1440 * 60 * 1e3;
-const targets = /* @__PURE__ */ new Map();
-function storeTarget(key, binding) {
-	const existing = targets.get(key);
-	if (existing) clearTimeout(existing.cleanupTimer);
-	const target = {
-		...binding,
-		terminal: false,
-		expiresAtMs: Date.now() + TARGET_TTL_MS,
-		cleanupTimer: setTimeout(() => {
-			if (targets.get(key) === target) targets.delete(key);
-		}, TARGET_TTL_MS)
-	};
-	target.cleanupTimer.unref?.();
-	targets.set(key, target);
-	questionGatewayRuntime.registerChannelDelivery({
-		questionId: binding.questionId,
-		deliveryId: `whatsapp-reaction:${key}`,
-		finalize: () => {
-			target.terminal = true;
-		}
-	});
-}
-function buildKey(accountId, remoteJid, messageId) {
-	const parts = [
-		accountId,
-		remoteJid,
-		messageId
-	].map((part) => part.trim());
-	return parts.every(Boolean) ? parts.join(":") : void 0;
-}
-function addCandidate(values, value) {
-	const normalized = value?.trim();
-	if (normalized && !values.includes(normalized)) values.push(normalized);
-}
-function listDeliveredIdentities(results) {
-	const identities = [];
-	const seen = /* @__PURE__ */ new Set();
-	const add = (messageId, remoteJid) => {
-		const id = messageId?.trim() ?? "";
-		const jid = remoteJid?.trim() ?? "";
-		const key = `${jid}:${id}`;
-		if (id && id !== "unknown" && jid && !seen.has(key)) {
-			seen.add(key);
-			identities.push({
-				messageId: id,
-				remoteJid: jid
-			});
-		}
-	};
-	for (const result of results) {
-		if (result.channel !== "whatsapp") continue;
-		add(result.messageId, result.toJid);
-		for (const raw of result.receipt?.raw ?? []) add(raw.messageId, raw.toJid);
-		for (const part of result.receipt?.parts ?? []) add(part.raw?.messageId ?? part.platformMessageId, part.raw?.toJid);
-	}
-	return identities;
-}
-function registerWhatsAppQuestionReactionTargetForDeliveredPayload(params) {
-	const binding = questionGatewayRuntime.readReactionBinding(params.payload);
-	if (params.target.channel !== "whatsapp" || !binding) return false;
-	const accountId = resolveWhatsAppAccount({
-		cfg: params.cfg,
-		accountId: params.target.accountId
-	}).accountId;
-	let registered = false;
-	for (const identity of listDeliveredIdentities(params.results)) {
-		const key = buildKey(accountId, identity.remoteJid, identity.messageId);
-		if (!key) continue;
-		storeTarget(key, binding);
-		registered = true;
-	}
-	return registered;
-}
-async function maybeResolveWhatsAppQuestionReaction(params) {
-	const reaction = params.msg.message?.reactionMessage;
-	const reactionKey = reaction?.text?.trim() ?? "";
-	const messageId = reaction?.key?.id?.trim() ?? "";
-	const optionIndex = questionGatewayRuntime.resolveReactionIndex(reactionKey);
-	if (optionIndex === void 0 || !messageId) return false;
-	const remoteJids = [];
-	addCandidate(remoteJids, reaction?.key?.remoteJid);
-	addCandidate(remoteJids, params.msg.key?.remoteJid);
-	const candidates = [];
-	for (const remoteJid of remoteJids) {
-		addCandidate(candidates, remoteJid);
-		for (const mapped of await params.resolveReactionTargetJids?.(remoteJid) ?? []) addCandidate(candidates, mapped);
-	}
-	let matched;
-	for (const remoteJid of candidates) {
-		const key = buildKey(params.accountId, remoteJid, messageId);
-		const target = key ? targets.get(key) : void 0;
-		if (key && target) {
-			matched = {
-				key,
-				target
-			};
-			break;
-		}
-	}
-	if (!matched) return false;
-	if (matched.target.expiresAtMs <= Date.now() || matched.target.terminal) {
-		matched.target.terminal = true;
-		params.logDebug?.(`whatsapp: stale question reaction ignored id=${matched.target.questionId}`);
-		return true;
-	}
-	const optionValue = matched.target.optionValues[optionIndex];
-	if (!optionValue) {
-		params.logDebug?.(`whatsapp: out-of-range question reaction ignored id=${matched.target.questionId}`);
-		return true;
-	}
-	try {
-		const result = await questionGatewayRuntime.resolveReaction({
-			cfg: params.cfg,
-			questionId: matched.target.questionId,
-			optionValue,
-			senderId: params.senderId,
-			gatewayUrl: params.gatewayUrl,
-			clientDisplayName: `WhatsApp question (${params.senderId})`
-		});
-		matched.target.terminal = result?.status === "answered" || result?.status === "already-terminal";
-		if (result?.status === "already-terminal") params.logDebug?.(`whatsapp: stale question reaction ignored id=${matched.target.questionId}`);
-	} catch (error) {
-		params.logDebug?.(`whatsapp: question reaction failed id=${matched.target.questionId}: ${String(error)}`);
-	}
-	return true;
-}
-function clearWhatsAppQuestionReactionTargetsForTest() {
-	for (const target of targets.values()) clearTimeout(target.cleanupTimer);
-	targets.clear();
-}
-//#endregion
-export { question_reactions_exports as n, maybeResolveWhatsAppQuestionReaction as t };

package/dist/runtime-BLlToOi6.js

@@ -1,21 +0,0 @@
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
-//#region extensions/whatsapp/src/runtime.ts
-const runtimeStore = createPluginRuntimeStore({
-	pluginId: "whatsapp",
-	errorMessage: "WhatsApp runtime not initialized"
-});
-const channelRuntimeStore = createPluginRuntimeStore({
-	key: "plugin-runtime:whatsapp:channel-context-owner",
-	errorMessage: "WhatsApp channel runtime not initialized"
-});
-/** Injects current helpers while preserving the process-lifetime channel context owner. */
-function setWhatsAppRuntime(next) {
-	if (!channelRuntimeStore.tryGetRuntime()) channelRuntimeStore.setRuntime(next.channel);
-	runtimeStore.setRuntime(next);
-}
-const getWhatsAppRuntime = runtimeStore.getRuntime;
-const getOptionalWhatsAppRuntime = runtimeStore.tryGetRuntime;
-const getWhatsAppChannelRuntime = channelRuntimeStore.getRuntime;
-const getOptionalWhatsAppChannelRuntime = channelRuntimeStore.tryGetRuntime;
-//#endregion
-export { setWhatsAppRuntime as a, getWhatsAppRuntime as i, getOptionalWhatsAppRuntime as n, getWhatsAppChannelRuntime as r, getOptionalWhatsAppChannelRuntime as t };

package/dist/send-D37ddk22.js

@@ -1,436 +0,0 @@
-import { a as resolveWhatsAppAccount, c as resolveMergedWhatsAppAccountConfig, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CSqLvCY5.js";
-import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
-import { n as isWhatsAppNewsletterJid } from "./normalize-target-CugRyONv.js";
-import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-DG0tuYuw.js";
-import "./normalize-C7Hkc_vE.js";
-import { a as markdownToWhatsAppChunks, c as toWhatsappJid } from "./targets-runtime-TMk0lGuy.js";
-import { a as stripToolCallXmlTags, i as sanitizeAssistantVisibleTextWithProfile, r as sanitizeAssistantVisibleText } from "./text-runtime-CaKLhowd.js";
-import path from "node:path";
-import { normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveReactionLevel } from "openclaw/plugin-sdk/status-helpers";
-import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
-import { generateSecureUuid } from "openclaw/plugin-sdk/core";
-import { PlatformMessageNotDispatchedError } from "openclaw/plugin-sdk/error-runtime";
-import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
-import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
-import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
-import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
-import { normalizePollInput } from "openclaw/plugin-sdk/poll-runtime";
-import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
-import { createSubsystemLogger, getChildLogger as getChildLogger$1 } from "openclaw/plugin-sdk/runtime-env";
-import { extensionForMime, mediaKindFromMime, mimeTypeFromFilePath, normalizeMimeType } from "openclaw/plugin-sdk/media-mime";
-import { sanitizeForPlainText } from "openclaw/plugin-sdk/channel-outbound";
-import { MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS, transcodeAudioBufferToOpus } from "openclaw/plugin-sdk/media-runtime";
-import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
-//#region extensions/whatsapp/src/reaction-level.ts
-/** Resolve the effective reaction level and its implications for WhatsApp. */
-function resolveWhatsAppReactionLevel(params) {
-	return resolveReactionLevel({
-		value: resolveMergedWhatsAppAccountConfig({
-			cfg: params.cfg,
-			accountId: params.accountId
-		}).reactionLevel,
-		defaultLevel: "minimal",
-		invalidFallback: "minimal"
-	});
-}
-//#endregion
-//#region extensions/whatsapp/src/document-filename.ts
-const WHATSAPP_DEFAULT_DOCUMENT_FILE_NAME = "file";
-function resolveWhatsAppDefaultDocumentFileName(mimetype) {
-	const extension = extensionForMime(mimetype);
-	return extension ? `${WHATSAPP_DEFAULT_DOCUMENT_FILE_NAME}${extension}` : WHATSAPP_DEFAULT_DOCUMENT_FILE_NAME;
-}
-function resolveWhatsAppDocumentFileName(params) {
-	const fallbackName = resolveWhatsAppDefaultDocumentFileName(params.mimetype);
-	return stripAsciiControlCharacters(params.fileName ?? "").trim() || fallbackName;
-}
-function stripAsciiControlCharacters(value) {
-	let stripped = "";
-	for (const char of value) {
-		const code = char.charCodeAt(0);
-		if (code > 31 && code !== 127) stripped += char;
-	}
-	return stripped;
-}
-//#endregion
-//#region extensions/whatsapp/src/outbound-media-contract.ts
-const WHATSAPP_VOICE_FILE_NAME = "voice.ogg";
-const WHATSAPP_VOICE_SAMPLE_RATE_HZ = 48e3;
-const WHATSAPP_VOICE_BITRATE = "64k";
-const WHATSAPP_VOICE_MIMETYPE = "audio/ogg; codecs=opus";
-function stripWhatsAppPluralToolXml(text) {
-	return stripToolCallXmlTags(text, { stripFunctionCallsXmlPayloads: true });
-}
-function finalizeWhatsAppVisibleText(text) {
-	return sanitizeForPlainText(stripWhatsAppPluralToolXml(text));
-}
-function normalizeWhatsAppPayloadText(text) {
-	return finalizeWhatsAppVisibleText(sanitizeAssistantVisibleText(text ?? "")).trimStart();
-}
-function stripLeadingBlankLines(text) {
-	return text.replace(/^(?:[ \t]*\r?\n)+/, "");
-}
-function normalizeWhatsAppPayloadTextPreservingIndentation(text) {
-	const normalized = stripLeadingBlankLines(finalizeWhatsAppVisibleText(sanitizeAssistantVisibleTextWithProfile(stripLeadingBlankLines(text ?? ""), "history")));
-	return normalized.trim() ? normalized : "";
-}
-function resolveAdditiveWhatsAppMediaUrls(payload) {
-	return normalizeUniqueStringEntries([...payload.mediaUrl ? [payload.mediaUrl] : [], ...payload.mediaUrls ?? []]);
-}
-function normalizeWhatsAppOutboundPayload(payload, options) {
-	const preferredMediaUrls = normalizeUniqueStringEntries(payload.mediaUrls);
-	const mediaUrls = normalizeUniqueStringEntries(resolveOutboundMediaUrls({
-		mediaUrl: payload.mediaUrl,
-		mediaUrls: preferredMediaUrls
-	}));
-	const normalizeText = options?.normalizeText ?? normalizeWhatsAppPayloadText;
-	return {
-		...payload,
-		text: normalizeText(payload.text),
-		mediaUrl: mediaUrls[0],
-		mediaUrls: mediaUrls.length > 0 ? mediaUrls : void 0
-	};
-}
-function inferWhatsAppMediaKind(media, resolvedContentType) {
-	const isGenericDocument = media.kind === "document" && normalizeMimeType(media.contentType) === "application/octet-stream";
-	if (media.kind === "image" || media.kind === "audio" || media.kind === "video" || media.kind === "document" && !isGenericDocument) return media.kind;
-	const inferredKind = mediaKindFromMime(normalizeMimeType(resolvedContentType));
-	return !inferredKind || inferredKind === "sticker" || inferredKind === "unknown" ? "document" : inferredKind;
-}
-function normalizeWhatsAppLoadedMedia(media, mediaUrl) {
-	const filenameMimeType = mimeTypeFromFilePath(media.fileName);
-	const normalizedContentType = normalizeMimeType(media.contentType);
-	const resolvedContentType = !normalizedContentType || normalizedContentType === "application/octet-stream" ? filenameMimeType ?? media.contentType : media.contentType;
-	const kind = inferWhatsAppMediaKind(media, resolvedContentType);
-	const mimetype = kind === "audio" && isWhatsAppNativeVoiceAudio({
-		contentType: media.contentType,
-		fileName: media.fileName,
-		mediaUrl
-	}) ? WHATSAPP_VOICE_MIMETYPE : resolvedContentType ?? "application/octet-stream";
-	const fileName = kind === "document" ? resolveWhatsAppDocumentFileName({
-		fileName: media.fileName ?? deriveWhatsAppDocumentFileName(mediaUrl),
-		mimetype
-	}) : media.fileName;
-	return {
-		buffer: media.buffer,
-		kind,
-		mimetype,
-		...fileName ? { fileName } : {}
-	};
-}
-async function prepareWhatsAppOutboundMedia(media, mediaUrl) {
-	const normalized = normalizeWhatsAppLoadedMedia(media, mediaUrl);
-	if (normalized.kind !== "audio") return normalized;
-	if (isWhatsAppNativeVoiceAudio({
-		contentType: media.contentType,
-		fileName: media.fileName,
-		mediaUrl
-	})) return normalized;
-	return {
-		buffer: await transcodeToWhatsAppVoiceOpus({
-			buffer: media.buffer,
-			fileName: media.fileName ?? deriveWhatsAppDocumentFileName(mediaUrl) ?? "audio"
-		}),
-		kind: "audio",
-		mimetype: WHATSAPP_VOICE_MIMETYPE
-	};
-}
-function isWhatsAppNativeVoiceAudio(params) {
-	const contentType = normalizeMimeType(params.contentType);
-	if (contentType === "audio/ogg" || contentType === "audio/opus") return true;
-	const fileName = params.fileName ?? deriveWhatsAppDocumentFileName(params.mediaUrl) ?? "";
-	const ext = path.extname(fileName).toLowerCase();
-	return ext === ".ogg" || ext === ".opus";
-}
-async function transcodeToWhatsAppVoiceOpus(params) {
-	return await transcodeAudioBufferToOpus({
-		audioBuffer: params.buffer,
-		inputFileName: params.fileName,
-		tempPrefix: "whatsapp-voice-",
-		outputFileName: WHATSAPP_VOICE_FILE_NAME,
-		maxDurationSeconds: MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS,
-		sampleRateHz: WHATSAPP_VOICE_SAMPLE_RATE_HZ,
-		channels: 1,
-		bitrate: WHATSAPP_VOICE_BITRATE
-	});
-}
-function deriveWhatsAppDocumentFileName(mediaUrl) {
-	if (!mediaUrl) return;
-	try {
-		const parsed = new URL(mediaUrl);
-		const fileName = path.posix.basename(parsed.pathname);
-		return fileName ? decodeURIComponent(fileName) : void 0;
-	} catch {
-		return (mediaUrl.split(/[?#]/, 1)[0] ?? "").split(/[\\/]/).pop() || void 0;
-	}
-}
-//#endregion
-//#region extensions/whatsapp/src/send.ts
-const outboundLog = createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
-function supportsForcedDocumentDelivery(kind) {
-	return kind === "image" || kind === "video";
-}
-function buildWhatsAppMediaSendState(params) {
-	const { media, caption } = params;
-	const forceDocumentDelivery = Boolean(params.forceDocument && supportsForcedDocumentDelivery(media.kind));
-	let text = caption ?? "";
-	let documentFileName = media.kind === "document" ? media.fileName : void 0;
-	let visibleTextAfterVoice;
-	if (media.kind === "audio" && caption) {
-		visibleTextAfterVoice = caption;
-		text = "";
-	}
-	if (forceDocumentDelivery) documentFileName ??= resolveWhatsAppDocumentFileName({
-		fileName: media.fileName,
-		mimetype: media.mimetype
-	});
-	return {
-		mediaBuffer: media.buffer,
-		mediaType: media.mimetype,
-		text,
-		forceDocumentDelivery,
-		...documentFileName ? { documentFileName } : {},
-		...visibleTextAfterVoice ? { visibleTextAfterVoice } : {}
-	};
-}
-function resolveOutboundWhatsAppAccountId(params) {
-	const explicitAccountId = params.accountId?.trim();
-	if (explicitAccountId) return explicitAccountId;
-	return resolveDefaultWhatsAppAccountId(params.cfg);
-}
-function requireOutboundActiveWebListener(params) {
-	const resolvedAccountId = resolveOutboundWhatsAppAccountId(params) ?? resolveDefaultWhatsAppAccountId(params.cfg);
-	const listener = getWhatsAppConnectionController(resolvedAccountId)?.getActiveListener() ?? null;
-	if (!listener) {
-		const cause = /* @__PURE__ */ new Error(`No active WhatsApp Web listener (account: ${resolvedAccountId}). Start the gateway, then link WhatsApp with: ${formatCliCommand(`openclaw channels login --channel whatsapp --account ${resolvedAccountId}`)}.`);
-		throw new PlatformMessageNotDispatchedError(cause.message, { cause });
-	}
-	return {
-		accountId: resolvedAccountId,
-		listener
-	};
-}
-function resolveActualSentRemoteJid(result, fallbackJid) {
-	if (!result || typeof result !== "object") return fallbackJid;
-	const rawKeys = result.keys;
-	const keys = Array.isArray(rawKeys) ? rawKeys : [];
-	for (const key of keys) if (typeof key?.remoteJid === "string" && key.remoteJid.trim()) return key.remoteJid.trim();
-	return fallbackJid;
-}
-async function sendMessageWhatsApp(to, body, options) {
-	let text = options.preserveLeadingWhitespace ? body : normalizeWhatsAppPayloadText(body);
-	const jid = toWhatsappJid(to);
-	const mediaUrls = resolveAdditiveWhatsAppMediaUrls(options);
-	const mediaPayload = options.mediaPayload;
-	const primaryMediaUrl = mediaUrls[0] ?? mediaPayload?.fileName;
-	const hasMedia = Boolean(mediaPayload || primaryMediaUrl);
-	if (!text && !hasMedia) return {
-		messageId: "",
-		toJid: jid
-	};
-	const correlationId = generateSecureUuid();
-	const startedAt = Date.now();
-	const cfg = requireRuntimeConfig(options.cfg, "WhatsApp send");
-	const { listener: active, accountId: resolvedAccountId } = requireOutboundActiveWebListener({
-		cfg,
-		accountId: options.accountId
-	});
-	const account = resolveWhatsAppAccount({
-		cfg,
-		accountId: resolvedAccountId ?? options.accountId
-	});
-	const tableMode = resolveMarkdownTableMode({
-		cfg,
-		channel: "whatsapp",
-		accountId: resolvedAccountId ?? options.accountId
-	});
-	const accountIdForFormatting = resolvedAccountId ?? options.accountId;
-	const textLimit = Math.min(resolveTextChunkLimit(cfg, "whatsapp", accountIdForFormatting, { fallbackLimit: 4e3 }), 4096);
-	const textChunks = markdownToWhatsAppChunks(text, textLimit, tableMode, resolveChunkMode(cfg, "whatsapp", accountIdForFormatting));
-	text = textChunks.shift() ?? "";
-	if (!text && !hasMedia) return {
-		messageId: "",
-		toJid: jid
-	};
-	const redactedTo = redactIdentifier(to);
-	const logger = getChildLogger$1({
-		module: "web-outbound",
-		correlationId,
-		to: redactedTo
-	});
-	try {
-		const redactedJid = redactIdentifier(jid);
-		let mediaBuffer;
-		let mediaType;
-		let documentFileName;
-		let visibleTextAfterVoice;
-		let forceDocumentDelivery = false;
-		let media;
-		if (mediaPayload) media = await prepareWhatsAppOutboundMedia(mediaPayload, primaryMediaUrl);
-		else if (primaryMediaUrl) media = await prepareWhatsAppOutboundMedia(await loadOutboundMediaFromUrl(primaryMediaUrl, {
-			maxBytes: resolveWhatsAppMediaMaxBytes(account),
-			optimizeImages: options.forceDocument ? false : void 0,
-			mediaAccess: options.mediaAccess,
-			mediaLocalRoots: options.mediaLocalRoots,
-			mediaReadFile: options.mediaReadFile
-		}), primaryMediaUrl);
-		if (media) {
-			const mediaSendState = buildWhatsAppMediaSendState({
-				media,
-				caption: text || void 0,
-				forceDocument: options.forceDocument
-			});
-			mediaBuffer = mediaSendState.mediaBuffer;
-			mediaType = mediaSendState.mediaType;
-			documentFileName = mediaSendState.documentFileName;
-			visibleTextAfterVoice = mediaSendState.visibleTextAfterVoice;
-			forceDocumentDelivery = mediaSendState.forceDocumentDelivery;
-			text = mediaSendState.text;
-		}
-		outboundLog.info(`Sending message -> ${redactedJid}${hasMedia ? " (media)" : ""}`);
-		logger.info({
-			jid: redactedJid,
-			hasMedia
-		}, "sending message");
-		if (!isWhatsAppNewsletterJid(jid)) {
-			await active.assertSendReady?.(to);
-			await active.sendComposingTo(to);
-		}
-		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
-		const sendOptions = options.gifPlayback || forceDocumentDelivery || accountId || documentFileName || options.quotedMessageKey ? {
-			...options.gifPlayback ? { gifPlayback: true } : {},
-			...forceDocumentDelivery ? { asDocument: true } : {},
-			...documentFileName ? { fileName: documentFileName } : {},
-			...options.quotedMessageKey ? { quotedMessageKey: options.quotedMessageKey } : {},
-			accountId
-		} : void 0;
-		const result = sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType);
-		const messageId = result?.messageId ?? "unknown";
-		const sentRemoteJid = resolveActualSentRemoteJid(result, jid);
-		const trailingTextChunks = [visibleTextAfterVoice, ...textChunks].filter((chunk) => Boolean(chunk));
-		if (trailingTextChunks.length > 0) {
-			await options.onDeliveryResult?.({
-				messageId,
-				toJid: sentRemoteJid
-			});
-			for (const trailingText of trailingTextChunks) {
-				const trailingResult = sendOptions ? await active.sendMessage(to, trailingText, void 0, void 0, sendOptions) : await active.sendMessage(to, trailingText, void 0, void 0);
-				await options.onDeliveryResult?.({
-					messageId: trailingResult?.messageId ?? "unknown",
-					toJid: resolveActualSentRemoteJid(trailingResult, jid)
-				});
-			}
-		}
-		const durationMs = Date.now() - startedAt;
-		outboundLog.info(`Sent message ${messageId} -> ${redactedJid}${hasMedia ? " (media)" : ""} (${durationMs}ms)`);
-		logger.info({
-			jid: redactedJid,
-			messageId
-		}, "sent message");
-		return {
-			messageId,
-			toJid: sentRemoteJid
-		};
-	} catch (err) {
-		logger.error({
-			err: String(err),
-			to: redactedTo,
-			hasMedia
-		}, "failed to send via web session");
-		throw err;
-	}
-}
-async function sendTypingWhatsApp(to, options) {
-	const { listener: active } = requireOutboundActiveWebListener({
-		cfg: requireRuntimeConfig(options.cfg, "WhatsApp typing send"),
-		accountId: options.accountId
-	});
-	if (!isWhatsAppNewsletterJid(toWhatsappJid(to))) {
-		await active.assertSendReady?.(to);
-		await active.sendComposingTo(to);
-	}
-}
-async function sendReactionWhatsApp(chatJid, messageId, emoji, options) {
-	const correlationId = generateSecureUuid();
-	const { listener: active } = requireOutboundActiveWebListener({
-		cfg: requireRuntimeConfig(options.cfg, "WhatsApp reaction"),
-		accountId: options.accountId
-	});
-	const redactedChatJid = redactIdentifier(chatJid);
-	const logger = getChildLogger$1({
-		module: "web-outbound",
-		correlationId,
-		chatJid: redactedChatJid,
-		messageId
-	});
-	try {
-		const redactedJid = redactIdentifier(toWhatsappJid(chatJid));
-		outboundLog.info(`Sending reaction "${emoji}" -> message ${messageId}`);
-		logger.info({
-			chatJid: redactedJid,
-			messageId,
-			emoji
-		}, "sending reaction");
-		await active.sendReaction(chatJid, messageId, emoji, options.fromMe ?? false, options.participant);
-		outboundLog.info(`Sent reaction "${emoji}" -> message ${messageId}`);
-		logger.info({
-			chatJid: redactedJid,
-			messageId,
-			emoji
-		}, "sent reaction");
-	} catch (err) {
-		logger.error({
-			err: String(err),
-			chatJid: redactedChatJid,
-			messageId,
-			emoji
-		}, "failed to send reaction via web session");
-		throw err;
-	}
-}
-async function sendPollWhatsApp(to, poll, options) {
-	const correlationId = generateSecureUuid();
-	const startedAt = Date.now();
-	const { listener: active } = requireOutboundActiveWebListener({
-		cfg: requireRuntimeConfig(options.cfg, "WhatsApp poll"),
-		accountId: options.accountId
-	});
-	const redactedTo = redactIdentifier(to);
-	const logger = getChildLogger$1({
-		module: "web-outbound",
-		correlationId,
-		to: redactedTo
-	});
-	try {
-		const jid = toWhatsappJid(to);
-		const redactedJid = redactIdentifier(jid);
-		const normalized = normalizePollInput(poll, { maxOptions: 12 });
-		outboundLog.info(`Sending poll -> ${redactedJid}`);
-		logger.info({
-			jid: redactedJid,
-			optionCount: normalized.options.length,
-			maxSelections: normalized.maxSelections
-		}, "sending poll");
-		if (!isWhatsAppNewsletterJid(jid)) await active.assertSendReady?.(to);
-		const messageId = (await active.sendPoll(to, normalized))?.messageId ?? "unknown";
-		const durationMs = Date.now() - startedAt;
-		outboundLog.info(`Sent poll ${messageId} -> ${redactedJid} (${durationMs}ms)`);
-		logger.info({
-			jid: redactedJid,
-			messageId
-		}, "sent poll");
-		return {
-			messageId,
-			toJid: jid
-		};
-	} catch (err) {
-		logger.error({
-			err: String(err),
-			to: redactedTo
-		}, "failed to send poll via web session");
-		throw err;
-	}
-}
-//#endregion
-export { normalizeWhatsAppOutboundPayload as a, prepareWhatsAppOutboundMedia as c, sendTypingWhatsApp as i, resolveWhatsAppDocumentFileName as l, sendPollWhatsApp as n, normalizeWhatsAppPayloadText as o, sendReactionWhatsApp as r, normalizeWhatsAppPayloadTextPreservingIndentation as s, sendMessageWhatsApp as t, resolveWhatsAppReactionLevel as u };

package/dist/session.runtime-Nsqaehbd.js

@@ -1,16 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { BufferJSON, DEFAULT_CONNECTION_CONFIG, fetchLatestBaileysVersion, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState } from "baileys";
-//#region extensions/whatsapp/src/session.runtime.ts
-var session_runtime_exports = /* @__PURE__ */ __exportAll({
-	BufferJSON: () => BufferJSON,
-	createBaileysSignalRepository: () => createBaileysSignalRepository,
-	fetchLatestBaileysVersion: () => fetchLatestBaileysVersion,
-	makeCacheableSignalKeyStore: () => makeCacheableSignalKeyStore,
-	makeWASocket: () => makeWASocket,
-	useMultiFileAuthState: () => useMultiFileAuthState
-});
-function createBaileysSignalRepository(...args) {
-	return DEFAULT_CONNECTION_CONFIG.makeSignalRepository(...args);
-}
-//#endregion
-export { makeWASocket as a, makeCacheableSignalKeyStore as i, createBaileysSignalRepository as n, session_runtime_exports as o, fetchLatestBaileysVersion as r, useMultiFileAuthState as s, BufferJSON as t };