* Moved source code projects directory to 'src'

* Updatedt Solution format

src/Telegrator.Hosting.Web/Components/ITelegramBotWebHost.cs

@@ -0,0 +1,15 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Routing;
+using Telegrator.Hosting.Components;
+
+namespace Telegrator.Hosting.Web.Components
+{
+    /// <summary>
+    /// Interface for Telegram bot hosts with Webhook update receiving.
+    /// Combines wbe application capabilities with reactive Telegram bot functionality.
+    /// </summary>
+    public interface ITelegramBotWebHost : ITelegramBotHost, IEndpointRouteBuilder, IApplicationBuilder, IAsyncDisposable
+    {
+
+    }
+}

src/Telegrator.Hosting.Web/GlobalSuppressions.cs

@@ -0,0 +1,10 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Style", "IDE0290")]
+[assembly: SuppressMessage("Style", "IDE0090")]
+[assembly: SuppressMessage("Usage", "CA2254")]

src/Telegrator.Hosting.Web/Polling/HostedUpdateWebhooker.cs

@@ -0,0 +1,96 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Primitives;
+using System.Text.Json;
+using Telegram.Bot;
+using Telegram.Bot.Types;
+using Telegrator.MadiatorCore;
+
+namespace Telegrator.Hosting.Web.Polling
+{
+    /// <summary>
+    /// Service for receiving updates for Hosted telegram bots via Webhooks
+    /// </summary>
+    public class HostedUpdateWebhooker : IHostedService
+    {
+        private const string SecretTokenHeader = "X-Telegram-Bot-Api-Secret-Token";
+
+        private readonly IEndpointRouteBuilder _botHost;
+        private readonly ITelegramBotClient _botClient;
+        private readonly IUpdateRouter _updateRouter;
+        private readonly TelegratorWebOptions _options;
+
+        /// <summary>
+        /// Initiallizes new instance of <see cref="HostedUpdateWebhooker"/>
+        /// </summary>
+        /// <param name="botHost"></param>
+        /// <param name="botClient"></param>
+        /// <param name="updateRouter"></param>
+        /// <param name="options"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public HostedUpdateWebhooker(IEndpointRouteBuilder botHost, ITelegramBotClient botClient, IUpdateRouter updateRouter, IOptions<TelegratorWebOptions> options)
+        {
+            if (string.IsNullOrEmpty(options.Value.WebhookUri))
+                throw new ArgumentNullException(nameof(options), "Option \"WebhookUrl\" must be set to subscribe for update recieving");
+
+            _botHost = botHost;
+            _botClient = botClient;
+            _updateRouter = updateRouter;
+            _options = options.Value;
+        }
+
+        /// <inheritdoc/>
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            StartInternal(cancellationToken);
+            return Task.CompletedTask;
+        }
+
+        private async void StartInternal(CancellationToken cancellationToken)
+        {
+            string pattern = new UriBuilder(_options.WebhookUri).Path;
+            _botHost.MapPost(pattern, (Delegate)ReceiveUpdate);
+
+            await _botClient.SetWebhook(
+                url: _options.WebhookUri,
+                maxConnections: _options.MaxConnections,
+                allowedUpdates: _updateRouter.HandlersProvider.AllowedTypes,
+                dropPendingUpdates: _options.DropPendingUpdates,
+                secretToken: _options.SecretToken,
+                cancellationToken: cancellationToken);
+        }
+
+        /// <inheritdoc/>
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            _botClient.DeleteWebhook(_options.DropPendingUpdates, cancellationToken);
+            return Task.CompletedTask;
+        }
+
+        private async Task<IResult> ReceiveUpdate(HttpContext ctx)
+        {
+            if (_options.SecretToken != null)
+            {
+                if (!ctx.Request.Headers.TryGetValue(SecretTokenHeader, out StringValues strings))
+                    return Results.BadRequest();
+
+                string? secret = strings.SingleOrDefault();
+                if (secret == null)
+                    return Results.BadRequest();
+
+                if (_options.SecretToken != secret)
+                    return Results.StatusCode(401);
+            }
+
+            Update? update = await JsonSerializer.DeserializeAsync<Update>(ctx.Request.Body, JsonBotAPI.Options, ctx.RequestAborted);
+            if (update is not { Id: > 0 })
+                return Results.BadRequest();
+
+            await _updateRouter.HandleUpdateAsync(_botClient, update, ctx.RequestAborted);
+            return Results.Ok();
+        }
+    }
+}

src/Telegrator.Hosting.Web/README.md

@@ -0,0 +1,87 @@
+# Telegrator.Hosting.Web
+
+**Telegrator.Hosting.Web** is an extension for the Telegrator framework that enables seamless integration with ASP.NET Core and webhook-based Telegram bots. It is designed for scalable, production-ready web applications.
+
+---
+
+## Features
+- ASP.NET Core integration for webhook-based bots
+- Automatic handler discovery and registration
+- Strongly-typed configuration via `appsettings.json` and environment variables
+- Dependency injection and middleware support
+- Graceful startup/shutdown and lifecycle management
+- Advanced error handling and logging
+- Supports all Telegrator handler/filter/state features
+
+---
+
+## Requirements
+- .NET 8.0 or later
+- ASP.NET Core
+
+---
+
+## Installation
+
+```shell
+dotnet add package Telegrator.Hosting.Web
+```
+
+---
+
+## Quick Start Example
+
+**Program.cs (ASP.NET Core):**
+```csharp
+using Telegrator.Hosting;
+using Telegrator.Hosting.Web;
+
+// Creating builder
+TelegramBotWebHostBuilder builder = TelegramBotWebHost.CreateBuilder(new TelegramBotWebOptions()
+{
+    Args = args,
+    ExceptIntersectingCommandAliases = true
+});
+
+// Register handlers
+builder.Handlers.CollectHandlersAssemblyWide();
+
+// Register your services
+builder.Services.AddSingleton<IMyService, MyService>();
+
+// Building and running application
+TelegramBotWebHost telegramBot = builder.Build();
+telegramBot.SetBotCommands();
+telegramBot.Run();
+```
+
+---
+
+## Configuration (appsettings.json)
+
+```json
+{
+  "TelegramBotClientOptions": {
+    "Token": "YOUR_BOT_TOKEN"
+  }
+
+  "TelegratorWebOptions": {
+    "WebhookUri" = "https://you-public-host.ru/bot",
+    "DropPendingUpdates": true
+  }
+}
+```
+
+- `TelegramBotClientOptions`: Bot token and client settings
+
+---
+
+## Documentation
+- [Telegrator Main Docs](https://github.com/Rikitav/Telegrator)
+- [Getting Started Guide](https://github.com/Rikitav/Telegrator/wiki/Getting-started)
+- [Annotation Overview](https://github.com/Rikitav/Telegrator/wiki/Annotation-overview)
+
+---
+
+## License
+GPLv3 

src/Telegrator.Hosting.Web/TelegramBotWebHost.cs

@@ -0,0 +1,177 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Telegrator.Hosting.Components;
+using Telegrator.Hosting.Web.Components;
+using Telegrator.MadiatorCore;
+
+namespace Telegrator.Hosting.Web
+{
+    /// <summary>
+    /// Represents a web hosted telegram bot
+    /// </summary>
+    public class TelegramBotWebHost : ITelegramBotWebHost
+    {
+        private readonly WebApplication _innerApp;
+        private readonly IUpdateRouter _updateRouter;
+        private readonly ILogger<TelegramBotWebHost> _logger;
+
+        private bool _disposed;
+
+        /// <inheritdoc/>
+        public IServiceProvider Services => _innerApp.Services;
+
+        /// <inheritdoc/>
+        public IUpdateRouter UpdateRouter => _updateRouter;
+
+        /// <inheritdoc/>
+        public ICollection<EndpointDataSource> DataSources => ((IEndpointRouteBuilder)_innerApp).DataSources;
+
+        /// <summary>
+        /// Allows consumers to be notified of application lifetime events.
+        /// </summary>
+        public IHostApplicationLifetime Lifetime => _innerApp.Lifetime;
+
+        /// <summary>
+        /// This application's logger
+        /// </summary>
+        public ILogger<TelegramBotWebHost> Logger => _logger;
+
+        // Private interface fields
+        IServiceProvider IEndpointRouteBuilder.ServiceProvider => Services;
+        IServiceProvider IApplicationBuilder.ApplicationServices { get => Services; set => throw new NotImplementedException(); }
+        IFeatureCollection IApplicationBuilder.ServerFeatures => ((IApplicationBuilder)_innerApp).ServerFeatures;
+        IDictionary<string, object?> IApplicationBuilder.Properties => ((IApplicationBuilder)_innerApp).Properties;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WebApplicationBuilder"/> class.
+        /// </summary>
+        /// <param name="webApplicationBuilder">The proxied instance of host builder.</param>
+        /// <param name="handlers"></param>
+        public TelegramBotWebHost(WebApplicationBuilder webApplicationBuilder, IHandlersCollection handlers)
+        {
+            // Registering this host in services for easy access
+            RegisterHostServices(webApplicationBuilder.Services, handlers);
+
+            // Building proxy application
+            _innerApp = webApplicationBuilder.Build();
+            _innerApp.UseTelegratorWeb();
+
+            // Reruesting services for this host
+            _updateRouter = Services.GetRequiredService<IUpdateRouter>();
+            _logger = Services.GetRequiredService<ILogger<TelegramBotWebHost>>();
+        }
+
+        /// <summary>
+        /// Creates new <see cref="TelegramBotHostBuilder"/> with default services and webhook update receiving scheme
+        /// </summary>
+        /// <returns></returns>
+        public static TelegramBotWebHostBuilder CreateBuilder(TelegramBotWebOptions settings)
+        {
+            ArgumentNullException.ThrowIfNull(settings, nameof(settings));
+            WebApplicationBuilder innerApp = WebApplication.CreateBuilder(settings.ToWebApplicationOptions());
+            TelegramBotWebHostBuilder builder = new TelegramBotWebHostBuilder(innerApp, settings);
+            builder.Services.AddTelegramBotHostDefaults();
+            builder.Services.AddTelegramWebhook();
+            return builder;
+        }
+
+        /// <summary>
+        /// Creates new SLIM <see cref="TelegramBotHostBuilder"/> with default services and webhook update receiving scheme
+        /// </summary>
+        /// <returns></returns>
+        public static TelegramBotWebHostBuilder CreateSlimBuilder(TelegramBotWebOptions settings)
+        {
+            ArgumentNullException.ThrowIfNull(settings, nameof(settings));
+            WebApplicationBuilder innerApp = WebApplication.CreateSlimBuilder(settings.ToWebApplicationOptions());
+            TelegramBotWebHostBuilder builder = new TelegramBotWebHostBuilder(innerApp, settings);
+            builder.Services.AddTelegramBotHostDefaults();
+            builder.Services.AddTelegramWebhook();
+            return builder;
+        }
+
+        /// <summary>
+        /// Creates new EMPTY <see cref="TelegramBotHostBuilder"/> WITHOUT any services or update receiving schemes
+        /// </summary>
+        /// <returns></returns>
+        public static TelegramBotWebHostBuilder CreateEmptyBuilder(TelegramBotWebOptions settings)
+        {
+            ArgumentNullException.ThrowIfNull(settings, nameof(settings));
+            WebApplicationBuilder innerApp = WebApplication.CreateEmptyBuilder(settings.ToWebApplicationOptions());
+            return new TelegramBotWebHostBuilder(innerApp, settings);
+        }
+
+        /// <inheritdoc/>
+        public async Task StartAsync(CancellationToken cancellationToken = default)
+        {
+            await _innerApp.StartAsync(cancellationToken);
+        }
+
+        /// <inheritdoc/>
+        public async Task StopAsync(CancellationToken cancellationToken = default)
+        {
+            await _innerApp.StopAsync(cancellationToken);
+        }
+
+        /// <inheritdoc/>
+        public IApplicationBuilder CreateApplicationBuilder()
+            => ((IEndpointRouteBuilder)_innerApp).CreateApplicationBuilder();
+
+        /// <inheritdoc/>
+        public IApplicationBuilder Use(Func<RequestDelegate, RequestDelegate> middleware)
+            => _innerApp.Use(middleware);
+
+        /// <inheritdoc/>
+        public IApplicationBuilder New()
+            => ((IApplicationBuilder)_innerApp).New();
+
+        /// <inheritdoc/>
+        public RequestDelegate Build()
+            => ((IApplicationBuilder)_innerApp).Build();
+
+        /// <summary>
+        /// Disposes the host.
+        /// </summary>
+        public async ValueTask DisposeAsync()
+        {
+            if (_disposed)
+                return;
+
+            await _innerApp.DisposeAsync();
+
+            GC.SuppressFinalize(this);
+            _disposed = true;
+        }
+
+        /// <summary>
+        /// Disposes the host.
+        /// </summary>
+        public void Dispose()
+        {
+            if (_disposed)
+                return;
+
+            // Sorry for this, i really dont know how to handle such cases
+            ValueTask disposeTask = _innerApp.DisposeAsync();
+            while (!disposeTask.IsCompleted)
+                Thread.Sleep(100);
+
+            GC.SuppressFinalize(this);
+            _disposed = true;
+        }
+
+        private void RegisterHostServices(IServiceCollection services, IHandlersCollection handlers)
+        {
+            //service.RemoveAll<IHost>();
+            //service.AddSingleton<IHost>(this);
+
+            services.AddSingleton<ITelegramBotHost>(this);
+            services.AddSingleton<ITelegramBotWebHost>(this);
+            services.AddSingleton<ITelegratorBot>(this);
+        }
+    }
+}

src/Telegrator.Hosting.Web/TelegramBotWebHostBuilder.cs

@@ -0,0 +1,108 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Telegram.Bot;
+using Telegrator.Hosting.Components;
+using Telegrator.Hosting.Configuration;
+using Telegrator.Hosting.Providers;
+using Telegrator.Hosting.Providers.Components;
+using Telegrator.MadiatorCore;
+
+#pragma warning disable IDE0001
+namespace Telegrator.Hosting.Web
+{
+    /// <summary>
+    /// Represents a web hosted telegram bots and services builder that helps manage configuration, logging, lifetime, and more.
+    /// </summary>
+    public class TelegramBotWebHostBuilder : ITelegramBotHostBuilder
+    {
+        private readonly WebApplicationBuilder _innerBuilder;
+        private readonly TelegramBotWebOptions _settings;
+        private readonly IHandlersCollection _handlers;
+
+        /// <inheritdoc/>
+        public IHandlersCollection Handlers => _handlers;
+
+        /// <inheritdoc/>
+        public IConfigurationManager Configuration => _innerBuilder.Configuration;
+
+        /// <inheritdoc/>
+        public ILoggingBuilder Logging => _innerBuilder.Logging;
+
+        /// <inheritdoc/>
+        public IServiceCollection Services => _innerBuilder.Services;
+
+        /// <inheritdoc/>
+        public IHostEnvironment Environment => _innerBuilder.Environment;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TelegramBotWebHostBuilder"/> class.
+        /// </summary>
+        /// <param name="webApplicationBuilder"></param>
+        /// <param name="settings"></param>
+        public TelegramBotWebHostBuilder(WebApplicationBuilder webApplicationBuilder, TelegramBotWebOptions settings)
+        {
+            _innerBuilder = webApplicationBuilder ?? throw new ArgumentNullException(nameof(webApplicationBuilder));
+            _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+            _handlers = new HostHandlersCollection(Services, _settings);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TelegramBotWebHostBuilder"/> class.
+        /// </summary>
+        /// <param name="webApplicationBuilder"></param>
+        /// <param name="handlers"></param>
+        /// <param name="settings"></param>
+        public TelegramBotWebHostBuilder(WebApplicationBuilder webApplicationBuilder, TelegramBotWebOptions settings, IHandlersCollection handlers)
+        {
+            _innerBuilder = webApplicationBuilder ?? throw new ArgumentNullException(nameof(webApplicationBuilder));
+            _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+            _handlers = handlers ?? throw new ArgumentNullException(nameof(settings));
+
+            _innerBuilder.AddTelegratorWeb(settings);
+        }
+
+        /// <summary>
+        /// Builds the host.
+        /// </summary>
+        /// <returns></returns>
+        public TelegramBotWebHost Build()
+        {
+            if (_handlers is IHostHandlersCollection hostHandlers)
+            {
+                foreach (PreBuildingRoutine preBuildRoutine in hostHandlers.PreBuilderRoutines)
+                {
+                    try
+                    {
+                        preBuildRoutine.Invoke(this);
+                    }
+                    catch (NotImplementedException)
+                    {
+                        _ = 0xBAD + 0xC0DE;
+                    }
+                }
+            }
+
+            if (!_settings.DisableAutoConfigure)
+            {
+                Services.Configure<TelegratorWebOptions>(Configuration.GetSection(nameof(TelegratorWebOptions)));
+                Services.Configure<TelegramBotClientOptions>(Configuration.GetSection(nameof(TelegramBotClientOptions)), new TelegramBotClientOptionsProxy());
+            }
+            else
+            {
+                if (null == Services.SingleOrDefault(srvc => srvc.ImplementationType == typeof(IOptions<TelegratorWebOptions>)))
+                    throw new MissingMemberException("Auto configuration disabled, yet no options of type 'TelegratorWebOptions' wasn't registered. This configuration is runtime required!");
+
+                if (null == Services.SingleOrDefault(srvc => srvc.ImplementationType == typeof(IOptions<TelegramBotClientOptions>)))
+                    throw new MissingMemberException("Auto configuration disabled, yet no options of type 'TelegramBotClientOptions' wasn't registered. This configuration is runtime required!");
+            }
+
+            Services.AddSingleton<IConfigurationManager>(Configuration);
+            Services.AddSingleton<IOptions<TelegratorOptions>>(Options.Create(_settings));
+            return new TelegramBotWebHost(_innerBuilder, _handlers);
+        }
+    }
+}

src/Telegrator.Hosting.Web/TelegramBotWebOptions.cs

@@ -0,0 +1,40 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Options;
+
+namespace Telegrator.Hosting.Web
+{
+    /// <summary>
+    /// Options for configuring the behavior for TelegramBotWebHost.
+    /// </summary>
+    public class TelegramBotWebOptions : TelegratorOptions
+    {
+        /// <summary>
+        /// Disables automatic configuration for all of required <see cref="IOptions{TOptions}"/> instances
+        /// </summary>
+        public bool DisableAutoConfigure { get; set; }
+
+        /// <inheritdoc cref="WebApplicationOptions.Args"/>
+        public string[]? Args { get; init; }
+
+        /// <inheritdoc cref="WebApplicationOptions.EnvironmentName"/>
+        public string? EnvironmentName { get; init; }
+
+        /// <inheritdoc cref="WebApplicationOptions.ApplicationName"/>
+        public string? ApplicationName { get; init; }
+
+        /// <inheritdoc cref="WebApplicationOptions.ContentRootPath"/>
+        public string? ContentRootPath { get; init; }
+
+        /// <inheritdoc cref="WebApplicationOptions.WebRootPath"/>
+        public string? WebRootPath { get; init; }
+
+        internal WebApplicationOptions ToWebApplicationOptions() => new WebApplicationOptions()
+        {
+            ApplicationName = ApplicationName,
+            Args = Args,
+            ContentRootPath = ContentRootPath,
+            EnvironmentName = EnvironmentName,
+            WebRootPath = WebRootPath
+        };
+    }
+}

src/Telegrator.Hosting.Web/Telegrator.Hosting.Web.csproj

@@ -0,0 +1,45 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+	<LangVersion>latest</LangVersion>
+	<BaseOutputPath>..\..\bin</BaseOutputPath>
+	<DocumentationFile>..\..\docs\$(AssemblyName).xml</DocumentationFile>
+	  
+    <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
+    <EnableNETAnalyzers>True</EnableNETAnalyzers>
+    <EnforceCodeStyleInBuild>True</EnforceCodeStyleInBuild>
+	  
+    <Title>Telegrator.Hosting.Web</Title>
+    <Version>1.16.0</Version>
+	<Authors>Rikitav Tim4ik</Authors>
+    <Company>Rikitav Tim4ik</Company>
+    <RepositoryUrl>https://github.com/Rikitav/Telegrator</RepositoryUrl>
+    <PackageTags>telegram;bot;mediator;attributes;aspect;hosting;host;framework;easy;simple;handlers</PackageTags>
+	  
+    <PackageIcon>telegrator_nuget.png</PackageIcon>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageLicenseFile>LICENSE</PackageLicenseFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\LICENSE" Pack="True" PackagePath="\" />
+    <None Include="..\README.md" Pack="True" PackagePath="\" />
+    <None Include="..\resources\telegrator_nuget.png" Pack="True" PackagePath="\" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <ProjectReference Include="..\Telegrator.Hosting\Telegrator.Hosting.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+	<FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Telegram.Bot.AspNetCore" Version="22.5.0" />
+  </ItemGroup>
+</Project>

src/Telegrator.Hosting.Web/TelegratorWebOptions.cs

@@ -0,0 +1,35 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Telegrator.Hosting.Web
+{
+    /// <summary>
+    /// Configuration options for Telegram bot behavior and execution settings.
+    /// Controls various aspects of bot operation including concurrency, routing, webhook receiving, and execution policies.
+    /// </summary>
+    public class TelegratorWebOptions
+    {
+        /// <summary>
+        /// Gets or sets HTTPS URL to send updates to. Use an empty string to remove webhook integration
+        /// </summary>
+        [StringSyntax(StringSyntaxAttribute.Uri)]
+        public required string WebhookUri { get; set; }
+
+        /// <summary>
+        /// A secret token to be sent in a header “X-Telegram-Bot-Api-Secret-Token” in every webhook request, 1-256 characters.
+        /// Only characters A-Z, a-z, 0-9, _ and - are allowed.
+        /// The header is useful to ensure that the request comes from a webhook set by you.
+        /// </summary>
+        public string? SecretToken { get; set; }
+
+        /// <summary>
+        /// The maximum allowed number of simultaneous HTTPS connections to the webhook for update delivery, 1-100. Defaults to 40.
+        /// Use lower values to limit the load on your bot's server, and higher values to increase your bot's throughput.
+        /// </summary>
+        public int MaxConnections { get; set; } = 40;
+
+        /// <summary>
+        /// Pass true to drop all pending updates
+        /// </summary>
+        public bool DropPendingUpdates { get; set; }
+    }
+}

src/Telegrator.Hosting.Web/TypesExtensions.cs

@@ -0,0 +1,117 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using System.Diagnostics;
+using Telegram.Bot;
+using Telegrator.Configuration;
+using Telegrator.Hosting.Providers;
+using Telegrator.Hosting.Providers.Components;
+using Telegrator.Hosting.Web.Components;
+using Telegrator.Hosting.Web.Polling;
+using Telegrator.MadiatorCore;
+
+namespace Telegrator.Hosting.Web
+{
+    /// <summary>
+    /// Contains extensions for <see cref="IServiceCollection"/>
+    /// Provides method to configure <see cref="ITelegramBotWebHost"/>
+    /// </summary>
+    public static class ServicesCollectionExtensions
+    {
+        /// <summary>
+        /// Replaces TelegramBotWebHostBuilder. Configures DI, options, and handlers.
+        /// </summary>
+        public static WebApplicationBuilder AddTelegratorWeb(this WebApplicationBuilder builder, TelegramBotWebOptions settings, IHandlersCollection? handlers = null)
+        {
+            if (settings is null)
+                throw new ArgumentNullException(nameof(settings));
+
+            IServiceCollection services = builder.Services;
+            ConfigurationManager configuration = builder.Configuration;
+
+            handlers ??= new HostHandlersCollection(services, settings);
+
+            if (handlers is IHostHandlersCollection hostHandlers)
+            {
+                foreach (PreBuildingRoutine preBuildRoutine in hostHandlers.PreBuilderRoutines)
+                {
+                    try
+                    {
+                        // TODO: fix
+                        //preBuildRoutine.Invoke(builder);
+                        Debug.WriteLine("Pre-Building routine was not executed");
+                    }
+                    catch (NotImplementedException)
+                    {
+                        _ = 0xBAD + 0xC0DE;
+                    }
+                }
+            }
+
+            if (!settings.DisableAutoConfigure)
+            {
+                services.Configure<TelegratorWebOptions>(configuration.GetSection(nameof(TelegratorWebOptions)));
+            }
+            else
+            {
+                if (!services.Any(srvc => srvc.ImplementationType == typeof(IOptions<TelegratorWebOptions>)))
+                    throw new MissingMemberException("Auto configuration disabled, yet no options of type 'TelegratorWebOptions' wasn't registered. This configuration is runtime required!");
+
+                if (!services.Any(srvc => srvc.ImplementationType == typeof(IOptions<TelegramBotClientOptions>)))
+                    throw new MissingMemberException("Auto configuration disabled, yet no options of type 'TelegramBotClientOptions' wasn't registered. This configuration is runtime required!");
+            }
+
+            IOptions<TelegramBotWebOptions> options = Options.Create(settings);
+            services.AddSingleton((IOptions<TelegratorOptions>)options);
+            services.AddSingleton(options);
+            services.AddSingleton(handlers);
+
+            if (handlers is IHandlersManager manager)
+            {
+                ServiceDescriptor descriptor = new ServiceDescriptor(typeof(IHandlersProvider), manager);
+                services.Replace(descriptor);
+                services.AddSingleton(manager);
+            }
+
+            services.AddTelegramBotHostDefaults();
+            services.AddTelegramWebhook();
+
+            return builder;
+        }
+
+        /// <summary>
+        /// Replaces the initialization logic from TelegramBotWebHost constructor. 
+        /// Initializes the bot and logs handlers on application startup.
+        /// </summary>
+        public static WebApplication UseTelegratorWeb(this WebApplication app)
+        {
+            ITelegramBotInfo info = app.Services.GetRequiredService<ITelegramBotInfo>();
+            IHandlersCollection handlers = app.Services.GetRequiredService<IHandlersCollection>();
+            ILoggerFactory loggerFactory = app.Services.GetRequiredService<ILoggerFactory>();
+            ILogger logger = loggerFactory.CreateLogger("Telegrator.Hosting.Web.TelegratorHost");
+
+            logger.LogInformation("Telegrator Bot ASP.NET WebHost started");
+            logger.LogHandlers(handlers);
+
+            return app;
+        }
+
+        /// <summary>
+        /// Registers <see cref="ITelegramBotClient"/> service with <see cref="HostedUpdateWebhooker"/> to receive updates using webhook
+        /// </summary>
+        /// <param name="services"></param>
+        /// <returns></returns>
+        public static IServiceCollection AddTelegramWebhook(this IServiceCollection services)
+        {
+            services.AddHttpClient<ITelegramBotClient>("tgwebhook").RemoveAllLoggers().AddTypedClient(TypedTelegramBotClientFactory);
+            services.AddHostedService<HostedUpdateWebhooker>();
+            return services;
+        }
+
+        private static ITelegramBotClient TypedTelegramBotClientFactory(HttpClient httpClient, IServiceProvider provider)
+            => new TelegramBotClient(provider.GetRequiredService<IOptions<TelegramBotClientOptions>>().Value, httpClient);
+    }
+}