remoteclaw 0.0.0 → 0.0.1

package/dist/send-BxQ1YFYH.js

@@ -0,0 +1,1178 @@
+import { F as expandHomePrefix, l as CONFIG_DIR, t as createSubsystemLogger, v as danger, y as logVerbose } from "./subsystem-DE8w_S23.js";
+import { G as isTruthyEnvValue, M as readConfigFileSnapshotForWrite, N as writeConfigFile, W as resolveTelegramAccount, _ as normalizeMimeType, g as isGifMedia, h as getFileExtension, j as loadConfig, o as resolveMarkdownTableMode, r as markdownToIR, t as loadWebMedia, v as mediaKindFromMime } from "./media-DgxPvn2i.js";
+import { i as resolveProcessScopedMap, n as normalizeTelegramLookupTarget, r as parseTelegramTarget, t as normalizeTelegramChatId } from "./targets-C99szk_e.js";
+import { t as resolveFetch } from "./fetch-CduIccDV.js";
+import "./retry-D7zwz3HY.js";
+import { a as formatErrorMessage, i as extractErrorCode, o as formatUncaughtError, r as createTelegramRetryRunner, s as redactSensitiveText, t as recordChannelActivity } from "./channel-activity-nsL1WwXH.js";
+import { t as renderMarkdownWithMarkers } from "./render-6ahYfPwj.js";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import fs$1, { readFileSync } from "node:fs";
+import JSON5 from "json5";
+import crypto from "node:crypto";
+import * as dns from "node:dns";
+import { Agent, ProxyAgent, fetch, setGlobalDispatcher } from "undici";
+import * as net from "node:net";
+import process$1 from "node:process";
+import { Bot, HttpError, InputFile } from "grammy";
+
+//#region src/plugin-sdk/file-lock.ts
+const HELD_LOCKS = resolveProcessScopedMap(Symbol.for("remoteclaw.fileLockHeldLocks"));
+
+//#endregion
+//#region src/pairing/pairing-store.ts
+const PAIRING_PENDING_TTL_MS = 3600 * 1e3;
+
+//#endregion
+//#region src/media/audio.ts
+const TELEGRAM_VOICE_AUDIO_EXTENSIONS = new Set([
+	".oga",
+	".ogg",
+	".opus",
+	".mp3",
+	".m4a"
+]);
+/**
+* MIME types compatible with voice messages.
+* Telegram sendVoice supports OGG/Opus, MP3, and M4A.
+* https://core.telegram.org/bots/api#sendvoice
+*/
+const TELEGRAM_VOICE_MIME_TYPES = new Set([
+	"audio/ogg",
+	"audio/opus",
+	"audio/mpeg",
+	"audio/mp3",
+	"audio/mp4",
+	"audio/x-m4a",
+	"audio/m4a"
+]);
+function isTelegramVoiceCompatibleAudio(opts) {
+	const mime = normalizeMimeType(opts.contentType);
+	if (mime && TELEGRAM_VOICE_MIME_TYPES.has(mime)) return true;
+	const fileName = opts.fileName?.trim();
+	if (!fileName) return false;
+	const ext = getFileExtension(fileName);
+	if (!ext) return false;
+	return TELEGRAM_VOICE_AUDIO_EXTENSIONS.has(ext);
+}
+
+//#endregion
+//#region src/infra/diagnostic-flags.ts
+const DIAGNOSTICS_ENV = "REMOTECLAW_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/bot-access.ts
+const log$1 = createSubsystemLogger("telegram/bot-access");
+
+//#endregion
+//#region src/telegram/bot/helpers.ts
+const TELEGRAM_GENERAL_TOPIC_ID = 1;
+/**
+* Build thread params for Telegram API calls (messages, media).
+*
+* IMPORTANT: Thread IDs behave differently based on chat type:
+* - DMs (private chats): Include message_thread_id when present (DM topics)
+* - Forum topics: Skip thread_id=1 (General topic), include others
+* - Regular groups: Thread IDs are ignored by Telegram
+*
+* General forum topic (id=1) must be treated like a regular supergroup send:
+* Telegram rejects sendMessage/sendMedia with message_thread_id=1 ("thread not found").
+*
+* @param thread - Thread specification with ID and scope
+* @returns API params object or undefined if thread_id should be omitted
+*/
+function buildTelegramThreadParams(thread) {
+	if (thread?.id == null) return;
+	const normalized = Math.trunc(thread.id);
+	if (thread.scope === "dm") return normalized > 0 ? { message_thread_id: normalized } : void 0;
+	if (normalized === TELEGRAM_GENERAL_TOPIC_ID) return;
+	return { message_thread_id: normalized };
+}
+
+//#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/infra/wsl.ts
+function isWSLEnv() {
+	if (process.env.WSL_INTEROP || process.env.WSL_DISTRO_NAME || process.env.WSLENV) return true;
+	return false;
+}
+/**
+* Synchronously check if running in WSL.
+* Checks env vars first, then /proc/version.
+*/
+function isWSLSync() {
+	if (process.platform !== "linux") return false;
+	if (isWSLEnv()) return true;
+	try {
+		const release = readFileSync("/proc/version", "utf8").toLowerCase();
+		return release.includes("microsoft") || release.includes("wsl");
+	} catch {
+		return false;
+	}
+}
+/**
+* Synchronously check if running in WSL2.
+*/
+function isWSL2Sync() {
+	if (!isWSLSync()) return false;
+	try {
+		const version = readFileSync("/proc/version", "utf8").toLowerCase();
+		return version.includes("wsl2") || version.includes("microsoft-standard");
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/telegram/network-config.ts
+const TELEGRAM_DISABLE_AUTO_SELECT_FAMILY_ENV = "REMOTECLAW_TELEGRAM_DISABLE_AUTO_SELECT_FAMILY";
+const TELEGRAM_ENABLE_AUTO_SELECT_FAMILY_ENV = "REMOTECLAW_TELEGRAM_ENABLE_AUTO_SELECT_FAMILY";
+const TELEGRAM_DNS_RESULT_ORDER_ENV = "REMOTECLAW_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 REMOTECLAW_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.setDefaultAutoSelectFamily === "function") try {
+			net.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 });
+}
+
+//#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/proxy.ts
+function makeProxyFetch(proxyUrl) {
+	const agent = new ProxyAgent(proxyUrl);
+	const fetcher = ((input, init) => fetch(input, {
+		...init,
+		dispatcher: agent
+	}));
+	return fetcher;
+}
+
+//#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);
+}
+
+//#endregion
+//#region src/cron/store.ts
+const DEFAULT_CRON_DIR = path.join(CONFIG_DIR, "cron");
+const DEFAULT_CRON_STORE_PATH = path.join(DEFAULT_CRON_DIR, "jobs.json");
+function resolveCronStorePath(storePath) {
+	if (storePath?.trim()) {
+		const raw = storePath.trim();
+		if (raw.startsWith("~")) return path.resolve(expandHomePrefix(raw));
+		return path.resolve(raw);
+	}
+	return DEFAULT_CRON_STORE_PATH;
+}
+async function loadCronStore(storePath) {
+	try {
+		const raw = await fs$1.promises.readFile(storePath, "utf-8");
+		let parsed;
+		try {
+			parsed = JSON5.parse(raw);
+		} catch (err) {
+			throw new Error(`Failed to parse cron store at ${storePath}: ${String(err)}`, { cause: err });
+		}
+		const parsedRecord = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+		return {
+			version: 1,
+			jobs: (Array.isArray(parsedRecord.jobs) ? parsedRecord.jobs : []).filter(Boolean)
+		};
+	} catch (err) {
+		if (err?.code === "ENOENT") return {
+			version: 1,
+			jobs: []
+		};
+		throw err;
+	}
+}
+async function saveCronStore(storePath, store) {
+	await fs$1.promises.mkdir(path.dirname(storePath), { recursive: true });
+	const { randomBytes } = await import("node:crypto");
+	const tmp = `${storePath}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+	const json = JSON.stringify(store, null, 2);
+	await fs$1.promises.writeFile(tmp, json, "utf-8");
+	await fs$1.promises.rename(tmp, storePath);
+	try {
+		await fs$1.promises.copyFile(storePath, `${storePath}.bak`);
+	} catch {}
+}
+
+//#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
+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 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 isTelegramThreadNotFoundError(err) {
+	return THREAD_NOT_FOUND_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 = String(result?.message_id ?? "unknown");
+		const resolvedChatId = String(result?.chat?.id ?? chatId);
+		if (result?.message_id) recordSentMessage(chatId, result.message_id);
+		recordChannelActivity({
+			channel: "telegram",
+			accountId: account.accountId,
+			direction: "outbound"
+		});
+		if (needsSeparateText && followUpText) {
+			const textParams = hasThreadParams || replyMarkup ? {
+				...threadParams,
+				...replyMarkup ? { reply_markup: replyMarkup } : {}
+			} : void 0;
+			const textRes = await sendTelegramText(followUpText, textParams);
+			return {
+				messageId: String(textRes?.message_id ?? mediaMessageId),
+				chatId: resolvedChatId
+			};
+		}
+		return {
+			messageId: 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 = String(res?.message_id ?? "unknown");
+	if (res?.message_id) recordSentMessage(chatId, res.message_id);
+	recordChannelActivity({
+		channel: "telegram",
+		accountId: account.accountId,
+		direction: "outbound"
+	});
+	return {
+		messageId,
+		chatId: String(res?.chat?.id ?? 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";
+	}
+}
+
+//#endregion
+export { sendMessageTelegram };