Обновить .gitea/workflows/release-package.yaml

.gitea/workflows/release-package.yaml

@@ -48,12 +48,6 @@ jobs:
             BotPages.Telegram
             BotPages
 
-      - name: Upload package artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: nuget-packages
-          path: artifacts/*.nupkg
-
       - name: Publish to NuGet
         env:
           NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}

BotPages.Core/Abstractions/AdapterOptionsBag.cs

@@ -0,0 +1,44 @@
+namespace BotPages.Core.Abstractions;
+
+/// <summary>
+/// Êîíòåéíåð äëÿ àäàïòåð-ñïåöèôè÷íûõ îïöèé, ïîçâîëÿþùèé õðàíèòü ïàðàìåòðû äëÿ íåñêîëüêèõ àäàïòåðîâ.
+/// Èñïîëüçóåòñÿ âíóòðè <see cref="SendRequest.AdapterOptions"/>.
+/// </summary>
+public sealed class AdapterOptionsBag
+{
+    private readonly Dictionary<string, object?> _map = new(StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Óñòàíîâèòü îïöèè äëÿ àäàïòåðà.
+    /// </summary>
+    public void Set<T>(string adapterKey, T options)
+    {
+        if (adapterKey is null) throw new ArgumentNullException(nameof(adapterKey));
+        _map[adapterKey] = options;
+    }
+
+    /// <summary>
+    /// Ïîïðîáîâàòü ïîëó÷èòü îïöèè äëÿ àäàïòåðà.
+    /// </summary>
+    public bool TryGet<T>(string adapterKey, out T? options)
+    {
+        if (adapterKey is null) throw new ArgumentNullException(nameof(adapterKey));
+        if (_map.TryGetValue(adapterKey, out var o) && o is T t)
+        {
+            options = t;
+            return true;
+        }
+
+        options = default;
+        return false;
+    }
+
+    /// <summary>
+    /// Ïîëó÷èòü îïöèè èëè âåðíóòü null.
+    /// </summary>
+    public T? GetOrDefault<T>(string adapterKey)
+    {
+        TryGet(adapterKey, out T? v);
+        return v;
+    }
+}

BotPages.Core/Abstractions/CompositeSessionKey.cs

@@ -1,6 +1,28 @@
-namespace BotPages.Core.Abstractions;
+using BotPages.Core.Context;
+
+namespace BotPages.Core.Abstractions;
 
 /// <summary>
 /// Ключ для идентификации пользовательской сессии.
 /// </summary>
-public readonly record struct CompositeSessionKey(string MessengerType, string ChatId, string? UserId);
+public readonly record struct CompositeSessionKey(string AdapterId, string ChatId, string? UserId)
+{
+    /// <summary>
+    /// Создает ключ сессии из UpdateContext.
+    /// </summary>
+    public static CompositeSessionKey FromUpdate(UpdateContext update)
+    {
+        return new CompositeSessionKey(
+            update.Adapter.Id,
+            update.Chat.Id,
+            update.User.Id);
+    }
+
+    /// <summary>
+    /// Получить ключ для определенного адаптера.
+    /// </summary>
+    public CompositeSessionKey ForAdapter(string adapterId)
+    {
+        return new CompositeSessionKey(adapterId, ChatId, UserId);
+    }
+}

BotPages.Core/Abstractions/IMessengerAdapter.cs

@@ -9,34 +9,78 @@ namespace BotPages.Core.Abstractions;
 /// </summary>
 public interface IMessengerAdapter
 {
+    /// <summary>
+    /// Уникальный идентификатор адаптера.
+    /// </summary>
+    string Id { get; }
+
+    /// <summary>
+    /// Тип адаптера (Telegram, VK, WhatsApp и т.д.).
+    /// </summary>
+    string Type { get; }
+
     /// <summary>
     /// Доступные возможности мессенджера.
     /// </summary>
     Capabilities Capabilities { get; }
 
     /// <summary>
-    /// Отправить текстовое сообщение в чат.
+    /// Универсальный метод отправки с использованием общего описания запроса.
     /// </summary>
-    Task<string?> SendTextAsync(string chatId, 
+    Task<string?> SendAsync(SendRequest request, CancellationToken ct = default);
-        string text, 
-        MessageFormat format = MessageFormat.Plain,
-        IEnumerable<IEnumerable<InlineButton>>? inline = null,
-        IEnumerable<IEnumerable<ReplyButton>>? reply = null,
-        string? messageId = null, 
-        CancellationToken ct = default
-    );
 
     /// <summary>
-    /// Отправить файл в чат.
+    /// Универсальный метод удаления сообщения.
     /// </summary>
-    Task SendFileAsync(string chatId, 
+    Task DeleteAsync(string chatId, string messageId, CancellationToken ct = default);
-        FileDescriptor file, 
+
-        string? caption = null, 
+    /// <summary>
-        MessageFormat? captionFormat = null,
+    /// Удалить несколько сообщений за раз.
-        IEnumerable<IEnumerable<InlineButton>>? inline = null,
+    /// </summary>
-        IEnumerable<IEnumerable<ReplyButton>>? reply = null,
+    Task<bool> DeleteMultipleAsync(string chatId, IEnumerable<string> messageIds, CancellationToken ct = default);
+
+    /// <summary>
+    /// Редактировать только текст сообщения.
+    /// </summary>
+    Task<string?> EditTextAsync(string chatId, string messageId, string text,
+        MessageFormat? format = null, CancellationToken ct = default);
+
+    /// <summary>
+    /// Редактировать только клавиатуру сообщения.
+    /// </summary>
+    Task<string?> EditButtonsAsync(string chatId, string messageId,
+        IEnumerable<IEnumerable<InlineButton>>? inlineButtons = null,
         CancellationToken ct = default);
 
+    /// <summary>
+    /// Закрепить сообщение в чате.
+    /// </summary>
+    Task<bool> PinMessageAsync(string chatId, string messageId, bool disableNotification = false,
+        CancellationToken ct = default);
+
+    /// <summary>
+    /// Открепить сообщение в чате.
+    /// </summary>
+    Task<bool> UnpinMessageAsync(string chatId, string messageId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Получить информацию о сообщении.
+    /// </summary>
+    Task<MessageInfo?> GetMessageInfoAsync(string chatId, string messageId, CancellationToken ct = default);
+
+    /// <summary>
+    /// Переслать сообщение.
+    /// </summary>
+    Task<string?> ForwardMessageAsync(string fromChatId, string messageId, string toChatId,
+        bool disableNotification = false, CancellationToken ct = default);
+
+    /// <summary>
+    /// Копировать сообщение с возможностью редактирования.
+    /// </summary>
+    Task<string?> CopyMessageAsync(string fromChatId, string messageId, string toChatId,
+        string? caption = null, MessageFormat? captionFormat = null,
+        bool disableNotification = false, CancellationToken ct = default);
+
     /// <summary>
     /// Создать билдер альбома для отправки медиагруппы.
     /// </summary>
@@ -51,13 +95,19 @@ public interface IMessengerAdapter
 /// <summary>
 /// Контракт конфигурации адаптера.
 /// </summary>
-public interface IMessangerAdapterSetup : IMessengerAdapter
+public interface IMessengerAdapterSetup : IMessengerAdapter
 {
+    /// <summary>
+    /// Внутренний метод для установки ID адаптера.
+    /// </summary>
+    void SetAdapterId(string adapterId);
+
     /// <summary>
     /// Запуск работы адаптера
     /// </summary>
     /// <param name="onUpdate"></param>
+    /// <param name="commands"></param>
     /// <param name="ct"></param>
     /// <returns></returns>
-    Task StartAdapterAsync(Func<UpdateContext, Task> onUpdate, CancellationToken ct);
+    Task StartAdapterAsync(Func<UpdateContext, Task> onUpdate, List<Routing.Command> commands, CancellationToken ct);
 }

BotPages.Core/Abstractions/IMessengerAdapterFactory.cs

@@ -1,44 +1,53 @@
-using BotPages.Core.Context;
+namespace BotPages.Core.Abstractions;
-
-namespace BotPages.Core.Abstractions;
 
 /// <summary>
 /// Фабрика адаптеров мессенджеров.
-/// Используется для разрешения конкретного <see cref="IMessangerAdapterSetup"/> по типу мессенджера.
+/// Используется для разрешения конкретного <see cref="IMessengerAdapterSetup"/> по ID адаптера.
 /// </summary>
 public interface IMessengerAdapterFactory
 {
     /// <summary>
-    /// Список зарегистрированных адаптеров.
+    /// Список всех зарегистрированных адаптеров.
     /// </summary>
-    Dictionary<string, IMessangerAdapterSetup> Adapters { get; }
+    IReadOnlyList<IMessengerAdapterSetup> AllAdapters { get; }
 
     /// <summary>
-    /// Зарегистрировать адаптер для указанного типа мессенджера.
+    /// Зарегистрировать адаптер с уникальным идентификатором.
     /// </summary>
-    /// <param name="messengerType">
+    /// <param name="adapterId">Уникальный идентификатор адаптера.</param>
-    /// Тип мессенджера (например, "Telegram", "Slack", "VK").
+    /// <param name="adapter">Экземпляр адаптера.</param>
-    /// </param>
+    /// <returns>Текущий экземпляр фабрики для цепочки вызовов.</returns>
-    /// <param name="adapter">
+    /// <exception cref="ArgumentException">Если адаптер с таким ID уже зарегистрирован.</exception>
-    /// Экземпляр адаптера, реализующий <see cref="IMessengerAdapter"/>.
+    IMessengerAdapterFactory Register(string adapterId, IMessengerAdapterSetup adapter);
-    /// </param>
-    /// <returns>
-    /// Текущий экземпляр <see cref="MultiAdapterFactory"/> для цепочки вызовов.
-    /// </returns>
-    IMessengerAdapterFactory Register(string messengerType, IMessangerAdapterSetup adapter);
 
     /// <summary>
-    /// Получить адаптер для указанного мессенджера.
+    /// Зарегистрировать адаптер с автоматически сгенерированным ID.
     /// </summary>
-    /// <param name="messengerType">
+    IMessengerAdapterFactory Register(IMessengerAdapterSetup adapter);
-    /// Тип мессенджера (например, "Telegram", "Slack", "VK").
+
-    /// Значение должно совпадать с <see cref="UpdateContext.MessengerType"/>.
+    /// <summary>
-    /// </param>
+    /// Получить адаптер по ID.
-    /// <returns>
+    /// </summary>
-    /// Экземпляр <see cref="IMessengerAdapter"/>, зарегистрированный для данного типа мессенджера.
+    /// <exception cref="InvalidOperationException">Если адаптер не найден.</exception>
-    /// </returns>
+    IMessengerAdapter Resolve(string adapterId);
-    /// <exception cref="InvalidOperationException">
+
-    /// Выбрасывается, если адаптер для указанного типа не зарегистрирован.
+    /// <summary>
-    /// </exception>
+    /// Попытаться получить адаптер по ID.
-    IMessengerAdapter Resolve(string messengerType);
+    /// </summary>
+    bool TryResolve(string adapterId, out IMessengerAdapter? adapter);
+
+    /// <summary>
+    /// Получить все адаптеры определенного типа.
+    /// </summary>
+    IReadOnlyList<IMessengerAdapter> GetAdaptersByType(string adapterType);
+
+    /// <summary>
+    /// Проверить, зарегистрирован ли адаптер с указанным ID.
+    /// </summary>
+    bool Contains(string adapterId);
+
+    /// <summary>
+    /// Удалить адаптер по ID.
+    /// </summary>
+    bool Remove(string adapterId);
 }

BotPages.Core/Abstractions/MessageInfo.cs

@@ -0,0 +1,34 @@
+namespace BotPages.Core.Abstractions;
+
+/// <summary>
+/// Информация о сообщении.
+/// </summary>
+public class MessageInfo
+{
+    /// <summary>ID сообщения.</summary>
+    public required string MessageId { get; init; }
+
+    /// <summary>ID чата.</summary>
+    public required string ChatId { get; init; }
+
+    /// <summary>Текст сообщения.</summary>
+    public string? Text { get; init; }
+
+    /// <summary>Формат текста.</summary>
+    public MessageFormat? Format { get; init; }
+
+    /// <summary>Дата отправки.</summary>
+    public DateTime Date { get; init; }
+
+    /// <summary>ID отправителя.</summary>
+    public string? FromUserId { get; init; }
+
+    /// <summary>Закреплено ли сообщение.</summary>
+    public bool IsPinned { get; init; }
+
+    /// <summary>Является ли ответом на другое сообщение.</summary>
+    public bool IsReply { get; init; }
+
+    /// <summary>ID сообщения, на которое отвечает.</summary>
+    public string? ReplyToMessageId { get; init; }
+}

BotPages.Core/Abstractions/MultiAdapterFactory.cs

@@ -1,50 +1,128 @@
 namespace BotPages.Core.Abstractions;
 
-
 /// <summary>
-/// Реализация <see cref="IMessengerAdapterFactory"/>, позволяющая регистрировать и разрешать несколько адаптеров мессенджеров.
+/// Реализация <see cref="IMessengerAdapterFactory"/>, позволяющая регистрировать и разрешать несколько адаптеров.
 /// </summary>
 public sealed class MultiAdapterFactory : IMessengerAdapterFactory
 {
-    private readonly Dictionary<string, IMessangerAdapterSetup> _adapters = new(StringComparer.OrdinalIgnoreCase);
+    private readonly List<IMessengerAdapterSetup> _allAdapters = new();
+    private readonly Dictionary<string, IMessengerAdapterSetup> _adaptersById = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, List<IMessengerAdapterSetup>> _adaptersByType = new(StringComparer.OrdinalIgnoreCase);
 
     /// <summary>
-    /// Список зарегистрированных адаптеров.
+    /// Список всех зарегистрированных адаптеров.
     /// </summary>
-    public Dictionary<string, IMessangerAdapterSetup> Adapters => _adapters;
+    public IReadOnlyList<IMessengerAdapterSetup> AllAdapters => _allAdapters;
 
     /// <summary>
-    /// Зарегистрировать адаптер для указанного типа мессенджера.
+    /// Зарегистрировать адаптер с уникальным идентификатором.
     /// </summary>
-    /// <param name="messengerType">
+    public IMessengerAdapterFactory Register(string adapterId, IMessengerAdapterSetup adapter)
-    /// Тип мессенджера (например, "Telegram", "Slack", "VK").
-    /// </param>
-    /// <param name="adapter">
-    /// Экземпляр адаптера, реализующий <see cref="IMessengerAdapter"/>.
-    /// </param>
-    /// <returns>
-    /// Текущий экземпляр <see cref="MultiAdapterFactory"/> для цепочки вызовов.
-    /// </returns>
-    public IMessengerAdapterFactory Register(string messengerType, IMessangerAdapterSetup adapter)
     {
-        _adapters[messengerType] = adapter;
+        if (string.IsNullOrWhiteSpace(adapterId))
+            throw new ArgumentException("Adapter ID cannot be null or empty", nameof(adapterId));
+
+        if (_adaptersById.ContainsKey(adapterId))
+            throw new ArgumentException($"Adapter with ID '{adapterId}' is already registered", nameof(adapterId));
+
+        // Устанавливаем идентификатор в адаптер
+        adapter.SetAdapterId(adapterId);
+
+        _allAdapters.Add(adapter);
+        _adaptersById[adapterId] = adapter;
+
+        // Группируем по типу
+        var adapterType = adapter.Type;
+        if (!_adaptersByType.TryGetValue(adapterType, out var typeList))
+        {
+            typeList = new List<IMessengerAdapterSetup>();
+            _adaptersByType[adapterType] = typeList;
+        }
+        typeList.Add(adapter);
+
         return this;
     }
 
     /// <summary>
-    /// Получить адаптер для указанного мессенджера.
+    /// Зарегистрировать адаптер с автоматически сгенерированным ID.
     /// </summary>
-    /// <param name="messengerType">
+    public IMessengerAdapterFactory Register(IMessengerAdapterSetup adapter)
-    /// Тип мессенджера (например, "Telegram", "Slack", "VK").
+    {
-    /// </param>
+        var adapterId = GenerateAdapterId(adapter);
-    /// <returns>
+        return Register(adapterId, adapter);
-    /// Экземпляр <see cref="IMessengerAdapter"/>, зарегистрированный для данного типа мессенджера.
+    }
-    /// </returns>
+
-    /// <exception cref="InvalidOperationException">
+    /// <summary>
-    /// Выбрасывается, если адаптер для указанного типа не зарегистрирован.
+    /// Получить адаптер по ID.
-    /// </exception>
+    /// </summary>
-    public IMessengerAdapter Resolve(string messengerType)
+    public IMessengerAdapter Resolve(string adapterId)
-        => _adapters.TryGetValue(messengerType, out var adapter)
+    {
-            ? adapter
+        if (_adaptersById.TryGetValue(adapterId, out var adapter))
-            : throw new InvalidOperationException($"No adapter registered for {messengerType}");
+        {
+            return adapter;
+        }
+
+        throw new InvalidOperationException($"No adapter registered with ID '{adapterId}'");
+    }
+
+    /// <summary>
+    /// Попытаться получить адаптер по ID.
+    /// </summary>
+    public bool TryResolve(string adapterId, out IMessengerAdapter? adapter)
+    {
+        var result = _adaptersById.TryGetValue(adapterId, out var adapterSetup);
+        adapter = adapterSetup;
+        return result;
+    }
+
+    /// <summary>
+    /// Получить все адаптеры определенного типа.
+    /// </summary>
+    public IReadOnlyList<IMessengerAdapter> GetAdaptersByType(string adapterType)
+    {
+        if (_adaptersByType.TryGetValue(adapterType, out var adapters))
+        {
+            return adapters.AsReadOnly();
+        }
+
+        return Array.Empty<IMessengerAdapter>();
+    }
+
+    /// <summary>
+    /// Проверить, зарегистрирован ли адаптер с указанным ID.
+    /// </summary>
+    public bool Contains(string adapterId) => _adaptersById.ContainsKey(adapterId);
+
+    /// <summary>
+    /// Удалить адаптер по ID.
+    /// </summary>
+    public bool Remove(string adapterId)
+    {
+        if (_adaptersById.TryGetValue(adapterId, out var adapter))
+        {
+            _allAdapters.Remove(adapter);
+            _adaptersById.Remove(adapterId);
+
+            var adapterType = adapter.Type;
+            if (_adaptersByType.TryGetValue(adapterType, out var typeList))
+            {
+                typeList.Remove(adapter);
+                if (typeList.Count == 0)
+                {
+                    _adaptersByType.Remove(adapterType);
+                }
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    private static string GenerateAdapterId(IMessengerAdapter adapter)
+    {
+        var adapterType = adapter.Type;
+        var guid = Guid.NewGuid().ToString("N").Substring(0, 8);
+        return $"{adapterType}_{guid}".ToLowerInvariant();
+    }
 }

BotPages.Core/Abstractions/SendRequest.cs

@@ -0,0 +1,104 @@
+using BotPages.Core.Messaging;
+
+namespace BotPages.Core.Abstractions;
+
+/// <summary>
+/// Универсальная структура запроса на отправку сообщения/файла, используемая адаптерами.
+/// </summary>
+public sealed class SendRequest
+{
+    /// <summary>Идентификатор чата/сессии в мессенджере.</summary>
+    public required string ChatId { get; init; }
+
+    /// <summary>Текст сообщения (если отправляется текст).</summary>
+    public string? Text { get; init; }
+
+    /// <summary>Формат текста (HTML/Markdown/Plain).</summary>
+    public MessageFormat? TextFormat { get; init; }
+
+    /// <summary>Inline кнопки (строки кнопок).</summary>
+    public IEnumerable<IEnumerable<InlineButton>>? Inline { get; init; }
+
+    /// <summary>Reply клавиатура (строки кнопок).</summary>
+    public IEnumerable<IEnumerable<ReplyButton>>? Reply { get; init; }
+
+    /// <summary>Id редактируемого сообщения (если редактируем).</summary>
+    public string? MessageId { get; init; }
+
+    /// <summary>Файл для отправки (если отправляется файл).</summary>
+    public FileDescriptor? File { get; init; }
+
+    /// <summary>Подпись для файла.</summary>
+    public string? Caption { get; init; }
+
+    /// <summary>Формат подписи/подписи для файла.</summary>
+    public MessageFormat? CaptionFormat { get; init; }
+
+    /// <summary>
+    /// Контейнер адаптер-специфичных опций.
+    /// Содержит имена/ключи адаптеров и соответствующие объекты опций.
+    /// </summary>
+    public AdapterOptionsBag? AdapterOptions { get; init; }
+
+    /// <summary>
+    /// ID сообщения, на которое отвечаем.
+    /// </summary>
+    public string? ReplyToMessageId { get; init; }
+
+    /// <summary>
+    /// Цитировать ли оригинальное сообщение при ответе.
+    /// </summary>
+    public bool QuoteReply { get; init; } = true;
+
+    /// <summary>
+    /// Заголовок цитаты (для некоторых мессенджеров).
+    /// </summary>
+    public string? QuoteTitle { get; init; }
+
+    /// <summary>
+    /// Показывать ли предпросмотр ссылок в сообщении.
+    /// </summary>
+    public bool DisableWebPagePreview { get; init; } = false;
+
+    /// <summary>
+    /// Отключает уведомление о сообщении.
+    /// </summary>
+    public bool DisableNotification { get; init; } = false;
+
+    /// <summary>
+    /// Защищает содержимое сообщения от пересылки и сохранения.
+    /// </summary>
+    public bool ProtectContent { get; init; } = false;
+
+    /// <summary>
+    /// Стиль разметки сообщения (для некоторых мессенджеров).
+    /// </summary>
+    public MessageStyle? Style { get; init; }
+
+    /// <summary>
+    /// Позволяет указать дату отправки сообщения (для планирования).
+    /// </summary>
+    public DateTime? ScheduleDate { get; init; }
+
+    /// <summary>
+    /// Тема сообщения (для форумов и тредов).
+    /// </summary>
+    public string? Topic { get; init; }
+}
+
+/// <summary>
+/// Стиль оформления сообщения.
+/// </summary>
+public enum MessageStyle
+{
+    /// <summary>Обычный стиль.</summary>
+    Default,
+    /// <summary>Стиль заголовка.</summary>
+    Heading,
+    /// <summary>Стиль предупреждения.</summary>
+    Warning,
+    /// <summary>Стиль успеха.</summary>
+    Success,
+    /// <summary>Стиль ошибки.</summary>
+    Error
+}

BotPages.Core/BotPagesApp.cs

@@ -5,12 +5,13 @@ using BotPages.Core.Context;
 using BotPages.Core.Logging;
 using BotPages.Core.Routing;
 using System.Reflection;
+using System.Threading;
 
 /// <summary>
 /// Основное приложение BotPages.
 /// Управляет маршрутизацией, командами, middleware и страницами.
 /// </summary>
-public sealed class BotPagesApp
+public sealed class BotPagesApp : IDisposable, IAsyncDisposable
 {
     private readonly IMessengerAdapterFactory _adapterFactory;
     private readonly List<IPageMiddleware> _middlewares = new();
@@ -19,12 +20,21 @@ public sealed class BotPagesApp
     private readonly IStateStorage _state;
     private readonly ILogger _logger;
     private readonly NavigationService _navigation;
+    private CancellationTokenSource? _internalCts;
+    private bool _isRunning;
+    private bool _disposed;
 
     /// <summary>
     /// Серсвис логирования.
     /// </summary>
     public ILogger Logger => _logger;
 
+    /// <summary>
+    /// ТОкен отмены приложения. Отменяется при вызове Stop() или при отмене внешнего токена, переданного в RunAsync.
+    /// </summary>
+    public CancellationToken CancellationToken => _internalCts?.Token ?? CancellationToken.None;
+
+
     /// <summary>
     /// Создать приложение BotPages.
     /// </summary>
@@ -38,14 +48,40 @@ public sealed class BotPagesApp
     }
 
     /// <summary>
-    /// Добавить адаптер.
+    /// Добавить адаптер с указанием ID.
     /// </summary>
-    public BotPagesApp AddAdapter(string messengerType, IMessangerAdapterSetup adapter)
+    /// <exception cref="ArgumentException">Если адаптер с таким ID уже существует.</exception>
+    public BotPagesApp AddAdapter(string adapterId, IMessengerAdapterSetup adapter)
     {
-        _adapterFactory.Register(messengerType, adapter);
+        _adapterFactory.Register(adapterId, adapter);
         return this;
     }
 
+    /// <summary>
+    /// Добавить адаптер с автоматическим ID.
+    /// </summary>
+    public BotPagesApp AddAdapter(IMessengerAdapterSetup adapter)
+    {
+        _adapterFactory.Register(adapter);
+        return this;
+    }
+
+    /// <summary>
+    /// Проверить, существует ли адаптер с указанным ID.
+    /// </summary>
+    public bool HasAdapter(string adapterId) => _adapterFactory.Contains(adapterId);
+
+    /// <summary>
+    /// Получить адаптер по ID.
+    /// </summary>
+    public IMessengerAdapter GetAdapter(string adapterId) => _adapterFactory.Resolve(adapterId);
+
+    /// <summary>
+    /// Получить все адаптеры определенного типа.
+    /// </summary>
+    public IReadOnlyList<IMessengerAdapter> GetAdaptersByType(string adapterType)
+        => _adapterFactory.GetAdaptersByType(adapterType);
+
     /// <summary>
     /// Установить страницу по умолчанию.
     /// </summary>
@@ -69,16 +105,34 @@ public sealed class BotPagesApp
     /// </summary>
     public BotPagesApp MapCommand<TPage>(string commandTemplate) where TPage : Page
     {
-        _commands.Map<TPage>(commandTemplate);
+        _commands.Map<TPage>(commandTemplate, false, null);
+        return this;
+    }
+
+    /// <summary>
+    /// Зарегистрировать команду, ведущую на страницу.
+    /// </summary>
+    public BotPagesApp MapCommand<TPage>(string commandTemplate, bool publish, string description) where TPage : Page
+    {
+        _commands.Map<TPage>(commandTemplate, publish, description);
         return this;
     }
 
     /// <summary>
     /// Зарегистрировать команду с кастомным обработчиком.
     /// </summary>
-    public BotPagesApp MapCommand(string template, Func<PageContext, CancellationToken, Task> handler)
+    public BotPagesApp MapCommand(string template, CommandHandler handler)
     {
-        _commands.Map(template, handler);
+        _commands.Map(template, handler, false, null);
+        return this;
+    }
+
+    /// <summary>
+    /// Зарегистрировать команду с кастомным обработчиком.
+    /// </summary>
+    public BotPagesApp MapCommand(string template, CommandHandler handler, bool publish, string description)
+    {
+        _commands.Map(template, handler, publish, description);
         return this;
     }
 
@@ -133,16 +187,15 @@ public sealed class BotPagesApp
     /// <summary>
     /// Обработать входящее обновление.
     /// </summary>
-    public async Task HandleUpdateAsync(UpdateContext update, CancellationToken ct)
+    public async Task HandleUpdateAsync(UpdateContext update)
     {
-        var ctx = await CreatePageContextAsync(update, ct);
+        var ctx = await CreatePageContextAsync(update);
 
         // Команды выше событий страниц
         if (update.Kind == UpdateKind.Text && update.Text is not null && update.Text.StartsWith("/"))
         {
-            if (_commands.TryDispatch(ctx, update.Text, ct, out var dispatched) && dispatched is not null)
+            if (_commands.TryDispatch(ctx, update.Text, this.CancellationToken, out var dispatched) && dispatched is not null)
             {
-                _logger.Log(LogLevel.Info, $"Command '{update.Text}' dispatched.");
                 await dispatched;
                 return;
             }
@@ -151,74 +204,72 @@ public sealed class BotPagesApp
         // Конвейер middleware
         var pipeline = BuildPipeline(ctx, async () =>
         {
-            await DispatchToPageAsync(ctx, update, ct);
+            await DispatchToPageAsync(ctx, update);
         });
 
         await pipeline();
     }
 
+    /// <summary>
+    /// Создать контекст страницы для текущего обновления.
+    /// </summary>
+    private async Task<PageContext> CreatePageContextAsync(UpdateContext update)
+    {
+        var sessionKey = CompositeSessionKey.FromUpdate(update);
+
+        var ctx = new PageContext
+        {
+            Update = update,
+            SessionKey = sessionKey,
+            StateStorage = _state,
+            Navigation = _navigation,
+            Adapter = _adapterFactory.Resolve(update.Adapter.Id),
+            AdapterFactory = _adapterFactory,
+        };
+
+        return await Task.FromResult(ctx);
+    }
+
     private Func<Task> BuildPipeline(PageContext ctx, Func<Task> terminal)
     {
         Func<Task> next = terminal;
         foreach (var mw in _middlewares.AsEnumerable().Reverse())
         {
             var prev = next;
-            next = () => mw.InvokeAsync(ctx, prev, _currentCt);
+            next = () => mw.InvokeAsync(ctx, prev, this.CancellationToken);
         }
         return next;
     }
 
-    // Технические поля для конвейера
-    private CancellationToken _currentCt;
-
-    /// <summary>
-    /// Создать контекст страницы для текущего обновления.
-    /// </summary>
-    private async Task<PageContext> CreatePageContextAsync(UpdateContext update, CancellationToken ct)
-    {
-        _currentCt = ct;
-
-        var sessionKey = new CompositeSessionKey(update.MessengerType, update.Chat.Id, update.User.Id);
-
-        var ctx = new PageContext
-        {
-            Update = update,
-            SessionKey = sessionKey,
-            StateStorage = _state,
-            Navigation = _navigation,
-            Adapter = _adapterFactory.Resolve(update.MessengerType),
-        };
-
-        return await Task.FromResult(ctx);
-    }
-
     /// <summary>
     /// Отправить обновление на текущую страницу.
     /// </summary>
-    private async Task DispatchToPageAsync(PageContext ctx, UpdateContext update, CancellationToken ct)
+    private async Task DispatchToPageAsync(PageContext ctx, UpdateContext update)
     {
         var page = ResolveCurrentPage(ctx);
 
         if (page is null)
         {
-            await ctx.Navigation.GoToHomeAsync(ctx, ct);
+            await ctx.Navigation.GoToHomeAsync(ctx, this.CancellationToken);
             return;
         }
 
 
         try
         {
-            await page.OnUpdate(ctx, update, ct);
+            await page.OnUpdate(ctx, update, this.CancellationToken);
 
-            if (update.Kind.HasFlag(UpdateKind.Text) && update.Text is not null) await page.OnText(ctx, update.Text, ct);
+            if (update.Kind.HasFlag(UpdateKind.Text) && update.Text is not null) await page.OnText(ctx, update.Text, this.CancellationToken);
-            if (update.Kind.HasFlag(UpdateKind.Button) && update.Text is not null) await page.OnButton(ctx, update.Text, ct);
+            if (update.Kind.HasFlag(UpdateKind.Button) && update.Text is not null) await page.OnButton(ctx, update.Text, this.CancellationToken);
-            if (update.Kind.HasFlag(UpdateKind.File) && update.Files.Count > 0) await page.OnFile(ctx, update.Files, ct);
+            if (update.Kind.HasFlag(UpdateKind.File) && update.Files.Count > 0) await page.OnFile(ctx, update.Files, this.CancellationToken);
+            if (update.Kind.HasFlag(UpdateKind.Pin) && update.PinInfo is not null) await page.OnPin(ctx, update.PinInfo, this.CancellationToken);
+            if (update.Kind.HasFlag(UpdateKind.Delete) && update.DeleteInfo is not null) await page.OnDelete(ctx, update.DeleteInfo, this.CancellationToken);
 
         }
         catch (Exception ex)
         {
             _logger.Log(LogLevel.Critical, "Unhandled page error.", ex);
-            await page.OnError(ctx, ex, ct);
+            await page.OnError(ctx, ex, this.CancellationToken);
         }
     }
 
@@ -228,16 +279,166 @@ public sealed class BotPagesApp
     private Page? ResolveCurrentPage(PageContext ctx)
         => _navigation.ResolveCurrentPage(ctx);
 
+
+    /// <summary>
+    /// Запустить приложение и синхронно ожидать его завершения.
+    /// </summary>
+    /// <param name="ct">Токен отмены для остановки приложения извне</param>
+    public void Run(CancellationToken ct = default)
+    {
+        RunAsync(ct).Wait();
+    }
+
     /// <summary>
     /// Сборка и запуск приложения.
     /// </summary>
-    /// <param name="cancellationToken"></param>
     /// <returns></returns>
-    public async Task Build(CancellationToken cancellationToken)
+    public async Task RunAsync() => await RunAsync(new CancellationTokenSource().Token);
+
+    /// <summary>
+    /// Сборка и запуск приложения.
+    /// </summary>
+    /// <returns></returns>
+    public async Task RunAsync(CancellationToken ct = default)
     {
-        foreach (var adapter in _adapterFactory.Adapters)
+        if (_isRunning)
+            throw new InvalidOperationException("Application is already running.");
+
+        if (_disposed)
+            throw new ObjectDisposedException(nameof(BotPagesApp));
+
+        _internalCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+
+        try
         {
-            await adapter.Value.StartAdapterAsync(update => HandleUpdateAsync(update, cancellationToken), cancellationToken);
+            _logger.Log(LogLevel.Info, "Starting BotPages application...");
+
+            var adapterTasks = new List<Task>();
+            foreach (var adapter in _adapterFactory.AllAdapters)
+            {
+                var adapterTask = adapter.StartAdapterAsync(HandleUpdateAsync, _commands.Commands, CancellationToken);
+                adapterTasks.Add(adapterTask);
+            }
+
+            await Task.WhenAll(adapterTasks);
+
+            _isRunning = true;
+            _logger.Log(LogLevel.Info, "BotPages application started successfully.");
+        }
+        catch (Exception ex)
+        {
+            _internalCts?.Dispose();
+            _internalCts = null;
+            _logger.Log(LogLevel.Critical, "Failed to start BotPages application.", ex);
+            throw;
+        }
+
+        _isRunning = true;
+    }
+
+    /// <summary>
+    /// Остановить работу приложения.
+    /// </summary>
+    public void Stop()
+    {
+        if (!_isRunning || _disposed)
+            return;
+
+        _logger.Log(LogLevel.Info, "Stopping BotPages application...");
+        _internalCts?.Cancel();
+    }
+
+    /// <summary>
+    /// Синхронно ожидать завершения работы приложения.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Если приложение не запущено</exception>
+    public void Wait()
+    {
+        if (!_isRunning)
+            throw new InvalidOperationException("Application is not running.");
+
+        try
+        {
+            // Ждем, пока токен не будет отменен
+            WaitHandle.WaitAny([_internalCts.Token.WaitHandle]);
+        }
+        catch (AggregateException ex) when (ex.InnerException is OperationCanceledException)
+        {
+            // Игнорируем отмену операции
+        }
+        finally
+        {
+            _isRunning = false;
+        }
+    }
+
+    /// <summary>
+    /// Асинхронно ожидать завершения работы приложения.
+    /// Ожидает, пока не будет вызван <see cref="Stop"/> или внешний <see cref="CancellationTokenSource"/> не будет отменен.
+    /// </summary>
+    public async Task WaitAsync()
+    {
+        if (!_isRunning || _internalCts == null)
+            return;
+
+        try
+        {
+            var tcs = new TaskCompletionSource<bool>();
+
+            using (_internalCts.Token.Register(() => tcs.TrySetResult(true)))
+            {
+                await tcs.Task;
+            }
+        }
+        catch (ObjectDisposedException)
+        {
+            // Токен уже освобожден
+        }
+        finally
+        {
+            _isRunning = false;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Dispose()
+    {
+        DisposeAsync().AsTask().Wait();
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask DisposeAsync()
+    {
+        if (_disposed)
+            return;
+
+        _disposed = true;
+
+        // Останавливаем приложение, если оно запущено
+        if (_isRunning)
+        {
+            Stop();
+        }
+
+        _internalCts?.Dispose();
+
+        foreach (var adapter in _adapterFactory.AllAdapters)
+        {
+            try
+            {
+                if (adapter is IAsyncDisposable asyncDisposable)
+                {
+                    await asyncDisposable.DisposeAsync();
+                }
+                else if (adapter is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.Log(LogLevel.Warn, $"Error disposing adapter {adapter.Id}: {ex.Message}");
+            }
         }
     }
 }

BotPages.Core/Context/ChatContext.cs

@@ -1,6 +1,4 @@
-using BotPages.Core.Abstractions;
+namespace BotPages.Core;
-
-namespace BotPages.Core;
 
 /// <summary>
 /// Данные чата.

BotPages.Core/Context/DeleteInfo.cs

@@ -0,0 +1,16 @@
+namespace BotPages.Core.Context;
+
+/// <summary>
+/// Информация об удалении сообщения.
+/// </summary>
+public class DeleteInfo
+{
+    /// <summary>ID удаленного сообщения.</summary>
+    public required string MessageId { get; init; }
+
+    /// <summary>Дата удаления.</summary>
+    public DateTime DeleteDate { get; init; }
+
+    /// <summary>Удалено ли массово.</summary>
+    public bool IsBulkDelete { get; init; }
+}

BotPages.Core/Context/EditInfo.cs

@@ -0,0 +1,16 @@
+namespace BotPages.Core.Context;
+
+/// <summary>
+/// Информация о редактировании сообщения.
+/// </summary>
+public class EditInfo
+{
+    /// <summary>Новый текст сообщения.</summary>
+    public string? NewText { get; init; }
+
+    /// <summary>Дата редактирования.</summary>
+    public DateTime EditDate { get; init; }
+
+    /// <summary>Были ли изменены кнопки.</summary>
+    public bool ButtonsChanged { get; init; }
+}

BotPages.Core/Context/PageContext.cs

@@ -1,6 +1,5 @@
 using BotPages.Core.Abstractions;
 using BotPages.Core.Context;
-using BotPages.Core.Messaging;
 
 namespace BotPages.Core;
 
@@ -17,9 +16,14 @@ public sealed class PageContext
 
     /// <summary>Хранилище состояния.</summary>
     public required IStateStorage StateStorage { get; init; }
+
     /// <summary>Сервис навигации.</summary>
     public required NavigationService Navigation { get; init; }
-    /// <summary>Адаптер мессенджера.</summary>
+
+    /// <summary>Фабрика адаптеров (для получения других адаптеров).</summary>
+    public required IMessengerAdapterFactory AdapterFactory { get; init; }
+
+    /// <summary>Текущий адаптер мессенджера.</summary>
     public required IMessengerAdapter Adapter { get; init; }
 
     /// <summary>
@@ -27,4 +31,36 @@ public sealed class PageContext
     /// </summary>
     public IAlbumBuilder Albums => Adapter.CreateAlbumBuilder(this);
 
+    /// <summary>
+    /// Получить адаптер по ID.
+    /// </summary>
+    public IMessengerAdapter GetAdapter(string adapterId)
+        => AdapterFactory.Resolve(adapterId);
+
+    /// <summary>
+    /// Попытаться получить адаптер по ID.
+    /// </summary>
+    public bool TryGetAdapter(string adapterId, out IMessengerAdapter? adapter)
+        => AdapterFactory.TryResolve(adapterId, out adapter);
+
+    /// <summary>
+    /// Получить все адаптеры определенного типа.
+    /// </summary>
+    public IReadOnlyList<IMessengerAdapter> GetAdaptersByType(string adapterType)
+        => AdapterFactory.GetAdaptersByType(adapterType);
+
+    /// <summary>
+    /// Получить текущий тип адаптера.
+    /// </summary>
+    public string CurrentAdapterType => Update.Adapter.Type;
+
+    /// <summary>
+    /// Получить текущий ID адаптера.
+    /// </summary>
+    public string CurrentAdapterId => Update.Adapter.Id;
+
+    /// <summary>
+    /// Получить все адаптеры.
+    /// </summary>
+    public IReadOnlyList<IMessengerAdapter> AllAdapters => AdapterFactory.AllAdapters;
 }

BotPages.Core/Context/PageContextAdapterExtensions.cs

@@ -4,38 +4,124 @@ using BotPages.Core.Messaging;
 namespace BotPages.Core;
 
 /// <summary>
-/// Расширения <see cref="PageContext"/> для работы с <see cref="IMessengerAdapter"/>
+/// Расширения <see cref="PageContext"/> для работы с адаптером.
+/// Упрощают создание универсального `SendRequest`.
 /// </summary>
 public static class PageContextAdapterExtensions
 {
     /// <summary>
-    /// Отправить текстовое сообщение.
+    /// Отправить сообщение универсальным запросом через привязанный адаптер.
     /// </summary>
-    public static Task<string?> SendTextAsync(this PageContext ctx, 
+    public static Task<string?> SendAsync(this PageContext ctx, SendRequest request, CancellationToken ct = default)
-        string text, 
+        => ctx.Adapter.SendAsync(request, ct);
-        MessageFormat format = MessageFormat.Plain,
-        IEnumerable<IEnumerable<InlineButton>>? inline = null,
-        IEnumerable<IEnumerable<ReplyButton>>? reply = null,
-        string? messageId = null,
-        CancellationToken ct = default)
-        => ctx.Adapter.SendTextAsync(ctx.Update.Chat.Id, text, format, inline, reply, messageId, ct);
 
     /// <summary>
-    /// Отправить файл.
+    /// Удалить сообщение через привязанный адаптер.
     /// </summary>
-    public static Task SendFileAsync(this PageContext ctx, 
+    public static Task DeleteAsync(this PageContext ctx, string chatId, string messageId, CancellationToken ct = default)
-        FileDescriptor file, 
+        => ctx.Adapter.DeleteAsync(chatId, messageId, ct);
-        string? caption = null, 
+
-        MessageFormat? captionFormat = null,
+    /// <summary>
-        IEnumerable<IEnumerable<InlineButton>>? inline = null,
+    /// Удалить сообщение (используя ChatId из контекста).
-        IEnumerable<IEnumerable<ReplyButton>>? reply = null,
+    /// </summary>
-        CancellationToken ct = default
+    public static Task DeleteAsync(this PageContext ctx, string messageId, CancellationToken ct = default)
-    )
+        => ctx.Adapter.DeleteAsync(ctx.Update.Chat.Id, messageId, ct);
-        => ctx.Adapter.SendFileAsync(chatId: ctx.Update.Chat.Id, 
+
-            file: file, 
+    /// <summary>
-            caption: caption, 
+    /// Удалить несколько сообщений.
-            captionFormat: captionFormat,
+    /// </summary>
-            inline: inline,
+    public static Task<bool> DeleteMultipleAsync(this PageContext ctx, string chatId, IEnumerable<string> messageIds, CancellationToken ct = default)
-            reply: reply,
+        => ctx.Adapter.DeleteMultipleAsync(chatId, messageIds, ct);
-            ct: ct);
+
+    /// <summary>
+    /// Удалить несколько сообщений (используя ChatId из контекста).
+    /// </summary>
+    public static Task<bool> DeleteMultipleAsync(this PageContext ctx, IEnumerable<string> messageIds, CancellationToken ct = default)
+        => ctx.Adapter.DeleteMultipleAsync(ctx.Update.Chat.Id, messageIds, ct);
+
+    /// <summary>
+    /// Редактировать текст сообщения.
+    /// </summary>
+    public static Task<string?> EditTextAsync(this PageContext ctx, string chatId, string messageId, string text,
+        MessageFormat? format = null, CancellationToken ct = default)
+        => ctx.Adapter.EditTextAsync(chatId, messageId, text, format, ct);
+
+    /// <summary>
+    /// Редактировать текст сообщения (используя ChatId из контекста).
+    /// </summary>
+    public static Task<string?> EditTextAsync(this PageContext ctx, string messageId, string text,
+        MessageFormat? format = null, CancellationToken ct = default)
+        => ctx.Adapter.EditTextAsync(ctx.Update.Chat.Id, messageId, text, format, ct);
+
+    /// <summary>
+    /// Редактировать кнопки сообщения.
+    /// </summary>
+    public static Task<string?> EditButtonsAsync(this PageContext ctx, string chatId, string messageId,
+        IEnumerable<IEnumerable<InlineButton>>? inlineButtons = null, CancellationToken ct = default)
+        => ctx.Adapter.EditButtonsAsync(chatId, messageId, inlineButtons, ct);
+
+    /// <summary>
+    /// Редактировать кнопки сообщения (используя ChatId из контекста).
+    /// </summary>
+    public static Task<string?> EditButtonsAsync(this PageContext ctx, string messageId,
+        IEnumerable<IEnumerable<InlineButton>>? inlineButtons = null, CancellationToken ct = default)
+        => ctx.Adapter.EditButtonsAsync(ctx.Update.Chat.Id, messageId, inlineButtons, ct);
+
+    /// <summary>
+    /// Закрепить сообщение.
+    /// </summary>
+    public static Task<bool> PinMessageAsync(this PageContext ctx, string chatId, string messageId,
+        bool disableNotification = false, CancellationToken ct = default)
+        => ctx.Adapter.PinMessageAsync(chatId, messageId, disableNotification, ct);
+
+    /// <summary>
+    /// Закрепить сообщение (используя ChatId из контекста).
+    /// </summary>
+    public static Task<bool> PinMessageAsync(this PageContext ctx, string messageId,
+        bool disableNotification = false, CancellationToken ct = default)
+        => ctx.Adapter.PinMessageAsync(ctx.Update.Chat.Id, messageId, disableNotification, ct);
+
+    /// <summary>
+    /// Открепить сообщение.
+    /// </summary>
+    public static Task<bool> UnpinMessageAsync(this PageContext ctx, string chatId, string messageId,
+        CancellationToken ct = default)
+        => ctx.Adapter.UnpinMessageAsync(chatId, messageId, ct);
+
+    /// <summary>
+    /// Открепить сообщение (используя ChatId из контекста).
+    /// </summary>
+    public static Task<bool> UnpinMessageAsync(this PageContext ctx, string messageId,
+        CancellationToken ct = default)
+        => ctx.Adapter.UnpinMessageAsync(ctx.Update.Chat.Id, messageId, ct);
+
+    /// <summary>
+    /// Получить информацию о сообщении.
+    /// </summary>
+    public static Task<MessageInfo?> GetMessageInfoAsync(this PageContext ctx, string chatId, string messageId,
+        CancellationToken ct = default)
+        => ctx.Adapter.GetMessageInfoAsync(chatId, messageId, ct);
+
+    /// <summary>
+    /// Получить информацию о сообщении (используя ChatId из контекста).
+    /// </summary>
+    public static Task<MessageInfo?> GetMessageInfoAsync(this PageContext ctx, string messageId,
+        CancellationToken ct = default)
+        => ctx.Adapter.GetMessageInfoAsync(ctx.Update.Chat.Id, messageId, ct);
+
+    /// <summary>
+    /// Переслать сообщение.
+    /// </summary>
+    public static Task<string?> ForwardMessageAsync(this PageContext ctx, string fromChatId, string messageId,
+        string toChatId, bool disableNotification = false, CancellationToken ct = default)
+        => ctx.Adapter.ForwardMessageAsync(fromChatId, messageId, toChatId, disableNotification, ct);
+
+    /// <summary>
+    /// Копировать сообщение.
+    /// </summary>
+    public static Task<string?> CopyMessageAsync(this PageContext ctx, string fromChatId, string messageId,
+        string toChatId, string? caption = null, MessageFormat? captionFormat = null,
+        bool disableNotification = false, CancellationToken ct = default)
+        => ctx.Adapter.CopyMessageAsync(fromChatId, messageId, toChatId, caption, captionFormat,
+            disableNotification, ct);
 }

BotPages.Core/Context/PinInfo.cs

@@ -0,0 +1,16 @@
+namespace BotPages.Core.Context;
+
+/// <summary>
+/// Информация о закреплении сообщения.
+/// </summary>
+public class PinInfo
+{
+    /// <summary>ID закрепленного сообщения.</summary>
+    public required string MessageId { get; init; }
+
+    /// <summary>Дата закрепления.</summary>
+    public DateTime PinDate { get; init; }
+
+    /// <summary>Отключено ли уведомление.</summary>
+    public bool NotificationDisabled { get; init; }
+}

BotPages.Core/Context/UpdateContext.cs

@@ -1,25 +1,6 @@
-namespace BotPages.Core.Context;
+using BotPages.Core.Abstractions;
 
-using BotPages.Core.Abstractions;
+namespace BotPages.Core.Context;
-
-/// <summary>
-/// Тип входящего обновления.
-/// </summary>
-[Flags]
-public enum UpdateKind
-{
-    /// <summary>Неизвестное сообщение.</summary>
-    None = 0,
-
-    /// <summary>Текстовое сообщение.</summary>
-    Text = 1 << 0,
-
-    /// <summary>Файлы (один или несколько).</summary>
-    File = 1 << 1,
-
-    /// <summary>Нажатие кнопки.</summary>
-    Button = 1 << 2,
-}
 
 /// <summary>
 /// Контекст входящего обновления от мессенджера.
@@ -27,8 +8,8 @@ public enum UpdateKind
 /// </summary>
 public sealed class UpdateContext
 {
-    /// <summary>Тип мессенджера.</summary>
+    /// <summary>Адаптер, от которого пришло обновление.</summary>
-    public required string MessengerType { get; init; }
+    public required IMessengerAdapter Adapter { get; init; }
 
     /// <summary>
     /// Данные пользователя, от которого пришло обновление.
@@ -51,9 +32,34 @@ public sealed class UpdateContext
     /// </summary>
     public string? Text { get; init; }
 
+    /// <summary>
+    /// ID сообщения, к которому относится обновление.
+    /// </summary>
+    public string? MessageId { get; init; }
+
+    /// <summary>
+    /// ID сообщения, на которое дан ответ (если есть).
+    /// </summary>
+    public string? ReplyToMessageId { get; init; }
+
     /// <summary>
     /// Список файлов, если Kind = File.
     /// Может содержать один или несколько файлов.
     /// </summary>
     public List<FileDescriptor> Files { get; init; } = new();
+
+    /// <summary>
+    /// Информация о редактировании (если Kind = Edit).
+    /// </summary>
+    public EditInfo? EditInfo { get; init; }
+
+    /// <summary>
+    /// Информация об удалении (если Kind = Delete).
+    /// </summary>
+    public DeleteInfo? DeleteInfo { get; init; }
+
+    /// <summary>
+    /// Информация о закреплении (если Kind = Pin).
+    /// </summary>
+    public PinInfo? PinInfo { get; init; }
 }

BotPages.Core/Context/UpdateKind.cs

@@ -0,0 +1,32 @@
+namespace BotPages.Core.Context;
+
+/// <summary>
+/// Тип входящего обновления.
+/// </summary>
+[Flags]
+public enum UpdateKind
+{
+    /// <summary>Неизвестное сообщение.</summary>
+    None = 0,
+
+    /// <summary>Текстовое сообщение.</summary>
+    Text = 1 << 0,
+
+    /// <summary>Файлы (один или несколько).</summary>
+    File = 1 << 1,
+
+    /// <summary>Нажатие кнопки.</summary>
+    Button = 1 << 2,
+
+    /// <summary>Редактирование сообщения.</summary>
+    Edit = 1 << 3,
+
+    /// <summary>Удаление сообщения.</summary>
+    Delete = 1 << 4,
+
+    /// <summary>Закрепление сообщения.</summary>
+    Pin = 1 << 5,
+
+    /// <summary>Ответ на сообщение.</summary>
+    Reply = 1 << 6,
+}

BotPages.Core/Messaging/InlineButton.cs

@@ -22,6 +22,11 @@ public class InlineButton
         this.Value = value;
     }
 
+    /// <summary>
+    /// Стиль кнопки.
+    /// </summary>
+    public ButtonStyle Style { get; set; } = ButtonStyle.Default;
+
     /// <inheritdoc/>
     public InlineButton(Enum value)
     {

BotPages.Core/Messaging/MessageBuilder.cs

@@ -4,6 +4,7 @@ namespace BotPages.Core.Messaging;
 
 /// <summary>
 /// Fluent‑билдер для отправки сообщений (текст, кнопки, файлы, альбомы, прогресс).
+/// Поддерживает указание адаптер-специфичных опций через <see cref="WithAdapterOption{T}(string, T)"/>.
 /// </summary>
 public sealed class MessageBuilder
 {
@@ -15,11 +16,88 @@ public sealed class MessageBuilder
     private readonly List<(FileDescriptor file, string? caption, MessageFormat? captionFormat)> _files = new();
     private readonly List<(FileDescriptor file, string? caption, MessageFormat? captionFormat)> _album = new();
     private bool _disableReplyKeyboard;
-    private string? _editMessageId = null;
+    private AdapterOptionsBag? _adapterOptions = null;
+    private string? _replyToMessageId = null;
+    private bool _quoteReply = true;
+    private string? _quoteTitle = null;
+    private bool _disableWebPagePreview = false;
+    private bool _disableNotification = false;
+    private bool _protectContent = false;
+    private MessageStyle? _style = null;
+    private DateTime? _scheduleDate = null;
+    private string? _topic = null;
+    private string? _messageId = null;
+    private IMessengerAdapter? _targetAdapter = null;
+    private string? _targetChatId = null;
 
     /// <summary>Создать билдер сообщений.</summary>
     public MessageBuilder(PageContext ctx) => _ctx = ctx;
 
+    /// <summary>
+    /// Отправить сообщение через указанный адаптер.
+    /// </summary>
+    public MessageBuilder WithAdapter(IMessengerAdapter adapter)
+    {
+        _targetAdapter = adapter;
+        return this;
+    }
+    /// <summary>
+    /// Отправить сообщение через адаптер по ID.
+    /// </summary>
+    public MessageBuilder WithAdapter(string adapterId)
+    {
+        _targetAdapter = _ctx.AdapterFactory.Resolve(adapterId);
+        return this;
+    }
+
+    /// <summary>
+    /// Использовать текущий адаптер (по умолчанию).
+    /// </summary>
+    public MessageBuilder UseCurrentAdapter()
+    {
+        _targetAdapter = null;
+        return this;
+    }
+
+    /// <summary>
+    /// Отправить в указанный чат (с указанием адаптера).
+    /// </summary>
+    public MessageBuilder ToChat(string chatId, IMessengerAdapter? adapter)
+    {
+        _targetChatId = chatId;
+        _targetAdapter = adapter;
+        return this;
+    }
+
+    /// <summary>
+    /// Отправить в указанный чат через адаптер по ID.
+    /// </summary>
+    public MessageBuilder ToChat(string chatId, string adapterId)
+    {
+        _targetChatId = chatId;
+        _targetAdapter = _ctx.AdapterFactory.Resolve(adapterId);
+        return this;
+    }
+
+    /// <summary>
+    /// Отправить в указанный чат.
+    /// </summary>
+    public MessageBuilder ToChat(string chatId)
+    {
+        _targetChatId = chatId;
+        return this;
+    }
+
+    /// <summary>
+    /// Установить опции для конкретного адаптера. Ключ адаптера определяется адаптером (напр., "telegram").
+    /// </summary>
+    public MessageBuilder WithAdapterOption<T>(string adapterType, T options)
+    {
+        if (_adapterOptions is null) _adapterOptions = new AdapterOptionsBag();
+        _adapterOptions.Set(adapterType, options);
+        return this;
+    }
+
     /// <summary>Текст сообщения.</summary>
     public MessageBuilder Text(string text, MessageFormat format = MessageFormat.Plain)
     {
@@ -28,10 +106,68 @@ public sealed class MessageBuilder
         return this;
     }
 
-    /// <summary>Редактировать сообщение.</summary>
+    /// <summary>Стиль сообщения.</summary>
-    public MessageBuilder EditMessage(string messagId)
+    public MessageBuilder Style(MessageStyle style)
     {
-        _editMessageId = messagId;
+        _style = style;
+        return this;
+    }
+
+    /// <summary>Тема сообщения (для форумов).</summary>
+    public MessageBuilder Topic(string topic)
+    {
+        _topic = topic;
+        return this;
+    }
+
+    /// <summary>Запланировать отправку на определенную дату.</summary>
+    public MessageBuilder Schedule(DateTime scheduleDate)
+    {
+        _scheduleDate = scheduleDate;
+        return this;
+    }
+
+    /// <summary>Отключить предпросмотр ссылок.</summary>
+    public MessageBuilder DisableWebPagePreview()
+    {
+        _disableWebPagePreview = true;
+        return this;
+    }
+
+    /// <summary>Отключить уведомление.</summary>
+    public MessageBuilder DisableNotification()
+    {
+        _disableNotification = true;
+        return this;
+    }
+
+    /// <summary>Защитить содержимое от пересылки.</summary>
+    public MessageBuilder ProtectContent()
+    {
+        _protectContent = true;
+        return this;
+    }
+
+    /// <summary>Ответить на сообщение.</summary>
+    public MessageBuilder ReplyTo(string messageId, bool quote = true, string? quoteTitle = null)
+    {
+        _replyToMessageId = messageId;
+        _quoteReply = quote;
+        _quoteTitle = quoteTitle;
+        return this;
+    }
+
+    /// <summary>Ответить на текущее сообщение.</summary>
+    public MessageBuilder ReplyToCurrent(bool quote = true, string? quoteTitle = null)
+    {
+        if (_ctx.Update is not null)
+        {
+            // Предполагаем, что Update содержит ID текущего сообщения
+            // Это может потребовать расширения UpdateContext
+            _replyToMessageId = _ctx.Update.MessageId;
+            _quoteReply = quote;
+            _quoteTitle = quoteTitle;
+        }
         return this;
     }
 
@@ -63,7 +199,7 @@ public sealed class MessageBuilder
         return this;
     }
 
-    /// <summary>Добавить строку inline‑кнопок.</summary>
+    /// <summary>Добавить строки inline‑кнопок.</summary>
     public MessageBuilder Inline(IEnumerable<IEnumerable<InlineButton>> row)
     {
         _inline.AddRange(row.Select(t => t.ToList()).ToList());
@@ -73,7 +209,6 @@ public sealed class MessageBuilder
     /// <summary>
     /// Отключение Reply клавиатуры.
     /// </summary>
-    /// <returns></returns>
     public MessageBuilder DisableReply()
     {
         _disableReplyKeyboard = true;
@@ -96,7 +231,7 @@ public sealed class MessageBuilder
         return this;
     }
 
-    /// <summary>Добавить строку reply‑кнопок.</summary>
+    /// <summary>Добавить строки reply‑кнопок.</summary>
     public MessageBuilder Reply(IEnumerable<IEnumerable<ReplyButton>> row)
     {
         _disableReplyKeyboard = false;
@@ -118,46 +253,238 @@ public sealed class MessageBuilder
         return this;
     }
 
+    /// <summary>Удалить сообщение.</summary>
+    public async Task DeleteAsync(string messageId, CancellationToken ct = default)
+    {
+        await _ctx.Adapter.DeleteAsync(GetEffectiveChatId(), messageId, ct);
+    }
+
+    /// <summary>Удалить несколько сообщений.</summary>
+    public async Task<bool> DeleteMultipleAsync(IEnumerable<string> messageIds, CancellationToken ct = default)
+    {
+        return await _ctx.Adapter.DeleteMultipleAsync(GetEffectiveChatId(), messageIds, ct);
+    }
+
+    /// <summary>Редактировать только текст сообщения.</summary>
+    public async Task<string?> EditTextAsync(string messageId, string newText,
+        MessageFormat? format = null, CancellationToken ct = default)
+    {
+        return await _ctx.Adapter.EditTextAsync(
+            GetEffectiveChatId(),
+            messageId,
+            newText,
+            format ?? _format,
+            ct);
+    }
+
+    /// <summary>Редактировать только кнопки сообщения.</summary>
+    public async Task<string?> EditButtonsAsync(string messageId,
+        IEnumerable<IEnumerable<InlineButton>>? inlineButtons = null,
+        CancellationToken ct = default)
+    {
+        return await _ctx.Adapter.EditButtonsAsync(
+            GetEffectiveChatId(),
+            messageId,
+            inlineButtons ?? _inline,
+            ct);
+    }
+
+    /// <summary>Закрепить сообщение.</summary>
+    public async Task<bool> PinAsync(string messageId, bool disableNotification = false,
+        CancellationToken ct = default)
+    {
+        return await _ctx.Adapter.PinMessageAsync(
+            GetEffectiveChatId(),
+            messageId,
+            disableNotification,
+            ct);
+    }
+
+    /// <summary>Открепить сообщение.</summary>
+    public async Task<bool> UnpinAsync(string messageId, CancellationToken ct = default)
+    {
+        return await _ctx.Adapter.UnpinMessageAsync(
+            GetEffectiveChatId(),
+            messageId,
+            ct);
+    }
+
+    /// <summary>Получить информацию о сообщении.</summary>
+    public async Task<MessageInfo?> GetInfoAsync(string messageId, CancellationToken ct = default)
+    {
+        return await _ctx.Adapter.GetMessageInfoAsync(
+            GetEffectiveChatId(),
+            messageId,
+            ct);
+    }
+
+    /// <summary>Переслать сообщение.</summary>
+    public async Task<string?> ForwardAsync(string fromChatId, string messageId, string toChatId,
+        bool disableNotification = false, CancellationToken ct = default)
+    {
+        return await _ctx.Adapter.ForwardMessageAsync(
+            fromChatId,
+            messageId,
+            toChatId ?? GetEffectiveChatId(),
+            disableNotification,
+            ct);
+    }
+
+    /// <summary>Копировать сообщение.</summary>
+    public async Task<string?> CopyAsync(string fromChatId, string messageId, string toChatId,
+        string? caption = null, MessageFormat? captionFormat = null,
+        bool disableNotification = false, CancellationToken ct = default)
+    {
+        return await _ctx.Adapter.CopyMessageAsync(
+            fromChatId,
+            messageId,
+            toChatId ?? GetEffectiveChatId(),
+            caption,
+            captionFormat,
+            disableNotification,
+            ct);
+    }
+
+    private string GetEffectiveChatId()
+    {
+        return _targetChatId ?? _ctx.Update.Chat.Id;
+    }
+
+    private IMessengerAdapter GetEffectiveAdapter()
+    {
+        return _targetAdapter ?? _ctx.Adapter
+            ?? throw new InvalidOperationException("No adapter specified for sending message");
+    }
+
     /// <summary>Отправить собранное сообщение.</summary>
     public async Task<string?> SendAsync(CancellationToken ct = default)
+        => await SendAsync(string.Empty, ct);
+
+    /// <summary>Редактировать сообщение.</summary>
+    public async Task<string?> SendAsync(string messageId, CancellationToken ct = default)
     {
-        string? messageId = null;
+        _messageId = string.IsNullOrWhiteSpace(messageId) ? null : messageId;
+        string? outMessageId = null;
 
         List<List<ReplyButton>>? reply = null;
         if (_disableReplyKeyboard) reply = new();
         else if (_reply.Any()) reply = _reply;
 
+        // Определяем целевой адаптер
+        var adapter = GetEffectiveAdapter();
+
+        // Определяем целевой чат
+        var targetChatId = GetEffectiveChatId();
+
         // Текст
         if (!string.IsNullOrWhiteSpace(_text))
         {
-            messageId = await _ctx.SendTextAsync(_text, _format, _inline, reply, _editMessageId, ct);
+            var req = new SendRequest
+            {
+                ChatId = targetChatId,
+                Text = _text,
+                TextFormat = _format,
+                Inline = _inline,
+                Reply = reply,
+                MessageId = _messageId,
+                ReplyToMessageId = _replyToMessageId,
+                QuoteReply = _quoteReply,
+                QuoteTitle = _quoteTitle,
+                DisableWebPagePreview = _disableWebPagePreview,
+                DisableNotification = _disableNotification,
+                ProtectContent = _protectContent,
+                Style = _style,
+                ScheduleDate = _scheduleDate,
+                Topic = _topic,
+                AdapterOptions = _adapterOptions
+            };
+
+            outMessageId = await adapter.SendAsync(req, ct);
         }
 
         // Файлы
         foreach (var (file, caption, captionFormat) in _files)
-            await _ctx.SendFileAsync(file: file
+        {
-                , caption: caption
+            var req = new SendRequest
-                , captionFormat: captionFormat
+            {
-                , reply: reply
+                ChatId = targetChatId,
-                , inline: _inline
+                File = file,
-                , ct: ct
+                Caption = caption,
-            );
+                CaptionFormat = captionFormat,
+                Inline = _inline,
+                Reply = reply,
+                ReplyToMessageId = _replyToMessageId,
+                QuoteReply = _quoteReply,
+                QuoteTitle = _quoteTitle,
+                DisableWebPagePreview = _disableWebPagePreview,
+                DisableNotification = _disableNotification,
+                ProtectContent = _protectContent,
+                Style = _style,
+                ScheduleDate = _scheduleDate,
+                Topic = _topic,
+                AdapterOptions = _adapterOptions
+            };
+
+            var res = await adapter.SendAsync(req, ct);
+            // сохранить первый возвращённый id сообщения
+            if (outMessageId is null && res is not null) outMessageId = res;
+        }
 
         // Альбом
         if (_album.Count > 0)
         {
-            var builder = _ctx.Albums;
+            // Для альбома нужен PageContext с правильным адаптером
+            var albumCtx = CreateAlbumContext(_ctx, adapter);
+            var builder = adapter.CreateAlbumBuilder(albumCtx);
             foreach (var (file, caption, captionFormat) in _album)
                 builder.Add(file, caption, captionFormat);
             await builder.SendAsync(ct);
         }
 
+        Reset();
+
+        return outMessageId;
+    }
+
+    private PageContext CreateAlbumContext(PageContext originalCtx, IMessengerAdapter adapter)
+    {
+        // Создаем новый контекст для альбома с указанным адаптером
+        return new PageContext
+        {
+            SessionKey = originalCtx.SessionKey,
+            Update = originalCtx.Update,
+            StateStorage = originalCtx.StateStorage,
+            Navigation = originalCtx.Navigation,
+            AdapterFactory = originalCtx.AdapterFactory,
+            Adapter = adapter,
+        };
+    }
+
+    /// <summary>
+    /// Сбросить состояние билдера для повторного использования.
+    /// </summary>
+    public MessageBuilder Reset()
+    {
         _text = null;
         _files.Clear();
         _album.Clear();
+        _adapterOptions = null;
+        _targetAdapter = null;
+        _targetChatId = null;
+        _replyToMessageId = null;
+        _quoteReply = true;
+        _quoteTitle = null;
+        _disableWebPagePreview = false;
+        _disableNotification = false;
+        _protectContent = false;
+        _style = null;
+        _scheduleDate = null;
+        _topic = null;
+        _messageId = null;
+        _reply.Clear();
+        _inline.Clear();
+        _disableReplyKeyboard = false;
 
-        _editMessageId = null;
+        return this;
-
-        return messageId;
     }
 }

BotPages.Core/Messaging/MessageBuilderAdapterExtensions.cs

@@ -0,0 +1,55 @@
+using BotPages.Core.Abstractions;
+
+namespace BotPages.Core.Messaging;
+
+/// <summary>
+/// Расширения для MessageBuilder для работы с разными адаптерами.
+/// </summary>
+public static class MessageBuilderAdapterExtensions
+{
+    /// <summary>
+    /// Отправить сообщение через конкретный адаптер.
+    /// </summary>
+    public static MessageBuilder WithAdapter(this MessageBuilder builder, IMessengerAdapter adapter)
+    {
+        builder.WithAdapter(adapter);
+        return builder;
+    }
+
+    /// <summary>
+    /// Отправить сообщение через адаптер по типу и ID экземпляра.
+    /// </summary>
+    public static MessageBuilder WithAdapter(this MessageBuilder builder, string messengerType, string instanceId)
+    {
+        // Получаем фабрику адаптеров через сервис локатор или контекст
+        // В реальной реализации нужно будет передать фабрику адаптеров
+        return builder;
+    }
+
+    /// <summary>
+    /// Отправить сообщение через адаптер по полному ключу.
+    /// </summary>
+    public static MessageBuilder WithAdapter(this MessageBuilder builder, string fullMessengerKey)
+    {
+        // В реальной реализации нужно будет передать фабрику адаптеров
+        return builder;
+    }
+
+    /// <summary>
+    /// Отправить сообщение в указанный чат с указанным адаптером.
+    /// </summary>
+    public static MessageBuilder ToChat(this MessageBuilder builder, string chatId, IMessengerAdapter adapter)
+    {
+        return builder.ToChat(chatId, adapter);
+    }
+
+    /// <summary>
+    /// Отправить сообщение в чат в другом адаптере того же типа.
+    /// </summary>
+    public static MessageBuilder ToChatInOtherInstance(this MessageBuilder builder, string chatId, string instanceId)
+    {
+        // Получаем тип текущего адаптера и используем другой экземпляр
+        // В реальной реализации нужно будет передать фабрику адаптеров
+        return builder;
+    }
+}

BotPages.Core/Messaging/ReplyButton.cs

@@ -22,6 +22,11 @@ public class ReplyButton
         this.Label = value.GetButtonLabel();
     }
 
+    /// <summary>
+    /// Стиль кнопки.
+    /// </summary>
+    public ButtonStyle Style { get; set; } = ButtonStyle.Default;
+
     /// <summary>
     /// Преобразование строки к кнопке.
     /// </summary>
@@ -34,3 +39,19 @@ public class ReplyButton
     /// <param name="en"></param>
     public static implicit operator ReplyButton(Enum en) => new ReplyButton(en);
 }
+
+
+/// <summary>
+/// Стиль оформления сообщения.
+/// </summary>
+public enum ButtonStyle
+{
+    /// <summary>Обычный стиль.</summary>
+    Default,
+    /// <summary>Стиль информационого сообщения.</summary>
+    Info,
+    /// <summary>Стиль успеха.</summary>
+    Success,
+    /// <summary>Стиль ошибки.</summary>
+    Error,
+}

BotPages.Core/Middleware/ErrorHandlingMiddleware.cs

@@ -27,8 +27,12 @@ public sealed class ErrorHandlingMiddleware : IPageMiddleware
         {
             _logger.Log(LogLevel.Critical, "Unhandled exception in middleware pipeline.", ex);
 
-            // Теперь можно напрямую использовать PageContext для ответа
+            // Отправляем универсальный запрос с текстом об ошибке
-            await ctx.SendTextAsync("Произошла ошибка при обработке запроса. Попробуйте ещё раз.", ct: ct);
+            await ctx.SendAsync(new SendRequest
+            {
+                ChatId = ctx.Update.Chat.Id,
+                Text = "Произошла ошибка при обработке запроса. Попробуйте ещё раз."
+            }, ct);
         }
     }
 }

BotPages.Core/Middleware/LoggingMiddleware.cs

@@ -17,7 +17,7 @@ public sealed class LoggingMiddleware : IPageMiddleware
     public async Task InvokeAsync(PageContext ctx, Func<Task> next, CancellationToken ct)
     {
         // Логируем базовую информацию
-        _logger.Log(LogLevel.Info, $"Update from {ctx.Update.MessengerType} | Chat: {ctx.Update.Chat.Id} | User: {ctx.Update.User.Id}");
+        _logger.Log(LogLevel.Info, $"Update from {ctx.Update.Adapter.Id} | Chat: {ctx.Update.Chat.Id} | User: {ctx.Update.User.Id}");
 
         // Логируем текст, кнопки, файлы
         if (ctx.Update.Text is not null)

BotPages.Core/Pages/Page.cs

@@ -10,19 +10,34 @@ public abstract class Page
 {
     /// <summary>Вход на страницу.</summary>
     public virtual Task OnEnter(PageContext ctx, CancellationToken ct) => Task.CompletedTask;
+
     /// <summary>Общий обработчик обновлений.</summary>
     public virtual Task OnUpdate(PageContext ctx, UpdateContext update, CancellationToken ct) => Task.CompletedTask;
+
     /// <summary>Обработка текста.</summary>
     public virtual Task OnText(PageContext ctx, string text, CancellationToken ct) => Task.CompletedTask;
+
     /// <summary>Обработка файлов.</summary>
     public virtual Task OnFile(PageContext ctx, List<FileDescriptor> files, CancellationToken ct) => Task.CompletedTask;
+
     /// <summary>Обработка кнопки.</summary>
     public virtual Task OnButton(PageContext ctx, string payload, CancellationToken ct) => Task.CompletedTask;
+
+    /// <summary>Обработка редактирования сообщения.</summary>
+    public virtual Task OnEdit(PageContext ctx, EditInfo editInfo, CancellationToken ct) => Task.CompletedTask;
+
+    /// <summary>Обработка удаления сообщения.</summary>
+    public virtual Task OnDelete(PageContext ctx, DeleteInfo deleteInfo, CancellationToken ct) => Task.CompletedTask;
+
+    /// <summary>Обработка закрепления сообщения.</summary>
+    public virtual Task OnPin(PageContext ctx, PinInfo pinInfo, CancellationToken ct) => Task.CompletedTask;
+
     /// <summary>Выход со страницы.</summary>
     public virtual Task OnLeave(PageContext ctx, CancellationToken ct) => Task.CompletedTask;
+
     /// <summary>Таймаут бездействия.</summary>
     public virtual Task OnTimeout(PageContext ctx, TimeSpan timeout, CancellationToken ct) => Task.CompletedTask;
+
     /// <summary>Обработка ошибок.</summary>
     public virtual Task OnError(PageContext ctx, Exception ex, CancellationToken ct) => Task.CompletedTask;
-
 }

BotPages.Core/Routing/Command.cs

@@ -0,0 +1,34 @@
+namespace BotPages.Core.Routing;
+
+using System.Text.RegularExpressions;
+
+/// <summary>
+/// Команда действий. Например "/start"
+/// </summary>
+public class Command
+{
+    /// <summary>
+    /// Название команды.
+    /// </summary>
+    public required string Name { get; init; }
+
+    /// <summary>
+    /// Шаблон команды.
+    /// </summary>
+    public required Regex Pattern { get; init; }
+
+    /// <summary>
+    /// Обработчик команды.
+    /// </summary>
+    public required CommandHandler Handler { get; init; }
+
+    /// <summary>
+    /// Описание команды.
+    /// </summary>
+    public string? Description { get; init; }
+
+    /// <summary>
+    /// Публичный? нужно ли регистрировать в боте.
+    /// </summary>
+    public required bool Publish { get; init; }
+}

BotPages.Core/Routing/CommandHandler.cs

@@ -0,0 +1,6 @@
+namespace BotPages.Core.Routing;
+
+/// <summary>
+/// Обработчик команды: получает контекст страницы, аргументы команды и токен отмены.
+/// </summary>
+public delegate Task CommandHandler(PageContext context, IReadOnlyDictionary<string, string>? args, CancellationToken cancellationToken);

BotPages.Core/Routing/CommandsRegistry.cs

@@ -2,30 +2,38 @@
 
 using System.Text.RegularExpressions;
 
+
 /// <summary>
 /// Реестр команд, доступных из любого места.
 /// </summary>
 internal sealed class CommandsRegistry
 {
-    private readonly List<(Regex pattern, Func<PageContext, CancellationToken, Task> handler)> _commands = new();
+    private readonly List<Command> _commands = new();
+
+    public List<Command> Commands => _commands;
 
     /// <summary>
     /// Зарегистрировать команду, ведущую на страницу.
     /// </summary>
-    public CommandsRegistry Map<TPage>(string commandTemplate) where TPage : Page
+    public CommandsRegistry Map<TPage>(string commandTemplate, bool publish = false, string? description = null) where TPage : Page
     {
-        var pattern = ToRegex(commandTemplate);
+        return Map(commandTemplate, (ctx, args, ct) => ctx.Navigation.GoToAsync<TPage>(ctx, ct), publish, description);
-        _commands.Add((pattern, (ctx, ct) => ctx.Navigation.GoToAsync<TPage>(ctx, ct)));
-        return this;
     }
 
     /// <summary>
     /// Зарегистрировать команду с кастомным обработчиком.
     /// </summary>
-    public CommandsRegistry Map(string commandTemplate, Func<PageContext, CancellationToken, Task> handler)
+    public CommandsRegistry Map(string commandTemplate, CommandHandler handler, bool publish = false, string? description = null)
     {
         var pattern = ToRegex(commandTemplate);
-        _commands.Add((pattern, handler));
+        _commands.Add(new Command()
+        {
+            Name = ToCommandName(commandTemplate),
+            Pattern = pattern,
+            Handler = handler,
+            Publish = publish,
+            Description = string.IsNullOrWhiteSpace(description) ? null : description
+        });
         return this;
     }
 
@@ -34,11 +42,17 @@ internal sealed class CommandsRegistry
     /// </summary>
     public bool TryDispatch(PageContext ctx, string command, CancellationToken ct, out Task? task)
     {
-        foreach (var (pattern, handler) in _commands)
+        foreach (var cmd in _commands)
         {
-            if (pattern.IsMatch(command))
+            var match = cmd.Pattern.Match(command);
+            if (match.Success)
             {
-                task = handler(ctx, ct);
+                // Собираем именованные группы (без числовых)
+                var args = cmd.Pattern.GetGroupNames()
+                    .Where(n => !int.TryParse(n, out _))
+                    .ToDictionary(n => n, n => match.Groups[n].Value);
+
+                task = cmd.Handler(ctx, args, ct);
                 return true;
             }
         }
@@ -46,14 +60,37 @@ internal sealed class CommandsRegistry
         return false;
     }
 
+    /// <summary>
+    /// Универсальный парсер шаблонов: /cmd {a} {b?} {c}
+    /// </summary>
     private static Regex ToRegex(string template)
     {
-        // Простейшее преобразование шаблона: "/open {page} {id?}" -> Regex
+        // Заменяем все {name} и {name?} на регулярные группы
-        var escaped = Regex.Escape(template)
+        var pattern = "^" + Regex.Replace(template, @"\s*\{(\w+)(\?)?\}", m =>
-            .Replace("\\{", "{").Replace("\\}", "}");
+        {
-        var pattern = "^" + escaped
+            var name = m.Groups[1].Value;
-            .Replace("{page}", "(?<page>\\S+)")
+            var optional = m.Groups[2].Success;
-            .Replace("{id?}", "(?<id>\\S+)?") + "$";
+
+            var argPattern = $"(?:\"(?<{name}>[^\"]+)\"|(?<{name}>\\S+))";
+
+            if (optional)
+            {
+                // необязательный параметр: пробел + значение целиком необязательны
+                return $"(?:\\s+{argPattern})?";
+            }
+            else
+            {
+                // обязательный параметр: пробел обязателен
+                return $"\\s+{argPattern}";
+            }
+        }) + "\\s*$"; // допускаем пробелы/переносы в конце
+
         return new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
     }
+
+    private static string ToCommandName(string template)
+    {
+        // Простейшее преобразование шаблона: "/open {page} {id?}" -> "/open"
+        return template.Split(" ", StringSplitOptions.RemoveEmptyEntries).First().ToLowerInvariant();
+    }
 }

BotPages.Telegram/BotPages.Telegram.csproj

@@ -14,7 +14,7 @@
 	</PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Telegram.Bot" Version="22.7.5" />
+    <PackageReference Include="Telegram.Bot" Version="22.9.0" />
   </ItemGroup>
 
   <ItemGroup>

BotPages.Telegram/BotPagesAppExtension.cs

@@ -1,4 +1,5 @@
 using BotPages.Core;
+using System;
 
 namespace BotPages.Telegram;
 
@@ -8,19 +9,28 @@ namespace BotPages.Telegram;
 public static class BotPagesAppExtension
 {
     /// <summary>
-    /// Добавление адаптера для телеграмм в <see cref="BotPages.Core.Abstractions.IMessengerAdapterFactory"/>
+    /// Добавление адаптера для Telegram.
     /// </summary>
-    /// <param name="app"></param>
+    /// <exception cref="ArgumentException">Если адаптер с таким ID уже существует.</exception>
-    /// <param name="token"></param>
+    public static BotPagesApp AddTelegramAdapter(this BotPagesApp app, string token, string adapterId, TelegramOptions? options = null)
-    /// <param name="messengerType"></param>
-    /// <returns></returns>
-    public static BotPagesApp AddTelegramAdapter(this BotPagesApp app, string token, string messengerType = "")
     {
-        var telegram = new TelegramAdapter(app.Logger, token);
+        if (app.HasAdapter(adapterId))
+        {
+            throw new ArgumentException($"Adapter with ID '{adapterId}' already exists", nameof(adapterId));
+        }
 
-        if (!string.IsNullOrWhiteSpace(messengerType)) telegram.MessengerType = messengerType;
+        var telegram = new TelegramAdapter(app.Logger, token, options);
+        app.AddAdapter(adapterId, telegram);
+        return app;
+    }
 
-        app.AddAdapter(telegram.MessengerType, telegram);
+    /// <summary>
+    /// Добавить Telegram бота с автоматическим ID.
+    /// </summary>
+    public static BotPagesApp AddTelegramAdapter(this BotPagesApp app, string token, TelegramOptions? options = null)
+    {
+        var telegram = new TelegramAdapter(app.Logger, token, options);
+        app.AddAdapter(telegram);
         return app;
     }
 }

BotPages.Telegram/TelegramAdapter.cs

@@ -16,16 +16,16 @@ using Telegram.Bot.Types.ReplyMarkups;
 
 namespace BotPages.Telegram;
 
-
 /// <summary>
 /// Адаптер для Telegram на базе Telegram.Bot.
 /// Реализует отправку текста, кнопок, файлов, альбомов и прогресса.
 /// </summary>
-public sealed class TelegramAdapter : IMessangerAdapterSetup
+public sealed class TelegramAdapter : IMessengerAdapterSetup
 {
     private readonly ILogger _logger;
     private TelegramBotClient? _client;
     private string _token;
+    private readonly TelegramOptions _options;
     private static Capabilities _capabilities = new()
     {
         SupportsInlineButtons = true,
@@ -37,16 +37,29 @@ public sealed class TelegramAdapter : IMessangerAdapterSetup
     };
 
     /// <summary>Создать адаптер Telegram.</summary>
-    public TelegramAdapter(ILogger logger, string token)
+    public TelegramAdapter(ILogger logger, string token, TelegramOptions? options = null)
     {
         _logger = logger;
         _token = token;
+        _options = options ?? new TelegramOptions();
+
+        Id = Guid.NewGuid().ToString();
+        DisplayName = $"Telegram {Id}";
     }
 
+    /// <inheritdoc/>
+    public string Type => "Telegram";
+
+    /// <inheritdoc/>
+    public string Id { get; set; }
+
     /// <summary>
-    ///Идентификатор мессенджера / адаптера
+    /// Получение отображаемого имени бота (например, "Telegram: @mybot"). Доступно после запуска адаптера.
     /// </summary>
-    public string MessengerType { get; set; } = "Telegram: " + Guid.NewGuid().ToString();
+    public string DisplayName { get; private set; }
+
+    /// <inheritdoc/>
+    public void SetAdapterId(string adapterId) => Id = adapterId;
 
     /// <summary>
     /// Доступные возможности адаптера.
@@ -56,248 +69,505 @@ public sealed class TelegramAdapter : IMessangerAdapterSetup
     /// <summary>
     /// Запустить polling для приема обновлений от Telegram.
     /// </summary>
-    public async Task StartAdapterAsync(Func<UpdateContext, Task> onUpdate, CancellationToken ct)
+    public async Task StartAdapterAsync(Func<UpdateContext, Task> onUpdate, List<BotPages.Core.Routing.Command> commands, CancellationToken ct)
     {
         _client = new TelegramBotClient(_token);
 
         _client.StartReceiving(
             updateHandler: async (_, update, ct2) =>
             {
-                var mapped = TelegramUpdateMapper.Map(MessengerType, update, _client);
+                var mapped = TelegramUpdateMapper.Map(this, update, _client);
                 if (mapped is not null)
                     await onUpdate(mapped);
+                if (update.CallbackQuery is not null)
+                {
+                    await _.AnswerCallbackQuery(update.CallbackQuery.Id);
+                }
             },
 
             errorHandler: async (_, ex, ct2) =>
             {
-                _logger.Log(LogLevel.Warn, $"{MessengerType} error.", ex);
+                _logger.Log(LogLevel.Warn, $"{Type} ({Id}) error.", ex);
                 await Task.CompletedTask;
             },
 
             cancellationToken: ct
         );
 
+        await _client.SetMyCommands(commands.Where(t => t.Publish).Select(t => new BotCommand(t.Name, t.Description ?? t.Name.TrimStart('/'))), cancellationToken: ct);
 
         var me = await _client.GetMe();
-        _logger.Log(LogLevel.Info, $"{MessengerType} started: @{me.Username}");
+        DisplayName = $"Telegram: @{me.Username}";
+        _logger.Log(LogLevel.Info, $"{Type} ({Id}) started: {DisplayName}");
 
         return;
     }
 
+    /// <summary>
+    /// Универсальный внутренний метод отправки — определяет, нужно ли отправлять текст или файл по параметрам.
+    /// Возвращает id сообщения (или null).
+    /// </summary>
+    public async Task<string?> SendAsync(SendRequest req, CancellationToken ct)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return null;
+        }
+
+        // Определите параметры адаптера (TelegramOptions) из папки или используйте параметры адаптера по умолчанию.
+        TelegramOptions telegramOptions = _options;
+        if (req.AdapterOptions is AdapterOptionsBag bag && bag.TryGet(Type, out TelegramOptions? opt) && opt is not null)
+        {
+            telegramOptions = opt;
+        }
+        var disableNotification = !telegramOptions.NotifyOnSend || req.DisableNotification;
+
+        // Build markup
+        var inlineMarkup = BuildInlineMarkup(req.Inline);
+        ReplyMarkup? markup = BuildReplyMarkup(req.Reply);
+
+        // Ответ на сообщение
+        int? replyToMessageId = null;
+        if (!string.IsNullOrEmpty(req.ReplyToMessageId) && int.TryParse(req.ReplyToMessageId, out var replyId))
+        {
+            replyToMessageId = replyId;
+        }
+
+        // Файлы: сейчас поддерживается один файл через SendRequest.File.
+        // При необходимости для нескольких файлов следует использовать альбомы (CreateAlbumBuilder)
+        if (req.File is not null)
+        {
+            if (inlineMarkup is not null) markup = inlineMarkup;
+
+            var sent = await SendFileAsync(req.File, req.ChatId, markup, disableNotification,
+                req.Caption, req.CaptionFormat, replyToMessageId, req.ProtectContent, ct);
+            return sent?.MessageId.ToString();
+        }
+
+        // Текст
+        if (!string.IsNullOrWhiteSpace(req.Text))
+        {
+            return await SendTextAsync(req, inlineMarkup, markup, disableNotification,
+                replyToMessageId, req.DisableWebPagePreview, req.ProtectContent, ct);
+        }
+
+        return null;
+    }
+
     /// <inheritdoc/>
-    public async Task<string?> SendTextAsync(string chatId, string text, 
+    public Task DeleteAsync(string chatId, string messageId, CancellationToken ct = default)
-        MessageFormat format = MessageFormat.Plain,
+    {
-        IEnumerable<IEnumerable<InlineButton>>? inline = null,
+        if (_client is null)
-        IEnumerable<IEnumerable<ReplyButton>>? reply = null,
+        {
-        string? messageId = null, 
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return Task.CompletedTask;
+        }
+
+        return _client.DeleteMessage(chatId, Convert.ToInt32(messageId), ct);
+    }
+
+    /// <inheritdoc/>
+    public async Task<bool> DeleteMultipleAsync(string chatId, IEnumerable<string> messageIds, CancellationToken ct = default)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return false;
+        }
+
+        try
+        {
+            // Telegram не поддерживает массовое удаление, удаляем по одному
+            foreach (var messageId in messageIds)
+            {
+                await DeleteAsync(chatId, messageId, ct);
+            }
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.Log(LogLevel.Warn, $"Failed to delete multiple messages: {ex.Message}");
+            return false;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<string?> EditTextAsync(string chatId, string messageId, string text,
+        MessageFormat? format = null, CancellationToken ct = default)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return null;
+        }
+
+        try
+        {
+            var parseMode = GetParseMode(format);
+            await _client.EditMessageText(
+                chatId: long.Parse(chatId),
+                messageId: int.Parse(messageId),
+                text: text,
+                parseMode: parseMode,
+                cancellationToken: ct
+            );
+            return messageId;
+        }
+        catch (Exception ex)
+        {
+            _logger.Log(LogLevel.Warn, $"Failed to edit text: {ex.Message}");
+            return null;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<string?> EditButtonsAsync(string chatId, string messageId,
+        IEnumerable<IEnumerable<InlineButton>>? inlineButtons = null, CancellationToken ct = default)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return null;
+        }
+
+        try
+        {
+            var inlineMarkup = BuildInlineMarkup(inlineButtons);
+            await _client.EditMessageReplyMarkup(
+                chatId: long.Parse(chatId),
+                messageId: int.Parse(messageId),
+                replyMarkup: inlineMarkup,
+                cancellationToken: ct
+            );
+            return messageId;
+        }
+        catch (Exception ex)
+        {
+            _logger.Log(LogLevel.Warn, $"Failed to edit buttons: {ex.Message}");
+            return null;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<bool> PinMessageAsync(string chatId, string messageId, bool disableNotification = false,
         CancellationToken ct = default)
     {
         if (_client is null)
         {
-            _logger.Log(LogLevel.Critical, $"{MessengerType} client is not initialized.");
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return false;
+        }
+
+        try
+        {
+            await _client.PinChatMessage(
+                chatId: long.Parse(chatId),
+                messageId: int.Parse(messageId),
+                disableNotification: disableNotification,
+                cancellationToken: ct
+            );
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.Log(LogLevel.Warn, $"Failed to pin message: {ex.Message}");
+            return false;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<bool> UnpinMessageAsync(string chatId, string messageId, CancellationToken ct = default)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return false;
+        }
+
+        try
+        {
+            await _client.UnpinChatMessage(
+                chatId: long.Parse(chatId),
+                messageId: int.Parse(messageId),
+                cancellationToken: ct
+            );
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.Log(LogLevel.Warn, $"Failed to unpin message: {ex.Message}");
+            return false;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<MessageInfo?> GetMessageInfoAsync(string chatId, string messageId, CancellationToken ct = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    /// <inheritdoc/>
+    public async Task<string?> ForwardMessageAsync(string fromChatId, string messageId, string toChatId,
+        bool disableNotification = false, CancellationToken ct = default)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
             return null;
         }
 
-        InlineKeyboardMarkup? inlineMarkup = null;
+        try
-        ReplyMarkup? markup = null;
-
-        if (inline is not null && inline.Any())
         {
-            inlineMarkup = new InlineKeyboardMarkup(
+            var message = await _client.ForwardMessage(
-                inline.Select(row => row.Select(b => new InlineKeyboardButton(b.Label, b.Value)).ToArray())
+                chatId: long.Parse(toChatId),
-                      .ToArray()
+                fromChatId: long.Parse(fromChatId),
+                messageId: int.Parse(messageId),
+                disableNotification: disableNotification,
+                cancellationToken: ct
+            );
+
+            return message.MessageId.ToString();
+        }
+        catch (Exception ex)
+        {
+            _logger.Log(LogLevel.Warn, $"Failed to forward message: {ex.Message}");
+            return null;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<string?> CopyMessageAsync(string fromChatId, string messageId, string toChatId,
+        string? caption = null, MessageFormat? captionFormat = null,
+        bool disableNotification = false, CancellationToken ct = default)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return null;
+        }
+
+        try
+        {
+            var parseMode = GetParseMode(captionFormat);
+            var message = await _client.CopyMessage(
+                chatId: long.Parse(toChatId),
+                fromChatId: long.Parse(fromChatId),
+                messageId: int.Parse(messageId),
+                caption: caption,
+                parseMode: parseMode,
+                disableNotification: disableNotification,
+                cancellationToken: ct
+            );
+
+            return message.Id.ToString();
+        }
+        catch (Exception ex)
+        {
+            _logger.Log(LogLevel.Warn, $"Failed to copy message: {ex.Message}");
+            return null;
+        }
+    }
+
+    // --- Helpers ---
+
+    private InlineKeyboardMarkup? BuildInlineMarkup(IEnumerable<IEnumerable<InlineButton>>? inline)
+    {
+        if (inline is null || !inline.Any()) return null;
+        return new InlineKeyboardMarkup(
+            inline.Select(row => row.Select(b => new InlineKeyboardButton(b.Label, b.Value)
+            {
+                Style = b.Style switch
+                {
+                    ButtonStyle.Default => null,
+                    ButtonStyle.Info => KeyboardButtonStyle.Primary,
+                    ButtonStyle.Error => KeyboardButtonStyle.Danger,
+                    ButtonStyle.Success => KeyboardButtonStyle.Success,
+                    _ => null,
+                }
+            }).ToArray()).ToArray()
         );
     }
-        else if (reply is not null)
+
+    private ReplyMarkup? BuildReplyMarkup(IEnumerable<IEnumerable<ReplyButton>>? reply)
     {
+        if (reply is null) return null;
+
         if (reply.Any())
         {
-                markup = new ReplyKeyboardMarkup(
+            return new ReplyKeyboardMarkup(reply.Select(row => row.Select(b => new KeyboardButton(b.Label)
-                    reply.Select(row => row.Select(b => new KeyboardButton(b.Label)).ToArray()).ToArray()
+            {
-                )
+                Style = b.Style switch
+                {
+                    ButtonStyle.Default => null,
+                    ButtonStyle.Info => KeyboardButtonStyle.Primary,
+                    ButtonStyle.Error => KeyboardButtonStyle.Danger,
+                    ButtonStyle.Success => KeyboardButtonStyle.Success,
+                    _ => null,
+                }
+            }).ToArray()).ToArray())
             {
                 ResizeKeyboard = true
             };
         }
         else
         {
-                markup = new ReplyKeyboardRemove();
+            return new ReplyKeyboardRemove();
         }
     }
 
-        var parseMode = ParseMode.None;
+    private static ParseMode GetParseMode(MessageFormat? format)
+    {
+        return format switch
+        {
+            MessageFormat.Html => ParseMode.Html,
+            MessageFormat.Markdown => ParseMode.MarkdownV2,
+            MessageFormat.Plain => ParseMode.None,
+            _ => ParseMode.None,
+        };
+    }
 
-        switch (format)
+    private async Task<InputFile> CreateInputFileAsync(FileDescriptor file, CancellationToken ct)
     {
-            case MessageFormat.Html:
+        Stream? stream = null;
+        if (file.GetStreamAsync is not null)
         {
-                    parseMode = ParseMode.Html;
+            stream = await file.GetStreamAsync(ct);
-                    break;
+            if (stream is not null) stream.Position = 0;
         }
-            case MessageFormat.Plain:
+
+        if (stream is not null && stream != Stream.Null)
         {
-                    parseMode = ParseMode.None;
+            return new InputFileStream(stream, file.Name);
-                    break;
         }
-            case MessageFormat.Markdown:
+        else if (file.Id.StartsWith("http://") || file.Id.StartsWith("https://"))
         {
-                    parseMode = ParseMode.MarkdownV2;
+            return new InputFileUrl(file.Id);
-                    break;
         }
-            default:
+        else
         {
-                    _logger.Log(LogLevel.Warn, $"MessageFormat '{format}' not supported. Degraded to plain text.");
+            return new InputFileId(file.Id);
-                    break;
         }
     }
 
-        // Длина сообщения
+    private async Task<Message?> SendFileAsync(FileDescriptor file, string chatId, ReplyMarkup? markup,
+        bool disableNotification, string? caption, MessageFormat? captionFormat, int? replyToMessageId,
+        bool protectContent, CancellationToken ct)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return null;
+        }
+
+        var inputFile = await CreateInputFileAsync(file, ct);
+        var parseMode = GetParseMode(captionFormat);
+
+        return file.Kind switch
+        {
+            FileKind.Photo => await _client.SendPhoto(
+                long.Parse(chatId),
+                inputFile,
+                caption ?? "",
+                parseMode,
+                replyParameters: replyToMessageId,
+                replyMarkup: markup,
+                disableNotification: disableNotification,
+                protectContent: protectContent,
+                cancellationToken: ct),
+
+            FileKind.Video => await _client.SendVideo(
+                long.Parse(chatId),
+                inputFile,
+                caption: caption ?? "",
+                parseMode,
+                replyParameters: replyToMessageId,
+                replyMarkup: markup,
+                disableNotification: disableNotification,
+                protectContent: protectContent,
+                cancellationToken: ct),
+
+            FileKind.Audio => await _client.SendAudio(
+                long.Parse(chatId),
+                inputFile,
+                caption ?? "",
+                parseMode,
+                replyParameters: replyToMessageId,
+                replyMarkup: markup,
+                disableNotification: disableNotification,
+                protectContent: protectContent,
+                cancellationToken: ct),
+
+            _ => await _client.SendDocument(
+                long.Parse(chatId),
+                inputFile,
+                caption ?? "",
+                parseMode,
+                replyParameters: replyToMessageId,
+                replyMarkup: markup,
+                disableNotification: disableNotification,
+                protectContent: protectContent,
+                cancellationToken: ct),
+        };
+    }
+
+    private async Task<string?> SendTextAsync(SendRequest req, InlineKeyboardMarkup? inlineMarkup,
+        ReplyMarkup? markup, bool disableNotification, int? replyToMessageId,
+        bool disableWebPagePreview, bool protectContent, CancellationToken ct)
+    {
+        if (_client is null)
+        {
+            _logger.Log(LogLevel.Critical, $"{Type} client is not initialized.");
+            return null;
+        }
+
+        var format = req.TextFormat ?? MessageFormat.Plain;
+        var parseMode = GetParseMode(format);
+
+        var text = req.Text!;
         if (text.Length > Capabilities.MaxMessageLength)
         {
             _logger.Log(LogLevel.Warn, $"Message too long ({text.Length}). Truncated to {Capabilities.MaxMessageLength}.");
             text = text.Substring(0, Capabilities.MaxMessageLength);
         }
 
-        if (!string.IsNullOrWhiteSpace(messageId))
+        if (!string.IsNullOrWhiteSpace(req.MessageId))
         {
             await _client.EditMessageText(
-                messageId: int.Parse(messageId),
+                messageId: int.Parse(req.MessageId),
-                chatId: long.Parse(chatId),
+                chatId: long.Parse(req.ChatId),
                 text: text,
                 parseMode: parseMode,
+                linkPreviewOptions: new()
+                {
+                    IsDisabled = disableWebPagePreview,
+                },
                 replyMarkup: inlineMarkup,
                 cancellationToken: ct
             );
 
-            return messageId;
+            return req.MessageId;
         }
         else
         {
             if (inlineMarkup is not null) markup = inlineMarkup;
 
             var message = await _client.SendMessage(
-                chatId: long.Parse(chatId),
+                chatId: long.Parse(req.ChatId),
                 text: text,
                 parseMode: parseMode,
+                linkPreviewOptions: new()
+                {
+                    IsDisabled = disableWebPagePreview,
+                },
                 replyMarkup: markup,
+                replyParameters: replyToMessageId,
+                disableNotification: disableNotification,
+                protectContent: protectContent,
                 cancellationToken: ct
             );
 
-            return message.Id.ToString();
+            return message.MessageId.ToString();
-        }
-    }
-
-    /// <inheritdoc />
-    public async Task SendFileAsync(string chatId, 
-        FileDescriptor file, 
-        string? caption = null, 
-        MessageFormat? captionFormat = null,
-        IEnumerable<IEnumerable<InlineButton>>? inline = null,
-        IEnumerable<IEnumerable<ReplyButton>>? reply = null,
-        CancellationToken ct = default
-    )
-    {
-        if (_client is null)
-        {
-            _logger.Log(LogLevel.Critical, $"{MessengerType} client is not initialized.");
-            return;
-        }
-
-        // Получаем поток, если он задан
-        Stream? stream = null;
-        if (file.GetStreamAsync is not null)
-        {
-            stream = await file.GetStreamAsync(ct);
-            stream.Position = 0;
-        }
-
-        InputFile inputFile;
-
-        if (stream is not null && stream != Stream.Null)
-        {
-            inputFile = new InputFileStream(stream, file.Name);
-        }
-        else if (file.Id.StartsWith("http://") || file.Id.StartsWith("https://"))
-        {
-            inputFile = new InputFileUrl(file.Id);
-        }
-        else
-        {
-            inputFile = new InputFileId(file.Id);
-        }
-
-        var parseMode = ParseMode.None;
-
-        switch (captionFormat)
-        {
-            case MessageFormat.Html:
-                {
-                    parseMode = ParseMode.Html;
-                    break;
-                }
-            case MessageFormat.Plain:
-                {
-                    parseMode = ParseMode.None;
-                    break;
-                }
-            case MessageFormat.Markdown:
-                {
-                    parseMode = ParseMode.MarkdownV2;
-                    break;
-                }
-            case null:
-                {
-                    parseMode = ParseMode.None;
-                    break;
-                }
-            default:
-                {
-                    _logger.Log(LogLevel.Warn, $"MessageFormat '{captionFormat}' not supported. Degraded to plain text.");
-                    break;
-                }
-        }
-
-        ReplyMarkup? markup = null;
-
-        if (inline is not null && inline.Any())
-        {
-            markup = new InlineKeyboardMarkup(
-                inline.Select(row => row.Select(b => new InlineKeyboardButton(b.Label, b.Value)).ToArray())
-                      .ToArray()
-            );
-        }
-        else if (reply is not null)
-        {
-            if (reply.Any())
-            {
-                markup = new ReplyKeyboardMarkup(
-                    reply.Select(row => row.Select(b => new KeyboardButton(b.Label)).ToArray()).ToArray()
-                )
-                {
-                    ResizeKeyboard = true
-                };
-            }
-            else
-            {
-                markup = new ReplyKeyboardRemove();
-            }
-        }
-
-        // В зависимости от FileKind выбираем подходящий метод
-        switch (file.Kind)
-        {
-            case FileKind.Photo:
-                await _client.SendPhoto(long.Parse(chatId), inputFile, caption ?? "", parseMode, replyMarkup: markup, cancellationToken: ct);
-                break;
-            case FileKind.Video:
-                await _client.SendVideo(long.Parse(chatId), inputFile, caption: caption ?? "", parseMode, replyMarkup: markup, cancellationToken: ct);
-                break;
-            case FileKind.Audio:
-                await _client.SendAudio(long.Parse(chatId), inputFile, caption ?? "", parseMode, replyMarkup: markup, cancellationToken: ct);
-                break;
-            default:
-                await _client.SendDocument(long.Parse(chatId), inputFile, caption ?? "", parseMode, replyMarkup: markup, cancellationToken: ct);
-                break;
         }
     }
 

BotPages.Telegram/TelegramAlbumBuilder.cs

@@ -53,7 +53,17 @@ public sealed class TelegramAlbumBuilder : IAlbumBuilder
         {
             _logger.Log(LogLevel.Warn, "Albums not supported. Degraded to sequential sends.");
             foreach (var (file, caption, captionFormat) in _items)
-                await _adapter.SendFileAsync(_ctx.Update.Chat.Id, file, caption, captionFormat, ct: ct);
+            {
+                var req = new SendRequest
+                {
+                    ChatId = _ctx.Update.Chat.Id,
+                    File = file,
+                    Caption = caption,
+                    CaptionFormat = captionFormat
+                };
+
+                await _ctx.SendAsync(req, ct);
+            }
             return;
         }
 
@@ -95,7 +105,16 @@ public sealed class TelegramAlbumBuilder : IAlbumBuilder
             {
                 // Telegram не поддерживает document в альбомах — деградация
                 _logger.Log(LogLevel.Warn, $"Document '{file.Kind}' in album not supported. Sending document separately.");
-                await _adapter.SendFileAsync(_ctx.Update.Chat.Id, file, caption, captionFormat, ct: ct);
+
+                var req = new SendRequest
+                {
+                    ChatId = _ctx.Update.Chat.Id,
+                    File = file,
+                    Caption = caption,
+                    CaptionFormat = captionFormat
+                };
+
+                await _ctx.SendAsync(req, ct);
             }
         }
 

BotPages.Telegram/TelegramOptions.cs

@@ -0,0 +1,14 @@
+namespace BotPages.Telegram;
+
+/// <summary>
+/// Настройки адаптера Telegram, применяемые по умолчанию при отправке сообщений.
+/// </summary>
+public sealed class TelegramOptions
+{
+    /// <summary>
+    /// Отправлять ли уведомление (sound) при отправке сообщения. По умолчанию true.
+    /// </summary>
+    public bool NotifyOnSend { get; set; } = true;
+
+    // В будущем можно добавить: default parse mode, disable web page preview и т.д.
+}

BotPages.Telegram/TelegramUpdateMapper.cs

@@ -19,29 +19,56 @@ public static class TelegramUpdateMapper
     /// <summary>
     /// Маппинг Telegram Update в UpdateContext BotPages.
     /// </summary>
-    public static UpdateContext Map(string MessengerType, Update update, TelegramBotClient client)
+    public static UpdateContext? Map(TelegramAdapter adapter, Update update, TelegramBotClient client)
     {
-        var chat = update.Message?.Chat ?? update.CallbackQuery?.Message?.Chat;
+        var chat = update.Message?.Chat ?? update.CallbackQuery?.Message?.Chat ?? update.EditedMessage?.Chat;
-        var user = update.Message?.From ?? update.CallbackQuery?.From;
+        var user = update.Message?.From ?? update.CallbackQuery?.From ?? update.EditedMessage?.From;
+
+        if (chat == null || user == null)
+            return null;
 
         var userContext = new UserContext
         {
-            Id = user?.Id.ToString() ?? "unknown",
+            Id = user.Id.ToString(),
-            DisplayName = user?.Username,
+            DisplayName = user.Username,
         };
 
         var chatContext = new ChatContext
         {
-            Id = chat?.Id.ToString() ?? "unknown",
+            Id = chat.Id.ToString(),
-            Title = chat?.Title,
+            Title = chat.Title,
         };
 
         string? text = null;
         UpdateKind kind = UpdateKind.None;
         var files = new List<FileDescriptor>();
+        string? messageId = null;
+        string? replyToMessageId = null;
+        EditInfo? editInfo = null;
+        DeleteInfo? deleteInfo = null;
+        PinInfo? pinInfo = null;
 
+        // Обработка разных типов обновлений
         if (update.Message is { } msg)
         {
+            messageId = msg.MessageId.ToString();
+
+            if (msg.ReplyToMessage != null)
+            {
+                kind |= UpdateKind.Reply;
+                replyToMessageId = msg.ReplyToMessage.MessageId.ToString();
+            }
+
+            if (msg.PinnedMessage != null)
+            {
+                kind |= UpdateKind.Pin;
+                pinInfo = new PinInfo
+                {
+                    MessageId = msg.PinnedMessage.MessageId.ToString(),
+                    PinDate = msg.Date,
+                    NotificationDisabled = false // Telegram не передает эту информацию
+                };
+            }
 
             if (msg.Text is not null)
             {
@@ -112,37 +139,80 @@ public static class TelegramUpdateMapper
                 kind |= UpdateKind.File;
             }
         }
-
+        else if (update.EditedMessage is { } editedMsg)
-        if (update.CallbackQuery is { } cb)
         {
+            messageId = editedMsg.MessageId.ToString();
+            kind |= UpdateKind.Edit;
+            text = editedMsg.Text;
+
+            editInfo = new EditInfo
+            {
+                NewText = editedMsg.Text,
+                EditDate = editedMsg.EditDate ?? DateTime.UtcNow
+            };
+        }
+        else if (update.CallbackQuery is { } cb)
+        {
+            messageId = cb.Message?.MessageId.ToString();
             kind |= UpdateKind.Button;
             text = cb.Data;
         }
+        else if (update.ChannelPost is { } channelPost)
+        {
+            messageId = channelPost.MessageId.ToString();
 
+            if (channelPost.Text is not null)
+            {
+                text = channelPost.Text;
+                kind |= UpdateKind.Text;
+            }
+        }
+        else if (update.EditedChannelPost is { } editedChannelPost)
+        {
+            messageId = editedChannelPost.MessageId.ToString();
+            kind |= UpdateKind.Edit;
+            text = editedChannelPost.Text;
+
+            editInfo = new EditInfo
+            {
+                NewText = editedChannelPost.Text,
+                EditDate = editedChannelPost.EditDate ?? DateTime.UtcNow
+            };
+        }
 
         return new UpdateContext
         {
-            MessengerType = MessengerType,
+            Adapter = adapter,
             User = userContext,
             Chat = chatContext,
             Text = text,
             Kind = kind,
-            Files = files
+            MessageId = messageId,
+            ReplyToMessageId = replyToMessageId,
+            Files = files,
+            EditInfo = editInfo,
+            DeleteInfo = deleteInfo,
+            PinInfo = pinInfo
         };
     }
 
     private static Func<CancellationToken, Task<Stream>> GetStreamAsync(TelegramBotClient client, string fileId)
     {
-
+        return async ct =>
-        Func<CancellationToken, Task<Stream>> getStreamAsync = async _ =>
         {
-            var file = await client.GetFile(fileId);
+            try
+            {
+                var file = await client.GetFile(fileId, ct);
                 var stream = new MemoryStream();
-            await client.DownloadFile(file, stream);
+                await client.DownloadFile(file.FilePath!, stream, ct);
                 stream.Position = 0;
                 return stream;
+            }
+            catch (Exception ex)
+            {
+                return Stream.Null;
+                throw;
+            }
         };
-
-        return getStreamAsync;
     }
 }

Demo/Pages/DetailsPage.cs

@@ -1,26 +1,26 @@
 using BotPages.Core;
 using BotPages.Core.Messaging;
+using BotPages.Core.Routing;
 
 namespace Demo.Pages;
 
 /// <summary>
 /// Страница ввода деталей заявки.
-/// Страница с параметрами и получением состояния.
 /// </summary>
-public sealed class DetailsPage : StatefullPage<DetailsArgs>
+public sealed class DetailsPage : StatefullPage<string>
 {
     [Statefull("Request")]
     private Models.Request Request;
 
-    public override Task OnEnter(PageContext ctx, DetailsArgs args, CancellationToken ct)
+    public override Task OnEnter(PageContext ctx, string args, CancellationToken ct)
     {
         Request = new()
         {
-            Title = args.Title,
+            Title = args,
         };
 
         return new MessageBuilder(ctx)
-            .Text($"Заголовок: {args.Title}\nДобавьте детали или нажмите Далее.")
+            .Text($"Заголовок: {args}\nДобавьте детали или нажмите Далее.")
             .Inline(new InlineButton("Далее", "next"), new InlineButton("Назад", "back"))
             .Reply("Отмена")
             .SendAsync(ct);
@@ -31,20 +31,15 @@ public sealed class DetailsPage : StatefullPage<DetailsArgs>
         switch (payload)
         {
             case "next":
-                {
                 await SaveState(ctx, ct);
                 await ctx.Navigation.GoToAsync<FilesPage>(ctx, ct);
                 break;
-                }
 
             case "back":
-                {
                 await ctx.Navigation.GoToAsync<TitlePage>(ctx, ct);
                 break;
         }
     }
-        ;
-    }
 
     public override async Task OnText(PageContext ctx, string text, CancellationToken ct)
     {
@@ -52,12 +47,14 @@ public sealed class DetailsPage : StatefullPage<DetailsArgs>
         await SaveState(ctx, ct);
         await ctx.Navigation.GoToAsync<FilesPage>(ctx, ct);
     }
-}
 
-/// <summary>
+    internal static string Command => "/create_request {title?}";
-/// Аргументы для страницы DetailsPage.
+    internal static string CommandDescription => "создание заявки /create_request {title}";
-/// </summary>
+    internal static CommandHandler CommandHandler = async (ctx, args, ct) =>
-public sealed class DetailsArgs
     {
-    public string Title { get; set; } = "";
+        string? title = "";
+        args?.TryGetValue("title", out title);
+
+        await ctx.Navigation.GoToAsync<DetailsPage, string>(ctx, title ?? "", ct);
+    };
 }

Demo/Pages/FileSendPage.cs

@@ -1,19 +1,21 @@
 using BotPages.Core;
 using BotPages.Core.Abstractions;
 using BotPages.Core.Messaging;
+using BotPages.Core.Routing;
 
 namespace Demo.Pages;
 
+[Route("FileSend")]
 public sealed class FileSendPage : SingletonPage
 {
-    public override Task OnEnter(PageContext ctx, CancellationToken ct)
+    public override async Task OnEnter(PageContext ctx, CancellationToken ct)
     {
         var content = "Hello from BotPages! This file is generated on the fly.";
         var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(content));
 
         var demoFile = new FileDescriptor
         {
-            Id = "", // не используется при отправке нового файла
+            Id = "",
             Name = "demo.txt",
             Extension = "txt",
             Size = stream.Length,
@@ -21,9 +23,11 @@ public sealed class FileSendPage : SingletonPage
             GetStreamAsync = _ => Task.FromResult<Stream>(stream)
         };
 
-        return new MessageBuilder(ctx)
+        var msg = await new MessageBuilder(ctx)
             .Text("Вот пример отправки нового файла 📎", MessageFormat.Markdown)
             .File(demoFile, "Демонстрационный файл")
             .SendAsync(ct);
+
+        await ctx.GoToHomeAsync(ct);
     }
 }

Demo/Pages/FilesPage.cs

@@ -6,7 +6,7 @@ namespace Demo.Pages;
 
 /// <summary>
 /// Страница загрузки файлов.
-/// Обычная страница с полученим и сохранением состояния.
+/// Обычная страница с получением и сохранением состояния.
 /// </summary>
 public sealed class FilesPage : SingletonPage
 {
@@ -18,15 +18,17 @@ public sealed class FilesPage : SingletonPage
 
     public override async Task OnFile(PageContext ctx, List<FileDescriptor> files, CancellationToken ct)
     {
+        // Пересылаем каждый файл обратно с подтверждением
         foreach (var file in files)
         {
-            await ctx.SendFileAsync(file, $"Файл '{file.Name}' получен и отправлен обратно.", ct: ct);
+            await new MessageBuilder(ctx)
+                .File(file, $"Файл '{file.Name}' получен и отправлен обратно.")
+                .SendAsync(ct);
         }
 
-        //Обращение через Storage
+        // Сохраняем данные в хранилище состояния
         var request = await ctx.StateStorage.GetAsync<Models.Request>(ctx.SessionKey, "Request", ct);
         request.FilesCount = files.Count;
-        //Обращение через Context
         await ctx.SetStorageAsync("Request", request, ct);
 
         await new MessageBuilder(ctx)

Demo/Pages/SubmitPage.cs

@@ -10,9 +10,7 @@ public sealed class SubmitPage : SingletonPage
 {
     public override async Task OnEnter(PageContext ctx, CancellationToken ct)
     {
-        var progress = new MessageBuilder(ctx);
+        var messageId = await new MessageBuilder(ctx)
-
-        var messageId = await progress
             .Text("Отправка заявки\n7%")
             .SendAsync(ct);
 
@@ -21,10 +19,9 @@ public sealed class SubmitPage : SingletonPage
         {
             i += 25;
             Thread.Sleep(TimeSpan.FromMilliseconds(200));
-            await progress
+            await new MessageBuilder(ctx)
                 .Text($"Отправка заявки\n{i}%")
-                .EditMessage(messageId!)
+                .SendAsync(messageId, ct);
-                .SendAsync(ct);
         }
         while (i < 100);
 

Demo/Pages/TitlePage.cs

@@ -5,7 +5,6 @@ using BotPages.Core.Messaging;
 namespace Demo.Pages;
 /// <summary>
 /// Страница ввода заголовка заявки.
-/// Обычная страница вводом текста.
 /// </summary>
 public sealed class TitlePage : SingletonPage
 {
@@ -23,7 +22,7 @@ public sealed class TitlePage : SingletonPage
         }
         else
         {
-            return ctx.Navigation.GoToAsync<DetailsPage, DetailsArgs>(ctx, new DetailsArgs { Title = text }, ct);
+            return ctx.Navigation.GoToAsync<DetailsPage, string>(ctx, text, ct);
         }
     }
 }

Demo/Pages/WelcomePage.cs

@@ -1,13 +1,14 @@
 using BotPages.Core;
 using BotPages.Core.Abstractions;
 using BotPages.Core.Messaging;
+using BotPages.Core.Routing;
 
 namespace Demo.Pages;
 
 /// <summary>
 /// Стартовая страница демо‑бота.
-/// Обычная страница с кнопками
 /// </summary>
+[Route("Welcome")]
 public sealed class WelcomePage : SingletonPage
 {
     public override async Task OnEnter(PageContext ctx, CancellationToken ct)
@@ -29,20 +30,14 @@ public sealed class WelcomePage : SingletonPage
         switch (button)
         {
             case WelcomePageButtons.CreateRequest:
-                {
                 return ctx.Navigation.GoToAsync<TitlePage>(ctx, ct);
-                }
 
             case WelcomePageButtons.Help:
-                {
+                return new MessageBuilder(ctx).Text("Здесь будет справка.", MessageFormat.Plain).Style(MessageStyle.Success).SendAsync(ct);
-                    return new MessageBuilder(ctx).Text("Здесь будет справка.", MessageFormat.Plain).SendAsync(ct);
-                }
 
             case WelcomePageButtons.SendFile:
-                {
                 return ctx.Navigation.GoToAsync<FileSendPage>(ctx, ct);
         }
-        }
 
         return base.OnText(ctx, text, ct);
     }

Demo/Program.cs

@@ -1,6 +1,7 @@
 using BotPages.Core;
 using BotPages.Core.Logging;
 using BotPages.Core.Middleware;
+using BotPages.Core.Routing;
 using BotPages.Core.Storage;
 using BotPages.Telegram;
 using Demo.Pages;
@@ -16,18 +17,50 @@ namespace Demo
 
             var logger = new ConsoleLogger();
             var state = new InMemoryStateStorage();
-            using var cts = new CancellationTokenSource();
+
+            // Можно использовать команды для открытия страниц с роутингом
+            // /open Welcome
+            // /open FileSend
+            CommandHandler openHandler = async (ctx, args, ct) =>
+            {
+                if (args is null || !args.TryGetValue("page", out var pageName))
+                {
+                    var req = new BotPages.Core.Abstractions.SendRequest
+                    {
+                        ChatId = ctx.Update.Chat.Id,
+                        Text = "Не указана страница для открытия."
+                    };
+
+                    await ctx.SendAsync(req, ct: ct);
+                    return;
+                }
+
+                // Навигация на страницу по имени
+                await ctx.Navigation.GoToAsync(pageName, ctx, ct);
+            };
 
             var app = new BotPagesApp(state, logger)
                 .AddDefaultPage<WelcomePage>()
-                .MapCommand<WelcomePage>("/start")
+                .MapCommand<WelcomePage>("/start", true, "Главная")
-                .AddMiddleware(new ErrorHandlingMiddleware(logger))
+                .MapCommand("/open {page}", openHandler, true, "открыть страницу /open {page}")
-                .AddMiddleware(new LoggingMiddleware(logger))
+                .MapCommand(DetailsPage.Command, DetailsPage.CommandHandler, true, DetailsPage.CommandDescription)
+                .AutoMapRoute()
                 .AddTelegramAdapter(token, "Telegram")
-                .Build(cts.Token);
+                .AddMiddleware(new ErrorHandlingMiddleware(logger))
+                .AddMiddleware(new LoggingMiddleware(logger));
 
-            Console.ReadKey();
+            await app.RunAsync();
-            cts.Cancel();
+
+            logger.Log(LogLevel.Info, "Bot is running. Press Ctrl+C to stop.");
+
+            Console.CancelKeyPress += (sender, e) =>
+            {
+                Console.WriteLine("Cancel key pressed");
+                app.Stop();
+                e.Cancel = true;
+            };
+
+            await app.WaitAsync();
         }
     }
 }

README.md

@@ -1,92 +1,82 @@
-# BotPages Framework
+# BotPages
 
-BotPages — это архитектурный фреймворк для построения Telegram/MAX‑ботов с чистыми слоями, расширяемыми API и удобным developer experience.
+BotPages — кроссплатформенный фреймворк для создания диалоговых ботов с моделью страниц (page‑based conversational framework).
 
-## ✨ Возможности
+Цели проекта:
-- **Навигация через страницы**: каждая страница — отдельный обработчик логики.
+- Простая модель страниц и навигации.
-- **Единый метод GoToAsync**: автоматически поддерживает как `SingletonPage`, так и `StatefulPage`.
+- Портируемость между мессенджерами через адаптеры.
-- **StatefulPage**: свойства автоматически сохраняются в `StateStorage`.
+- Поддержка middleware и декларативной системы команд.
-- **SingletonPage**: один экземпляр на всё приложение, без состояния.
+- Минимум boilerplate и удобный developer experience.
-- **Middleware**: подключение промежуточных обработчиков (логирование, обработка ошибок).
-- **Автоматическая регистрация страниц**: через рефлексию.
-- **Роутинг страниц**: возможность устанавливать пути вызова для страниц.
-- **Команды**: возможность установки команд, которые работают приоритетнее обработчиков страниц.
-- **Минимум boilerplate**: декларативные интерфейсы и fluent API.
 
-## 🚀 Быстрый старт
+Структура репозитория
-```csharp
+
-var app = new BotPagesApp(factory, state, logger)
+- `BotPages.Core` — ядро фреймворка: навигация, страницы, маршрутизация, реестр команд, middleware, абстракции адаптеров и хранилища состояния.
-    .UseDefaultPage<WelcomePage>()
+- `BotPages.Telegram` — адаптер для Telegram Bot API (реализация `IMessengerAdapter`).
-    .MapCommand<WelcomePage>("/start")
+- `Demo` — пример приложения с несколькими страницами и конфигурацией адаптера.
-    .AddMiddleware(new LoggingMiddleware(logger))
+- `BotPages` — мета‑проект для упаковки библиотек.
-    .AddMiddleware(new ErrorHandlingMiddleware(logger));
+- `docs/` — внутренняя документация проекта (Quickstart, API reference и т.д.).
+
+Требования
+
+- .NET 8 SDK
+- C# 12
+
+Быстрый старт (локально)
+
+1. Клонируйте репозиторий:
+
+```bash
+git clone https://git.frigat.duckdns.org/FrigaT/BotPages.git
+cd BotPages
 ```
 
-## 📄 Пример страниц
+2. Соберите решения:
 
-### StatefulPage
+```bash
-```csharp
+dotnet build
-public sealed class WelcomePage : StatefulPage
-{
-    [Statefull("visitCount")]
-    private int VisitCount;
-
-    private PageContext? Context { get; set; }
-
-    public override async Task OnEnter(PageContext ctx, CancellationToken ct)
-    {
-        Context = ctx;
-
-        LoadState();
-        VisitCount++;
-        SaveState();
-
-        await ctx.SendTextAsync($"Добро пожаловать 🚀. Вы заходили сюда {VisitCount} раз(а).", ct: ct);
-    }
-}
 ```
 
-### SingletonPage
+3. Запуск демо (Telegram):
-```csharp
+
-public sealed class HelpPage : SingletonPage
+- Установите переменную окружения `TELEGRAM_TOKEN` с токеном бота.
-{
+
-    public override Task OnEnter(PageContext ctx, CancellationToken ct)
+```bash
-        => ctx.SendTextAsync("Это справка 📖", ct: ct);
+setx TELEGRAM_TOKEN "<token>"   # Windows
-}
+export TELEGRAM_TOKEN="<token>" # Linux/macOS
 ```
 
-## 🧩 Навигация
+- Запустите demo:
-```csharp
+
-await ctx.Navigation.GoToAsync<WelcomePage>(ctx, ct); // Stateful
+```bash
-await ctx.Navigation.GoToAsync<WelcomePage>(ctx, agrs, ct);    // Stateful with arguments
+dotnet run --project Demo
-await ctx.Navigation.GoToAsync<HelpPage>(ctx, ct);    // Singleton
-await ctx.Navigation.GoToHome(ctx, ct); // Stateful
 ```
 
-## ⚙️ Middleware
+Простой пример конфигурации
-```csharp
-public sealed class LoggingMiddleware : IPageMiddleware
-{
-    private readonly ILogger _logger;
-    public LoggingMiddleware(ILogger logger) => _logger = logger;
 
-    public async Task InvokeAsync(PageContext ctx, Func<Task> next, CancellationToken ct)
+```csharp
-    {
+var app = new BotPagesApp(stateStorage, logger)
-        _logger.Log(LogLevel.Info, $"Update: {ctx.Update.Kind}");
+    .AddTelegramAdapter(token)
-        await next();
+    .AddDefaultPage<WelcomePage>()
-    }
+    .MapCommand<WelcomePage>('/start')
-}
+    .AddMiddleware(new LoggingMiddleware(logger));
+
+await app.Build(CancellationToken.None);
 ```
 
-## 🏗 Архитектурные принципы
+Ключевые концепции
-- **Separation of concerns**: страницы не знают о транспорте, всё через адаптеры.
-- **Расширяемость**: новые страницы и middleware подключаются декларативно.
-- **Прозрачность**: минимум скрытой логики, всё явно через контекст.
-- **Developer Experience**: удобные API, автоматическая регистрация, документация через `///summary`.
 
-## 📌 Итог
+- `SendRequest` — единый формат запроса на отправку (текст, файлы, кнопки, опции). Адаптеры реализуют `IMessengerAdapter.SendAsync(SendRequest)`.
-BotPages позволяет писать чистые, расширяемые и удобные для команды боты:
+- `Page`, `StatefulPage`, `SingletonPage` — модели страниц с жизненным циклом (`OnEnter`, `OnUpdate`, `OnText`, `OnButton`, `OnFile`, `OnError`).
-- минимум boilerplate,
+- `NavigationService` — управление переходами между страницами.
-- декларативные интерфейсы,
+- `IPageMiddleware` — middleware-конвейер, выполняющийся для каждого апдейта.
-- прозрачная навигация,
+
-- автоматическое управление состоянием.
+Документация
+
+Полная внутренняя документация находится в `docs/`:
+- `docs/GETTING_STARTED.md` — быстрый старт и примеры конфигурации.
+- `docs/API_REFERENCE.md` — краткий reference публичных API.
+- `docs/PROJECT_DOCUMENTATION.md` — обзор архитектуры и компонентов.
+
+Лицензия
+
+Проект распространяется под лицензией MIT. Смотрите файл `LICENSE`.

TZ.md

@@ -1,162 +0,0 @@
-# Техническое задание  
-## Проект: BotPages
-
-### 1. Общая информация
-- **Название:** BotPages  
-- **Цель:** Создание библиотеки (NuGet‑пакета) для управления страницами в ботах (Telegram, VK, Discord, WhatsApp и др.), позволяющей строить логику без жёсткой привязки к конкретному API.  
-- **Платформа:** .NET 8  
-- **Артефакты:**  
-  - `BotPages.Core` — ядро, независимое от транспорта.  
-  - `BotPages.Telegram` — адаптер для Telegram.  
-  - В будущем: адаптеры для VK, Discord, WhatsApp.  
-- **Демо:** `Demo.exe` — демонстрация работы (создание заявки через несколько страниц, кнопки, файлы).
-
----
-
-### 2. Основные понятия
-- **Page** — класс, отвечающий за состояние экрана бота.  
-  - `Page` — базовый класс.  
-  - `Page<TArguments>` — страница с аргументами.  
-- **Контекст:**  
-  - `UserContext` — данные пользователя (UserId, MessengerType).  
-  - `ChatContext` — данные чата (ChatId, Title, ThreadId?, ленивое обновление).  
-  - `PageContext` — объединяет UserContext, ChatContext, состояние, навигацию, файлы.  
-- **Состояние:**  
-  - `IStateStorage` — универсальный интерфейс хранения.  
-  - Базовая реализация: InMemory.  
-  - Ключ: `CompositeSessionKey(MessengerType:string, ChatId, UserId)`.  
-  - История состояний: опционально (None, LastN, TimeWindow, Full).  
-
----
-
-### 3. Жизненный цикл страницы
-- Методы (все async, с `CancellationToken`):  
-  - `OnEnter(ctx)` — вход.  
-  - `OnUpdate(ctx, update)` — общий обработчик.  
-  - `OnText(ctx, text)` — текстовые сообщения.  
-  - `OnFile(ctx, file)` — файлы.  
-  - `OnButton(ctx, action)` — кнопки.  
-  - `OnLeave(ctx)` — выход.  
-  - `OnError(ctx, exception)` — ошибки.  
-  - `OnTimeout(ctx, timeoutInfo)` — таймауты.  
-- Прогресс фоновых операций:  
-  - `StartProgress()`, `UpdateProgress(percent)` + событие обновления.
-
----
-
-### 4. Навигация
-- Императивный API:  
-  ```csharp
-  ctx.GoTo<CitySelectionPage>();
-  ctx.GoTo<ConfirmationPage>(new ConfirmationArgs { PhotoId = photoId });
-  ctx.GoTo<DetailsPage>(args => { args.Photo = photoId; });
-  ctx.ReplaceWith<MainPage>();
-  ctx.Back();
-  ```
-- Декларативный роутинг:  
-  - Атрибуты `[Route("order/create")]`.  
-  - Реестр `routes.Map<CreateOrderPage>("order/create")`.  
-  - Проверка конфликтов при старте.  
-- Стек навигации: отдельный пакет `BotPages.Navigation.Stack`.  
-
----
-
-### 5. Команды
-- Команды имеют приоритет над событиями страниц.  
-- Поддержка шаблонов:  
-  ```csharp
-  app.Commands.Map("/start").To<WelcomePage>();
-  app.Commands.Map("/open {page} {id?}")
-      .To(ctx => ctx.GoToByName(page, new { id }));
-  ```
-- Возможность указать страницу, которая открывается при вводе команды.
-
----
-
-### 6. Файлы
-- **FileDescriptor:**  
-  - `Id`, `Name`, `Extension`, `Size`, `Mime`, `Type(enum)`, `SourceMessenger`, `GetStreamAsync()`, `Checksum?`.  
-- Отправка:  
-  ```csharp
-  await ctx.Chat.SendFileAsync(file, caption: "Документ");
-  await ctx.Chat.Files.BeginAlbum().Add(file1).Add(file2).SendAsync();
-  ```
-- Альбомы, сжатие — на уровне адаптера.  
-- Метаданные файлов — временно в контексте, экспорт в состояние вручную.
-
----
-
-### 7. Адаптеры
-- Интерфейс `IMessengerAdapter`:  
-  - `SendMessage`, `EditMessage`, `DeleteMessage`, `SendFile`, `SendAlbum`.  
-  - `ReceiveUpdate`.  
-  - `GetChat`, `GetFileStream`.  
-  - `AnswerCallback`, `SetTypingIndicator`.  
-- Telegram: первая реализация.  
-- Поддержка **Webhook** и **Polling** (выбор конфигом).  
-
----
-
-### 8. Capabilities
-- В `ChatContext.Capabilities`:  
-  - `SupportsInlineButtons`, `SupportsReplyButtons`, `SupportsAlbums`, `SupportsFormattingMarkdown`, `SupportsFormattingHtml`, `MaxMessageLength`.  
-- Разработчик может проверять возможности.  
-- Адаптер всегда деградирует и логирует `Warn`.  
-
----
-
-### 9. Логирование
-- Уровни: `Info`, `Warn`, `Critical`.  
-- Примеры:  
-  - Info: вход на страницу, прогресс.  
-  - Warn: деградация возможностей.  
-  - Critical: падение хранилища.  
-
----
-
-### 10. Middleware
-- Интерфейс:
-  ```csharp
-  public interface IUpdateMiddleware
-  {
-      Task InvokeAsync(UpdateContext ctx, Func<Task> next, CancellationToken ct);
-  }
-  ```
-- Пример:
-  ```csharp
-  app.AddMiddleware<LoggingMiddleware>();
-  app.AddMiddleware<ErrorMiddleware>(params);
-  ```
-- Порядок регистрации = порядок выполнения.  
-- Middleware только для входящих обновлений.  
-
----
-
-### 11. Дефолтная страница
-- Конфигурация:
-  ```csharp
-  app.UseDefaultPage<WelcomePage>();
-  ```
-- Одна дефолтная страница для всех мессенджеров.  
-- Условия не нужны.  
-
----
-
-### 12. Demo.exe
-- Сценарий: создание заявки.  
-- Страницы:  
-  1. **StartPage** — приветствие, кнопка «Создать заявку».  
-  2. **TitlePage** — ввод текста.  
-  3. **DetailsPage** — доп. поля, inline/reply кнопки.  
-  4. **FilesPage** — загрузка файлов, просмотр списка.  
-  5. **ConfirmPage** — подтверждение заявки.  
-  6. **SubmitPage** — отправка, итоговое сообщение.  
-
----
-
-### 13. TODO (будущие версии)
-- Поддержка модальных страниц со стеком.  
-- Расширенные Capabilities (rate limits, threads).  
-- View‑DSL как надстройка над контекстом.  
-- Cross‑transport identity.  
-- Расширенные таймауты и политики отката.  

docfx.json

@@ -0,0 +1,30 @@
+{
+  "metadata": [
+    {
+      "src": [
+        { "files": ["BotPages.Core/BotPages.Core.csproj"] },
+        { "files": ["BotPages.Telegram/BotPages.Telegram.csproj"] },
+        { "files": ["BotPages/BotPages.csproj"] }
+      ],
+      "dest": "api",
+      "properties": {
+        "TargetFramework": "net8.0"
+      }
+    }
+  ],
+  "build": {
+    "content": [
+      { "files": ["docs/**.md"] },
+      { "files": ["README.md"] },
+      { "files": ["api/**.yml"], "dest": "api" }
+    ],
+    "resource": [
+      { "files": ["docs/**.png", "docs/**.jpg", "docs/**.svg"] }
+    ],
+    "dest": "_site",
+    "globalMetadata": {
+      "_enableSearch": true
+    },
+    "template": [ "default" ]
+  }
+}

docs/API_REFERENCE.md

@@ -0,0 +1,46 @@
+# Справочник API
+
+Ниже краткое описание публичных API проекта BotPages.
+
+## BotPages.Core
+
+### `BotPagesApp`
+- `AddTelegramAdapter(string token)` — регистрирует Telegram адаптер с заданным токеном.
+- `AddAdapter(string messengerType, IMessengerAdapter adapter)` — регистрирует произвольный адаптер.
+- `AddMiddleware(IPageMiddleware middleware)` — добавляет middleware в pipeline.
+- `MapCommand<TPage>(string template)` — привязать команду к странице.
+- `MapRoute<TPage>(string template)` — зарегистрировать маршрут.
+- `AutoMapRoute()` — выполнить автопоиск Page?классов и зарегистрировать их маршруты.
+- `Build(CancellationToken ct)` — подготовить и запустить приложение.
+
+### `IMessengerAdapter`
+- `Task<string?> SendAsync(SendRequest request, CancellationToken ct = default)` — универсальный метод отправки для всех адаптеров.
+- `IAlbumBuilder CreateAlbumBuilder(PageContext ctx)` — создать билдер альбома (если поддерживается).
+- `Task OnLeaveAsync(PageContext ctx, CancellationToken ct)` — вызывается при уходе со страницы.
+
+### `SendRequest`
+- `ChatId` — идентификатор чата.
+- `Text`, `TextFormat` — текст и формат.
+- `File`, `Caption`, `CaptionFormat` — файл и подпись.
+- `Inline`, `Reply` — inline и reply клавиатуры.
+- `MessageId` — id редактируемого сообщения.
+- `AdapterOptions` — адаптер?специфичные опции (например `TelegramOptions`).
+
+### `PageContext` расширения
+- `SendAsync(SendRequest request, CancellationToken ct = default)` — отправить `SendRequest`.
+- `SendTextAsync(...)`, `SendFileAsync(...)` — удобные оболочки, создающие `SendRequest`.
+
+## BotPages.Telegram
+- `TelegramAdapter` — реализация `IMessengerAdapter` для Telegram.
+- `TelegramOptions` — настройки адаптера (например `NotifyOnSend`).
+- `MessageBuilderExtensions.WithTelegramOptions` — расширение для установки `TelegramOptions` для конкретного сообщения.
+
+
+# Генерация документации
+
+Рекомендуется использовать `docfx` или `Doxygen` для генерации HTML-документации из XML-файлов, которые генерируются при сборке (см. `GenerateDocumentationFile` в `.csproj`).
+
+
+# Примечания
+
+Этот документ — краткое описание API. Для полного списка публичных типов и методов можно сгенерировать reference из XML-вывода компиляции.

docs/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing to BotPages
+
+Спасибо за интерес к проекту! Пожалуйста, перед отправкой PR убедитесь, что:
+
+- Ваш код проходит сборку: `dotnet build`.
+- Добавлены/обновлены тесты, если уместно.
+- Следуется стиль кода проекта и включены nullable-аннотации.
+
+Документация генерируется через `docfx`. См. `docfx.json` в корне репозитория и скрипты в `scripts/`.
+
+Пример локальной генерации документации:
+
+```bash
+# Unix
+./scripts/generate-docs.sh
+
+# Windows PowerShell
+./scripts/generate-docs.ps1
+```

docs/GETTING_STARTED.md

@@ -0,0 +1,47 @@
+# Быстрый старт с BotPages
+
+Это руководство поможет быстро запустить demo?приложение с Telegram?адаптером.
+
+Требования
+- .NET 8 SDK
+- Токен Telegram?бота (для demo)
+
+Сборка
+
+```bash
+dotnet build
+```
+
+Запуск demo
+
+1. Установите переменную окружения `TELEGRAM_TOKEN`:
+
+```bash
+setx TELEGRAM_TOKEN "<token>"   # Windows
+export TELEGRAM_TOKEN="<token>" # Linux/macOS
+```
+
+2. Запустите demo:
+
+```bash
+dotnet run --project Demo
+```
+
+Пример конфигурации приложения
+
+```csharp
+var app = new BotPagesApp(stateStorage, logger)
+    .AddTelegramAdapter(token)
+    .AddDefaultPage<WelcomePage>()
+    .MapCommand<WelcomePage>("/start")
+    .AddMiddleware(new LoggingMiddleware(logger));
+
+await app.Build(CancellationToken.None);
+```
+
+Основные понятия
+- `SendRequest` — единый формат запроса на отправку (текст, файлы, кнопки, адаптер?опции). Используйте `PageContext.SendAsync` для отправки.
+- `Page` / `StatefulPage` / `SingletonPage` — модели страниц и их жизненный цикл.
+- `IPageMiddleware` — middleware выполняется для каждого входящего обновления.
+
+Далее: см. `docs/API_REFERENCE.md` для описания публичных API.

docs/PROJECT_DOCUMENTATION.md

@@ -0,0 +1,114 @@
+# Документация проекта BotPages
+
+Краткая документация по всему проекту. Описывает архитектуру, основные компоненты, сценарии использования и сборки.
+
+## Структура репозитория
+
+- `BotPages.Core` — ядро фреймворка.
+  - Навигация: `NavigationService`, страницы: `Page`, `StatefulPage`, `SingletonPage`.
+  - Маршрутизация: `RoutesRegistry` (авторегистрация через `AutoMapRoute`).
+  - Команды: `CommandsRegistry` (парсер шаблонов команд, `TryDispatch`).
+  - Middleware: интерфейс `IPageMiddleware` и реализация `LoggingMiddleware`.
+  - Абстракции адаптеров/адаптер-фабрика: `IMessangerAdapterSetup`, `IMessengerAdapterFactory` (например `MultiAdapterFactory`).
+  - Хранилище состояния: `IStateStorage`.
+
+- `BotPages.Telegram` — реализация адаптера для Telegram (использует `Telegram.Bot`).
+
+- `Demo` — демонстрационное приложение с примерами страниц и конфигурации.
+
+- `BotPages` — мета-проект/пакет для упаковки.
+
+## Главные сущности и сценарии использования
+
+- `BotPagesApp` — точка конфигурации и запуска приложения.
+  - Регистрация адаптеров: `AddAdapter(string messengerType, IMessangerAdapterSetup adapter)`.
+  - Регистрация middleware: `AddMiddleware<T>(T instance)`.
+  - Регистрация команд: `MapCommand<TPage>(string template)` или `MapCommand(string template, CommandHandler handler)`.
+  - Маршруты: `MapRoute<TPage>(string template)` и `AutoMapRoute()` для автоматического поиска страниц по рефлексии.
+  - Запуск: `Build(CancellationToken)` — старт адаптеров и приём апдейтов.
+
+- Страницы:
+  - `Page` — базовый класс (абстрактный) с жизненным циклом (`OnEnter`, `OnUpdate`, `OnText`, `OnButton`, `OnFile`, `OnError`).
+  - `StatefulPage` — хранит состояние в `IStateStorage` (сериализация полей, атрибуты для stateful-полей).
+  - `SingletonPage` — один экземпляр на приложение, без per-session состояния.
+
+- Навигация: `NavigationService` управляет текущей страницей пользователя (определяется по `PageContext.SessionKey`) и предоставляет методы `GoToAsync<TPage>`, `GoToHomeAsync`.
+
+- Команды: шаблоны вида `/cmd {arg} {opt?}`. Парсер в `CommandsRegistry.ToRegex` поддерживает именованные группы и опциональные аргументы. При совпадении вызывается `CommandHandler(PageContext, IDictionary<string,string>, CancellationToken)`.
+
+- Middleware: реализуют `IPageMiddleware.InvokeAsync(PageContext, Func<Task> next, CancellationToken ct)`; вызываются в порядке регистрации (конвейер).
+
+## Формат и схема апдейта
+
+- `UpdateContext` содержит данные апдейта: `MessengerType`, `Chat`, `User`, `Kind` (флаги `Text`, `Button`, `File`), `Text`, `Files`.
+- При поступлении апдейта `BotPagesApp.HandleUpdateAsync` создаёт `PageContext` и:
+  1. Проверяет команды (если текст и начинается с `/`) — команды имеют приоритет.
+  2. Запускает pipeline middleware.
+  3. Передаёт управление текущей странице через `DispatchToPageAsync`.
+
+## Расширение и адаптеры
+
+- Чтобы добавить новый мессенджер, реализуйте `IMessangerAdapterSetup`/`IMessengerAdapter` и зарегистрируйте через `BotPagesApp.AddAdapter`.
+- `MultiAdapterFactory` служит для хранения и разрешения адаптеров по ключу `messengerType`.
+
+## Сборка и запуск
+
+Требования:
+- .NET 8 SDK
+
+Сборка проекта:
+
+```bash
+dotnet build
+```
+
+Запуск демонстрации:
+
+```bash
+dotnet run --project Demo
+```
+
+Для Telegram-адаптера настройте токен и параметры в `Demo` (или в коде инициализации адаптера).
+
+## Документы API и комментарии
+
+XML-документация генерируется флагом `GenerateDocumentationFile` в `.csproj` для проектов. Для автогенерации документации используйте стандартные инструменты (например, `docfx`, `doxygen` или `MkDocs` с генерацией из XML).
+
+## Примеры
+
+- Пример регистрации кусочка конфигурации:
+
+```csharp
+var app = new BotPagesApp(stateStorage, logger)
+    .AddAdapter("telegram", new TelegramAdapterSetup(token))
+    .AddMiddleware(new LoggingMiddleware(logger))
+    .MapCommand<WelcomePage>("/start")
+    .AddDefaultPage<WelcomePage>();
+
+await app.Build(CancellationToken.None);
+```
+
+- Пример простой страницы:
+
+```csharp
+public sealed class WelcomePage : StatefulPage
+{
+    public override async Task OnEnter(PageContext ctx, CancellationToken ct)
+    {
+        await ctx.SendTextAsync("Добро пожаловать", ct: ct);
+    }
+}
+```
+
+## Вклад и тестирование
+
+- Направляйте PR в репозиторий. Описывайте изменения в заголовке и теле PR.
+- Поддерживайте единый стиль кода и null-safe практики (`Nullable` включён).
+
+## Лицензия
+
+Проект распространяется под лицензией MIT (см. `.csproj` и `LICENSE`).
+
+---
+
+Это краткий обзор. При необходимости можно сгенерировать подробный Reference по API (список публичных типов и методов) в отдельный документ.

docs/docfx_project/docfx.css

@@ -0,0 +1,2 @@
+/* Minimal styling overrides for docfx output */
+body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", "Liberation Sans", sans-serif; }

docs/docfx_project/docfx.js

@@ -0,0 +1,7 @@
+module.exports = {
+  "templates": {
+    "global": {
+      "favicon": "favicon.ico"
+    }
+  }
+};

scripts/generate-docs.ps1

@@ -0,0 +1,22 @@
+Param(
+    [string]$DocfxPath = "docfx",
+    [string]$WorkingDir = "$(Resolve-Path .)"
+)
+
+$ErrorActionPreference = 'Stop'
+
+Write-Host "Generating docfx documentation..."
+
+if (-not (Get-Command $DocfxPath -ErrorAction SilentlyContinue)) {
+    Write-Host "Docfx not found on PATH. Install docfx or provide full path to docfx.exe" -ForegroundColor Yellow
+}
+
+Push-Location $WorkingDir
+try {
+    & $DocfxPath metadata docfx.json
+    & $DocfxPath build docfx.json
+    Write-Host "Docfx build complete. Output in _site folder" -ForegroundColor Green
+}
+finally {
+    Pop-Location
+}

scripts/generate-docs.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+DOCFX_PATH=${DOCFX_PATH:-docfx}
+WORKING_DIR=$(pwd)
+
+if ! command -v "$DOCFX_PATH" >/dev/null 2>&1; then
+  echo "docfx not found. Install it or set DOCFX_PATH to the executable path."
+fi
+
+pushd "$WORKING_DIR" > /dev/null
+$DOCFX_PATH metadata docfx.json
+$DOCFX_PATH build docfx.json
+popd > /dev/null
+
+echo "Docfx build complete. Output in _site folder"