@noxsoft/anima 2.0.2 → 2.0.4

package/dist/outbound-CkKgc6iR.js

@@ -0,0 +1,2062 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { t as STATE_DIR } from "./paths-DA9WYabg.js";
+import { g as DEFAULT_ACCOUNT_ID } from "./workspace-DLna1IxR.js";
+import { G as toWhatsappJid, Y as logVerbose, Z as shouldLogVerbose, c as logWarn, k as escapeRegExp, l as createSubsystemLogger, n as runExec, nt as getChildLogger, z as resolveUserPath } from "./exec-B7sUS164.js";
+import { t as formatCliCommand } from "./command-format-CP1YTNCl.js";
+import { n as loadConfig } from "./config-kVVm5EYV.js";
+import { c as maxBytesForKind, l as mediaKindFromMime, n as extensionForMime, t as detectMime } from "./mime-Bm1xTtpY.js";
+import { t as resolveMarkdownTableMode } from "./markdown-tables-CqwihY2m.js";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import MarkdownIt from "markdown-it";
+import { lookup } from "node:dns";
+import { lookup as lookup$1 } from "node:dns/promises";
+import { Agent } from "undici";
+
+//#region src/markdown/ir.ts
+function createMarkdownIt(options) {
+	const md = new MarkdownIt({
+		html: false,
+		linkify: options.linkify ?? true,
+		breaks: false,
+		typographer: false
+	});
+	md.enable("strikethrough");
+	if (options.tableMode && options.tableMode !== "off") md.enable("table");
+	else md.disable("table");
+	if (options.autolink === false) md.disable("autolink");
+	return md;
+}
+function getAttr(token, name) {
+	if (token.attrGet) return token.attrGet(name);
+	if (token.attrs) {
+		for (const [key, value] of token.attrs) if (key === name) return value;
+	}
+	return null;
+}
+function createTextToken(base, content) {
+	return {
+		...base,
+		type: "text",
+		content,
+		children: void 0
+	};
+}
+function applySpoilerTokens(tokens) {
+	for (const token of tokens) if (token.children && token.children.length > 0) token.children = injectSpoilersIntoInline(token.children);
+}
+function injectSpoilersIntoInline(tokens) {
+	const result = [];
+	const state = { spoilerOpen: false };
+	for (const token of tokens) {
+		if (token.type !== "text") {
+			result.push(token);
+			continue;
+		}
+		const content = token.content ?? "";
+		if (!content.includes("||")) {
+			result.push(token);
+			continue;
+		}
+		let index = 0;
+		while (index < content.length) {
+			const next = content.indexOf("||", index);
+			if (next === -1) {
+				if (index < content.length) result.push(createTextToken(token, content.slice(index)));
+				break;
+			}
+			if (next > index) result.push(createTextToken(token, content.slice(index, next)));
+			state.spoilerOpen = !state.spoilerOpen;
+			result.push({ type: state.spoilerOpen ? "spoiler_open" : "spoiler_close" });
+			index = next + 2;
+		}
+	}
+	return result;
+}
+function initRenderTarget() {
+	return {
+		text: "",
+		styles: [],
+		openStyles: [],
+		links: [],
+		linkStack: []
+	};
+}
+function resolveRenderTarget(state) {
+	return state.table?.currentCell ?? state;
+}
+function appendText(state, value) {
+	if (!value) return;
+	const target = resolveRenderTarget(state);
+	target.text += value;
+}
+function openStyle(state, style) {
+	const target = resolveRenderTarget(state);
+	target.openStyles.push({
+		style,
+		start: target.text.length
+	});
+}
+function closeStyle(state, style) {
+	const target = resolveRenderTarget(state);
+	for (let i = target.openStyles.length - 1; i >= 0; i -= 1) if (target.openStyles[i]?.style === style) {
+		const start = target.openStyles[i].start;
+		target.openStyles.splice(i, 1);
+		const end = target.text.length;
+		if (end > start) target.styles.push({
+			start,
+			end,
+			style
+		});
+		return;
+	}
+}
+function appendParagraphSeparator(state) {
+	if (state.env.listStack.length > 0) return;
+	if (state.table) return;
+	state.text += "\n\n";
+}
+function appendListPrefix(state) {
+	const stack = state.env.listStack;
+	const top = stack[stack.length - 1];
+	if (!top) return;
+	top.index += 1;
+	const indent = "  ".repeat(Math.max(0, stack.length - 1));
+	const prefix = top.type === "ordered" ? `${top.index}. ` : "• ";
+	state.text += `${indent}${prefix}`;
+}
+function renderInlineCode(state, content) {
+	if (!content) return;
+	const target = resolveRenderTarget(state);
+	const start = target.text.length;
+	target.text += content;
+	target.styles.push({
+		start,
+		end: start + content.length,
+		style: "code"
+	});
+}
+function renderCodeBlock(state, content) {
+	let code = content ?? "";
+	if (!code.endsWith("\n")) code = `${code}\n`;
+	const target = resolveRenderTarget(state);
+	const start = target.text.length;
+	target.text += code;
+	target.styles.push({
+		start,
+		end: start + code.length,
+		style: "code_block"
+	});
+	if (state.env.listStack.length === 0) target.text += "\n";
+}
+function handleLinkClose(state) {
+	const target = resolveRenderTarget(state);
+	const link = target.linkStack.pop();
+	if (!link?.href) return;
+	const href = link.href.trim();
+	if (!href) return;
+	const start = link.labelStart;
+	const end = target.text.length;
+	if (end <= start) {
+		target.links.push({
+			start,
+			end,
+			href
+		});
+		return;
+	}
+	target.links.push({
+		start,
+		end,
+		href
+	});
+}
+function initTableState() {
+	return {
+		headers: [],
+		rows: [],
+		currentRow: [],
+		currentCell: null,
+		inHeader: false
+	};
+}
+function finishTableCell(cell) {
+	closeRemainingStyles(cell);
+	return {
+		text: cell.text,
+		styles: cell.styles,
+		links: cell.links
+	};
+}
+function trimCell(cell) {
+	const text = cell.text;
+	let start = 0;
+	let end = text.length;
+	while (start < end && /\s/.test(text[start] ?? "")) start += 1;
+	while (end > start && /\s/.test(text[end - 1] ?? "")) end -= 1;
+	if (start === 0 && end === text.length) return cell;
+	const trimmedText = text.slice(start, end);
+	const trimmedLength = trimmedText.length;
+	const trimmedStyles = [];
+	for (const span of cell.styles) {
+		const sliceStart = Math.max(0, span.start - start);
+		const sliceEnd = Math.min(trimmedLength, span.end - start);
+		if (sliceEnd > sliceStart) trimmedStyles.push({
+			start: sliceStart,
+			end: sliceEnd,
+			style: span.style
+		});
+	}
+	const trimmedLinks = [];
+	for (const span of cell.links) {
+		const sliceStart = Math.max(0, span.start - start);
+		const sliceEnd = Math.min(trimmedLength, span.end - start);
+		if (sliceEnd > sliceStart) trimmedLinks.push({
+			start: sliceStart,
+			end: sliceEnd,
+			href: span.href
+		});
+	}
+	return {
+		text: trimmedText,
+		styles: trimmedStyles,
+		links: trimmedLinks
+	};
+}
+function appendCell(state, cell) {
+	if (!cell.text) return;
+	const start = state.text.length;
+	state.text += cell.text;
+	for (const span of cell.styles) state.styles.push({
+		start: start + span.start,
+		end: start + span.end,
+		style: span.style
+	});
+	for (const link of cell.links) state.links.push({
+		start: start + link.start,
+		end: start + link.end,
+		href: link.href
+	});
+}
+function appendCellTextOnly(state, cell) {
+	if (!cell.text) return;
+	state.text += cell.text;
+}
+function renderTableAsBullets(state) {
+	if (!state.table) return;
+	const headers = state.table.headers.map(trimCell);
+	const rows = state.table.rows.map((row) => row.map(trimCell));
+	if (headers.length === 0 && rows.length === 0) return;
+	if (headers.length > 1 && rows.length > 0) for (const row of rows) {
+		if (row.length === 0) continue;
+		const rowLabel = row[0];
+		if (rowLabel?.text) {
+			const labelStart = state.text.length;
+			appendCell(state, rowLabel);
+			const labelEnd = state.text.length;
+			if (labelEnd > labelStart) state.styles.push({
+				start: labelStart,
+				end: labelEnd,
+				style: "bold"
+			});
+			state.text += "\n";
+		}
+		for (let i = 1; i < row.length; i++) {
+			const header = headers[i];
+			const value = row[i];
+			if (!value?.text) continue;
+			state.text += "• ";
+			if (header?.text) {
+				appendCell(state, header);
+				state.text += ": ";
+			} else state.text += `Column ${i}: `;
+			appendCell(state, value);
+			state.text += "\n";
+		}
+		state.text += "\n";
+	}
+	else for (const row of rows) {
+		for (let i = 0; i < row.length; i++) {
+			const header = headers[i];
+			const value = row[i];
+			if (!value?.text) continue;
+			state.text += "• ";
+			if (header?.text) {
+				appendCell(state, header);
+				state.text += ": ";
+			}
+			appendCell(state, value);
+			state.text += "\n";
+		}
+		state.text += "\n";
+	}
+}
+function renderTableAsCode(state) {
+	if (!state.table) return;
+	const headers = state.table.headers.map(trimCell);
+	const rows = state.table.rows.map((row) => row.map(trimCell));
+	const columnCount = Math.max(headers.length, ...rows.map((row) => row.length));
+	if (columnCount === 0) return;
+	const widths = Array.from({ length: columnCount }, () => 0);
+	const updateWidths = (cells) => {
+		for (let i = 0; i < columnCount; i += 1) {
+			const width = cells[i]?.text.length ?? 0;
+			if (widths[i] < width) widths[i] = width;
+		}
+	};
+	updateWidths(headers);
+	for (const row of rows) updateWidths(row);
+	const codeStart = state.text.length;
+	const appendRow = (cells) => {
+		state.text += "|";
+		for (let i = 0; i < columnCount; i += 1) {
+			state.text += " ";
+			const cell = cells[i];
+			if (cell) appendCellTextOnly(state, cell);
+			const pad = widths[i] - (cell?.text.length ?? 0);
+			if (pad > 0) state.text += " ".repeat(pad);
+			state.text += " |";
+		}
+		state.text += "\n";
+	};
+	const appendDivider = () => {
+		state.text += "|";
+		for (let i = 0; i < columnCount; i += 1) {
+			const dashCount = Math.max(3, widths[i]);
+			state.text += ` ${"-".repeat(dashCount)} |`;
+		}
+		state.text += "\n";
+	};
+	appendRow(headers);
+	appendDivider();
+	for (const row of rows) appendRow(row);
+	const codeEnd = state.text.length;
+	if (codeEnd > codeStart) state.styles.push({
+		start: codeStart,
+		end: codeEnd,
+		style: "code_block"
+	});
+	if (state.env.listStack.length === 0) state.text += "\n";
+}
+function renderTokens(tokens, state) {
+	for (const token of tokens) switch (token.type) {
+		case "inline":
+			if (token.children) renderTokens(token.children, state);
+			break;
+		case "text":
+			appendText(state, token.content ?? "");
+			break;
+		case "em_open":
+			openStyle(state, "italic");
+			break;
+		case "em_close":
+			closeStyle(state, "italic");
+			break;
+		case "strong_open":
+			openStyle(state, "bold");
+			break;
+		case "strong_close":
+			closeStyle(state, "bold");
+			break;
+		case "s_open":
+			openStyle(state, "strikethrough");
+			break;
+		case "s_close":
+			closeStyle(state, "strikethrough");
+			break;
+		case "code_inline":
+			renderInlineCode(state, token.content ?? "");
+			break;
+		case "spoiler_open":
+			if (state.enableSpoilers) openStyle(state, "spoiler");
+			break;
+		case "spoiler_close":
+			if (state.enableSpoilers) closeStyle(state, "spoiler");
+			break;
+		case "link_open": {
+			const href = getAttr(token, "href") ?? "";
+			const target = resolveRenderTarget(state);
+			target.linkStack.push({
+				href,
+				labelStart: target.text.length
+			});
+			break;
+		}
+		case "link_close":
+			handleLinkClose(state);
+			break;
+		case "image":
+			appendText(state, token.content ?? "");
+			break;
+		case "softbreak":
+		case "hardbreak":
+			appendText(state, "\n");
+			break;
+		case "paragraph_close":
+			appendParagraphSeparator(state);
+			break;
+		case "heading_open":
+			if (state.headingStyle === "bold") openStyle(state, "bold");
+			break;
+		case "heading_close":
+			if (state.headingStyle === "bold") closeStyle(state, "bold");
+			appendParagraphSeparator(state);
+			break;
+		case "blockquote_open":
+			if (state.blockquotePrefix) state.text += state.blockquotePrefix;
+			openStyle(state, "blockquote");
+			break;
+		case "blockquote_close":
+			closeStyle(state, "blockquote");
+			break;
+		case "bullet_list_open":
+			if (state.env.listStack.length > 0) state.text += "\n";
+			state.env.listStack.push({
+				type: "bullet",
+				index: 0
+			});
+			break;
+		case "bullet_list_close":
+			state.env.listStack.pop();
+			if (state.env.listStack.length === 0) state.text += "\n";
+			break;
+		case "ordered_list_open": {
+			if (state.env.listStack.length > 0) state.text += "\n";
+			const start = Number(getAttr(token, "start") ?? "1");
+			state.env.listStack.push({
+				type: "ordered",
+				index: start - 1
+			});
+			break;
+		}
+		case "ordered_list_close":
+			state.env.listStack.pop();
+			if (state.env.listStack.length === 0) state.text += "\n";
+			break;
+		case "list_item_open":
+			appendListPrefix(state);
+			break;
+		case "list_item_close":
+			if (!state.text.endsWith("\n")) state.text += "\n";
+			break;
+		case "code_block":
+		case "fence":
+			renderCodeBlock(state, token.content ?? "");
+			break;
+		case "html_block":
+		case "html_inline":
+			appendText(state, token.content ?? "");
+			break;
+		case "table_open":
+			if (state.tableMode !== "off") {
+				state.table = initTableState();
+				state.hasTables = true;
+			}
+			break;
+		case "table_close":
+			if (state.table) {
+				if (state.tableMode === "bullets") renderTableAsBullets(state);
+				else if (state.tableMode === "code") renderTableAsCode(state);
+			}
+			state.table = null;
+			break;
+		case "thead_open":
+			if (state.table) state.table.inHeader = true;
+			break;
+		case "thead_close":
+			if (state.table) state.table.inHeader = false;
+			break;
+		case "tbody_open":
+		case "tbody_close": break;
+		case "tr_open":
+			if (state.table) state.table.currentRow = [];
+			break;
+		case "tr_close":
+			if (state.table) {
+				if (state.table.inHeader) state.table.headers = state.table.currentRow;
+				else state.table.rows.push(state.table.currentRow);
+				state.table.currentRow = [];
+			}
+			break;
+		case "th_open":
+		case "td_open":
+			if (state.table) state.table.currentCell = initRenderTarget();
+			break;
+		case "th_close":
+		case "td_close":
+			if (state.table?.currentCell) {
+				state.table.currentRow.push(finishTableCell(state.table.currentCell));
+				state.table.currentCell = null;
+			}
+			break;
+		case "hr":
+			state.text += "───\n\n";
+			break;
+		default:
+			if (token.children) renderTokens(token.children, state);
+			break;
+	}
+}
+function closeRemainingStyles(target) {
+	for (let i = target.openStyles.length - 1; i >= 0; i -= 1) {
+		const open = target.openStyles[i];
+		const end = target.text.length;
+		if (end > open.start) target.styles.push({
+			start: open.start,
+			end,
+			style: open.style
+		});
+	}
+	target.openStyles = [];
+}
+function clampStyleSpans(spans, maxLength) {
+	const clamped = [];
+	for (const span of spans) {
+		const start = Math.max(0, Math.min(span.start, maxLength));
+		const end = Math.max(start, Math.min(span.end, maxLength));
+		if (end > start) clamped.push({
+			start,
+			end,
+			style: span.style
+		});
+	}
+	return clamped;
+}
+function clampLinkSpans(spans, maxLength) {
+	const clamped = [];
+	for (const span of spans) {
+		const start = Math.max(0, Math.min(span.start, maxLength));
+		const end = Math.max(start, Math.min(span.end, maxLength));
+		if (end > start) clamped.push({
+			start,
+			end,
+			href: span.href
+		});
+	}
+	return clamped;
+}
+function mergeStyleSpans(spans) {
+	const sorted = [...spans].toSorted((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		if (a.end !== b.end) return a.end - b.end;
+		return a.style.localeCompare(b.style);
+	});
+	const merged = [];
+	for (const span of sorted) {
+		const prev = merged[merged.length - 1];
+		if (prev && prev.style === span.style && (span.start < prev.end || span.start === prev.end && span.style !== "blockquote")) {
+			prev.end = Math.max(prev.end, span.end);
+			continue;
+		}
+		merged.push({ ...span });
+	}
+	return merged;
+}
+function markdownToIRWithMeta(markdown, options = {}) {
+	const env = { listStack: [] };
+	const tokens = createMarkdownIt(options).parse(markdown ?? "", env);
+	if (options.enableSpoilers) applySpoilerTokens(tokens);
+	const tableMode = options.tableMode ?? "off";
+	const state = {
+		text: "",
+		styles: [],
+		openStyles: [],
+		links: [],
+		linkStack: [],
+		env,
+		headingStyle: options.headingStyle ?? "none",
+		blockquotePrefix: options.blockquotePrefix ?? "",
+		enableSpoilers: options.enableSpoilers ?? false,
+		tableMode,
+		table: null,
+		hasTables: false
+	};
+	renderTokens(tokens, state);
+	closeRemainingStyles(state);
+	const trimmedLength = state.text.trimEnd().length;
+	let codeBlockEnd = 0;
+	for (const span of state.styles) {
+		if (span.style !== "code_block") continue;
+		if (span.end > codeBlockEnd) codeBlockEnd = span.end;
+	}
+	const finalLength = Math.max(trimmedLength, codeBlockEnd);
+	return {
+		ir: {
+			text: finalLength === state.text.length ? state.text : state.text.slice(0, finalLength),
+			styles: mergeStyleSpans(clampStyleSpans(state.styles, finalLength)),
+			links: clampLinkSpans(state.links, finalLength)
+		},
+		hasTables: state.hasTables
+	};
+}
+
+//#endregion
+//#region src/markdown/render.ts
+const STYLE_RANK = new Map([
+	"blockquote",
+	"code_block",
+	"code",
+	"bold",
+	"italic",
+	"strikethrough",
+	"spoiler"
+].map((style, index) => [style, index]));
+function sortStyleSpans(spans) {
+	return [...spans].toSorted((a, b) => {
+		if (a.start !== b.start) return a.start - b.start;
+		if (a.end !== b.end) return b.end - a.end;
+		return (STYLE_RANK.get(a.style) ?? 0) - (STYLE_RANK.get(b.style) ?? 0);
+	});
+}
+function renderMarkdownWithMarkers(ir, options) {
+	const text = ir.text ?? "";
+	if (!text) return "";
+	const styleMarkers = options.styleMarkers;
+	const styled = sortStyleSpans(ir.styles.filter((span) => Boolean(styleMarkers[span.style])));
+	const boundaries = /* @__PURE__ */ new Set();
+	boundaries.add(0);
+	boundaries.add(text.length);
+	const startsAt = /* @__PURE__ */ new Map();
+	for (const span of styled) {
+		if (span.start === span.end) continue;
+		boundaries.add(span.start);
+		boundaries.add(span.end);
+		const bucket = startsAt.get(span.start);
+		if (bucket) bucket.push(span);
+		else startsAt.set(span.start, [span]);
+	}
+	for (const spans of startsAt.values()) spans.sort((a, b) => {
+		if (a.end !== b.end) return b.end - a.end;
+		return (STYLE_RANK.get(a.style) ?? 0) - (STYLE_RANK.get(b.style) ?? 0);
+	});
+	const linkStarts = /* @__PURE__ */ new Map();
+	if (options.buildLink) for (const link of ir.links) {
+		if (link.start === link.end) continue;
+		const rendered = options.buildLink(link, text);
+		if (!rendered) continue;
+		boundaries.add(rendered.start);
+		boundaries.add(rendered.end);
+		const openBucket = linkStarts.get(rendered.start);
+		if (openBucket) openBucket.push(rendered);
+		else linkStarts.set(rendered.start, [rendered]);
+	}
+	const points = [...boundaries].toSorted((a, b) => a - b);
+	const stack = [];
+	let out = "";
+	for (let i = 0; i < points.length; i += 1) {
+		const pos = points[i];
+		while (stack.length && stack[stack.length - 1]?.end === pos) {
+			const item = stack.pop();
+			if (item) out += item.close;
+		}
+		const openingItems = [];
+		const openingLinks = linkStarts.get(pos);
+		if (openingLinks && openingLinks.length > 0) for (const [index, link] of openingLinks.entries()) openingItems.push({
+			end: link.end,
+			open: link.open,
+			close: link.close,
+			kind: "link",
+			index
+		});
+		const openingStyles = startsAt.get(pos);
+		if (openingStyles) for (const [index, span] of openingStyles.entries()) {
+			const marker = styleMarkers[span.style];
+			if (!marker) continue;
+			openingItems.push({
+				end: span.end,
+				open: marker.open,
+				close: marker.close,
+				kind: "style",
+				style: span.style,
+				index
+			});
+		}
+		if (openingItems.length > 0) {
+			openingItems.sort((a, b) => {
+				if (a.end !== b.end) return b.end - a.end;
+				if (a.kind !== b.kind) return a.kind === "link" ? -1 : 1;
+				if (a.kind === "style" && b.kind === "style") return (STYLE_RANK.get(a.style) ?? 0) - (STYLE_RANK.get(b.style) ?? 0);
+				return a.index - b.index;
+			});
+			for (const item of openingItems) {
+				out += item.open;
+				stack.push({
+					close: item.close,
+					end: item.end
+				});
+			}
+		}
+		const next = points[i + 1];
+		if (next === void 0) break;
+		if (next > pos) out += options.escapeText(text.slice(pos, next));
+	}
+	return out;
+}
+
+//#endregion
+//#region src/markdown/tables.ts
+const MARKDOWN_STYLE_MARKERS = {
+	bold: {
+		open: "**",
+		close: "**"
+	},
+	italic: {
+		open: "_",
+		close: "_"
+	},
+	strikethrough: {
+		open: "~~",
+		close: "~~"
+	},
+	code: {
+		open: "`",
+		close: "`"
+	},
+	code_block: {
+		open: "```\n",
+		close: "```"
+	}
+};
+function convertMarkdownTables(markdown, mode) {
+	if (!markdown || mode === "off") return markdown;
+	const { ir, hasTables } = markdownToIRWithMeta(markdown, {
+		linkify: false,
+		autolink: false,
+		headingStyle: "none",
+		blockquotePrefix: "",
+		tableMode: mode
+	});
+	if (!hasTables) return markdown;
+	return renderMarkdownWithMarkers(ir, {
+		styleMarkers: MARKDOWN_STYLE_MARKERS,
+		escapeText: (text) => text,
+		buildLink: (link, text) => {
+			const href = link.href.trim();
+			if (!href) return null;
+			if (!text.slice(link.start, link.end)) return null;
+			return {
+				start: link.start,
+				end: link.end,
+				open: "[",
+				close: `](${href})`
+			};
+		}
+	});
+}
+
+//#endregion
+//#region src/markdown/whatsapp.ts
+/**
+* Convert standard Markdown formatting to WhatsApp-compatible markup.
+*
+* WhatsApp uses its own formatting syntax:
+*   bold:          *text*
+*   italic:        _text_
+*   strikethrough: ~text~
+*   monospace:     ```text```
+*
+* Standard Markdown uses:
+*   bold:          **text** or __text__
+*   italic:        *text* or _text_
+*   strikethrough: ~~text~~
+*   code:          `text` (inline) or ```text``` (block)
+*
+* The conversion preserves fenced code blocks and inline code,
+* then converts bold and strikethrough markers.
+*/
+/** Placeholder tokens used during conversion to protect code spans. */
+const FENCE_PLACEHOLDER = "\0FENCE";
+const INLINE_CODE_PLACEHOLDER = "\0CODE";
+/**
+* Convert standard Markdown bold/italic/strikethrough to WhatsApp formatting.
+*
+* Order of operations matters:
+* 1. Protect fenced code blocks (```...```) — already WhatsApp-compatible
+* 2. Protect inline code (`...`) — leave as-is
+* 3. Convert **bold** → *bold* and __bold__ → *bold*
+* 4. Convert ~~strike~~ → ~strike~
+* 5. Restore protected spans
+*
+* Italic *text* and _text_ are left alone since WhatsApp uses _text_ for italic
+* and single * is already WhatsApp bold — no conversion needed for single markers.
+*/
+function markdownToWhatsApp(text) {
+	if (!text) return text;
+	const fences = [];
+	let result = text.replace(/```[\s\S]*?```/g, (match) => {
+		fences.push(match);
+		return `${FENCE_PLACEHOLDER}${fences.length - 1}`;
+	});
+	const inlineCodes = [];
+	result = result.replace(/`[^`\n]+`/g, (match) => {
+		inlineCodes.push(match);
+		return `${INLINE_CODE_PLACEHOLDER}${inlineCodes.length - 1}`;
+	});
+	result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+	result = result.replace(/__(.+?)__/g, "*$1*");
+	result = result.replace(/~~(.+?)~~/g, "~$1~");
+	result = result.replace(new RegExp(`${escapeRegExp(INLINE_CODE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => inlineCodes[Number(idx)] ?? "");
+	result = result.replace(new RegExp(`${escapeRegExp(FENCE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => fences[Number(idx)] ?? "");
+	return result;
+}
+
+//#endregion
+//#region src/polls.ts
+function normalizePollInput(input, options = {}) {
+	const question = input.question.trim();
+	if (!question) throw new Error("Poll question is required");
+	const cleaned = (input.options ?? []).map((option) => option.trim()).filter(Boolean);
+	if (cleaned.length < 2) throw new Error("Poll requires at least 2 options");
+	if (options.maxOptions !== void 0 && cleaned.length > options.maxOptions) throw new Error(`Poll supports at most ${options.maxOptions} options`);
+	const maxSelectionsRaw = input.maxSelections;
+	const maxSelections = typeof maxSelectionsRaw === "number" && Number.isFinite(maxSelectionsRaw) ? Math.floor(maxSelectionsRaw) : 1;
+	if (maxSelections < 1) throw new Error("maxSelections must be at least 1");
+	if (maxSelections > cleaned.length) throw new Error("maxSelections cannot exceed option count");
+	const durationSecondsRaw = input.durationSeconds;
+	const durationSeconds = typeof durationSecondsRaw === "number" && Number.isFinite(durationSecondsRaw) ? Math.floor(durationSecondsRaw) : void 0;
+	if (durationSeconds !== void 0 && durationSeconds < 1) throw new Error("durationSeconds must be at least 1");
+	const durationRaw = input.durationHours;
+	const durationHours = typeof durationRaw === "number" && Number.isFinite(durationRaw) ? Math.floor(durationRaw) : void 0;
+	if (durationHours !== void 0 && durationHours < 1) throw new Error("durationHours must be at least 1");
+	if (durationSeconds !== void 0 && durationHours !== void 0) throw new Error("durationSeconds and durationHours are mutually exclusive");
+	return {
+		question,
+		options: cleaned,
+		maxSelections,
+		durationSeconds,
+		durationHours
+	};
+}
+
+//#endregion
+//#region src/web/active-listener.ts
+const listeners = /* @__PURE__ */ new Map();
+function resolveWebAccountId(accountId) {
+	return (accountId ?? "").trim() || DEFAULT_ACCOUNT_ID;
+}
+function requireActiveWebListener(accountId) {
+	const id = resolveWebAccountId(accountId);
+	const listener = listeners.get(id) ?? null;
+	if (!listener) throw new Error(`No active WhatsApp Web listener (account: ${id}). Start the gateway, then link WhatsApp with: ${formatCliCommand(`anima channels login --channel whatsapp --account ${id}`)}.`);
+	return {
+		accountId: id,
+		listener
+	};
+}
+function setActiveWebListener(accountIdOrListener, maybeListener) {
+	const { accountId, listener } = typeof accountIdOrListener === "string" ? {
+		accountId: accountIdOrListener,
+		listener: maybeListener ?? null
+	} : {
+		accountId: DEFAULT_ACCOUNT_ID,
+		listener: accountIdOrListener ?? null
+	};
+	const id = resolveWebAccountId(accountId);
+	if (!listener) listeners.delete(id);
+	else listeners.set(id, listener);
+	if (id === DEFAULT_ACCOUNT_ID) {}
+}
+function getActiveWebListener(accountId) {
+	const id = resolveWebAccountId(accountId);
+	return listeners.get(id) ?? null;
+}
+
+//#endregion
+//#region src/utils/fetch-timeout.ts
+/**
+* Relay abort without forwarding the Event argument as the abort reason.
+* Using .bind() avoids closure scope capture (memory leak prevention).
+*/
+function relayAbort() {
+	this.abort();
+}
+/** Returns a bound abort relay for use as an event listener. */
+function bindAbortRelay(controller) {
+	return relayAbort.bind(controller);
+}
+
+//#endregion
+//#region src/infra/net/ssrf.ts
+var SsrFBlockedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SsrFBlockedError";
+	}
+};
+const BLOCKED_HOSTNAMES = new Set(["localhost", "metadata.google.internal"]);
+function normalizeHostname(hostname) {
+	const normalized = hostname.trim().toLowerCase().replace(/\.$/, "");
+	if (normalized.startsWith("[") && normalized.endsWith("]")) return normalized.slice(1, -1);
+	return normalized;
+}
+function normalizeHostnameSet(values) {
+	if (!values || values.length === 0) return /* @__PURE__ */ new Set();
+	return new Set(values.map((value) => normalizeHostname(value)).filter(Boolean));
+}
+function normalizeHostnameAllowlist(values) {
+	if (!values || values.length === 0) return [];
+	return Array.from(new Set(values.map((value) => normalizeHostname(value)).filter((value) => value !== "*" && value !== "*." && value.length > 0)));
+}
+function isHostnameAllowedByPattern(hostname, pattern) {
+	if (pattern.startsWith("*.")) {
+		const suffix = pattern.slice(2);
+		if (!suffix || hostname === suffix) return false;
+		return hostname.endsWith(`.${suffix}`);
+	}
+	return hostname === pattern;
+}
+function matchesHostnameAllowlist(hostname, allowlist) {
+	if (allowlist.length === 0) return true;
+	return allowlist.some((pattern) => isHostnameAllowedByPattern(hostname, pattern));
+}
+function parseIpv4(address) {
+	const parts = address.split(".");
+	if (parts.length !== 4) return null;
+	const numbers = parts.map((part) => Number.parseInt(part, 10));
+	if (numbers.some((value) => Number.isNaN(value) || value < 0 || value > 255)) return null;
+	return numbers;
+}
+function stripIpv6ZoneId(address) {
+	const index = address.indexOf("%");
+	return index >= 0 ? address.slice(0, index) : address;
+}
+function parseIpv6Hextets(address) {
+	let input = stripIpv6ZoneId(address.trim().toLowerCase());
+	if (!input) return null;
+	if (input.includes(".")) {
+		const lastColon = input.lastIndexOf(":");
+		if (lastColon < 0) return null;
+		const ipv4 = parseIpv4(input.slice(lastColon + 1));
+		if (!ipv4) return null;
+		const high = (ipv4[0] << 8) + ipv4[1];
+		const low = (ipv4[2] << 8) + ipv4[3];
+		input = `${input.slice(0, lastColon)}:${high.toString(16)}:${low.toString(16)}`;
+	}
+	const doubleColonParts = input.split("::");
+	if (doubleColonParts.length > 2) return null;
+	const headParts = doubleColonParts[0]?.length > 0 ? doubleColonParts[0].split(":").filter(Boolean) : [];
+	const tailParts = doubleColonParts.length === 2 && doubleColonParts[1]?.length > 0 ? doubleColonParts[1].split(":").filter(Boolean) : [];
+	const missingParts = 8 - headParts.length - tailParts.length;
+	if (missingParts < 0) return null;
+	const fullParts = doubleColonParts.length === 1 ? input.split(":") : [
+		...headParts,
+		...Array.from({ length: missingParts }, () => "0"),
+		...tailParts
+	];
+	if (fullParts.length !== 8) return null;
+	const hextets = [];
+	for (const part of fullParts) {
+		if (!part) return null;
+		const value = Number.parseInt(part, 16);
+		if (Number.isNaN(value) || value < 0 || value > 65535) return null;
+		hextets.push(value);
+	}
+	return hextets;
+}
+function extractIpv4FromEmbeddedIpv6(hextets) {
+	if (!(hextets[0] === 0 && hextets[1] === 0 && hextets[2] === 0 && hextets[3] === 0) || hextets[4] !== 0) return null;
+	if (hextets[5] !== 65535 && hextets[5] !== 0) return null;
+	const high = hextets[6];
+	const low = hextets[7];
+	return [
+		high >>> 8 & 255,
+		high & 255,
+		low >>> 8 & 255,
+		low & 255
+	];
+}
+function isPrivateIpv4(parts) {
+	const [octet1, octet2] = parts;
+	if (octet1 === 0) return true;
+	if (octet1 === 10) return true;
+	if (octet1 === 127) return true;
+	if (octet1 === 169 && octet2 === 254) return true;
+	if (octet1 === 172 && octet2 >= 16 && octet2 <= 31) return true;
+	if (octet1 === 192 && octet2 === 168) return true;
+	if (octet1 === 100 && octet2 >= 64 && octet2 <= 127) return true;
+	return false;
+}
+function isPrivateIpAddress(address) {
+	let normalized = address.trim().toLowerCase();
+	if (normalized.startsWith("[") && normalized.endsWith("]")) normalized = normalized.slice(1, -1);
+	if (!normalized) return false;
+	if (normalized.includes(":")) {
+		const hextets = parseIpv6Hextets(normalized);
+		if (!hextets) return false;
+		const isUnspecified = hextets[0] === 0 && hextets[1] === 0 && hextets[2] === 0 && hextets[3] === 0 && hextets[4] === 0 && hextets[5] === 0 && hextets[6] === 0 && hextets[7] === 0;
+		const isLoopback = hextets[0] === 0 && hextets[1] === 0 && hextets[2] === 0 && hextets[3] === 0 && hextets[4] === 0 && hextets[5] === 0 && hextets[6] === 0 && hextets[7] === 1;
+		if (isUnspecified || isLoopback) return true;
+		const embeddedIpv4 = extractIpv4FromEmbeddedIpv6(hextets);
+		if (embeddedIpv4) return isPrivateIpv4(embeddedIpv4);
+		const first = hextets[0];
+		if ((first & 65472) === 65152) return true;
+		if ((first & 65472) === 65216) return true;
+		if ((first & 65024) === 64512) return true;
+		return false;
+	}
+	const ipv4 = parseIpv4(normalized);
+	if (!ipv4) return false;
+	return isPrivateIpv4(ipv4);
+}
+function isBlockedHostname(hostname) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) return false;
+	if (BLOCKED_HOSTNAMES.has(normalized)) return true;
+	return normalized.endsWith(".localhost") || normalized.endsWith(".local") || normalized.endsWith(".internal");
+}
+function createPinnedLookup(params) {
+	const normalizedHost = normalizeHostname(params.hostname);
+	const fallback = params.fallback ?? lookup;
+	const fallbackLookup = fallback;
+	const fallbackWithOptions = fallback;
+	const records = params.addresses.map((address) => ({
+		address,
+		family: address.includes(":") ? 6 : 4
+	}));
+	let index = 0;
+	return ((host, options, callback) => {
+		const cb = typeof options === "function" ? options : callback;
+		if (!cb) return;
+		const normalized = normalizeHostname(host);
+		if (!normalized || normalized !== normalizedHost) {
+			if (typeof options === "function" || options === void 0) return fallbackLookup(host, cb);
+			return fallbackWithOptions(host, options, cb);
+		}
+		const opts = typeof options === "object" && options !== null ? options : {};
+		const requestedFamily = typeof options === "number" ? options : typeof opts.family === "number" ? opts.family : 0;
+		const candidates = requestedFamily === 4 || requestedFamily === 6 ? records.filter((entry) => entry.family === requestedFamily) : records;
+		const usable = candidates.length > 0 ? candidates : records;
+		if (opts.all) {
+			cb(null, usable);
+			return;
+		}
+		const chosen = usable[index % usable.length];
+		index += 1;
+		cb(null, chosen.address, chosen.family);
+	});
+}
+async function resolvePinnedHostnameWithPolicy(hostname, params = {}) {
+	const normalized = normalizeHostname(hostname);
+	if (!normalized) throw new Error("Invalid hostname");
+	const allowPrivateNetwork = Boolean(params.policy?.allowPrivateNetwork);
+	const allowedHostnames = normalizeHostnameSet(params.policy?.allowedHostnames);
+	const hostnameAllowlist = normalizeHostnameAllowlist(params.policy?.hostnameAllowlist);
+	const isExplicitAllowed = allowedHostnames.has(normalized);
+	if (!matchesHostnameAllowlist(normalized, hostnameAllowlist)) throw new SsrFBlockedError(`Blocked hostname (not in allowlist): ${hostname}`);
+	if (!allowPrivateNetwork && !isExplicitAllowed) {
+		if (isBlockedHostname(normalized)) throw new SsrFBlockedError(`Blocked hostname: ${hostname}`);
+		if (isPrivateIpAddress(normalized)) throw new SsrFBlockedError("Blocked: private/internal IP address");
+	}
+	const results = await (params.lookupFn ?? lookup$1)(normalized, { all: true });
+	if (results.length === 0) throw new Error(`Unable to resolve hostname: ${hostname}`);
+	if (!allowPrivateNetwork && !isExplicitAllowed) {
+		for (const entry of results) if (isPrivateIpAddress(entry.address)) throw new SsrFBlockedError("Blocked: resolves to private/internal IP address");
+	}
+	const addresses = Array.from(new Set(results.map((entry) => entry.address)));
+	if (addresses.length === 0) throw new Error(`Unable to resolve hostname: ${hostname}`);
+	return {
+		hostname: normalized,
+		addresses,
+		lookup: createPinnedLookup({
+			hostname: normalized,
+			addresses
+		})
+	};
+}
+function createPinnedDispatcher(pinned) {
+	return new Agent({ connect: { lookup: pinned.lookup } });
+}
+async function closeDispatcher(dispatcher) {
+	if (!dispatcher) return;
+	const candidate = dispatcher;
+	try {
+		if (typeof candidate.close === "function") {
+			await candidate.close();
+			return;
+		}
+		if (typeof candidate.destroy === "function") candidate.destroy();
+	} catch {}
+}
+
+//#endregion
+//#region src/infra/net/fetch-guard.ts
+const DEFAULT_MAX_REDIRECTS = 3;
+function isRedirectStatus(status) {
+	return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function buildAbortSignal(params) {
+	const { timeoutMs, signal } = params;
+	if (!timeoutMs && !signal) return {
+		signal: void 0,
+		cleanup: () => {}
+	};
+	if (!timeoutMs) return {
+		signal,
+		cleanup: () => {}
+	};
+	const controller = new AbortController();
+	const timeoutId = setTimeout(controller.abort.bind(controller), timeoutMs);
+	const onAbort = bindAbortRelay(controller);
+	if (signal) if (signal.aborted) controller.abort();
+	else signal.addEventListener("abort", onAbort, { once: true });
+	const cleanup = () => {
+		clearTimeout(timeoutId);
+		if (signal) signal.removeEventListener("abort", onAbort);
+	};
+	return {
+		signal: controller.signal,
+		cleanup
+	};
+}
+async function fetchWithSsrFGuard(params) {
+	const fetcher = params.fetchImpl ?? globalThis.fetch;
+	if (!fetcher) throw new Error("fetch is not available");
+	const maxRedirects = typeof params.maxRedirects === "number" && Number.isFinite(params.maxRedirects) ? Math.max(0, Math.floor(params.maxRedirects)) : DEFAULT_MAX_REDIRECTS;
+	const { signal, cleanup } = buildAbortSignal({
+		timeoutMs: params.timeoutMs,
+		signal: params.signal
+	});
+	let released = false;
+	const release = async (dispatcher) => {
+		if (released) return;
+		released = true;
+		cleanup();
+		await closeDispatcher(dispatcher ?? void 0);
+	};
+	const visited = /* @__PURE__ */ new Set();
+	let currentUrl = params.url;
+	let redirectCount = 0;
+	while (true) {
+		let parsedUrl;
+		try {
+			parsedUrl = new URL(currentUrl);
+		} catch {
+			await release();
+			throw new Error("Invalid URL: must be http or https");
+		}
+		if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+			await release();
+			throw new Error("Invalid URL: must be http or https");
+		}
+		let dispatcher = null;
+		try {
+			const pinned = await resolvePinnedHostnameWithPolicy(parsedUrl.hostname, {
+				lookupFn: params.lookupFn,
+				policy: params.policy
+			});
+			if (params.pinDns !== false) dispatcher = createPinnedDispatcher(pinned);
+			const init = {
+				...params.init ? { ...params.init } : {},
+				redirect: "manual",
+				...dispatcher ? { dispatcher } : {},
+				...signal ? { signal } : {}
+			};
+			const response = await fetcher(parsedUrl.toString(), init);
+			if (isRedirectStatus(response.status)) {
+				const location = response.headers.get("location");
+				if (!location) {
+					await release(dispatcher);
+					throw new Error(`Redirect missing location header (${response.status})`);
+				}
+				redirectCount += 1;
+				if (redirectCount > maxRedirects) {
+					await release(dispatcher);
+					throw new Error(`Too many redirects (limit: ${maxRedirects})`);
+				}
+				const nextUrl = new URL(location, parsedUrl).toString();
+				if (visited.has(nextUrl)) {
+					await release(dispatcher);
+					throw new Error("Redirect loop detected");
+				}
+				visited.add(nextUrl);
+				response.body?.cancel();
+				await closeDispatcher(dispatcher);
+				currentUrl = nextUrl;
+				continue;
+			}
+			return {
+				response,
+				finalUrl: currentUrl,
+				release: async () => release(dispatcher)
+			};
+		} catch (err) {
+			if (err instanceof SsrFBlockedError) logWarn(`security: blocked URL fetch (${params.auditContext ?? "url-fetch"}) target=${parsedUrl.origin}${parsedUrl.pathname} reason=${err.message}`);
+			await release(dispatcher);
+			throw err;
+		}
+	}
+}
+
+//#endregion
+//#region src/media/read-response-with-limit.ts
+async function readResponseWithLimit(res, maxBytes, opts) {
+	const onOverflow = opts?.onOverflow ?? ((params) => /* @__PURE__ */ new Error(`Content too large: ${params.size} bytes (limit: ${params.maxBytes} bytes)`));
+	const body = res.body;
+	if (!body || typeof body.getReader !== "function") {
+		const fallback = Buffer.from(await res.arrayBuffer());
+		if (fallback.length > maxBytes) throw onOverflow({
+			size: fallback.length,
+			maxBytes,
+			res
+		});
+		return fallback;
+	}
+	const reader = body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value?.length) {
+				total += value.length;
+				if (total > maxBytes) {
+					try {
+						await reader.cancel();
+					} catch {}
+					throw onOverflow({
+						size: total,
+						maxBytes,
+						res
+					});
+				}
+				chunks.push(value);
+			}
+		}
+	} finally {
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+	return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)), total);
+}
+
+//#endregion
+//#region src/media/fetch.ts
+var MediaFetchError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "MediaFetchError";
+	}
+};
+function stripQuotes(value) {
+	return value.replace(/^["']|["']$/g, "");
+}
+function parseContentDispositionFileName(header) {
+	if (!header) return;
+	const starMatch = /filename\*\s*=\s*([^;]+)/i.exec(header);
+	if (starMatch?.[1]) {
+		const cleaned = stripQuotes(starMatch[1].trim());
+		const encoded = cleaned.split("''").slice(1).join("''") || cleaned;
+		try {
+			return path.basename(decodeURIComponent(encoded));
+		} catch {
+			return path.basename(encoded);
+		}
+	}
+	const match = /filename\s*=\s*([^;]+)/i.exec(header);
+	if (match?.[1]) return path.basename(stripQuotes(match[1].trim()));
+}
+async function readErrorBodySnippet(res, maxChars = 200) {
+	try {
+		const text = await res.text();
+		if (!text) return;
+		const collapsed = text.replace(/\s+/g, " ").trim();
+		if (!collapsed) return;
+		if (collapsed.length <= maxChars) return collapsed;
+		return `${collapsed.slice(0, maxChars)}…`;
+	} catch {
+		return;
+	}
+}
+async function fetchRemoteMedia(options) {
+	const { url, fetchImpl, filePathHint, maxBytes, maxRedirects, ssrfPolicy, lookupFn } = options;
+	let res;
+	let finalUrl = url;
+	let release = null;
+	try {
+		const result = await fetchWithSsrFGuard({
+			url,
+			fetchImpl,
+			maxRedirects,
+			policy: ssrfPolicy,
+			lookupFn
+		});
+		res = result.response;
+		finalUrl = result.finalUrl;
+		release = result.release;
+	} catch (err) {
+		throw new MediaFetchError("fetch_failed", `Failed to fetch media from ${url}: ${String(err)}`);
+	}
+	try {
+		if (!res.ok) {
+			const statusText = res.statusText ? ` ${res.statusText}` : "";
+			const redirected = finalUrl !== url ? ` (redirected to ${finalUrl})` : "";
+			let detail = `HTTP ${res.status}${statusText}`;
+			if (!res.body) detail = `HTTP ${res.status}${statusText}; empty response body`;
+			else {
+				const snippet = await readErrorBodySnippet(res);
+				if (snippet) detail += `; body: ${snippet}`;
+			}
+			throw new MediaFetchError("http_error", `Failed to fetch media from ${url}${redirected}: ${detail}`);
+		}
+		const contentLength = res.headers.get("content-length");
+		if (maxBytes && contentLength) {
+			const length = Number(contentLength);
+			if (Number.isFinite(length) && length > maxBytes) throw new MediaFetchError("max_bytes", `Failed to fetch media from ${url}: content length ${length} exceeds maxBytes ${maxBytes}`);
+		}
+		const buffer = maxBytes ? await readResponseWithLimit(res, maxBytes, { onOverflow: ({ maxBytes, res }) => new MediaFetchError("max_bytes", `Failed to fetch media from ${res.url || url}: payload exceeds maxBytes ${maxBytes}`) }) : Buffer.from(await res.arrayBuffer());
+		let fileNameFromUrl;
+		try {
+			const parsed = new URL(finalUrl);
+			fileNameFromUrl = path.basename(parsed.pathname) || void 0;
+		} catch {}
+		const headerFileName = parseContentDispositionFileName(res.headers.get("content-disposition"));
+		let fileName = headerFileName || fileNameFromUrl || (filePathHint ? path.basename(filePathHint) : void 0);
+		const filePathForMime = headerFileName && path.extname(headerFileName) ? headerFileName : filePathHint ?? finalUrl;
+		const contentType = await detectMime({
+			buffer,
+			headerMime: res.headers.get("content-type"),
+			filePath: filePathForMime
+		});
+		if (fileName && !path.extname(fileName) && contentType) {
+			const ext = extensionForMime(contentType);
+			if (ext) fileName = `${fileName}${ext}`;
+		}
+		return {
+			buffer,
+			contentType: contentType ?? void 0,
+			fileName
+		};
+	} finally {
+		if (release) await release();
+	}
+}
+
+//#endregion
+//#region src/media/image-ops.ts
+function isBun() {
+	return typeof process.versions.bun === "string";
+}
+function prefersSips() {
+	return process.env.ANIMA_IMAGE_BACKEND === "sips" || process.env.ANIMA_IMAGE_BACKEND !== "sharp" && isBun() && process.platform === "darwin";
+}
+async function loadSharp() {
+	const mod = await import("sharp");
+	const sharp = mod.default ?? mod;
+	return (buffer) => sharp(buffer, { failOnError: false });
+}
+/**
+* Reads EXIF orientation from JPEG buffer.
+* Returns orientation value 1-8, or null if not found/not JPEG.
+*
+* EXIF orientation values:
+* 1 = Normal, 2 = Flip H, 3 = Rotate 180, 4 = Flip V,
+* 5 = Rotate 270 CW + Flip H, 6 = Rotate 90 CW, 7 = Rotate 90 CW + Flip H, 8 = Rotate 270 CW
+*/
+function readJpegExifOrientation(buffer) {
+	if (buffer.length < 2 || buffer[0] !== 255 || buffer[1] !== 216) return null;
+	let offset = 2;
+	while (offset < buffer.length - 4) {
+		if (buffer[offset] !== 255) {
+			offset++;
+			continue;
+		}
+		const marker = buffer[offset + 1];
+		if (marker === 255) {
+			offset++;
+			continue;
+		}
+		if (marker === 225) {
+			const exifStart = offset + 4;
+			if (buffer.length > exifStart + 6 && buffer.toString("ascii", exifStart, exifStart + 4) === "Exif" && buffer[exifStart + 4] === 0 && buffer[exifStart + 5] === 0) {
+				const tiffStart = exifStart + 6;
+				if (buffer.length < tiffStart + 8) return null;
+				const isLittleEndian = buffer.toString("ascii", tiffStart, tiffStart + 2) === "II";
+				const readU16 = (pos) => isLittleEndian ? buffer.readUInt16LE(pos) : buffer.readUInt16BE(pos);
+				const readU32 = (pos) => isLittleEndian ? buffer.readUInt32LE(pos) : buffer.readUInt32BE(pos);
+				const ifd0Start = tiffStart + readU32(tiffStart + 4);
+				if (buffer.length < ifd0Start + 2) return null;
+				const numEntries = readU16(ifd0Start);
+				for (let i = 0; i < numEntries; i++) {
+					const entryOffset = ifd0Start + 2 + i * 12;
+					if (buffer.length < entryOffset + 12) break;
+					if (readU16(entryOffset) === 274) {
+						const value = readU16(entryOffset + 8);
+						return value >= 1 && value <= 8 ? value : null;
+					}
+				}
+			}
+			return null;
+		}
+		if (marker >= 224 && marker <= 239) {
+			const segmentLength = buffer.readUInt16BE(offset + 2);
+			offset += 2 + segmentLength;
+			continue;
+		}
+		if (marker === 192 || marker === 218) break;
+		offset++;
+	}
+	return null;
+}
+async function withTempDir(fn) {
+	const dir = await fs.mkdtemp(path.join(os.tmpdir(), "anima-img-"));
+	try {
+		return await fn(dir);
+	} finally {
+		await fs.rm(dir, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	}
+}
+async function sipsMetadataFromBuffer(buffer) {
+	return await withTempDir(async (dir) => {
+		const input = path.join(dir, "in.img");
+		await fs.writeFile(input, buffer);
+		const { stdout } = await runExec("/usr/bin/sips", [
+			"-g",
+			"pixelWidth",
+			"-g",
+			"pixelHeight",
+			input
+		], {
+			timeoutMs: 1e4,
+			maxBuffer: 512 * 1024
+		});
+		const w = stdout.match(/pixelWidth:\s*([0-9]+)/);
+		const h = stdout.match(/pixelHeight:\s*([0-9]+)/);
+		if (!w?.[1] || !h?.[1]) return null;
+		const width = Number.parseInt(w[1], 10);
+		const height = Number.parseInt(h[1], 10);
+		if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+		if (width <= 0 || height <= 0) return null;
+		return {
+			width,
+			height
+		};
+	});
+}
+async function sipsResizeToJpeg(params) {
+	return await withTempDir(async (dir) => {
+		const input = path.join(dir, "in.img");
+		const output = path.join(dir, "out.jpg");
+		await fs.writeFile(input, params.buffer);
+		await runExec("/usr/bin/sips", [
+			"-Z",
+			String(Math.max(1, Math.round(params.maxSide))),
+			"-s",
+			"format",
+			"jpeg",
+			"-s",
+			"formatOptions",
+			String(Math.max(1, Math.min(100, Math.round(params.quality)))),
+			input,
+			"--out",
+			output
+		], {
+			timeoutMs: 2e4,
+			maxBuffer: 1024 * 1024
+		});
+		return await fs.readFile(output);
+	});
+}
+async function sipsConvertToJpeg(buffer) {
+	return await withTempDir(async (dir) => {
+		const input = path.join(dir, "in.heic");
+		const output = path.join(dir, "out.jpg");
+		await fs.writeFile(input, buffer);
+		await runExec("/usr/bin/sips", [
+			"-s",
+			"format",
+			"jpeg",
+			input,
+			"--out",
+			output
+		], {
+			timeoutMs: 2e4,
+			maxBuffer: 1024 * 1024
+		});
+		return await fs.readFile(output);
+	});
+}
+async function getImageMetadata(buffer) {
+	if (prefersSips()) return await sipsMetadataFromBuffer(buffer).catch(() => null);
+	try {
+		const meta = await (await loadSharp())(buffer).metadata();
+		const width = Number(meta.width ?? 0);
+		const height = Number(meta.height ?? 0);
+		if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+		if (width <= 0 || height <= 0) return null;
+		return {
+			width,
+			height
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Applies rotation/flip to image buffer using sips based on EXIF orientation.
+*/
+async function sipsApplyOrientation(buffer, orientation) {
+	const ops = [];
+	switch (orientation) {
+		case 2:
+			ops.push("-f", "horizontal");
+			break;
+		case 3:
+			ops.push("-r", "180");
+			break;
+		case 4:
+			ops.push("-f", "vertical");
+			break;
+		case 5:
+			ops.push("-r", "270", "-f", "horizontal");
+			break;
+		case 6:
+			ops.push("-r", "90");
+			break;
+		case 7:
+			ops.push("-r", "90", "-f", "horizontal");
+			break;
+		case 8:
+			ops.push("-r", "270");
+			break;
+		default: return buffer;
+	}
+	return await withTempDir(async (dir) => {
+		const input = path.join(dir, "in.jpg");
+		const output = path.join(dir, "out.jpg");
+		await fs.writeFile(input, buffer);
+		await runExec("/usr/bin/sips", [
+			...ops,
+			input,
+			"--out",
+			output
+		], {
+			timeoutMs: 2e4,
+			maxBuffer: 1024 * 1024
+		});
+		return await fs.readFile(output);
+	});
+}
+async function resizeToJpeg(params) {
+	if (prefersSips()) {
+		const normalized = await normalizeExifOrientationSips(params.buffer);
+		if (params.withoutEnlargement !== false) {
+			const meta = await getImageMetadata(normalized);
+			if (meta) {
+				const maxDim = Math.max(meta.width, meta.height);
+				if (maxDim > 0 && maxDim <= params.maxSide) return await sipsResizeToJpeg({
+					buffer: normalized,
+					maxSide: maxDim,
+					quality: params.quality
+				});
+			}
+		}
+		return await sipsResizeToJpeg({
+			buffer: normalized,
+			maxSide: params.maxSide,
+			quality: params.quality
+		});
+	}
+	return await (await loadSharp())(params.buffer).rotate().resize({
+		width: params.maxSide,
+		height: params.maxSide,
+		fit: "inside",
+		withoutEnlargement: params.withoutEnlargement !== false
+	}).jpeg({
+		quality: params.quality,
+		mozjpeg: true
+	}).toBuffer();
+}
+async function convertHeicToJpeg(buffer) {
+	if (prefersSips()) return await sipsConvertToJpeg(buffer);
+	return await (await loadSharp())(buffer).jpeg({
+		quality: 90,
+		mozjpeg: true
+	}).toBuffer();
+}
+/**
+* Checks if an image has an alpha channel (transparency).
+* Returns true if the image has alpha, false otherwise.
+*/
+async function hasAlphaChannel(buffer) {
+	try {
+		const meta = await (await loadSharp())(buffer).metadata();
+		return meta.hasAlpha || meta.channels === 4;
+	} catch {
+		return false;
+	}
+}
+/**
+* Resizes an image to PNG format, preserving alpha channel (transparency).
+* Falls back to sharp only (no sips fallback for PNG with alpha).
+*/
+async function resizeToPng(params) {
+	const sharp = await loadSharp();
+	const compressionLevel = params.compressionLevel ?? 6;
+	return await sharp(params.buffer).rotate().resize({
+		width: params.maxSide,
+		height: params.maxSide,
+		fit: "inside",
+		withoutEnlargement: params.withoutEnlargement !== false
+	}).png({ compressionLevel }).toBuffer();
+}
+async function optimizeImageToPng(buffer, maxBytes) {
+	const sides = [
+		2048,
+		1536,
+		1280,
+		1024,
+		800
+	];
+	const compressionLevels = [
+		6,
+		7,
+		8,
+		9
+	];
+	let smallest = null;
+	for (const side of sides) for (const compressionLevel of compressionLevels) try {
+		const out = await resizeToPng({
+			buffer,
+			maxSide: side,
+			compressionLevel,
+			withoutEnlargement: true
+		});
+		const size = out.length;
+		if (!smallest || size < smallest.size) smallest = {
+			buffer: out,
+			size,
+			resizeSide: side,
+			compressionLevel
+		};
+		if (size <= maxBytes) return {
+			buffer: out,
+			optimizedSize: size,
+			resizeSide: side,
+			compressionLevel
+		};
+	} catch {}
+	if (smallest) return {
+		buffer: smallest.buffer,
+		optimizedSize: smallest.size,
+		resizeSide: smallest.resizeSide,
+		compressionLevel: smallest.compressionLevel
+	};
+	throw new Error("Failed to optimize PNG image");
+}
+/**
+* Internal sips-only EXIF normalization (no sharp fallback).
+* Used by resizeToJpeg to normalize before sips resize.
+*/
+async function normalizeExifOrientationSips(buffer) {
+	try {
+		const orientation = readJpegExifOrientation(buffer);
+		if (!orientation || orientation === 1) return buffer;
+		return await sipsApplyOrientation(buffer, orientation);
+	} catch {
+		return buffer;
+	}
+}
+
+//#endregion
+//#region src/web/media.ts
+function getDefaultLocalRoots() {
+	return [
+		os.tmpdir(),
+		path.join(STATE_DIR, "media"),
+		path.join(STATE_DIR, "agents"),
+		path.join(STATE_DIR, "workspace"),
+		path.join(STATE_DIR, "sandboxes")
+	];
+}
+async function assertLocalMediaAllowed(mediaPath, localRoots) {
+	if (localRoots === "any") return;
+	const roots = localRoots ?? getDefaultLocalRoots();
+	let resolved;
+	try {
+		resolved = await fs.realpath(mediaPath);
+	} catch {
+		resolved = path.resolve(mediaPath);
+	}
+	for (const root of roots) {
+		let resolvedRoot;
+		try {
+			resolvedRoot = await fs.realpath(root);
+		} catch {
+			resolvedRoot = path.resolve(root);
+		}
+		if (resolvedRoot === path.parse(resolvedRoot).root) throw new Error(`Invalid localRoots entry (refuses filesystem root): ${root}. Pass a narrower directory.`);
+		if (resolved === resolvedRoot || resolved.startsWith(resolvedRoot + path.sep)) return;
+	}
+	throw new Error(`Local media path is not under an allowed directory: ${mediaPath}`);
+}
+const HEIC_MIME_RE = /^image\/hei[cf]$/i;
+const HEIC_EXT_RE = /\.(heic|heif)$/i;
+const MB = 1024 * 1024;
+function formatMb(bytes, digits = 2) {
+	return (bytes / MB).toFixed(digits);
+}
+function formatCapLimit(label, cap, size) {
+	return `${label} exceeds ${formatMb(cap, 0)}MB limit (got ${formatMb(size)}MB)`;
+}
+function formatCapReduce(label, cap, size) {
+	return `${label} could not be reduced below ${formatMb(cap, 0)}MB (got ${formatMb(size)}MB)`;
+}
+function isHeicSource(opts) {
+	if (opts.contentType && HEIC_MIME_RE.test(opts.contentType.trim())) return true;
+	if (opts.fileName && HEIC_EXT_RE.test(opts.fileName.trim())) return true;
+	return false;
+}
+function toJpegFileName(fileName) {
+	if (!fileName) return;
+	const trimmed = fileName.trim();
+	if (!trimmed) return fileName;
+	const parsed = path.parse(trimmed);
+	if (!parsed.ext || HEIC_EXT_RE.test(parsed.ext)) return path.format({
+		dir: parsed.dir,
+		name: parsed.name || trimmed,
+		ext: ".jpg"
+	});
+	return path.format({
+		dir: parsed.dir,
+		name: parsed.name,
+		ext: ".jpg"
+	});
+}
+function logOptimizedImage(params) {
+	if (!shouldLogVerbose()) return;
+	if (params.optimized.optimizedSize >= params.originalSize) return;
+	if (params.optimized.format === "png") {
+		logVerbose(`Optimized PNG (preserving alpha) from ${formatMb(params.originalSize)}MB to ${formatMb(params.optimized.optimizedSize)}MB (side≤${params.optimized.resizeSide}px)`);
+		return;
+	}
+	logVerbose(`Optimized media from ${formatMb(params.originalSize)}MB to ${formatMb(params.optimized.optimizedSize)}MB (side≤${params.optimized.resizeSide}px, q=${params.optimized.quality})`);
+}
+async function optimizeImageWithFallback(params) {
+	const { buffer, cap, meta } = params;
+	if ((meta?.contentType === "image/png" || meta?.fileName?.toLowerCase().endsWith(".png")) && await hasAlphaChannel(buffer)) {
+		const optimized = await optimizeImageToPng(buffer, cap);
+		if (optimized.buffer.length <= cap) return {
+			...optimized,
+			format: "png"
+		};
+		if (shouldLogVerbose()) logVerbose(`PNG with alpha still exceeds ${formatMb(cap, 0)}MB after optimization; falling back to JPEG`);
+	}
+	return {
+		...await optimizeImageToJpeg(buffer, cap, meta),
+		format: "jpeg"
+	};
+}
+async function loadWebMediaInternal(mediaUrl, options = {}) {
+	const { maxBytes, optimizeImages = true, ssrfPolicy, localRoots, sandboxValidated = false, readFile: readFileOverride } = options;
+	mediaUrl = mediaUrl.replace(/^\s*MEDIA\s*:\s*/i, "");
+	if (mediaUrl.startsWith("file://")) try {
+		mediaUrl = fileURLToPath(mediaUrl);
+	} catch {
+		throw new Error(`Invalid file:// URL: ${mediaUrl}`);
+	}
+	const optimizeAndClampImage = async (buffer, cap, meta) => {
+		const originalSize = buffer.length;
+		const optimized = await optimizeImageWithFallback({
+			buffer,
+			cap,
+			meta
+		});
+		logOptimizedImage({
+			originalSize,
+			optimized
+		});
+		if (optimized.buffer.length > cap) throw new Error(formatCapReduce("Media", cap, optimized.buffer.length));
+		const contentType = optimized.format === "png" ? "image/png" : "image/jpeg";
+		const fileName = optimized.format === "jpeg" && meta && isHeicSource(meta) ? toJpegFileName(meta.fileName) : meta?.fileName;
+		return {
+			buffer: optimized.buffer,
+			contentType,
+			kind: "image",
+			fileName
+		};
+	};
+	const clampAndFinalize = async (params) => {
+		const cap = maxBytes !== void 0 ? maxBytes : maxBytesForKind(params.kind);
+		if (params.kind === "image") {
+			const isGif = params.contentType === "image/gif";
+			if (isGif || !optimizeImages) {
+				if (params.buffer.length > cap) throw new Error(formatCapLimit(isGif ? "GIF" : "Media", cap, params.buffer.length));
+				return {
+					buffer: params.buffer,
+					contentType: params.contentType,
+					kind: params.kind,
+					fileName: params.fileName
+				};
+			}
+			return { ...await optimizeAndClampImage(params.buffer, cap, {
+				contentType: params.contentType,
+				fileName: params.fileName
+			}) };
+		}
+		if (params.buffer.length > cap) throw new Error(formatCapLimit("Media", cap, params.buffer.length));
+		return {
+			buffer: params.buffer,
+			contentType: params.contentType ?? void 0,
+			kind: params.kind,
+			fileName: params.fileName
+		};
+	};
+	if (/^https?:\/\//i.test(mediaUrl)) {
+		const defaultFetchCap = maxBytesForKind("unknown");
+		const { buffer, contentType, fileName } = await fetchRemoteMedia({
+			url: mediaUrl,
+			maxBytes: maxBytes === void 0 ? defaultFetchCap : optimizeImages ? Math.max(maxBytes, defaultFetchCap) : maxBytes,
+			ssrfPolicy
+		});
+		return await clampAndFinalize({
+			buffer,
+			contentType,
+			kind: mediaKindFromMime(contentType),
+			fileName
+		});
+	}
+	if (mediaUrl.startsWith("~")) mediaUrl = resolveUserPath(mediaUrl);
+	if ((sandboxValidated || localRoots === "any") && !readFileOverride) throw new Error("Refusing localRoots bypass without readFile override. Use sandboxValidated with readFile, or pass explicit localRoots.");
+	if (!(sandboxValidated || localRoots === "any")) await assertLocalMediaAllowed(mediaUrl, localRoots);
+	const data = readFileOverride ? await readFileOverride(mediaUrl) : await fs.readFile(mediaUrl);
+	const mime = await detectMime({
+		buffer: data,
+		filePath: mediaUrl
+	});
+	const kind = mediaKindFromMime(mime);
+	let fileName = path.basename(mediaUrl) || void 0;
+	if (fileName && !path.extname(fileName) && mime) {
+		const ext = extensionForMime(mime);
+		if (ext) fileName = `${fileName}${ext}`;
+	}
+	return await clampAndFinalize({
+		buffer: data,
+		contentType: mime,
+		kind,
+		fileName
+	});
+}
+async function loadWebMedia(mediaUrl, maxBytesOrOptions, options) {
+	if (typeof maxBytesOrOptions === "number" || maxBytesOrOptions === void 0) return await loadWebMediaInternal(mediaUrl, {
+		maxBytes: maxBytesOrOptions,
+		optimizeImages: true,
+		ssrfPolicy: options?.ssrfPolicy,
+		localRoots: options?.localRoots
+	});
+	return await loadWebMediaInternal(mediaUrl, {
+		...maxBytesOrOptions,
+		optimizeImages: maxBytesOrOptions.optimizeImages ?? true
+	});
+}
+async function optimizeImageToJpeg(buffer, maxBytes, opts = {}) {
+	let source = buffer;
+	if (isHeicSource(opts)) try {
+		source = await convertHeicToJpeg(buffer);
+	} catch (err) {
+		throw new Error(`HEIC image conversion failed: ${String(err)}`, { cause: err });
+	}
+	const sides = [
+		2048,
+		1536,
+		1280,
+		1024,
+		800
+	];
+	const qualities = [
+		80,
+		70,
+		60,
+		50,
+		40
+	];
+	let smallest = null;
+	for (const side of sides) for (const quality of qualities) try {
+		const out = await resizeToJpeg({
+			buffer: source,
+			maxSide: side,
+			quality,
+			withoutEnlargement: true
+		});
+		const size = out.length;
+		if (!smallest || size < smallest.size) smallest = {
+			buffer: out,
+			size,
+			resizeSide: side,
+			quality
+		};
+		if (size <= maxBytes) return {
+			buffer: out,
+			optimizedSize: size,
+			resizeSide: side,
+			quality
+		};
+	} catch {}
+	if (smallest) return {
+		buffer: smallest.buffer,
+		optimizedSize: smallest.size,
+		resizeSide: smallest.resizeSide,
+		quality: smallest.quality
+	};
+	throw new Error("Failed to optimize image");
+}
+
+//#endregion
+//#region src/web/outbound.ts
+var outbound_exports = /* @__PURE__ */ __exportAll({
+	sendMessageWhatsApp: () => sendMessageWhatsApp,
+	sendPollWhatsApp: () => sendPollWhatsApp,
+	sendReactionWhatsApp: () => sendReactionWhatsApp
+});
+const outboundLog = createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
+async function sendMessageWhatsApp(to, body, options) {
+	let text = body;
+	const correlationId = randomUUID();
+	const startedAt = Date.now();
+	const { listener: active, accountId: resolvedAccountId } = requireActiveWebListener(options.accountId);
+	const tableMode = resolveMarkdownTableMode({
+		cfg: loadConfig(),
+		channel: "whatsapp",
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	text = convertMarkdownTables(text ?? "", tableMode);
+	text = markdownToWhatsApp(text);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		to
+	});
+	try {
+		const jid = toWhatsappJid(to);
+		let mediaBuffer;
+		let mediaType;
+		let documentFileName;
+		if (options.mediaUrl) {
+			const media = await loadWebMedia(options.mediaUrl);
+			const caption = text || void 0;
+			mediaBuffer = media.buffer;
+			mediaType = media.contentType;
+			if (media.kind === "audio") mediaType = media.contentType === "audio/ogg" ? "audio/ogg; codecs=opus" : media.contentType ?? "application/octet-stream";
+			else if (media.kind === "video") text = caption ?? "";
+			else if (media.kind === "image") text = caption ?? "";
+			else {
+				text = caption ?? "";
+				documentFileName = media.fileName;
+			}
+		}
+		outboundLog.info(`Sending message -> ${jid}${options.mediaUrl ? " (media)" : ""}`);
+		logger.info({
+			jid,
+			hasMedia: Boolean(options.mediaUrl)
+		}, "sending message");
+		await active.sendComposingTo(to);
+		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
+		const sendOptions = options.gifPlayback || accountId || documentFileName ? {
+			...options.gifPlayback ? { gifPlayback: true } : {},
+			...documentFileName ? { fileName: documentFileName } : {},
+			accountId
+		} : void 0;
+		const messageId = (sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType))?.messageId ?? "unknown";
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent message ${messageId} -> ${jid}${options.mediaUrl ? " (media)" : ""} (${durationMs}ms)`);
+		logger.info({
+			jid,
+			messageId
+		}, "sent message");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to,
+			hasMedia: Boolean(options.mediaUrl)
+		}, "failed to send via web session");
+		throw err;
+	}
+}
+async function sendReactionWhatsApp(chatJid, messageId, emoji, options) {
+	const correlationId = randomUUID();
+	const { listener: active } = requireActiveWebListener(options.accountId);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		chatJid,
+		messageId
+	});
+	try {
+		const jid = toWhatsappJid(chatJid);
+		outboundLog.info(`Sending reaction "${emoji}" -> message ${messageId}`);
+		logger.info({
+			chatJid: jid,
+			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: jid,
+			messageId,
+			emoji
+		}, "sent reaction");
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			chatJid,
+			messageId,
+			emoji
+		}, "failed to send reaction via web session");
+		throw err;
+	}
+}
+async function sendPollWhatsApp(to, poll, options) {
+	const correlationId = randomUUID();
+	const startedAt = Date.now();
+	const { listener: active } = requireActiveWebListener(options.accountId);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		to
+	});
+	try {
+		const jid = toWhatsappJid(to);
+		const normalized = normalizePollInput(poll, { maxOptions: 12 });
+		outboundLog.info(`Sending poll -> ${jid}: "${normalized.question}"`);
+		logger.info({
+			jid,
+			question: normalized.question,
+			optionCount: normalized.options.length,
+			maxSelections: normalized.maxSelections
+		}, "sending poll");
+		const messageId = (await active.sendPoll(to, normalized))?.messageId ?? "unknown";
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent poll ${messageId} -> ${jid} (${durationMs}ms)`);
+		logger.info({
+			jid,
+			messageId
+		}, "sent poll");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to,
+			question: poll.question
+		}, "failed to send poll via web session");
+		throw err;
+	}
+}
+
+//#endregion
+export { setActiveWebListener as _, loadWebMedia as a, convertMarkdownTables as b, MediaFetchError as c, fetchWithSsrFGuard as d, SsrFBlockedError as f, getActiveWebListener as g, bindAbortRelay as h, getDefaultLocalRoots as i, fetchRemoteMedia as l, isPrivateIpAddress as m, sendMessageWhatsApp as n, getImageMetadata as o, isBlockedHostname as p, sendReactionWhatsApp as r, resizeToJpeg as s, outbound_exports as t, readResponseWithLimit as u, normalizePollInput as v, markdownToWhatsApp as y };