Update Readme

Author: Meyn

README.md

@@ -1,106 +1,75 @@
 [![NuGet](https://img.shields.io/nuget/vpre/Shard.Requests)](https://www.nuget.org/packages/Shard.Requests) [![Downloads](https://img.shields.io/nuget/dt/Shard.Requests)](https://www.nuget.org/packages/Shard.Requests) [![License](https://img.shields.io/github/license/TypNull/requests.svg)](https://github.com/TypNull/requests/blob/master/LICENSE) ![Maintainability](https://img.shields.io/badge/Maintainability%20Index-86%25-brightgreen)
-# Requests
-## 🌟 What Is Requests?
 
-**Requests** is library for C# .NET 6; it's your trusty sidekick in the world of handling requests. Imagine a friendly companion that takes care of your requests, ensuring they're processed efficiently and systematically. Whether you're dealing with HTTP requests or tackling CPU-intensive tasks like directory searching.
+# Requests
 
-## 🚀 Why Choose Requests?
+Performance async task management with priority queues, automatic retries, and pause/resume capabilities for .NET
 
-- **Priority Magic**: Our priority channel ensures that high-priority requests get the VIP treatment—they're processed before the rest. No more waiting in line!
-- **Flexibility at Its Best**: Requests is designed to be as flexible as possible. Customize it to fit your specific needs, whatever you're building.
-- **Parallel Asynchronous Awesomeness**: Handle requests in parallel, like a symphony of asynchronous harmony. 🎶
+## Why Requests?
 
-## 📦 Installation
+**Requests** transforms chaotic async workflows into manageable,
+priority-driven operations. Built for developers who need more than
+basic task scheduling—think game engines, batch processors, API
+orchestrators, and complex data pipelines.
 
-Getting started with **Requests** is a breeze:
-1. Open your NuGet Package Manager.
-2. Search for "Shard.Requests"
-3. Install it. Voilà! 🎉
+### Key Features
 
- - [Nuget](https://www.nuget.org/packages/Shard.Requests)
- - [GitHub](https://github.com/TypNull/Requests)
+**Priority Scheduling**: High-priority requests jump the queue automatically
+**Smart Retries**: Configurable retry logic with exponential backoff
+**Pause & Resume**: Stop and restart long-running operations without data loss
+**Progress Tracking**: Real-time aggregated progress across multiple operations
+**Dynamic Parallelism**: Auto-adjusts concurrency based on system load
+**Zero Lock-in**: Simple wrapper pattern around your existing async code
 
-## Usage
+## Quick Start
 
-To utilize the Requests library in C#, begin by importing it:
+```bash
+dotnet add package Shard.Requests
+```
 
 ```csharp
 using Shard.Requests;
-```
-
-Next, instantiate a `Request` object, and it will automatically be included in the `RequestHandler`. If a request encounters an error, the `RequestHandler` will automatically retry the request based on the specified retry settings.
-
-## Classes
-
-This library includes the following classes:
-
-- **Request:** Main abstract class that can be used to expand functionality on a class-based level.
-    - All subclasses have a retry function ♾️
-    - A priority function 🔝
-    - Delegates to notify when a `Request` started, failed, completed, or canceled 📢
-    - Implementation for custom `CancellationToken` and a main `CancellationTokenSource` to cancel the request.
-- **OwnRequest:** Wrapper around your own request. It is an easy-to-expand class for handling the requests without the creation of a specific class.
-- **RequestContainer:** A container class to merge requests together and to start, pause, and await them.
-- **ProgressableContainer:** A container class to merge requests together that are using a `Progress` object to report the progress.
-- **RequestHandler:** A class to handle requests. Every handler is independent of any other handler.
-
-> Expand and use as you like!
->
-> Because handling requests should be as delightful as a warm cup of cocoa on a winter day.
-
- For additional information, refer to the Requests [Wiki](https://github.com/TypNull/Requests/wiki/).
 
-## Examples
-
-Meet our star, the `OwnRequest` class:
-
-```cs
-public class OwnRequest : Request<RequestOptions<VoidStruct, VoidStruct>, VoidStruct, VoidStruct>
+// Wrap any async operation
+var request = new OwnRequest(async token =>
 {
-    private readonly Func<CancellationToken, Task<bool>> _own;
-
-    public OwnRequest(Func<CancellationToken, Task<bool>> own, RequestOptions<VoidStruct, VoidStruct>? requestOptions = null) : base(requestOptions)
-    {
-        _own = own;
-        AutoStart();
-    }
-        
-    protected override async Task<RequestReturn> RunRequestAsync() 
-    { 
-        return new RequestReturn() { Successful = await _own.Invoke(Token) };
-    }
-}
+    var response = await httpClient.GetAsync(url, token);
+    return response.IsSuccessStatusCode;
+}, new() {
+    Priority = RequestPriority.High,
+    NumberOfAttempts = 3,
+    DelayBetweenAttempts = TimeSpan.FromSeconds(2)
+});
+
+// Request auto-starts with built-in retry and priority handling
+await request.Task;
 ```
 
-OwnRequest is a straightforward implementation of a child class of Request. It doesn’t overwhelm you with complexity, but it’s incredibly useful for quick implementations:
+## Architecture at a Glance
 
-```cs
-// Create an object and pass as a parameter an action that uses a CancellationToken
-new OwnRequest(async (token) =>
-{
-    using HttpClient client = new();
-    // Create your request message. Here the body of google.com
-    HttpRequestMessage requestMessage = new(HttpMethod.Get, "https://www.google.com");
-    // Send your request and get the result. Pass the CancellationToken for handling it later over the Request object
-    HttpResponseMessage response = await client.SendAsync(requestMessage, token);
-    // If the response does not succeed
-    if (!response.IsSuccessStatusCode)
-        return false; // Return false to retry and call the failed method
-                      // If the response succeeds. Do what you want and return to finish the request
-    Console.WriteLine("Finished");
-    return true;
-});
-```
+- **Request**: Base class for all operations with state machine and lifecycle hooks
+- **RequestHandler**: Parallel or sequential execution engines with priority channels
+- **RequestContainer**: Group multiple requests with unified control
+- **ProgressableContainer**: Track aggregated progress across request batches
+- **OwnRequest**: Zero-boilerplate wrapper for ad-hoc async operations
 
-Create your own requests with a sprinkle of magic! ✨
+## Advanced Capabilities
 
-## 🌟 Contributing
+- **Cooperative Cancellation**:`await Request.Yield()` for graceful interruption
+- **Subsequent Requests**: Chain operations without re-queuing
+- **Quaternary Heap**: O(log n) priority queue with FIFO ordering within priority levels
 
-Join our quest! If you'd like to contribute to this library, submit a pull request or open an issue. We appreciate your help in making `Requests` the best it can be!
+## Real-World Use Cases
 
-## 📜 License
+- **Batch Processing**: Download 1000 files with 10 parallel workers and retry failed transfers
+- **Game Development**: Priority-ordered asset loading with pause when backgrounded
+- **API Rate Limiting**: Throttle concurrent requests with dynamic parallelism control
+- **Long Operations**: Multi-hour processes with save/resume support
 
-**Requests** is licensed under the MIT license. 
+## Documentation
+
+**[Wiki](https://github.com/TypNull/Requests/wiki/)** Architecture deep-dives, examples, and API reference
 
 ## **Free Code** and **Free to Use**
-#### Have fun!
+#### Have fun!
+
+*Built for developers who need industrial-strength async control without the complexity*