@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/telegram/bot.js

@@ -1,30 +1,25 @@
-// @ts-nocheck
 import { sequentialize } from "@grammyjs/runner";
 import { apiThrottler } from "@grammyjs/transformer-throttler";
 import { Bot, webhookCallback } from "grammy";
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
-import { isControlCommandMessage } from "../auto-reply/command-detection.js";
 import { resolveTextChunkLimit } from "../auto-reply/chunk.js";
+import { isAbortRequestText } from "../auto-reply/reply/abort.js";
 import { DEFAULT_GROUP_HISTORY_LIMIT } from "../auto-reply/reply/history.js";
 import { isNativeCommandsExplicitlyDisabled, resolveNativeCommandsEnabled, resolveNativeSkillsEnabled, } from "../config/commands.js";
 import { loadConfig } from "../config/config.js";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention, } from "../config/group-policy.js";
 import { loadSessionStore, resolveStorePath } from "../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../globals.js";
-import { createSubsystemLogger } from "../logging/subsystem.js";
 import { formatUncaughtError } from "../infra/errors.js";
-import { enqueueSystemEvent } from "../infra/system-events.js";
 import { getChildLogger } from "../logging.js";
-import { withTelegramApiErrorLogging } from "./api-logging.js";
-import { resolveAgentRoute } from "../routing/resolve-route.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { resolveTelegramAccount } from "./accounts.js";
-import { buildTelegramGroupPeerId, buildTelegramParentPeer, resolveTelegramForumThreadId, resolveTelegramStreamMode, } from "./bot/helpers.js";
 import { registerTelegramHandlers } from "./bot-handlers.js";
 import { createTelegramMessageProcessor } from "./bot-message.js";
 import { registerTelegramNativeCommands } from "./bot-native-commands.js";
 import { buildTelegramUpdateKey, createTelegramUpdateDedupe, resolveTelegramUpdateId, } from "./bot-updates.js";
+import { buildTelegramGroupPeerId, resolveTelegramForumThreadId, resolveTelegramStreamMode, } from "./bot/helpers.js";
 import { resolveTelegramFetch } from "./fetch.js";
-import { wasSentByBot } from "./sent-message-cache.js";
 export function getTelegramSequentialKey(ctx) {
     // Handle reaction updates
     const reaction = ctx.update?.message_reaction;
@@ -38,10 +33,10 @@ export function getTelegramSequentialKey(ctx) {
     const chatId = msg?.chat?.id ?? ctx.chat?.id;
     const rawText = msg?.text ?? msg?.caption;
     const botUsername = ctx.me?.username;
-    if (rawText &&
-        isControlCommandMessage(rawText, undefined, botUsername ? { botUsername } : undefined)) {
-        if (typeof chatId === "number")
+    if (isAbortRequestText(rawText, botUsername ? { botUsername } : undefined)) {
+        if (typeof chatId === "number") {
             return `telegram:${chatId}:control`;
+        }
         return "telegram:control";
     }
     const isGroup = msg?.chat?.type === "group" || msg?.chat?.type === "supergroup";
@@ -88,30 +83,29 @@ export function createTelegramBot(opts) {
     const bot = new Bot(opts.token, client ? { client } : undefined);
     bot.api.config.use(apiThrottler());
     bot.use(sequentialize(getTelegramSequentialKey));
-    bot.catch((err) => {
-        runtime.error?.(danger(`telegram bot error: ${formatUncaughtError(err)}`));
-    });
     // Catch all errors from bot middleware to prevent unhandled rejections
     bot.catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        runtime.error?.(danger(`telegram bot error: ${message}`));
+        runtime.error?.(danger(`telegram bot error: ${formatUncaughtError(err)}`));
     });
     const recentUpdates = createTelegramUpdateDedupe();
     let lastUpdateId = typeof opts.updateOffset?.lastUpdateId === "number" ? opts.updateOffset.lastUpdateId : null;
     const recordUpdateId = (ctx) => {
         const updateId = resolveTelegramUpdateId(ctx);
-        if (typeof updateId !== "number")
+        if (typeof updateId !== "number") {
             return;
-        if (lastUpdateId !== null && updateId <= lastUpdateId)
+        }
+        if (lastUpdateId !== null && updateId <= lastUpdateId) {
             return;
+        }
         lastUpdateId = updateId;
         void opts.updateOffset?.onUpdateId?.(updateId);
     };
     const shouldSkipUpdate = (ctx) => {
         const updateId = resolveTelegramUpdateId(ctx);
         if (typeof updateId === "number" && lastUpdateId !== null) {
-            if (updateId <= lastUpdateId)
+            if (updateId <= lastUpdateId) {
                 return true;
+            }
         }
         const key = buildTelegramUpdateKey(ctx);
         const skipped = recentUpdates.check(key);
@@ -137,10 +131,10 @@ export function createTelegramBot(opts) {
                 ];
             }
             if (value && typeof value === "object") {
-                const obj = value;
-                if (seen.has(obj))
+                if (seen.has(value)) {
                     return "[Circular]";
-                seen.add(obj);
+                }
+                seen.add(value);
             }
             return value;
         });
@@ -172,8 +166,7 @@ export function createTelegramBot(opts) {
             ? telegramCfg.allowFrom
             : undefined) ??
         (opts.allowFrom && opts.allowFrom.length > 0 ? opts.allowFrom : undefined);
-    const replyToMode = opts.replyToMode ?? telegramCfg.replyToMode ?? "first";
-    const streamMode = resolveTelegramStreamMode(telegramCfg);
+    const replyToMode = opts.replyToMode ?? telegramCfg.replyToMode ?? "off";
     const nativeEnabled = resolveNativeCommandsEnabled({
         providerId: "telegram",
         providerSetting: telegramCfg.commands?.native,
@@ -192,32 +185,7 @@ export function createTelegramBot(opts) {
     const ackReactionScope = cfg.messages?.ackReactionScope ?? "group-mentions";
     const mediaMaxBytes = (opts.mediaMaxMb ?? telegramCfg.mediaMaxMb ?? 5) * 1024 * 1024;
     const logger = getChildLogger({ module: "telegram-auto-reply" });
-    let botHasTopicsEnabled;
-    const resolveBotTopicsEnabled = async (ctx) => {
-        if (typeof ctx?.me?.has_topics_enabled === "boolean") {
-            botHasTopicsEnabled = ctx.me.has_topics_enabled;
-            return botHasTopicsEnabled;
-        }
-        if (typeof botHasTopicsEnabled === "boolean")
-            return botHasTopicsEnabled;
-        if (typeof bot.api.getMe !== "function") {
-            botHasTopicsEnabled = false;
-            return botHasTopicsEnabled;
-        }
-        try {
-            const me = await withTelegramApiErrorLogging({
-                operation: "getMe",
-                runtime,
-                fn: () => bot.api.getMe(),
-            });
-            botHasTopicsEnabled = Boolean(me?.has_topics_enabled);
-        }
-        catch (err) {
-            logVerbose(`telegram getMe failed: ${String(err)}`);
-            botHasTopicsEnabled = false;
-        }
-        return botHasTopicsEnabled;
-    };
+    const streamMode = resolveTelegramStreamMode(telegramCfg);
     const resolveGroupPolicy = (chatId) => resolveChannelGroupPolicy({
         cfg,
         channel: "telegram",
@@ -232,10 +200,12 @@ export function createTelegramBot(opts) {
         try {
             const store = loadSessionStore(storePath);
             const entry = store[sessionKey];
-            if (entry?.groupActivation === "always")
+            if (entry?.groupActivation === "always") {
                 return false;
-            if (entry?.groupActivation === "mention")
+            }
+            if (entry?.groupActivation === "mention") {
                 return true;
+            }
         }
         catch (err) {
             logVerbose(`Failed to load session for activation check: ${String(err)}`);
@@ -252,8 +222,9 @@ export function createTelegramBot(opts) {
     });
     const resolveTelegramGroupConfig = (chatId, messageThreadId) => {
         const groups = telegramCfg.groups;
-        if (!groups)
+        if (!groups) {
             return { groupConfig: undefined, topicConfig: undefined };
+        }
         const groupKey = String(chatId);
         const groupConfig = groups[groupKey] ?? groups["*"];
         const topicConfig = messageThreadId != null ? groupConfig?.topics?.[String(messageThreadId)] : undefined;
@@ -279,7 +250,6 @@ export function createTelegramBot(opts) {
         streamMode,
         textLimit,
         opts,
-        resolveBotTopicsEnabled,
     });
     registerTelegramNativeCommands({
         bot,
@@ -300,84 +270,6 @@ export function createTelegramBot(opts) {
         shouldSkipUpdate,
         opts,
     });
-    // Handle emoji reactions to messages
-    bot.on("message_reaction", async (ctx) => {
-        try {
-            const reaction = ctx.messageReaction;
-            if (!reaction)
-                return;
-            if (shouldSkipUpdate(ctx))
-                return;
-            const chatId = reaction.chat.id;
-            const messageId = reaction.message_id;
-            const user = reaction.user;
-            // Resolve reaction notification mode (default: "own")
-            const reactionMode = telegramCfg.reactionNotifications ?? "own";
-            if (reactionMode === "off")
-                return;
-            if (user?.is_bot)
-                return;
-            if (reactionMode === "own" && !wasSentByBot(chatId, messageId))
-                return;
-            // Detect added reactions
-            const oldEmojis = new Set(reaction.old_reaction
-                .filter((r) => r.type === "emoji")
-                .map((r) => r.emoji));
-            const addedReactions = reaction.new_reaction
-                .filter((r) => r.type === "emoji")
-                .filter((r) => !oldEmojis.has(r.emoji));
-            if (addedReactions.length === 0)
-                return;
-            // Build sender label
-            const senderName = user
-                ? [user.first_name, user.last_name].filter(Boolean).join(" ").trim() || user.username
-                : undefined;
-            const senderUsername = user?.username ? `@${user.username}` : undefined;
-            let senderLabel = senderName;
-            if (senderName && senderUsername) {
-                senderLabel = `${senderName} (${senderUsername})`;
-            }
-            else if (!senderName && senderUsername) {
-                senderLabel = senderUsername;
-            }
-            if (!senderLabel && user?.id) {
-                senderLabel = `id:${user.id}`;
-            }
-            senderLabel = senderLabel || "unknown";
-            // Reactions target a specific message_id; the Telegram Bot API does not include
-            // message_thread_id on MessageReactionUpdated, so we route to the chat-level
-            // session (forum topic routing is not available for reactions).
-            const isGroup = reaction.chat.type === "group" || reaction.chat.type === "supergroup";
-            const isForum = reaction.chat.is_forum === true;
-            const resolvedThreadId = isForum
-                ? resolveTelegramForumThreadId({ isForum, messageThreadId: undefined })
-                : undefined;
-            const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : String(chatId);
-            const parentPeer = buildTelegramParentPeer({ isGroup, resolvedThreadId, chatId });
-            // Fresh config for bindings lookup; other routing inputs are payload-derived.
-            const route = resolveAgentRoute({
-                cfg: loadConfig(),
-                channel: "telegram",
-                accountId: account.accountId,
-                peer: { kind: isGroup ? "group" : "dm", id: peerId },
-                parentPeer,
-            });
-            const sessionKey = route.sessionKey;
-            // Enqueue system event for each added reaction
-            for (const r of addedReactions) {
-                const emoji = r.emoji;
-                const text = `Telegram reaction added: ${emoji} by ${senderLabel} on msg ${messageId}`;
-                enqueueSystemEvent(text, {
-                    sessionKey: sessionKey,
-                    contextKey: `telegram:reaction:add:${chatId}:${messageId}:${user?.id ?? "anon"}:${emoji}`,
-                });
-                logVerbose(`telegram: reaction event enqueued: ${text}`);
-            }
-        }
-        catch (err) {
-            runtime.error?.(danger(`telegram reaction handler failed: ${String(err)}`));
-        }
-    });
     registerTelegramHandlers({
         cfg,
         accountId: account.accountId,

package/dist/telegram/draft-stream.js

@@ -1,101 +1,110 @@
-const TELEGRAM_DRAFT_MAX_CHARS = 4096;
-const DEFAULT_THROTTLE_MS = 300;
+import { createDraftStreamLoop } from "../channels/draft-stream-loop.js";
+import { buildTelegramThreadParams } from "./bot/helpers.js";
+const TELEGRAM_STREAM_MAX_CHARS = 4096;
+const DEFAULT_THROTTLE_MS = 1000;
 export function createTelegramDraftStream(params) {
-    const maxChars = Math.min(params.maxChars ?? TELEGRAM_DRAFT_MAX_CHARS, TELEGRAM_DRAFT_MAX_CHARS);
-    const throttleMs = Math.max(50, params.throttleMs ?? DEFAULT_THROTTLE_MS);
-    const rawDraftId = Number.isFinite(params.draftId) ? Math.trunc(params.draftId) : 1;
-    const draftId = rawDraftId === 0 ? 1 : Math.abs(rawDraftId);
+    const maxChars = Math.min(params.maxChars ?? TELEGRAM_STREAM_MAX_CHARS, TELEGRAM_STREAM_MAX_CHARS);
+    const throttleMs = Math.max(250, params.throttleMs ?? DEFAULT_THROTTLE_MS);
+    const minInitialChars = params.minInitialChars;
     const chatId = params.chatId;
-    const threadParams = typeof params.messageThreadId === "number"
-        ? { message_thread_id: Math.trunc(params.messageThreadId) }
-        : undefined;
+    const threadParams = buildTelegramThreadParams(params.thread);
+    const replyParams = params.replyToMessageId != null
+        ? { ...threadParams, reply_to_message_id: params.replyToMessageId }
+        : threadParams;
+    let streamMessageId;
     let lastSentText = "";
-    let lastSentAt = 0;
-    let pendingText = "";
-    let inFlight = false;
-    let timer;
     let stopped = false;
-    const sendDraft = async (text) => {
-        if (stopped)
-            return;
+    let isFinal = false;
+    const sendOrEditStreamMessage = async (text) => {
+        // Allow final flush even if stopped (e.g., after clear()).
+        if (stopped && !isFinal) {
+            return false;
+        }
         const trimmed = text.trimEnd();
-        if (!trimmed)
-            return;
+        if (!trimmed) {
+            return false;
+        }
         if (trimmed.length > maxChars) {
-            // Drafts are capped at 4096 chars. Stop streaming once we exceed the cap
-            // so we don't keep sending failing updates or a truncated preview.
+            // Telegram text messages/edits cap at 4096 chars.
+            // Stop streaming once we exceed the cap to avoid repeated API failures.
             stopped = true;
-            params.warn?.(`telegram draft stream stopped (draft length ${trimmed.length} > ${maxChars})`);
-            return;
+            params.warn?.(`telegram stream preview stopped (text length ${trimmed.length} > ${maxChars})`);
+            return false;
+        }
+        if (trimmed === lastSentText) {
+            return true;
+        }
+        // Debounce first preview send for better push notification quality.
+        if (typeof streamMessageId !== "number" && minInitialChars != null && !isFinal) {
+            if (trimmed.length < minInitialChars) {
+                return false;
+            }
         }
-        if (trimmed === lastSentText)
-            return;
         lastSentText = trimmed;
-        lastSentAt = Date.now();
         try {
-            await params.api.sendMessageDraft(chatId, draftId, trimmed, threadParams);
+            if (typeof streamMessageId === "number") {
+                await params.api.editMessageText(chatId, streamMessageId, trimmed);
+                return true;
+            }
+            const sent = await params.api.sendMessage(chatId, trimmed, replyParams);
+            const sentMessageId = sent?.message_id;
+            if (typeof sentMessageId !== "number" || !Number.isFinite(sentMessageId)) {
+                stopped = true;
+                params.warn?.("telegram stream preview stopped (missing message id from sendMessage)");
+                return false;
+            }
+            streamMessageId = Math.trunc(sentMessageId);
+            return true;
         }
         catch (err) {
             stopped = true;
-            params.warn?.(`telegram draft stream failed: ${err instanceof Error ? err.message : String(err)}`);
+            params.warn?.(`telegram stream preview failed: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
         }
     };
-    const flush = async () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = undefined;
-        }
-        if (inFlight) {
-            schedule();
+    const loop = createDraftStreamLoop({
+        throttleMs,
+        isStopped: () => stopped,
+        sendOrEditStreamMessage,
+    });
+    const update = (text) => {
+        if (stopped || isFinal) {
             return;
         }
-        const text = pendingText;
-        pendingText = "";
-        if (!text.trim()) {
-            if (pendingText)
-                schedule();
+        loop.update(text);
+    };
+    const stop = async () => {
+        isFinal = true;
+        await loop.flush();
+    };
+    const clear = async () => {
+        stopped = true;
+        loop.stop();
+        await loop.waitForInFlight();
+        const messageId = streamMessageId;
+        streamMessageId = undefined;
+        if (typeof messageId !== "number") {
             return;
         }
-        inFlight = true;
         try {
-            await sendDraft(text);
+            await params.api.deleteMessage(chatId, messageId);
         }
-        finally {
-            inFlight = false;
+        catch (err) {
+            params.warn?.(`telegram stream preview cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-        if (pendingText)
-            schedule();
-    };
-    const schedule = () => {
-        if (timer)
-            return;
-        const delay = Math.max(0, throttleMs - (Date.now() - lastSentAt));
-        timer = setTimeout(() => {
-            void flush();
-        }, delay);
     };
-    const update = (text) => {
-        if (stopped)
-            return;
-        pendingText = text;
-        if (inFlight) {
-            schedule();
-            return;
-        }
-        if (!timer && Date.now() - lastSentAt >= throttleMs) {
-            void flush();
-            return;
-        }
-        schedule();
+    const forceNewMessage = () => {
+        streamMessageId = undefined;
+        lastSentText = "";
+        loop.resetPending();
     };
-    const stop = () => {
-        stopped = true;
-        pendingText = "";
-        if (timer) {
-            clearTimeout(timer);
-            timer = undefined;
-        }
+    params.log?.(`telegram stream preview ready (maxChars=${maxChars}, throttleMs=${throttleMs})`);
+    return {
+        update,
+        flush: loop.flush,
+        messageId: () => streamMessageId,
+        clear,
+        stop,
+        forceNewMessage,
     };
-    params.log?.(`telegram draft stream ready (draftId=${draftId}, maxChars=${maxChars}, throttleMs=${throttleMs})`);
-    return { update, flush, stop };
 }

package/dist/telegram/format.js

@@ -6,12 +6,66 @@ function escapeHtml(text) {
 function escapeHtmlAttr(text) {
     return escapeHtml(text).replace(/"/g, """);
 }
-function buildTelegramLink(link, _text) {
+/**
+ * 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", // Markdown (Moldova) - very common in repos
+    "go", // Go language - common in Go projects
+    "py", // Python (Paraguay) - common in Python projects
+    "pl", // Perl (Poland) - common in Perl projects
+    "sh", // Shell (Saint Helena) - common for scripts
+    "am", // Automake files (Armenia)
+    "at", // Assembly (Austria)
+    "be", // Backend files (Belgium)
+    "cc", // C++ source (Cocos Islands)
+]);
+/** Detects when markdown-it linkify auto-generated a link from a bare filename (e.g. README.md → http://README.md) */
+function isAutoLinkedFileRef(href, label) {
+    const stripped = href.replace(/^https?:\/\//i, "");
+    if (stripped !== 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;
+    }
+    // Reject if any path segment before the filename contains a dot (looks like a domain)
+    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)
+    if (!href) {
+        return null;
+    }
+    if (link.start === link.end) {
         return null;
-    if (link.start === link.end)
+    }
+    // Suppress auto-linkified file references (e.g. README.md → http://README.md)
+    const label = text.slice(link.start, link.end);
+    if (isAutoLinkedFileRef(href, label)) {
         return null;
+    }
     const safeHref = escapeHtmlAttr(href);
     return {
         start: link.start,
@@ -28,6 +82,8 @@ function renderTelegramHtml(ir) {
             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,
@@ -36,28 +92,116 @@ function renderTelegramHtml(ir) {
 export function markdownToTelegramHtml(markdown, options = {}) {
     const ir = markdownToIR(markdown ?? "", {
         linkify: true,
+        enableSpoilers: true,
         headingStyle: "none",
         blockquotePrefix: "",
         tableMode: options.tableMode,
     });
-    return renderTelegramHtml(ir);
+    const html = renderTelegramHtml(ir);
+    // Apply file reference wrapping if requested (for chunked rendering)
+    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;
+    }
+    const wrappedStandalone = text.replace(FILE_REFERENCE_PATTERN, wrapStandaloneFileRef);
+    return wrappedStandalone.replace(ORPHANED_TLD_PATTERN, (match, prefix, tld) => prefix === ">" ? match : `${prefix}<code>${escapeHtml(tld)}</code>`);
+}
+export function wrapFileReferencesInHtml(html) {
+    // Safety-net: de-linkify auto-generated anchors where href="http://<label>" (defense in depth for textMode: "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>`;
+    });
+    // Track nesting depth for tags that should not be modified
+    let codeDepth = 0;
+    let preDepth = 0;
+    let anchorDepth = 0;
+    let result = "";
+    let lastIndex = 0;
+    // Process tags token-by-token so we can skip protected regions while wrapping plain text.
+    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();
+        // Process text before this tag
+        const textBefore = deLinkified.slice(lastIndex, tagStart);
+        result += wrapSegmentFileRefs(textBefore, codeDepth, preDepth, anchorDepth);
+        // Update tag depth (clamp at 0 for malformed HTML with stray closing tags)
+        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;
+        }
+        // Add the tag itself
+        result += deLinkified.slice(tagStart, tagEnd);
+        lastIndex = tagEnd;
+    }
+    // Process remaining text
+    const remainingText = deLinkified.slice(lastIndex);
+    result += wrapSegmentFileRefs(remainingText, codeDepth, preDepth, anchorDepth);
+    return result;
 }
 export function renderTelegramHtmlText(text, options = {}) {
     const textMode = options.textMode ?? "markdown";
-    if (textMode === "html")
+    if (textMode === "html") {
+        // For HTML mode, trust caller markup - don't modify
         return text;
+    }
+    // markdownToTelegramHtml already wraps file references by default
     return markdownToTelegramHtml(text, { tableMode: options.tableMode });
 }
 export function markdownToTelegramChunks(markdown, limit, options = {}) {
     const ir = markdownToIR(markdown ?? "", {
         linkify: true,
+        enableSpoilers: true,
         headingStyle: "none",
         blockquotePrefix: "",
         tableMode: options.tableMode,
     });
     const chunks = chunkMarkdownIR(ir, limit);
     return chunks.map((chunk) => ({
-        html: renderTelegramHtml(chunk),
+        html: wrapFileReferencesInHtml(renderTelegramHtml(chunk)),
         text: chunk.text,
     }));
 }