remoteclaw 0.1.0-next.2abd2fa → 0.1.0-next.2e9a6cd

package/dist/send-BqVOxAmK.js

@@ -1,1174 +0,0 @@
-import { C as writeConfigFile, N as resolveTelegramAccount, P as isTruthyEnvValue, S as readConfigFileSnapshotForWrite, a as isGifMedia, i as getFileExtension, l as markdownToIR, o as normalizeMimeType, p as resolveMarkdownTableMode, s as mediaKindFromMime, t as loadWebMedia, x as loadConfig } from "./media-CojxZ45J.js";
-import { F as expandHomePrefix, l as CONFIG_DIR, t as createSubsystemLogger, v as danger, y as logVerbose } from "./subsystem-BUXAJwPD.js";
-import { n as normalizeTelegramLookupTarget, r as parseTelegramTarget, t as normalizeTelegramChatId } from "./targets-JCISV-hS.js";
-import { t as resolveFetch } from "./fetch-BFSBLBkA.js";
-import "./retry-DUjAzOBy.js";
-import { a as formatErrorMessage, i as extractErrorCode, o as formatUncaughtError, r as createTelegramRetryRunner, s as redactSensitiveText, t as recordChannelActivity } from "./channel-activity-C-G4n9BK.js";
-import { t as renderMarkdownWithMarkers } from "./render-6ahYfPwj.js";
-import path from "node:path";
-import fs, { readFileSync } from "node:fs";
-import os from "node:os";
-import JSON5 from "json5";
-import fs$1 from "node:fs/promises";
-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/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.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.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.promises.writeFile(tmp, json, "utf-8");
-	await fs.promises.rename(tmp, storePath);
-	try {
-		await fs.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 };