@noxsoft/anima 2.0.0

package/dist/media-THyainiE.js

@@ -0,0 +1,1342 @@
+import { B as STATE_DIR, D as shouldLogVerbose, w as logVerbose } from "./entry.js";
+import { t as formatCliCommand } from "./command-format-Clp46jkj.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./session-key-BGiG_JcT.js";
+import { y as resolveUserPath } from "./utils-C9sj30YY.js";
+import { c as logWarn } from "./exec-BizYYQgP.js";
+import { c as maxBytesForKind, l as mediaKindFromMime, n as extensionForMime, t as detectMime } from "./mime-B1ZoR53M.js";
+import { a as resizeToJpeg, c as createPinnedDispatcher, d as resolvePinnedHostnameWithPolicy, i as optimizeImageToPng, o as SsrFBlockedError, r as hasAlphaChannel, s as closeDispatcher, t as convertHeicToJpeg } from "./image-ops-Dlt3T7th.js";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import MarkdownIt from "markdown-it";
+
+//#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/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);
+}
+/**
+* Fetch wrapper that adds timeout support via AbortController.
+*
+* @param url - The URL to fetch
+* @param init - RequestInit options (headers, method, body, etc.)
+* @param timeoutMs - Timeout in milliseconds
+* @param fetchFn - The fetch implementation to use (defaults to global fetch)
+* @returns The fetch Response
+* @throws AbortError if the request times out
+*/
+async function fetchWithTimeout(url, init, timeoutMs, fetchFn = fetch) {
+	const controller = new AbortController();
+	const timer = setTimeout(controller.abort.bind(controller), Math.max(1, timeoutMs));
+	try {
+		return await fetchFn(url, {
+			...init,
+			signal: controller.signal
+		});
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+//#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/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
+export { readResponseWithLimit as a, fetchWithTimeout as c, setActiveWebListener as d, normalizePollInput as f, fetchRemoteMedia as i, getActiveWebListener as l, loadWebMedia as n, fetchWithSsrFGuard as o, convertMarkdownTables as p, MediaFetchError as r, bindAbortRelay as s, getDefaultLocalRoots as t, requireActiveWebListener as u };