@fased/fased 0.1.41 → 0.1.42

package/dist/plugin-sdk/send-BzFdvD_i.js

@@ -1,1351 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
-import { Dt as resolveTelegramAccount } from "./runtime-BPyuAmka.js";
-import { t as createSubsystemLogger } from "./subsystem-DBPNbQDQ.js";
-import { i as logVerbose, t as danger } from "./globals-B_jjtAje.js";
-import { a as readConfigFileSnapshotForWrite, cr as formatErrorMessage, lr as formatUncaughtError, n as loadConfig, s as writeConfigFile, sr as extractErrorCode, xr as isTruthyEnvValue } from "./config-DtqAN2L3.js";
-import { n as redactSensitiveText } from "./redact-CwCz68Mi.js";
-import { A as resolveCronStorePath, F as normalizeTelegramLookupTarget, I as parseTelegramTarget, M as isTelegramVoiceCompatibleAudio, P as normalizeTelegramChatId, j as saveCronStore, k as loadCronStore, t as isWSL2Sync, u as buildTelegramThreadParams } from "./wsl-PXrdWitE.js";
-import { E as mediaKindFromMime, d as chunkMarkdownIR, f as markdownToIR, n as loadWebMedia, x as isGifMedia } from "./media-Cxw-xLGU.js";
-import { n as resolveMarkdownTableMode } from "./markdown-tables-CCSD52rA.js";
-import { t as resolveFetch } from "./fetch-D70syO9t.js";
-import { n as normalizePollInput } from "./polls-D0YNJBfc.js";
-import { t as renderMarkdownWithMarkers } from "./render-C9LkRUhd.js";
-import { n as recordChannelActivity } from "./channel-activity-Cf5sKkfd.js";
-import { n as createTelegramRetryRunner } from "./retry-policy-sM01QZT2.js";
-import { t as makeProxyFetch } from "./proxy-CKQOQYAl.js";
-import process$1 from "node:process";
-import { Agent, setGlobalDispatcher } from "undici";
-import * as dns from "node:dns";
-import * as net$1 from "node:net";
-import { Bot, HttpError, InputFile } from "grammy";
-
-//#region src/infra/diagnostic-flags.ts
-const DIAGNOSTICS_ENV = "FASED_DIAGNOSTICS";
-function normalizeFlag(value) {
-	return value.trim().toLowerCase();
-}
-function parseEnvFlags(raw) {
-	if (!raw) return [];
-	const trimmed = raw.trim();
-	if (!trimmed) return [];
-	const lowered = trimmed.toLowerCase();
-	if ([
-		"0",
-		"false",
-		"off",
-		"none"
-	].includes(lowered)) return [];
-	if ([
-		"1",
-		"true",
-		"all",
-		"*"
-	].includes(lowered)) return ["*"];
-	return trimmed.split(/[,\s]+/).map(normalizeFlag).filter(Boolean);
-}
-function uniqueFlags(flags) {
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const flag of flags) {
-		const normalized = normalizeFlag(flag);
-		if (!normalized || seen.has(normalized)) continue;
-		seen.add(normalized);
-		out.push(normalized);
-	}
-	return out;
-}
-function resolveDiagnosticFlags(cfg, env = process.env) {
-	const configFlags = Array.isArray(cfg?.diagnostics?.flags) ? cfg?.diagnostics?.flags : [];
-	const envFlags = parseEnvFlags(env[DIAGNOSTICS_ENV]);
-	return uniqueFlags([...configFlags, ...envFlags]);
-}
-function matchesDiagnosticFlag(flag, enabledFlags) {
-	const target = normalizeFlag(flag);
-	if (!target) return false;
-	for (const raw of enabledFlags) {
-		const enabled = normalizeFlag(raw);
-		if (!enabled) continue;
-		if (enabled === "*" || enabled === "all") return true;
-		if (enabled.endsWith(".*")) {
-			const prefix = enabled.slice(0, -2);
-			if (target === prefix || target.startsWith(`${prefix}.`)) return true;
-		}
-		if (enabled.endsWith("*")) {
-			const prefix = enabled.slice(0, -1);
-			if (target.startsWith(prefix)) return true;
-		}
-		if (enabled === target) return true;
-	}
-	return false;
-}
-function isDiagnosticFlagEnabled(flag, cfg, env = process.env) {
-	return matchesDiagnosticFlag(flag, resolveDiagnosticFlags(cfg, env));
-}
-
-//#endregion
-//#region src/telegram/api-logging.ts
-const fallbackLogger = createSubsystemLogger("telegram/api");
-function resolveTelegramApiLogger(runtime, logger) {
-	if (logger) return logger;
-	if (runtime?.error) return runtime.error;
-	return (message) => fallbackLogger.error(message);
-}
-async function withTelegramApiErrorLogging({ operation, fn, runtime, logger, shouldLog }) {
-	try {
-		return await fn();
-	} catch (err) {
-		if (!shouldLog || shouldLog(err)) {
-			const errText = formatErrorMessage(err);
-			resolveTelegramApiLogger(runtime, logger)(danger(`telegram ${operation} failed: ${errText}`));
-		}
-		throw err;
-	}
-}
-
-//#endregion
-//#region src/telegram/caption.ts
-const TELEGRAM_MAX_CAPTION_LENGTH = 1024;
-function splitTelegramCaption(text) {
-	const trimmed = text?.trim() ?? "";
-	if (!trimmed) return {
-		caption: void 0,
-		followUpText: void 0
-	};
-	if (trimmed.length > TELEGRAM_MAX_CAPTION_LENGTH) return {
-		caption: void 0,
-		followUpText: trimmed
-	};
-	return {
-		caption: trimmed,
-		followUpText: void 0
-	};
-}
-
-//#endregion
-//#region src/telegram/network-config.ts
-const TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV = "FASED_TELEGRAM_DISABLE_AUTO_SELECT_FAMILY";
-const TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV = "FASED_TELEGRAM_ENABLE_AUTO_SELECT_FAMILY";
-const TELEGRAM_DNS_RESULT_ORDER_ENV = "FASED_TELEGRAM_DNS_RESULT_ORDER";
-let wsl2SyncCache;
-function isWSL2SyncCached() {
-	if (typeof wsl2SyncCache === "boolean") return wsl2SyncCache;
-	wsl2SyncCache = isWSL2Sync();
-	return wsl2SyncCache;
-}
-function resolveTelegramAutoSelectFamilyDecision(params) {
-	const env = params?.env ?? process$1.env;
-	const nodeMajor = typeof params?.nodeMajor === "number" ? params.nodeMajor : Number(process$1.versions.node.split(".")[0]);
-	if (isTruthyEnvValue(env[TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV])) return {
-		value: true,
-		source: `env:${TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV}`
-	};
-	if (isTruthyEnvValue(env[TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV])) return {
-		value: false,
-		source: `env:${TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV}`
-	};
-	if (typeof params?.network?.autoSelectFamily === "boolean") return {
-		value: params.network.autoSelectFamily,
-		source: "config"
-	};
-	if (isWSL2SyncCached()) return {
-		value: false,
-		source: "default-wsl2"
-	};
-	if (Number.isFinite(nodeMajor) && nodeMajor >= 22) return {
-		value: true,
-		source: "default-node22"
-	};
-	return { value: null };
-}
-/**
-* Resolve DNS result order setting for Telegram network requests.
-* Some networks/ISPs have issues with IPv6 causing fetch failures.
-* Setting "ipv4first" prioritizes IPv4 addresses in DNS resolution.
-*
-* Priority:
-* 1. Environment variable FASED_TELEGRAM_DNS_RESULT_ORDER
-* 2. Config: channels.telegram.network.dnsResultOrder
-* 3. Default: "ipv4first" on Node 22+ (to work around common IPv6 issues)
-*/
-function resolveTelegramDnsResultOrderDecision(params) {
-	const env = params?.env ?? process$1.env;
-	const nodeMajor = typeof params?.nodeMajor === "number" ? params.nodeMajor : Number(process$1.versions.node.split(".")[0]);
-	const envValue = env[TELEGRAM_DNS_RESULT_ORDER_ENV]?.trim().toLowerCase();
-	if (envValue === "ipv4first" || envValue === "verbatim") return {
-		value: envValue,
-		source: `env:${TELEGRAM_DNS_RESULT_ORDER_ENV}`
-	};
-	const configValue = (params?.network)?.dnsResultOrder?.trim().toLowerCase();
-	if (configValue === "ipv4first" || configValue === "verbatim") return {
-		value: configValue,
-		source: "config"
-	};
-	if (Number.isFinite(nodeMajor) && nodeMajor >= 22) return {
-		value: "ipv4first",
-		source: "default-node22"
-	};
-	return { value: null };
-}
-
-//#endregion
-//#region src/telegram/fetch.ts
-let appliedAutoSelectFamily = null;
-let appliedDnsResultOrder = null;
-let appliedGlobalDispatcherAutoSelectFamily = null;
-const log = createSubsystemLogger("telegram/network");
-function applyTelegramNetworkWorkarounds(network) {
-	const autoSelectDecision = resolveTelegramAutoSelectFamilyDecision({ network });
-	if (autoSelectDecision.value !== null && autoSelectDecision.value !== appliedAutoSelectFamily) {
-		if (typeof net$1.setDefaultAutoSelectFamily === "function") try {
-			net$1.setDefaultAutoSelectFamily(autoSelectDecision.value);
-			appliedAutoSelectFamily = autoSelectDecision.value;
-			const label = autoSelectDecision.source ? ` (${autoSelectDecision.source})` : "";
-			log.info(`autoSelectFamily=${autoSelectDecision.value}${label}`);
-		} catch {}
-	}
-	if (autoSelectDecision.value !== null && autoSelectDecision.value !== appliedGlobalDispatcherAutoSelectFamily) try {
-		setGlobalDispatcher(new Agent({ connect: {
-			autoSelectFamily: autoSelectDecision.value,
-			autoSelectFamilyAttemptTimeout: 300
-		} }));
-		appliedGlobalDispatcherAutoSelectFamily = autoSelectDecision.value;
-		log.info(`global undici dispatcher autoSelectFamily=${autoSelectDecision.value}`);
-	} catch {}
-	const dnsDecision = resolveTelegramDnsResultOrderDecision({ network });
-	if (dnsDecision.value !== null && dnsDecision.value !== appliedDnsResultOrder) {
-		if (typeof dns.setDefaultResultOrder === "function") try {
-			dns.setDefaultResultOrder(dnsDecision.value);
-			appliedDnsResultOrder = dnsDecision.value;
-			const label = dnsDecision.source ? ` (${dnsDecision.source})` : "";
-			log.info(`dnsResultOrder=${dnsDecision.value}${label}`);
-		} catch {}
-	}
-}
-function resolveTelegramFetch(proxyFetch, options) {
-	applyTelegramNetworkWorkarounds(options?.network);
-	if (proxyFetch) return resolveFetch(proxyFetch);
-	const fetchImpl = resolveFetch();
-	if (!fetchImpl) throw new Error("fetch is not available; set channels.telegram.proxy in config");
-	return fetchImpl;
-}
-
-//#endregion
-//#region src/telegram/format.ts
-function escapeHtml(text) {
-	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeHtmlAttr(text) {
-	return escapeHtml(text).replace(/"/g, "&quot;");
-}
-/**
-* File extensions that share TLDs and commonly appear in code/documentation.
-* These are wrapped in <code> tags to prevent Telegram from generating
-* spurious domain registrar previews.
-*
-* Only includes extensions that are:
-* 1. Commonly used as file extensions in code/docs
-* 2. Rarely used as intentional domain references
-*
-* Excluded: .ai, .io, .tv, .fm (popular domain TLDs like x.ai, vercel.io, github.io)
-*/
-const FILE_EXTENSIONS_WITH_TLD = new Set([
-	"md",
-	"go",
-	"py",
-	"pl",
-	"sh",
-	"am",
-	"at",
-	"be",
-	"cc"
-]);
-/** Detects when markdown-it linkify auto-generated a link from a bare filename (e.g. README.md → http://README.md) */
-function isAutoLinkedFileRef(href, label) {
-	if (href.replace(/^https?:\/\//i, "") !== label) return false;
-	const dotIndex = label.lastIndexOf(".");
-	if (dotIndex < 1) return false;
-	const ext = label.slice(dotIndex + 1).toLowerCase();
-	if (!FILE_EXTENSIONS_WITH_TLD.has(ext)) return false;
-	const segments = label.split("/");
-	if (segments.length > 1) {
-		for (let i = 0; i < segments.length - 1; i++) if (segments[i].includes(".")) return false;
-	}
-	return true;
-}
-function buildTelegramLink(link, text) {
-	const href = link.href.trim();
-	if (!href) return null;
-	if (link.start === link.end) return null;
-	if (isAutoLinkedFileRef(href, text.slice(link.start, link.end))) return null;
-	const safeHref = escapeHtmlAttr(href);
-	return {
-		start: link.start,
-		end: link.end,
-		open: `<a href="${safeHref}">`,
-		close: "</a>"
-	};
-}
-function renderTelegramHtml(ir) {
-	return renderMarkdownWithMarkers(ir, {
-		styleMarkers: {
-			bold: {
-				open: "<b>",
-				close: "</b>"
-			},
-			italic: {
-				open: "<i>",
-				close: "</i>"
-			},
-			strikethrough: {
-				open: "<s>",
-				close: "</s>"
-			},
-			code: {
-				open: "<code>",
-				close: "</code>"
-			},
-			code_block: {
-				open: "<pre><code>",
-				close: "</code></pre>"
-			},
-			spoiler: {
-				open: "<tg-spoiler>",
-				close: "</tg-spoiler>"
-			},
-			blockquote: {
-				open: "<blockquote>",
-				close: "</blockquote>"
-			}
-		},
-		escapeText: escapeHtml,
-		buildLink: buildTelegramLink
-	});
-}
-function markdownToTelegramHtml(markdown, options = {}) {
-	const html = renderTelegramHtml(markdownToIR(markdown ?? "", {
-		linkify: true,
-		enableSpoilers: true,
-		headingStyle: "none",
-		blockquotePrefix: "",
-		tableMode: options.tableMode
-	}));
-	if (options.wrapFileRefs !== false) return wrapFileReferencesInHtml(html);
-	return html;
-}
-/**
-* Wraps standalone file references (with TLD extensions) in <code> tags.
-* This prevents Telegram from treating them as URLs and generating
-* irrelevant domain registrar previews.
-*
-* Runs AFTER markdown→HTML conversion to avoid modifying HTML attributes.
-* Skips content inside <code>, <pre>, and <a> tags to avoid nesting issues.
-*/
-/** Escape regex metacharacters in a string */
-function escapeRegex(str) {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-const FILE_EXTENSIONS_PATTERN = Array.from(FILE_EXTENSIONS_WITH_TLD).map(escapeRegex).join("|");
-const AUTO_LINKED_ANCHOR_PATTERN = /<a\s+href="https?:\/\/([^"]+)"[^>]*>\1<\/a>/gi;
-const FILE_REFERENCE_PATTERN = new RegExp(`(^|[^a-zA-Z0-9_\\-/])([a-zA-Z0-9_.\\-./]+\\.(?:${FILE_EXTENSIONS_PATTERN}))(?=$|[^a-zA-Z0-9_\\-/])`, "gi");
-const ORPHANED_TLD_PATTERN = new RegExp(`([^a-zA-Z0-9]|^)([A-Za-z]\\.(?:${FILE_EXTENSIONS_PATTERN}))(?=[^a-zA-Z0-9/]|$)`, "g");
-const HTML_TAG_PATTERN = /(<\/?)([a-zA-Z][a-zA-Z0-9-]*)\b[^>]*?>/gi;
-function wrapStandaloneFileRef(match, prefix, filename) {
-	if (filename.startsWith("//")) return match;
-	if (/https?:\/\/$/i.test(prefix)) return match;
-	return `${prefix}<code>${escapeHtml(filename)}</code>`;
-}
-function wrapSegmentFileRefs(text, codeDepth, preDepth, anchorDepth) {
-	if (!text || codeDepth > 0 || preDepth > 0 || anchorDepth > 0) return text;
-	return text.replace(FILE_REFERENCE_PATTERN, wrapStandaloneFileRef).replace(ORPHANED_TLD_PATTERN, (match, prefix, tld) => prefix === ">" ? match : `${prefix}<code>${escapeHtml(tld)}</code>`);
-}
-function wrapFileReferencesInHtml(html) {
-	AUTO_LINKED_ANCHOR_PATTERN.lastIndex = 0;
-	const deLinkified = html.replace(AUTO_LINKED_ANCHOR_PATTERN, (_match, label) => {
-		if (!isAutoLinkedFileRef(`http://${label}`, label)) return _match;
-		return `<code>${escapeHtml(label)}</code>`;
-	});
-	let codeDepth = 0;
-	let preDepth = 0;
-	let anchorDepth = 0;
-	let result = "";
-	let lastIndex = 0;
-	HTML_TAG_PATTERN.lastIndex = 0;
-	let match;
-	while ((match = HTML_TAG_PATTERN.exec(deLinkified)) !== null) {
-		const tagStart = match.index;
-		const tagEnd = HTML_TAG_PATTERN.lastIndex;
-		const isClosing = match[1] === "</";
-		const tagName = match[2].toLowerCase();
-		const textBefore = deLinkified.slice(lastIndex, tagStart);
-		result += wrapSegmentFileRefs(textBefore, codeDepth, preDepth, anchorDepth);
-		if (tagName === "code") codeDepth = isClosing ? Math.max(0, codeDepth - 1) : codeDepth + 1;
-		else if (tagName === "pre") preDepth = isClosing ? Math.max(0, preDepth - 1) : preDepth + 1;
-		else if (tagName === "a") anchorDepth = isClosing ? Math.max(0, anchorDepth - 1) : anchorDepth + 1;
-		result += deLinkified.slice(tagStart, tagEnd);
-		lastIndex = tagEnd;
-	}
-	const remainingText = deLinkified.slice(lastIndex);
-	result += wrapSegmentFileRefs(remainingText, codeDepth, preDepth, anchorDepth);
-	return result;
-}
-function renderTelegramHtmlText(text, options = {}) {
-	if ((options.textMode ?? "markdown") === "html") return text;
-	return markdownToTelegramHtml(text, { tableMode: options.tableMode });
-}
-function markdownToTelegramChunks(markdown, limit, options = {}) {
-	return chunkMarkdownIR(markdownToIR(markdown ?? "", {
-		linkify: true,
-		enableSpoilers: true,
-		headingStyle: "none",
-		blockquotePrefix: "",
-		tableMode: options.tableMode
-	}), limit).map((chunk) => ({
-		html: wrapFileReferencesInHtml(renderTelegramHtml(chunk)),
-		text: chunk.text
-	}));
-}
-
-//#endregion
-//#region src/telegram/network-errors.ts
-const RECOVERABLE_ERROR_CODES = new Set([
-	"ECONNRESET",
-	"ECONNREFUSED",
-	"EPIPE",
-	"ETIMEDOUT",
-	"ESOCKETTIMEDOUT",
-	"ENETUNREACH",
-	"EHOSTUNREACH",
-	"ENOTFOUND",
-	"EAI_AGAIN",
-	"UND_ERR_CONNECT_TIMEOUT",
-	"UND_ERR_HEADERS_TIMEOUT",
-	"UND_ERR_BODY_TIMEOUT",
-	"UND_ERR_SOCKET",
-	"UND_ERR_ABORTED",
-	"ECONNABORTED",
-	"ERR_NETWORK"
-]);
-const RECOVERABLE_ERROR_NAMES = new Set([
-	"AbortError",
-	"TimeoutError",
-	"ConnectTimeoutError",
-	"HeadersTimeoutError",
-	"BodyTimeoutError"
-]);
-const ALWAYS_RECOVERABLE_MESSAGES = new Set(["fetch failed", "typeerror: fetch failed"]);
-const RECOVERABLE_MESSAGE_SNIPPETS = [
-	"undici",
-	"network error",
-	"network request",
-	"client network socket disconnected",
-	"socket hang up",
-	"getaddrinfo",
-	"timeout",
-	"timed out"
-];
-function normalizeCode(code) {
-	return code?.trim().toUpperCase() ?? "";
-}
-function getErrorName(err) {
-	if (!err || typeof err !== "object") return "";
-	return "name" in err ? String(err.name) : "";
-}
-function getErrorCode(err) {
-	const direct = extractErrorCode(err);
-	if (direct) return direct;
-	if (!err || typeof err !== "object") return;
-	const errno = err.errno;
-	if (typeof errno === "string") return errno;
-	if (typeof errno === "number") return String(errno);
-}
-function collectErrorCandidates(err) {
-	const queue = [err];
-	const seen = /* @__PURE__ */ new Set();
-	const candidates = [];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current == null || seen.has(current)) continue;
-		seen.add(current);
-		candidates.push(current);
-		if (typeof current === "object") {
-			const cause = current.cause;
-			if (cause && !seen.has(cause)) queue.push(cause);
-			const reason = current.reason;
-			if (reason && !seen.has(reason)) queue.push(reason);
-			const errors = current.errors;
-			if (Array.isArray(errors)) {
-				for (const nested of errors) if (nested && !seen.has(nested)) queue.push(nested);
-			}
-			if (getErrorName(current) === "HttpError") {
-				const wrappedError = current.error;
-				if (wrappedError && !seen.has(wrappedError)) queue.push(wrappedError);
-			}
-		}
-	}
-	return candidates;
-}
-function isRecoverableTelegramNetworkError(err, options = {}) {
-	if (!err) return false;
-	const allowMessageMatch = typeof options.allowMessageMatch === "boolean" ? options.allowMessageMatch : options.context !== "send";
-	for (const candidate of collectErrorCandidates(err)) {
-		const code = normalizeCode(getErrorCode(candidate));
-		if (code && RECOVERABLE_ERROR_CODES.has(code)) return true;
-		const name = getErrorName(candidate);
-		if (name && RECOVERABLE_ERROR_NAMES.has(name)) return true;
-		const message = formatErrorMessage(candidate).trim().toLowerCase();
-		if (message && ALWAYS_RECOVERABLE_MESSAGES.has(message)) return true;
-		if (allowMessageMatch && message) {
-			if (RECOVERABLE_MESSAGE_SNIPPETS.some((snippet) => message.includes(snippet))) return true;
-		}
-	}
-	return false;
-}
-
-//#endregion
-//#region src/telegram/sent-message-cache.ts
-/**
-* In-memory cache of sent message IDs per chat.
-* Used to identify bot's own messages for reaction filtering ("own" mode).
-*/
-const TTL_MS = 1440 * 60 * 1e3;
-const sentMessages = /* @__PURE__ */ new Map();
-function getChatKey(chatId) {
-	return String(chatId);
-}
-function cleanupExpired(entry) {
-	const now = Date.now();
-	for (const [msgId, timestamp] of entry.timestamps) if (now - timestamp > TTL_MS) entry.timestamps.delete(msgId);
-}
-/**
-* Record a message ID as sent by the bot.
-*/
-function recordSentMessage(chatId, messageId) {
-	const key = getChatKey(chatId);
-	let entry = sentMessages.get(key);
-	if (!entry) {
-		entry = { timestamps: /* @__PURE__ */ new Map() };
-		sentMessages.set(key, entry);
-	}
-	entry.timestamps.set(messageId, Date.now());
-	if (entry.timestamps.size > 100) cleanupExpired(entry);
-}
-/**
-* Check if a message was sent by the bot.
-*/
-function wasSentByBot(chatId, messageId) {
-	const key = getChatKey(chatId);
-	const entry = sentMessages.get(key);
-	if (!entry) return false;
-	cleanupExpired(entry);
-	return entry.timestamps.has(messageId);
-}
-
-//#endregion
-//#region src/telegram/target-writeback.ts
-const writebackLogger = createSubsystemLogger("telegram/target-writeback");
-function asObjectRecord(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	return value;
-}
-function normalizeTelegramLookupTargetForMatch(raw) {
-	const normalized = normalizeTelegramLookupTarget(raw);
-	if (!normalized) return;
-	return normalized.startsWith("@") ? normalized.toLowerCase() : normalized;
-}
-function normalizeTelegramTargetForMatch(raw) {
-	const parsed = parseTelegramTarget(raw);
-	const normalized = normalizeTelegramLookupTargetForMatch(parsed.chatId);
-	if (!normalized) return;
-	return `${normalized}|${parsed.messageThreadId == null ? "" : String(parsed.messageThreadId)}`;
-}
-function buildResolvedTelegramTarget(params) {
-	const { raw, parsed, resolvedChatId } = params;
-	if (parsed.messageThreadId == null) return resolvedChatId;
-	return raw.includes(":topic:") ? `${resolvedChatId}:topic:${parsed.messageThreadId}` : `${resolvedChatId}:${parsed.messageThreadId}`;
-}
-function resolveLegacyRewrite(params) {
-	const parsed = parseTelegramTarget(params.raw);
-	if (normalizeTelegramChatId(parsed.chatId)) return null;
-	const normalized = normalizeTelegramLookupTargetForMatch(parsed.chatId);
-	if (!normalized) return null;
-	return {
-		matchKey: `${normalized}|${parsed.messageThreadId == null ? "" : String(parsed.messageThreadId)}`,
-		resolvedTarget: buildResolvedTelegramTarget({
-			raw: params.raw,
-			parsed,
-			resolvedChatId: params.resolvedChatId
-		})
-	};
-}
-function rewriteTargetIfMatch(params) {
-	if (typeof params.rawValue !== "string" && typeof params.rawValue !== "number") return null;
-	const value = String(params.rawValue).trim();
-	if (!value) return null;
-	if (normalizeTelegramTargetForMatch(value) !== params.matchKey) return null;
-	return params.resolvedTarget;
-}
-function replaceTelegramDefaultToTargets(params) {
-	let changed = false;
-	const telegram = asObjectRecord(params.cfg.channels?.telegram);
-	if (!telegram) return changed;
-	const maybeReplace = (holder, key) => {
-		const nextTarget = rewriteTargetIfMatch({
-			rawValue: holder[key],
-			matchKey: params.matchKey,
-			resolvedTarget: params.resolvedTarget
-		});
-		if (!nextTarget) return;
-		holder[key] = nextTarget;
-		changed = true;
-	};
-	maybeReplace(telegram, "defaultTo");
-	const accounts = asObjectRecord(telegram.accounts);
-	if (!accounts) return changed;
-	for (const accountId of Object.keys(accounts)) {
-		const account = asObjectRecord(accounts[accountId]);
-		if (!account) continue;
-		maybeReplace(account, "defaultTo");
-	}
-	return changed;
-}
-async function maybePersistResolvedTelegramTarget(params) {
-	const raw = params.rawTarget.trim();
-	if (!raw) return;
-	const rewrite = resolveLegacyRewrite({
-		raw,
-		resolvedChatId: params.resolvedChatId
-	});
-	if (!rewrite) return;
-	const { matchKey, resolvedTarget } = rewrite;
-	try {
-		const { snapshot, writeOptions } = await readConfigFileSnapshotForWrite();
-		const nextConfig = structuredClone(snapshot.config ?? {});
-		if (replaceTelegramDefaultToTargets({
-			cfg: nextConfig,
-			matchKey,
-			resolvedTarget
-		})) {
-			await writeConfigFile(nextConfig, writeOptions);
-			if (params.verbose) writebackLogger.warn(`resolved Telegram defaultTo target ${raw} -> ${resolvedTarget}`);
-		}
-	} catch (err) {
-		if (params.verbose) writebackLogger.warn(`failed to persist Telegram defaultTo target ${raw}: ${String(err)}`);
-	}
-	try {
-		const storePath = resolveCronStorePath(params.cfg.cron?.store);
-		const store = await loadCronStore(storePath);
-		let cronChanged = false;
-		for (const job of store.jobs) {
-			if (job.delivery?.channel !== "telegram") continue;
-			const nextTarget = rewriteTargetIfMatch({
-				rawValue: job.delivery.to,
-				matchKey,
-				resolvedTarget
-			});
-			if (!nextTarget) continue;
-			job.delivery.to = nextTarget;
-			cronChanged = true;
-		}
-		if (cronChanged) {
-			await saveCronStore(storePath, store);
-			if (params.verbose) writebackLogger.warn(`resolved Telegram cron delivery target ${raw} -> ${resolvedTarget}`);
-		}
-	} catch (err) {
-		if (params.verbose) writebackLogger.warn(`failed to persist Telegram cron target ${raw}: ${String(err)}`);
-	}
-}
-
-//#endregion
-//#region src/telegram/voice.ts
-function resolveTelegramVoiceDecision(opts) {
-	if (!opts.wantsVoice) return { useVoice: false };
-	if (isTelegramVoiceCompatibleAudio(opts)) return { useVoice: true };
-	return {
-		useVoice: false,
-		reason: `media is ${opts.contentType ?? "unknown"} (${opts.fileName ?? "unknown"})`
-	};
-}
-function resolveTelegramVoiceSend(opts) {
-	const decision = resolveTelegramVoiceDecision(opts);
-	if (decision.reason && opts.logFallback) opts.logFallback(`Telegram voice requested but ${decision.reason}; sending as audio file instead.`);
-	return { useVoice: decision.useVoice };
-}
-
-//#endregion
-//#region src/telegram/send.ts
-var send_exports = /* @__PURE__ */ __exportAll({
-	buildInlineKeyboard: () => buildInlineKeyboard,
-	createForumTopicTelegram: () => createForumTopicTelegram,
-	deleteMessageTelegram: () => deleteMessageTelegram,
-	editMessageTelegram: () => editMessageTelegram,
-	reactMessageTelegram: () => reactMessageTelegram,
-	sendMessageTelegram: () => sendMessageTelegram,
-	sendPollTelegram: () => sendPollTelegram,
-	sendStickerTelegram: () => sendStickerTelegram
-});
-function resolveTelegramMessageIdOrThrow(result, context) {
-	if (typeof result?.message_id === "number" && Number.isFinite(result.message_id)) return Math.trunc(result.message_id);
-	throw new Error(`Telegram ${context} returned no message_id`);
-}
-const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
-const THREAD_NOT_FOUND_RE = /400:\s*Bad Request:\s*message thread not found/i;
-const MESSAGE_NOT_MODIFIED_RE = /400:\s*Bad Request:\s*message is not modified|MESSAGE_NOT_MODIFIED/i;
-const CHAT_NOT_FOUND_RE = /400: Bad Request: chat not found/i;
-const sendLogger = createSubsystemLogger("telegram/send");
-const diagLogger = createSubsystemLogger("telegram/diagnostic");
-function createTelegramHttpLogger(cfg) {
-	if (!isDiagnosticFlagEnabled("telegram.http", cfg)) return () => {};
-	return (label, err) => {
-		if (!(err instanceof HttpError)) return;
-		const detail = redactSensitiveText(formatUncaughtError(err.error ?? err));
-		diagLogger.warn(`telegram http error (${label}): ${detail}`);
-	};
-}
-function resolveTelegramClientOptions(account) {
-	const proxyUrl = account.config.proxy?.trim();
-	const fetchImpl = resolveTelegramFetch(proxyUrl ? makeProxyFetch(proxyUrl) : void 0, { network: account.config.network });
-	const timeoutSeconds = typeof account.config.timeoutSeconds === "number" && Number.isFinite(account.config.timeoutSeconds) ? Math.max(1, Math.floor(account.config.timeoutSeconds)) : void 0;
-	return fetchImpl || timeoutSeconds ? {
-		...fetchImpl ? { fetch: fetchImpl } : {},
-		...timeoutSeconds ? { timeoutSeconds } : {}
-	} : void 0;
-}
-function resolveToken(explicit, params) {
-	if (explicit?.trim()) return explicit.trim();
-	if (!params.token) throw new Error(`Telegram bot token missing for account "${params.accountId}" (set channels.telegram.accounts.${params.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
-	return params.token.trim();
-}
-async function resolveChatId(to, params) {
-	const numericChatId = normalizeTelegramChatId(to);
-	if (numericChatId) return numericChatId;
-	const lookupTarget = normalizeTelegramLookupTarget(to);
-	const getChat = params.api.getChat;
-	if (!lookupTarget || typeof getChat !== "function") throw new Error("Telegram recipient must be a numeric chat ID");
-	try {
-		const chat = await getChat.call(params.api, lookupTarget);
-		const resolved = normalizeTelegramChatId(String(chat?.id ?? ""));
-		if (!resolved) throw new Error(`resolved chat id is not numeric (${String(chat?.id ?? "")})`);
-		if (params.verbose) sendLogger.warn(`telegram recipient ${lookupTarget} resolved to numeric chat id ${resolved}`);
-		return resolved;
-	} catch (err) {
-		const detail = formatErrorMessage(err);
-		throw new Error(`Telegram recipient ${lookupTarget} could not be resolved to a numeric chat ID (${detail})`, { cause: err });
-	}
-}
-async function resolveAndPersistChatId(params) {
-	const chatId = await resolveChatId(params.lookupTarget, {
-		api: params.api,
-		verbose: params.verbose
-	});
-	await maybePersistResolvedTelegramTarget({
-		cfg: params.cfg,
-		rawTarget: params.persistTarget,
-		resolvedChatId: chatId,
-		verbose: params.verbose
-	});
-	return chatId;
-}
-function normalizeMessageId(raw) {
-	if (typeof raw === "number" && Number.isFinite(raw)) return Math.trunc(raw);
-	if (typeof raw === "string") {
-		const value = raw.trim();
-		if (!value) throw new Error("Message id is required for Telegram actions");
-		const parsed = Number.parseInt(value, 10);
-		if (Number.isFinite(parsed)) return parsed;
-	}
-	throw new Error("Message id is required for Telegram actions");
-}
-function isTelegramThreadNotFoundError(err) {
-	return THREAD_NOT_FOUND_RE.test(formatErrorMessage(err));
-}
-function isTelegramMessageNotModifiedError(err) {
-	return MESSAGE_NOT_MODIFIED_RE.test(formatErrorMessage(err));
-}
-function hasMessageThreadIdParam(params) {
-	if (!params) return false;
-	const value = params.message_thread_id;
-	if (typeof value === "number") return Number.isFinite(value);
-	if (typeof value === "string") return value.trim().length > 0;
-	return false;
-}
-function removeMessageThreadIdParam(params) {
-	if (!params || !hasMessageThreadIdParam(params)) return params;
-	const next = { ...params };
-	delete next.message_thread_id;
-	return Object.keys(next).length > 0 ? next : void 0;
-}
-function isTelegramHtmlParseError(err) {
-	return PARSE_ERR_RE.test(formatErrorMessage(err));
-}
-function buildTelegramThreadReplyParams(params) {
-	const messageThreadId = params.messageThreadId != null ? params.messageThreadId : params.targetMessageThreadId;
-	const threadScope = params.chatType === "direct" ? "dm" : "forum";
-	const threadIdParams = buildTelegramThreadParams(messageThreadId != null ? {
-		id: messageThreadId,
-		scope: threadScope
-	} : void 0);
-	const threadParams = threadIdParams ? { ...threadIdParams } : {};
-	if (params.replyToMessageId != null) {
-		const replyToMessageId = Math.trunc(params.replyToMessageId);
-		if (params.quoteText?.trim()) threadParams.reply_parameters = {
-			message_id: replyToMessageId,
-			quote: params.quoteText.trim()
-		};
-		else threadParams.reply_to_message_id = replyToMessageId;
-	}
-	return threadParams;
-}
-async function withTelegramHtmlParseFallback(params) {
-	try {
-		return await params.requestHtml(params.label);
-	} catch (err) {
-		if (!isTelegramHtmlParseError(err)) throw err;
-		if (params.verbose) sendLogger.warn(`telegram ${params.label} failed with HTML parse error, retrying as plain text: ${formatErrorMessage(err)}`);
-		return await params.requestPlain(`${params.label}-plain`);
-	}
-}
-function resolveTelegramApiContext(opts) {
-	const cfg = opts.cfg ?? loadConfig();
-	const account = resolveTelegramAccount({
-		cfg,
-		accountId: opts.accountId
-	});
-	const token = resolveToken(opts.token, account);
-	const client = resolveTelegramClientOptions(account);
-	return {
-		cfg,
-		account,
-		api: opts.api ?? new Bot(token, client ? { client } : void 0).api
-	};
-}
-function createTelegramRequestWithDiag(params) {
-	const request = createTelegramRetryRunner({
-		retry: params.retry,
-		configRetry: params.account.config.retry,
-		verbose: params.verbose,
-		...params.shouldRetry ? { shouldRetry: params.shouldRetry } : {}
-	});
-	const logHttpError = createTelegramHttpLogger(params.cfg);
-	return (fn, label, options) => {
-		const runRequest = () => request(fn, label);
-		return (params.useApiErrorLogging === false ? runRequest() : withTelegramApiErrorLogging({
-			operation: label ?? "request",
-			fn: runRequest,
-			...options?.shouldLog ? { shouldLog: options.shouldLog } : {}
-		})).catch((err) => {
-			logHttpError(label ?? "request", err);
-			throw err;
-		});
-	};
-}
-function wrapTelegramChatNotFoundError(err, params) {
-	if (!CHAT_NOT_FOUND_RE.test(formatErrorMessage(err))) return err;
-	return new Error([
-		`Telegram send failed: chat not found (chat_id=${params.chatId}).`,
-		"Likely: bot not started in DM, bot removed from group/channel, group migrated (new -100… id), or wrong bot token.",
-		`Input was: ${JSON.stringify(params.input)}.`
-	].join(" "));
-}
-async function withTelegramThreadFallback(params, label, verbose, attempt) {
-	try {
-		return await attempt(params, label);
-	} catch (err) {
-		if (!hasMessageThreadIdParam(params) || !isTelegramThreadNotFoundError(err)) throw err;
-		if (verbose) sendLogger.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
-		return await attempt(removeMessageThreadIdParam(params), `${label}-threadless`);
-	}
-}
-function createRequestWithChatNotFound(params) {
-	return async (fn, label) => params.requestWithDiag(fn, label).catch((err) => {
-		throw wrapTelegramChatNotFoundError(err, {
-			chatId: params.chatId,
-			input: params.input
-		});
-	});
-}
-function buildInlineKeyboard(buttons) {
-	if (!buttons?.length) return;
-	const rows = buttons.map((row) => row.filter((button) => button?.text && button?.callback_data).map((button) => ({
-		text: button.text,
-		callback_data: button.callback_data,
-		...button.style ? { style: button.style } : {}
-	}))).filter((row) => row.length > 0);
-	if (rows.length === 0) return;
-	return { inline_keyboard: rows };
-}
-async function sendMessageTelegram(to, text, opts = {}) {
-	const { cfg, account, api } = resolveTelegramApiContext(opts);
-	const target = parseTelegramTarget(to);
-	const chatId = await resolveAndPersistChatId({
-		cfg,
-		api,
-		lookupTarget: target.chatId,
-		persistTarget: to,
-		verbose: opts.verbose
-	});
-	const mediaUrl = opts.mediaUrl?.trim();
-	const replyMarkup = buildInlineKeyboard(opts.buttons);
-	const threadParams = buildTelegramThreadReplyParams({
-		targetMessageThreadId: target.messageThreadId,
-		messageThreadId: opts.messageThreadId,
-		chatType: target.chatType,
-		replyToMessageId: opts.replyToMessageId,
-		quoteText: opts.quoteText
-	});
-	const hasThreadParams = Object.keys(threadParams).length > 0;
-	const requestWithChatNotFound = createRequestWithChatNotFound({
-		requestWithDiag: createTelegramRequestWithDiag({
-			cfg,
-			account,
-			retry: opts.retry,
-			verbose: opts.verbose,
-			shouldRetry: (err) => isRecoverableTelegramNetworkError(err, { context: "send" })
-		}),
-		chatId,
-		input: to
-	});
-	const textMode = opts.textMode ?? "markdown";
-	const tableMode = resolveMarkdownTableMode({
-		cfg,
-		channel: "telegram",
-		accountId: account.accountId
-	});
-	const renderHtmlText = (value) => renderTelegramHtmlText(value, {
-		textMode,
-		tableMode
-	});
-	const linkPreviewOptions = account.config.linkPreview ?? true ? void 0 : { is_disabled: true };
-	const sendTelegramText = async (rawText, params, fallbackText) => {
-		return await withTelegramThreadFallback(params, "message", opts.verbose, async (effectiveParams, label) => {
-			const htmlText = renderHtmlText(rawText);
-			const baseParams = effectiveParams ? { ...effectiveParams } : {};
-			if (linkPreviewOptions) baseParams.link_preview_options = linkPreviewOptions;
-			const hasBaseParams = Object.keys(baseParams).length > 0;
-			const sendParams = {
-				parse_mode: "HTML",
-				...baseParams,
-				...opts.silent === true ? { disable_notification: true } : {}
-			};
-			return await withTelegramHtmlParseFallback({
-				label,
-				verbose: opts.verbose,
-				requestHtml: (retryLabel) => requestWithChatNotFound(() => api.sendMessage(chatId, htmlText, sendParams), retryLabel),
-				requestPlain: (retryLabel) => {
-					const plainParams = hasBaseParams ? baseParams : void 0;
-					return requestWithChatNotFound(() => plainParams ? api.sendMessage(chatId, fallbackText ?? rawText, plainParams) : api.sendMessage(chatId, fallbackText ?? rawText), retryLabel);
-				}
-			});
-		});
-	};
-	if (mediaUrl) {
-		const media = await loadWebMedia(mediaUrl, {
-			maxBytes: opts.maxBytes,
-			localRoots: opts.mediaLocalRoots
-		});
-		const kind = mediaKindFromMime(media.contentType ?? void 0);
-		const isGif = isGifMedia({
-			contentType: media.contentType,
-			fileName: media.fileName
-		});
-		const isVideoNote = kind === "video" && opts.asVideoNote === true;
-		const fileName = media.fileName ?? (isGif ? "animation.gif" : inferFilename(kind)) ?? "file";
-		const file = new InputFile(media.buffer, fileName);
-		let caption;
-		let followUpText;
-		if (isVideoNote) {
-			caption = void 0;
-			followUpText = text.trim() ? text : void 0;
-		} else {
-			const split = splitTelegramCaption(text);
-			caption = split.caption;
-			followUpText = split.followUpText;
-		}
-		const htmlCaption = caption ? renderHtmlText(caption) : void 0;
-		const needsSeparateText = Boolean(followUpText);
-		const baseMediaParams = {
-			...hasThreadParams ? threadParams : {},
-			...!needsSeparateText && replyMarkup ? { reply_markup: replyMarkup } : {}
-		};
-		const mediaParams = {
-			...htmlCaption ? {
-				caption: htmlCaption,
-				parse_mode: "HTML"
-			} : {},
-			...baseMediaParams,
-			...opts.silent === true ? { disable_notification: true } : {}
-		};
-		const sendMedia = async (label, sender) => await withTelegramThreadFallback(mediaParams, label, opts.verbose, async (effectiveParams, retryLabel) => requestWithChatNotFound(() => sender(effectiveParams), retryLabel));
-		const mediaSender = (() => {
-			if (isGif) return {
-				label: "animation",
-				sender: (effectiveParams) => api.sendAnimation(chatId, file, effectiveParams)
-			};
-			if (kind === "image") return {
-				label: "photo",
-				sender: (effectiveParams) => api.sendPhoto(chatId, file, effectiveParams)
-			};
-			if (kind === "video") {
-				if (isVideoNote) return {
-					label: "video_note",
-					sender: (effectiveParams) => api.sendVideoNote(chatId, file, effectiveParams)
-				};
-				return {
-					label: "video",
-					sender: (effectiveParams) => api.sendVideo(chatId, file, effectiveParams)
-				};
-			}
-			if (kind === "audio") {
-				const { useVoice } = resolveTelegramVoiceSend({
-					wantsVoice: opts.asVoice === true,
-					contentType: media.contentType,
-					fileName,
-					logFallback: logVerbose
-				});
-				if (useVoice) return {
-					label: "voice",
-					sender: (effectiveParams) => api.sendVoice(chatId, file, effectiveParams)
-				};
-				return {
-					label: "audio",
-					sender: (effectiveParams) => api.sendAudio(chatId, file, effectiveParams)
-				};
-			}
-			return {
-				label: "document",
-				sender: (effectiveParams) => api.sendDocument(chatId, file, effectiveParams)
-			};
-		})();
-		const result = await sendMedia(mediaSender.label, mediaSender.sender);
-		const mediaMessageId = resolveTelegramMessageIdOrThrow(result, "media send");
-		const resolvedChatId = String(result?.chat?.id ?? chatId);
-		recordSentMessage(chatId, mediaMessageId);
-		recordChannelActivity({
-			channel: "telegram",
-			accountId: account.accountId,
-			direction: "outbound"
-		});
-		if (needsSeparateText && followUpText) {
-			const textParams = hasThreadParams || replyMarkup ? {
-				...threadParams,
-				...replyMarkup ? { reply_markup: replyMarkup } : {}
-			} : void 0;
-			const textMessageId = resolveTelegramMessageIdOrThrow(await sendTelegramText(followUpText, textParams), "text follow-up send");
-			recordSentMessage(chatId, textMessageId);
-			return {
-				messageId: String(textMessageId),
-				chatId: resolvedChatId
-			};
-		}
-		return {
-			messageId: String(mediaMessageId),
-			chatId: resolvedChatId
-		};
-	}
-	if (!text || !text.trim()) throw new Error("Message must be non-empty for Telegram sends");
-	const res = await sendTelegramText(text, hasThreadParams || replyMarkup ? {
-		...threadParams,
-		...replyMarkup ? { reply_markup: replyMarkup } : {}
-	} : void 0, opts.plainText);
-	const messageId = resolveTelegramMessageIdOrThrow(res, "text send");
-	recordSentMessage(chatId, messageId);
-	recordChannelActivity({
-		channel: "telegram",
-		accountId: account.accountId,
-		direction: "outbound"
-	});
-	return {
-		messageId: String(messageId),
-		chatId: String(res?.chat?.id ?? chatId)
-	};
-}
-async function reactMessageTelegram(chatIdInput, messageIdInput, emoji, opts = {}) {
-	const { cfg, account, api } = resolveTelegramApiContext(opts);
-	const rawTarget = String(chatIdInput);
-	const chatId = await resolveAndPersistChatId({
-		cfg,
-		api,
-		lookupTarget: rawTarget,
-		persistTarget: rawTarget,
-		verbose: opts.verbose
-	});
-	const messageId = normalizeMessageId(messageIdInput);
-	const requestWithDiag = createTelegramRequestWithDiag({
-		cfg,
-		account,
-		retry: opts.retry,
-		verbose: opts.verbose,
-		shouldRetry: (err) => isRecoverableTelegramNetworkError(err, { context: "send" })
-	});
-	const remove = opts.remove === true;
-	const trimmedEmoji = emoji.trim();
-	const reactions = remove || !trimmedEmoji ? [] : [{
-		type: "emoji",
-		emoji: trimmedEmoji
-	}];
-	if (typeof api.setMessageReaction !== "function") throw new Error("Telegram reactions are unavailable in this bot API.");
-	try {
-		await requestWithDiag(() => api.setMessageReaction(chatId, messageId, reactions), "reaction");
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		if (/REACTION_INVALID/i.test(msg)) return {
-			ok: false,
-			warning: `Reaction unavailable: ${trimmedEmoji}`
-		};
-		throw err;
-	}
-	return { ok: true };
-}
-async function deleteMessageTelegram(chatIdInput, messageIdInput, opts = {}) {
-	const { cfg, account, api } = resolveTelegramApiContext(opts);
-	const rawTarget = String(chatIdInput);
-	const chatId = await resolveAndPersistChatId({
-		cfg,
-		api,
-		lookupTarget: rawTarget,
-		persistTarget: rawTarget,
-		verbose: opts.verbose
-	});
-	const messageId = normalizeMessageId(messageIdInput);
-	await createTelegramRequestWithDiag({
-		cfg,
-		account,
-		retry: opts.retry,
-		verbose: opts.verbose,
-		shouldRetry: (err) => isRecoverableTelegramNetworkError(err, { context: "send" })
-	})(() => api.deleteMessage(chatId, messageId), "deleteMessage");
-	logVerbose(`[telegram] Deleted message ${messageId} from chat ${chatId}`);
-	return { ok: true };
-}
-async function editMessageTelegram(chatIdInput, messageIdInput, text, opts = {}) {
-	const { cfg, account, api } = resolveTelegramApiContext({
-		...opts,
-		cfg: opts.cfg
-	});
-	const rawTarget = String(chatIdInput);
-	const chatId = await resolveAndPersistChatId({
-		cfg,
-		api,
-		lookupTarget: rawTarget,
-		persistTarget: rawTarget,
-		verbose: opts.verbose
-	});
-	const messageId = normalizeMessageId(messageIdInput);
-	const requestWithDiag = createTelegramRequestWithDiag({
-		cfg,
-		account,
-		retry: opts.retry,
-		verbose: opts.verbose
-	});
-	const requestWithEditShouldLog = (fn, label, shouldLog) => requestWithDiag(fn, label, shouldLog ? { shouldLog } : void 0);
-	const htmlText = renderTelegramHtmlText(text, {
-		textMode: opts.textMode ?? "markdown",
-		tableMode: resolveMarkdownTableMode({
-			cfg,
-			channel: "telegram",
-			accountId: account.accountId
-		})
-	});
-	const shouldTouchButtons = opts.buttons !== void 0;
-	const builtKeyboard = shouldTouchButtons ? buildInlineKeyboard(opts.buttons) : void 0;
-	const replyMarkup = shouldTouchButtons ? builtKeyboard ?? { inline_keyboard: [] } : void 0;
-	const editParams = { parse_mode: "HTML" };
-	if (opts.linkPreview === false) editParams.link_preview_options = { is_disabled: true };
-	if (replyMarkup !== void 0) editParams.reply_markup = replyMarkup;
-	const plainParams = {};
-	if (opts.linkPreview === false) plainParams.link_preview_options = { is_disabled: true };
-	if (replyMarkup !== void 0) plainParams.reply_markup = replyMarkup;
-	try {
-		await withTelegramHtmlParseFallback({
-			label: "editMessage",
-			verbose: opts.verbose,
-			requestHtml: (retryLabel) => requestWithEditShouldLog(() => api.editMessageText(chatId, messageId, htmlText, editParams), retryLabel, (err) => !isTelegramMessageNotModifiedError(err)),
-			requestPlain: (retryLabel) => requestWithEditShouldLog(() => Object.keys(plainParams).length > 0 ? api.editMessageText(chatId, messageId, text, plainParams) : api.editMessageText(chatId, messageId, text), retryLabel, (plainErr) => !isTelegramMessageNotModifiedError(plainErr))
-		});
-	} catch (err) {
-		if (isTelegramMessageNotModifiedError(err)) {} else throw err;
-	}
-	logVerbose(`[telegram] Edited message ${messageId} in chat ${chatId}`);
-	return {
-		ok: true,
-		messageId: String(messageId),
-		chatId
-	};
-}
-function inferFilename(kind) {
-	switch (kind) {
-		case "image": return "image.jpg";
-		case "video": return "video.mp4";
-		case "audio": return "audio.ogg";
-		default: return "file.bin";
-	}
-}
-/**
-* Send a sticker to a Telegram chat by file_id.
-* @param to - Chat ID or username (e.g., "123456789" or "@username")
-* @param fileId - Telegram file_id of the sticker to send
-* @param opts - Optional configuration
-*/
-async function sendStickerTelegram(to, fileId, opts = {}) {
-	if (!fileId?.trim()) throw new Error("Telegram sticker file_id is required");
-	const { cfg, account, api } = resolveTelegramApiContext(opts);
-	const target = parseTelegramTarget(to);
-	const chatId = await resolveAndPersistChatId({
-		cfg,
-		api,
-		lookupTarget: target.chatId,
-		persistTarget: to,
-		verbose: opts.verbose
-	});
-	const threadParams = buildTelegramThreadReplyParams({
-		targetMessageThreadId: target.messageThreadId,
-		messageThreadId: opts.messageThreadId,
-		chatType: target.chatType,
-		replyToMessageId: opts.replyToMessageId
-	});
-	const hasThreadParams = Object.keys(threadParams).length > 0;
-	const requestWithChatNotFound = createRequestWithChatNotFound({
-		requestWithDiag: createTelegramRequestWithDiag({
-			cfg,
-			account,
-			retry: opts.retry,
-			verbose: opts.verbose,
-			useApiErrorLogging: false
-		}),
-		chatId,
-		input: to
-	});
-	const result = await withTelegramThreadFallback(hasThreadParams ? threadParams : void 0, "sticker", opts.verbose, async (effectiveParams, label) => requestWithChatNotFound(() => api.sendSticker(chatId, fileId.trim(), effectiveParams), label));
-	const messageId = resolveTelegramMessageIdOrThrow(result, "sticker send");
-	const resolvedChatId = String(result?.chat?.id ?? chatId);
-	recordSentMessage(chatId, messageId);
-	recordChannelActivity({
-		channel: "telegram",
-		accountId: account.accountId,
-		direction: "outbound"
-	});
-	return {
-		messageId: String(messageId),
-		chatId: resolvedChatId
-	};
-}
-/**
-* Send a poll to a Telegram chat.
-* @param to - Chat ID or username (e.g., "123456789" or "@username")
-* @param poll - Poll input with question, options, maxSelections, and optional durationHours
-* @param opts - Optional configuration
-*/
-async function sendPollTelegram(to, poll, opts = {}) {
-	const { cfg, account, api } = resolveTelegramApiContext(opts);
-	const target = parseTelegramTarget(to);
-	const chatId = await resolveAndPersistChatId({
-		cfg,
-		api,
-		lookupTarget: target.chatId,
-		persistTarget: to,
-		verbose: opts.verbose
-	});
-	const normalizedPoll = normalizePollInput(poll, { maxOptions: 10 });
-	const threadParams = buildTelegramThreadReplyParams({
-		targetMessageThreadId: target.messageThreadId,
-		messageThreadId: opts.messageThreadId,
-		chatType: target.chatType,
-		replyToMessageId: opts.replyToMessageId
-	});
-	const pollOptions = normalizedPoll.options;
-	const requestWithChatNotFound = createRequestWithChatNotFound({
-		requestWithDiag: createTelegramRequestWithDiag({
-			cfg,
-			account,
-			retry: opts.retry,
-			verbose: opts.verbose,
-			shouldRetry: (err) => isRecoverableTelegramNetworkError(err, { context: "send" })
-		}),
-		chatId,
-		input: to
-	});
-	const durationSeconds = normalizedPoll.durationSeconds;
-	if (durationSeconds === void 0 && normalizedPoll.durationHours !== void 0) throw new Error("Telegram poll durationHours is not supported. Use durationSeconds (5-600) instead.");
-	if (durationSeconds !== void 0 && (durationSeconds < 5 || durationSeconds > 600)) throw new Error("Telegram poll durationSeconds must be between 5 and 600");
-	const result = await withTelegramThreadFallback({
-		allows_multiple_answers: normalizedPoll.maxSelections > 1,
-		is_anonymous: opts.isAnonymous ?? true,
-		...durationSeconds !== void 0 ? { open_period: durationSeconds } : {},
-		...Object.keys(threadParams).length > 0 ? threadParams : {},
-		...opts.silent === true ? { disable_notification: true } : {}
-	}, "poll", opts.verbose, async (effectiveParams, label) => requestWithChatNotFound(() => api.sendPoll(chatId, normalizedPoll.question, pollOptions, effectiveParams), label));
-	const messageId = resolveTelegramMessageIdOrThrow(result, "poll send");
-	const resolvedChatId = String(result?.chat?.id ?? chatId);
-	const pollId = result?.poll?.id;
-	recordSentMessage(chatId, messageId);
-	recordChannelActivity({
-		channel: "telegram",
-		accountId: account.accountId,
-		direction: "outbound"
-	});
-	return {
-		messageId: String(messageId),
-		chatId: resolvedChatId,
-		pollId
-	};
-}
-/**
-* Create a forum topic in a Telegram supergroup.
-* Requires the bot to have `can_manage_topics` permission.
-*
-* @param chatId - Supergroup chat ID
-* @param name - Topic name (1-128 characters)
-* @param opts - Optional configuration
-*/
-async function createForumTopicTelegram(chatId, name, opts = {}) {
-	if (!name?.trim()) throw new Error("Forum topic name is required");
-	const trimmedName = name.trim();
-	if (trimmedName.length > 128) throw new Error("Forum topic name must be 128 characters or fewer");
-	const cfg = loadConfig();
-	const account = resolveTelegramAccount({
-		cfg,
-		accountId: opts.accountId
-	});
-	const token = resolveToken(opts.token, account);
-	const client = resolveTelegramClientOptions(account);
-	const api = opts.api ?? new Bot(token, client ? { client } : void 0).api;
-	const normalizedChatId = await resolveAndPersistChatId({
-		cfg,
-		api,
-		lookupTarget: parseTelegramTarget(chatId).chatId,
-		persistTarget: chatId,
-		verbose: opts.verbose
-	});
-	const request = createTelegramRetryRunner({
-		retry: opts.retry,
-		configRetry: account.config.retry,
-		verbose: opts.verbose,
-		shouldRetry: (err) => isRecoverableTelegramNetworkError(err, { context: "send" })
-	});
-	const logHttpError = createTelegramHttpLogger(cfg);
-	const requestWithDiag = (fn, label) => withTelegramApiErrorLogging({
-		operation: label ?? "request",
-		fn: () => request(fn, label)
-	}).catch((err) => {
-		logHttpError(label ?? "request", err);
-		throw err;
-	});
-	const extra = {};
-	if (opts.iconColor != null) extra.icon_color = opts.iconColor;
-	if (opts.iconCustomEmojiId?.trim()) extra.icon_custom_emoji_id = opts.iconCustomEmojiId.trim();
-	const hasExtra = Object.keys(extra).length > 0;
-	const result = await requestWithDiag(() => api.createForumTopic(normalizedChatId, trimmedName, hasExtra ? extra : void 0), "createForumTopic");
-	const topicId = result.message_thread_id;
-	recordChannelActivity({
-		channel: "telegram",
-		accountId: account.accountId,
-		direction: "outbound"
-	});
-	return {
-		topicId,
-		name: result.name ?? trimmedName,
-		chatId: normalizedChatId
-	};
-}
-
-//#endregion
-export { splitTelegramCaption as _, reactMessageTelegram as a, send_exports as c, isRecoverableTelegramNetworkError as d, markdownToTelegramChunks as f, resolveTelegramFetch as g, wrapFileReferencesInHtml as h, editMessageTelegram as i, resolveTelegramVoiceSend as l, renderTelegramHtmlText as m, createForumTopicTelegram as n, sendMessageTelegram as o, markdownToTelegramHtml as p, deleteMessageTelegram as r, sendStickerTelegram as s, buildInlineKeyboard as t, wasSentByBot as u, withTelegramApiErrorLogging as v };