FlowBased.NetCore 1.0.1

FlowBased.NetCore

Enterprise Documentation & Business Flow Management Framework for .NET

FlowBased.NetCore is a plug-and-play documentation and business flow management framework that enables teams to document, track, and visualize business flows directly within their .NET applications. It provides a complete enterprise-grade dashboard with versioning, file attachments, Markdown/HTML content, full-text search, and an embedded SPA — all with a two-line integration.

Built by Muhammad Rehman Tahir.

---

Table of Contents

• Features
• Compatibility
• Installation
• Quick Start
• Complete Configuration Reference
• Authentication & Security
• Dashboard Overview
• Public Documentation Portal
• Creating & Managing Documentation
• Markdown Editor
• File Attachments & Uploads
• Versioning & Change History
• API Reference
• Architecture
• JSON Storage
• Deployment
• Customization & Branding
• NuGet Package Contents
• License

---

Features

Business Flow Documentation

Document business processes, workflows, APIs, and feature descriptions using Markdown or HTML. Each flow contains two documentation fields:

• Business Documentation — Business-facing content describing the process in user-friendly language
• Technical Documentation — Developer-facing details covering implementation, services, APIs, and database tables

Technical Implementation Mapping

Map each flow to its technical dependencies for full traceability:

• Related APIs — REST endpoints consumed or exposed by the flow
• Related Services — Backend services invoked during the flow
• Related Repositories — Data access interfaces or repositories
• Related Database Tables — Database tables affected or queried
• Code Snippets — Embedded code examples with language labels
• Tags — Categorization labels for filtering and search

Flow Versioning

Every change to a flow is automatically versioned:

• Automatic snapshots — Previous state is preserved before each edit
• Version history — Browse all previous versions with timestamps
• Change log — Auto-generated or user-provided release notes
• Rollback — Restore any previous version with one click

File Attachments

Attach files to applications, modules, or flows:

• Any file type — Images, PDFs, documents, videos, archives
• GUID-based storage — No filename collisions
• Inline preview — View images and documents in the browser
• Download — Force download with original filename
• Path traversal protection — Secure file access

Full-Text Search

Search across all your documentation:

• Flow names and descriptions
• Business and technical documentation content
• Tags
• Real-time autocomplete with debounced suggestions

Embedded Enterprise Dashboard

A complete, responsive single-page application served directly from the package:

• Statistics overview — Total applications, modules, flows, versions
• Application management — CRUD for applications
• Module organization — Group flows into modules
• Flow editor — Full-featured Markdown textarea with preview
• Version timeline — Visual version history
• Dependency graph — View related APIs, services, repos, tables
• Hierarchy tree — Navigate the full app/module/flow structure
• Dark mode — Independent theme toggle
• Responsive design — Works on desktop, tablet, and mobile

Public Documentation Portal

An optional read-only portal for end-users at a separate route:

• Sidebar navigation — Collapsible tree of all content
• Search — Full-text search with autocomplete
• Breadcrumbs — Navigation trail
• Markdown rendering — Consistent with the admin editor
• Independent theming — Separate dark mode toggle
• Separate auth control — Can be public while admin is private

Minimal Setup

builder.Services.AddFlowBased();
app.UseFlowBased();

Two lines. Zero configuration required. Everything works out of the box.

---

Compatibility

Target	Support
.NET 6	✅
.NET 7	✅
.NET 8	✅
.NET 9	✅
.NET 10	✅
.NET Standard 2.1	✅ (Shared models)
ASP.NET Core	✅
MVC	✅
Web API	✅
Minimal APIs	✅
Worker Services	✅
Console Applications	✅

---

Installation

dotnet add package FlowBased.NetCore

Or via the Package Manager Console:

Install-Package FlowBased.NetCore

Or search for FlowBased.NetCore in the Visual Studio NuGet Package Manager.

---

Quick Start

1. Register services and configure

In your Program.cs:

using FlowBased.NetCore.AspNetCore.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddFlowBased(options =>
{
    options.Title = "My Enterprise Docs";
    options.RoutePrefix = "docs";
    options.StoragePath = Path.Combine(
        builder.Environment.WebRootPath ?? "wwwroot", "FlowBasedDocs");
    options.EnableVersioning = true;
    options.AllowMarkdown = true;
    options.AllowHtml = true;
});

var app = builder.Build();

app.UseStaticFiles();
app.UseFlowBased();

app.Run();

2. Seed initial documentation data

using FlowBased.NetCore.Core.Interfaces;
using FlowBased.NetCore.Infrastructure.Services;

using (var scope = app.Services.CreateScope())
{
    var service = scope.ServiceProvider.GetRequiredService<IFlowService>();
    await SeedData.SeedAsync(service);
}

3. Open the dashboard

Navigate to /{RoutePrefix} (default /flowbased) in your browser.

---

Complete Configuration Reference

All configuration is done through the FlowBasedOptions class passed via the configure delegate in AddFlowBased():

builder.Services.AddFlowBased(options =>
{
    // ── Branding ──
    options.Title = "My App Documentation";
    options.RoutePrefix = "myapp";
    options.DocumentationRoute = "docs";

    // ── Storage ──
    options.StoragePath = Path.Combine(
        builder.Environment.ContentRootPath, "App_Data", "FlowBased");
    options.UploadPath = Path.Combine(
        builder.Environment.ContentRootPath, "App_Data", "Uploads");

    // ── Content ──
    options.AllowMarkdown = true;
    options.AllowHtml = true;
    options.EnableVersioning = true;
    options.EnableFileUploads = true;
    options.MaxFileSize = 10 * 1024 * 1024; // 10 MB

    // ── Discovery ──
    options.EnableAutoDiscovery = true;

    // ── Authentication ──
    options.EnableAuthentication = true;
    options.AllowedRoles = new[] { "Admin", "Editor" };
    options.RequireDocumentationAuth = false;

    // ── Public Docs Portal ──
    options.EnablePublicDocumentation = true;
});

Options Reference Table

Option	Type	Default	Description
Title	string	"FlowBased"	Dashboard title shown in the browser tab and sidebar
RoutePrefix	string	"flowbased"	URL prefix for the admin dashboard and its API
DocumentationRoute	string	"app-docs"	URL prefix for the public documentation portal
StoragePath	string	"App_Data/FlowBased"	Directory where JSON files are persisted
UploadPath	string	"App_Data/Uploads"	Directory for uploaded file attachments
MaxFileSize	long	10485760	Maximum file upload size in bytes (10 MB)
EnableFileUploads	bool	true	Enables the file upload endpoints and attachment UI
AllowMarkdown	bool	true	When true, flows can use Markdown documentation
AllowHtml	bool	true	When true, flows can use raw HTML documentation
EnableVersioning	bool	true	Tracks version history for each flow
EnableAutoDiscovery	bool	true	Auto-discover assemblies for annotation scanning
EnableAuthentication	bool	false	Enables role-based access control
AllowedRoles	string[]	null	Array of role names permitted to access the admin dashboard
RequireDocumentationAuth	bool	false	When true, the public docs portal requires authentication
EnablePublicDocumentation	bool	true	Enables the public documentation portal

---

Authentication & Security

Disabled by Default

FlowBased ships with authentication disabled (EnableAuthentication = false). All endpoints and the dashboard are publicly accessible. This makes initial setup and evaluation frictionless.

Enabling Authentication

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer();
builder.Services.AddAuthorization();

builder.Services.AddFlowBased(options =>
{
    options.EnableAuthentication = true;
    options.AllowedRoles = new[] { "Admin", "Editor" };
});

var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();
app.UseFlowBased();  // Must come after UseAuthorization()

Role Hierarchy

When authentication is enabled, a six-level role system controls access:

Role	Level	Permissions
None	0	No access
Viewer	1	Read-only access to documentation
Contributor	2	Can create and edit flows
Editor	3	Full content management including deletion
Moderator	4	Can review and approve content
Admin	5	Full system access including configuration

Public Docs Portal

The documentation portal has its own independent auth toggle, allowing scenarios where the admin dashboard is private but the documentation is public:

options.EnableAuthentication = true;        // Admin is private
options.RequireDocumentationAuth = false;   // Docs are public

Path Traversal Protection

All file access endpoints validate paths against traversal attacks:

var uploadDir = Path.GetFullPath(_options.UploadPath);
var fullPath = Path.GetFullPath(Path.Combine(uploadDir, fileName));
if (!fullPath.StartsWith(uploadDir, StringComparison.OrdinalIgnoreCase))
    return Results.Forbid();

---

Dashboard Overview

The embedded admin dashboard is accessible at /{RoutePrefix} and provides:

Navigation

• Sidebar — Logo, navigation links, theme toggle, public docs link
• Application selector — Dropdown to select an application
• Module selector — Dropdown to select a module within the selected application
• Hierarchy tree — Expandable tree view of all apps, modules, and flows

Content Management

Feature	Description
Create Application	Add new applications with name and description
Create Module	Add modules to the selected application
Create Flow	Create flows with documentation, tags, and dependencies
View	Open flow detail modal with tabs
Edit	Open flow editor with full Markdown textarea
Delete	Permanently remove with confirmation dialog

Flow Detail Modal

Each flow detail view has tabs:

Tab	Content
Documentation	Rendered business and technical documentation
Dependencies	Related APIs, services, repos, and database tables
Versions	Version history with rollback capability
Attachments	Uploaded files with preview and download

Statistics

The dashboard header displays:

• Total applications
• Total modules
• Total flows
• Total versions

---

Public Documentation Portal

The public documentation portal is a read-only SPA served at /{DocumentationRoute} (default /app-docs).

Features

Feature	Description
Sidebar Navigation	Collapsible tree of all apps, modules, and flows
Search	Real-time autocomplete with type-based suggestions
Breadcrumbs	Navigation trail showing current location
Markdown Rendering	Client-side via marked.parse() — consistent with admin editor
Dark Mode	Independent theme toggle (separate from admin)
Responsive Design	Hamburger menu on mobile, fluid layout
File Preview	Click attachment links to preview in new tab
File Download	Direct download of attached files

Configuration

options.EnablePublicDocumentation = true;  // Enable the portal
options.DocumentationRoute = "app-docs";    // URL prefix
options.RequireDocumentationAuth = false;   // Public by default

URL Routing

URL Pattern	Route
/app-docs	Home page with app cards
/app-docs/{appName}	Application detail page
/app-docs/{appName}/{moduleName}	Module detail page
/app-docs/{appName}/{moduleName}/{flowName}	Flow documentation page

---

Creating & Managing Documentation

Via the Dashboard

1. Navigate to /{RoutePrefix}
2. Select an Application from the dropdown
3. Select a Module from the second dropdown
4. Click "Create Flow"
5. Fill in the form:
   • Name (required): Short, descriptive name
   • Description: One-line summary
   • Documentation Type: Markdown or HTML
   • Business Documentation: Main content
   • Technical Documentation: Developer details
   • Tags: Categorization labels
   • Dependencies: Related APIs, services, repos, tables
   • Attachments: Upload files
6. Click Save

Via the REST API

POST /{RoutePrefix}/api/flows/{appId}/{moduleId}
Content-Type: application/json

{
  "name": "Order Processing",
  "description": "Handles incoming orders from all channels",
  "documentationType": "Markdown",
  "businessDocumentation": "# Order Processing\n\n...",
  "technicalDocumentation": "**Services:** OrderService\n**APIs:** /api/orders",
  "tags": ["orders", "fulfillment"],
  "relatedApis": ["/api/orders"],
  "relatedServices": ["OrderService"],
  "relatedRepositories": ["IOrderRepository"],
  "relatedDatabaseTables": ["Orders", "OrderItems"],
  "codeSnippets": [
    {
      "title": "Order Handler",
      "code": "public async Task<Order> ProcessOrderAsync(Cart cart) { ... }",
      "language": "csharp"
    }
  ]
}

Validation Rules

Field	Validation
Name	Required, 1–200 characters
Description	Max 500 characters
DocumentationType	Must be Markdown or HTML
Tags	Max 10 tags, each max 50 chars
BusinessDocumentation	Max 50,000 characters
TechnicalDocumentation	Max 50,000 characters

---

Markdown Editor

FlowBased includes a built-in textarea-based Markdown editor with a toolbar, live preview, and keyboard shortcuts.

Write / Preview Tabs

• Write: Full-screen textarea with monospace font
• Preview: Rendered HTML using marked.parse() with { breaks: true, gfm: true }

Toolbar

| Button | Markdown Inserted | Shortcut | |--------|-------------------|----------| | B Bold | **text** | Ctrl+B | | I Italic | *text* | Ctrl+I | | H1 | # text | — | | H2 | ## text | — | | H3 | ### text | — | | • UL | - item | — | | 1. OL | 1. item | — | | " Quote | > text | — | | 🔗 Link | [text](url) | Ctrl+K | | 🖼 Image | ![alt](url) | — | | Code | ``code`` | — | | ⎕ Table || Col1 | Col2 || — | | — HR |---` | — |

Writing Markdown Tables

| Header 1 | Header 2 | Header 3 |
|----------|----------|----------|
| Row 1    | Data     | Data     |
| Row 2    | Data     | Data     |

Colons control alignment:

| Left     | Center   | Right    |
|:---------|:--------:|---------:|
| Text     | Text     | Text     |

Code Blocks

Fenced code blocks with language identifier:

```csharp
public class Order
{
    public string Id { get; set; }
    public decimal Total { get; set; }
}
```

Images

![Screenshot](/api/file/preview?path=image-guid.png)

Consistent Rendering

All three views use the same rendering engine:

• Editor preview — marked.parse() client-side
• Admin detail view — marked.parse() client-side
• Public docs portal — marked.parse() client-side
• Server fallback — Markdig with .UseAdvancedExtensions().UsePipeTables()

---

File Attachments & Uploads

Upload Methods

Method	Description
Drag & Drop	Drag files onto the editor textarea
Paste	Paste images from clipboard (Ctrl+V)
Toolbar Button	Click the Image/Attachment button
API	POST to /api/upload or /api/upload/batch

Upload Flow

User drops/pastes image
         ↓
File read as Blob/File
         ↓
FormData POST to /api/upload
         ↓
Server saves to disk (GUID filename)
         ↓
Response: { url, fileName, contentType, size }
         ↓
Markdown or link inserted at cursor

File Lifecycle

Stage	Description
Uploaded	File saved to disk with GUID filename
Attached	File associated with a flow, module, or application
Deleted	File removed from disk, reference removed from entity

API Endpoints

Endpoint	Description
POST /api/upload	Upload a single file
POST /api/upload/batch	Upload multiple files
POST /api/editor/upload-image	Upload image for inline embedding
POST /api/attachments/upload	Upload and attach to an entity
GET /api/file/preview?path=	Preview file inline
GET /api/file/download?path=	Download file with original name

Configuration

options.EnableFileUploads = true;    // Enable upload endpoints
options.UploadPath = "App_Data/Uploads";  // Storage directory
options.MaxFileSize = 10485760;      // 10 MB limit

---

Versioning & Change History

How It Works

1. When a flow is created, version 1 is automatically saved
2. Each edit creates a new version with an incremented number
3. Previous versions are preserved indefinitely
4. Version includes: number, timestamp, notes, change log, and full snapshot

Version Model

public class FlowVersion
{
    public int VersionNumber { get; set; }
    public DateTime CreatedDate { get; set; }
    public string Notes { get; set; }
    public string ChangeLog { get; set; }
    public string Snapshot { get; set; }
}

Managing Versions

Via Dashboard:

• Open a flow's version history tab
• View all versions with timestamps and notes
• Click Restore to roll back to a previous version
• A new version is created documenting the rollback

Via API:

GET /{RoutePrefix}/api/flows/{appId}/{moduleId}/{flowId}/versions
POST /{RoutePrefix}/api/flows/{appId}/{moduleId}/{flowId}/versions

When Versions Are Created

Scenario	Version Created
Initial creation	Yes (v1)
Editing without notes	Yes (auto)
Editing with notes	Yes (with metadata)
Rollback	Yes (new version)
Deleting	No (all versions deleted)

---

API Reference

Endpoints are organized under /{RoutePrefix}/api:

Applications

Method	Endpoint	Description
GET	/api/applications	List all applications
GET	/api/applications/{id}	Get application details
POST	/api/applications	Create a new application
PUT	/api/applications/{id}	Update an application
DELETE	/api/applications/{id}	Delete an application

Modules

Method	Endpoint	Description
GET	/api/modules/{appId}	List modules for an application
GET	/api/modules/{appId}/{moduleId}	Get module details
POST	/api/modules/{appId}	Create a module
PUT	/api/modules/{appId}/{moduleId}	Update a module
DELETE	/api/modules/{appId}/{moduleId}	Delete a module

Flows

Method	Endpoint	Description
GET	/api/flows/{appId}/{moduleId}	List flows for a module
GET	/api/flows/{appId}/{moduleId}/{flowId}	Get flow details
POST	/api/flows/{appId}/{moduleId}	Create a flow
PUT	/api/flows/{appId}/{moduleId}/{flowId}	Update a flow
DELETE	/api/flows/{appId}/{moduleId}/{flowId}	Delete a flow

Versions

Method	Endpoint	Description
GET	/api/flows/{appId}/{moduleId}/{flowId}/versions	List all versions
POST	/api/flows/{appId}/{moduleId}/{flowId}/versions	Create a new version

Search

Method	Endpoint	Description
GET	/api/search?q={query}	Full-text search across all flows
GET	/api/search/suggestions?q={query}	Autocomplete suggestions

Uploads

Method	Endpoint	Description
POST	/api/upload	Upload a single file
POST	/api/upload/batch	Upload multiple files
POST	/api/editor/upload-image	Upload image for editor
GET	/api/file/preview?path=	Preview file inline
GET	/api/file/download?path=	Download file

Docs Portal (Public)

Method	Endpoint	Description
GET	/{DocumentationRoute}/api/config	Portal configuration
GET	/{DocumentationRoute}/api/applications	All applications
GET	/{DocumentationRoute}/api/applications/{id}	Application details
GET	/{DocumentationRoute}/api/modules/{id}	Module details
GET	/{DocumentationRoute}/api/flows/{id}	Flow details
GET	/{DocumentationRoute}/api/search?q=	Full-text search
GET	/{DocumentationRoute}/api/search/suggestions?q=	Autocomplete

Auth

Method	Endpoint	Description
GET	/api/auth/status	Authentication status
POST	/api/auth/login	Login (if custom auth integrated)
GET	/api/auth/user	Current user info
GET	/api/auth/roles	Available roles

Response Status Codes

Status	When
200 OK	Successful GET or POST with response body
201 Created	Resource successfully created
204 No Content	Successful DELETE
400 Bad Request	Validation failure
401 Unauthorized	Authentication required (when enabled)
403 Forbidden	Authenticated but insufficient role
404 Not Found	Resource does not exist

---

Architecture

FlowBased.NetCore follows Clean Architecture principles with five assemblies:

┌──────────────────────────────────────────────────────────┐
│                  Presentation (ASP.NET Core)               │
│     FlowBased.NetCore.AspNetCore                          │
│     Dashboard SPA  ·  API Endpoints  ·  Middleware         │
├──────────────────────────────────────────────────────────┤
│                  Infrastructure                            │
│     FlowBased.NetCore.Infrastructure                       │
│     JSON Storage  ·  Markdig Renderer  ·  Services         │
├──────────────────────────────────────────────────────────┤
│                  Core (Abstractions)                       │
│     FlowBased.NetCore.Core                                 │
│     Interfaces  ·  Domain Models  ·  Contracts             │
├──────────────────────────────────────────────────────────┤
│                  Shared                                    │
│     FlowBased.NetCore.Shared                               │
│     DTOs  ·  Enums  ·  Constants (netstandard2.1)          │
├──────────────────────────────────────────────────────────┤
│                  Sample / UI                               │
│     FlowBased.SampleServices  ·  FlowBased.NetCore.UI     │
└──────────────────────────────────────────────────────────┘

Dependency Rules

Layer	Depends On
AspNetCore	Infrastructure, Core, Shared
Infrastructure	Core, Shared
Core	Shared
Shared	(none — zero dependencies)
UI	Shared
SampleServices	Core, Shared

Key Design Decisions

Decision	Rationale
JSON file storage	Zero infrastructure, portable, easy to backup
Markdig for server rendering	Fast, extensible, .NET-native Markdown processor
System.Text.Json	Built into .NET, high performance, AOT compatible
Minimal APIs	Modern, lightweight, self-documenting routes
Embedded SPA	Single deployment artifact, no separate frontend build

---

JSON Storage

Documentation data is stored on the file system as JSON files. No database is required.

Folder Structure

{StoragePath}/
  ├── applications.json                    (list of all applications)
  ├── modules/
  │   └── {applicationId}.json            (modules for each app)
  └── flows/
      └── {moduleId}.json                 (flows for each module)
          └── {flowId}_versions.json      (version history)

Serialization

All JSON uses System.Text.Json with camelCase naming:

var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
    WriteIndented = true  // Pretty-print for readability
};

Atomic Writes

Content is first written to a temporary file, then atomically renamed:

var tempPath = Path.GetTempFileName();
await File.WriteAllTextAsync(tempPath, json);
File.Move(tempPath, targetPath, overwrite: true);

This prevents corruption if the process is interrupted mid-write.

Storage Provider Interface

For teams that need database storage, implement IStorageProvider:

public interface IStorageProvider
{
    Task<T> LoadAsync<T>(string key);
    Task SaveAsync<T>(string key, T data);
    Task DeleteAsync(string key);
    Task<IEnumerable<string>> GetKeysAsync(string prefix);
}

---

Deployment

Docker

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /app .
VOLUME ["/app/App_Data"]
EXPOSE 8080
ENV ASPNETCORE_URLS=http://+:8080
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:8080/flowbased || exit 1
ENTRYPOINT ["dotnet", "MyApp.dll"]

docker-compose

services:
  flowbased-app:
    build: .
    ports:
      - "5000:8080"
    environment:
      - ASPNETCORE_ENVIRONMENT=Production
      - FlowBased__Title=My App Docs
      - FlowBased__EnableAuthentication=true
    volumes:
      - flowbased-data:/app/App_Data
volumes:
  flowbased-data:
    driver: local

IIS

Publish and deploy to IIS with the ASP.NET Core Module (ANCM):

dotnet publish -c Release -o ./publish

Ensure the App_Data directory has write permissions for the application pool identity.

Azure App Service

1. Create App Service (Linux or Windows)
2. Set ASPNETCORE_ENVIRONMENT=Production in Application Settings
3. Configure FlowBased options via app settings:
   • FlowBased__Title
   • FlowBased__RoutePrefix

Backup Strategies

Method	Description	Recovery Time
File Copy	Copy App_Data/FlowBased directory	Minutes
ZIP Export	Compressed archive of all JSON	Minutes
API Export	GET /api/export endpoint	Seconds
Snapshot	VM/filesystem snapshot	Seconds

---

Customization & Branding

CSS Variables

Both the dashboard and portal use CSS custom properties for theming:

:root {
  --accent: #6366f1;          /* Primary accent (indigo) */
  --bg: #ffffff;               /* Main background */
  --text: #1e293b;             /* Body text */
  --sidebar-bg: #1e293b;      /* Sidebar background */
  --code-bg: #1e293b;          /* Code block background */
}

[data-bs-theme="dark"] {
  --bg: #0f172a;
  --text: #e2e8f0;
  --sidebar-bg: #020617;
}

Changing the Accent Color

Override --accent to match your brand:

:root {
  --accent: #dc2626;  /* Red accent */
}

Dashboard Title

options.Title = "Your Brand Documentation";

Independent Theme Toggle

Admin dashboard and docs portal have separate dark mode toggles, each stored in localStorage:

localStorage.setItem('flowbased-theme', 'dark');
localStorage.setItem('docs-theme', 'dark');

---

NuGet Package Contents

The FlowBased.NetCore NuGet package includes the following assemblies:

Assembly	Description	Target
FlowBased.NetCore.AspNetCore.dll	API endpoints, dashboard UI, middleware, DI extensions	net8.0
FlowBased.NetCore.Core.dll	Domain interfaces, abstractions, contracts	net8.0
FlowBased.NetCore.Infrastructure.dll	JSON storage, Markdig renderer, services	net8.0
FlowBased.NetCore.Shared.dll	Models, enums, DTOs (portable)	netstandard2.1
Markdig.dll	Markdown processing engine	net8.0

Additional files: README.md, icon.png, LICENSE

---

License

This project is licensed under the MIT License — see the LICENSE file for details.

Copyright (c) 2026 Muhammad Rehman Tahir