@push.rocks/taskbuffer 3.1.10 → 3.4.0

package/readme.md

@@ -1,417 +1,121 @@
 # @push.rocks/taskbuffer 🚀
 
-A **powerful**, **flexible**, and **TypeScript-first** task management library for orchestrating asynchronous operations with style. From simple task execution to complex distributed workflows, taskbuffer has got you covered.
+> **Modern TypeScript task orchestration with smart buffering, scheduling, and real-time progress tracking**
 
-## Install 📦
+[![npm version](https://img.shields.io/npm/v/@push.rocks/taskbuffer.svg)](https://www.npmjs.com/package/@push.rocks/taskbuffer)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue.svg)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-```bash
-npm install @push.rocks/taskbuffer --save
-```
+## 🌟 Features
 
-Or with **pnpm** (recommended):
+- **🎯 Type-Safe Task Management** - Full TypeScript support with generics and type inference
+- **📊 Real-Time Progress Tracking** - Step-based progress with percentage weights
+- **⚡ Smart Buffering** - Intelligent request debouncing and batching
+- **⏰ Cron Scheduling** - Schedule tasks with cron expressions
+- **🔄 Task Chains & Parallel Execution** - Sequential and parallel task orchestration
+- **🎨 Web Component Dashboard** - Real-time visualization of task execution
+- **📈 Comprehensive Metadata** - Track execution history, duration, and status
+- **🔒 Thread-Safe Operations** - Concurrency control and execution limits
+- **🎭 Event-Driven Architecture** - Observable task lifecycle events
+
+## 📦 Installation
 
 ```bash
+npm install @push.rocks/taskbuffer
+# or
 pnpm add @push.rocks/taskbuffer
+# or
+yarn add @push.rocks/taskbuffer
 ```
 
-## Why taskbuffer? 🤔
-
-In the modern JavaScript ecosystem, managing asynchronous tasks efficiently is crucial. Whether you're building a data pipeline, managing API rate limits, or orchestrating complex workflows, **@push.rocks/taskbuffer** provides the tools you need:
-
-- **🎯 TypeScript-first**: Built with TypeScript for TypeScript - enjoy complete type safety and excellent IDE support
-- **⚡ Flexible execution**: From simple tasks to complex parallel workflows with dependencies
-- **🔄 Smart buffering**: Control concurrent executions with intelligent buffer management
-- **⏰ Built-in scheduling**: Cron-based task scheduling without additional dependencies
-- **🎭 Multiple paradigms**: Support for debounced, throttled, and one-time execution patterns
-- **🔌 Extensible**: Clean architecture that's easy to extend and customize
-- **🏃 Zero dependencies on external schedulers**: Everything you need is included
-
-## Core Concepts 🎓
-
-### Task
-
-The fundamental unit of work. A task wraps an asynchronous function and provides powerful execution control.
-
-### Taskchain
-
-Sequential task execution - tasks run one after another, with results passed along the chain.
-
-### Taskparallel
-
-Parallel task execution - multiple tasks run simultaneously for maximum performance.
-
-### TaskManager
-
-Centralized task scheduling and management using cron expressions.
-
-### TaskDebounced
+## 🚀 Quick Start
 
-Debounced task execution - prevents rapid repeated executions, only running after a quiet period.
-
-### TaskOnce
-
-Singleton task execution - ensures a task runs exactly once, perfect for initialization routines.
-
-## Quick Start 🏁
-
-### Basic Task Execution
+### Basic Task Creation
 
 ```typescript
-import { Task } from '@push.rocks/taskbuffer';
+import { Task, TaskManager } from '@push.rocks/taskbuffer';
 
 // Create a simple task
-const myTask = new Task({
-  name: 'DataProcessor',
-  taskFunction: async () => {
-    const data = await fetchData();
-    return processData(data);
-  },
-});
-
-// Execute the task
-const result = await myTask.trigger();
-```
-
-## TypeScript Generics Support 🔬
-
-TaskBuffer leverages TypeScript's powerful generics system for complete type safety across your task chains and workflows.
-
-### Generic Task Functions
-
-Tasks support generic type parameters for both input and output types:
-
-```typescript
-import { Task, ITaskFunction } from '@push.rocks/taskbuffer';
-
-// Define typed interfaces
-interface UserData {
-  id: string;
-  name: string;
-  email: string;
-}
-
-interface ProcessedUser {
-  userId: string;
-  displayName: string;
-  normalized: boolean;
-}
-
-// Create strongly typed tasks
-const processUserTask = new Task<UserData, ProcessedUser>({
-  name: 'ProcessUser',
-  taskFunction: async (user: UserData): Promise<ProcessedUser> => {
-    return {
-      userId: user.id,
-      displayName: user.name.toUpperCase(),
-      normalized: true
-    };
-  }
-});
-
-// Type safety enforced at compile time
-const result: ProcessedUser = await processUserTask.trigger({
-  id: '123',
-  name: 'John Doe',
-  email: 'john@example.com'
-});
-```
-
-### Generic Setup Values
-
-Tasks can accept setup values through generics, perfect for configuration:
-
-```typescript
-interface TaskConfig {
-  apiEndpoint: string;
-  retryCount: number;
-  timeout: number;
-}
-
-const configuredTask = new Task<TaskConfig>({
-  name: 'ConfiguredTask',
-  taskSetup: async () => ({
-    apiEndpoint: 'https://api.example.com',
-    retryCount: 3,
-    timeout: 5000
-  }),
-  taskFunction: async (data: any, setupValue: TaskConfig) => {
-    // setupValue is fully typed!
-    for (let i = 0; i < setupValue.retryCount; i++) {
-      try {
-        return await fetchWithTimeout(
-          setupValue.apiEndpoint,
-          setupValue.timeout
-        );
-      } catch (error) {
-        if (i === setupValue.retryCount - 1) throw error;
-      }
-    }
-  }
-});
-```
-
-### Type-Safe Task Chains
-
-Chain tasks with preserved type flow:
-
-```typescript
-// Each task knows its input and output types
-const fetchTask = new Task<void, UserData[]>({
-  name: 'FetchUsers',
-  taskFunction: async (): Promise<UserData[]> => {
-    return await api.getUsers();
-  }
-});
-
-const filterTask = new Task<UserData[], UserData[]>({
-  name: 'FilterActive',
-  taskFunction: async (users: UserData[]): Promise<UserData[]> => {
-    return users.filter(user => user.isActive);
-  }
-});
-
-const mapTask = new Task<UserData[], ProcessedUser[]>({
-  name: 'MapToProcessed',
-  taskFunction: async (users: UserData[]): Promise<ProcessedUser[]> => {
-    return users.map(transformUser);
-  }
-});
-
-// Type safety flows through the chain
-const chain = new Taskchain({
-  name: 'UserPipeline',
-  taskArray: [fetchTask, filterTask, mapTask]
-});
-
-const finalResult: ProcessedUser[] = await chain.trigger();
-```
-
-## Buffer Behavior Deep Dive 🌊
-
-The buffer system in TaskBuffer provides intelligent control over concurrent executions, preventing system overload while maximizing throughput.
-
-### How Buffering Works
-
-When a task is buffered, TaskBuffer manages a queue of executions:
-
-```typescript
-const bufferedTask = new Task({
-  name: 'BufferedOperation',
+const dataProcessor = new Task({
+  name: 'ProcessData',
   taskFunction: async (data) => {
     console.log(`Processing: ${data}`);
-    await simulateWork();
+    // Your async logic here
     return `Processed: ${data}`;
-  },
-  buffered: true,
-  bufferMax: 3  // Maximum 3 concurrent executions
-});
-
-// Trigger 10 executions rapidly
-for (let i = 0; i < 10; i++) {
-  bufferedTask.trigger(`Item ${i}`);
-}
-
-// What happens:
-// 1. First 3 tasks start immediately
-// 2. Items 4-10 are queued
-// 3. As each task completes, next queued item starts
-// 4. Never more than 3 tasks running simultaneously
-```
-
-### Buffer Truncation Behavior
-
-When buffer limit is reached, new calls are intelligently managed:
-
-```typescript
-const truncatingTask = new Task({
-  name: 'TruncatingBuffer',
-  taskFunction: async (data) => {
-    await processData(data);
-  },
-  buffered: true,
-  bufferMax: 5  // Maximum 5 in buffer
-});
-
-// Rapid fire 100 calls
-for (let i = 0; i < 100; i++) {
-  truncatingTask.trigger(`Data ${i}`);
-}
-
-// Buffer behavior:
-// - First 5 calls: Added to buffer and start processing
-// - Calls 6-100: Each overwrites the 5th buffer slot
-// - Result: Only processes items 0,1,2,3, and 99 (last one)
-// - This prevents memory overflow in high-frequency scenarios
-```
-
-### Advanced Buffer Strategies
-
-#### 1. **Sliding Window Buffer**
-Perfect for real-time data processing where only recent items matter:
-
-```typescript
-const slidingWindowTask = new Task({
-  name: 'SlidingWindow',
-  taskFunction: async (data) => {
-    return await analyzeRecentData(data);
-  },
-  buffered: true,
-  bufferMax: 10,  // Keep last 10 items
-  execDelay: 100  // Process every 100ms
+  }
 });
 
-// In a real-time stream scenario
-dataStream.on('data', (chunk) => {
-  slidingWindowTask.trigger(chunk);
-  // Older items automatically dropped when buffer full
-});
+// Execute the task
+const result = await dataProcessor.trigger('my-data');
+console.log(result); // "Processed: my-data"
 ```
 
-#### 2. **Throttled Buffer**
-Combine buffering with execution delays for rate limiting:
+### Tasks with Progress Tracking 📊
 
 ```typescript
-const apiRateLimiter = new Task({
-  name: 'RateLimitedAPI',
-  taskFunction: async (request) => {
-    return await api.call(request);
-  },
-  buffered: true,
-  bufferMax: 10,     // Max 10 queued requests
-  execDelay: 1000    // 1 second between executions
+const deploymentTask = new Task({
+  name: 'DeployApplication',
+  steps: [
+    { name: 'build', description: 'Building application', percentage: 30 },
+    { name: 'test', description: 'Running tests', percentage: 20 },
+    { name: 'deploy', description: 'Deploying to server', percentage: 40 },
+    { name: 'verify', description: 'Verifying deployment', percentage: 10 }
+  ] as const, // Use 'as const' for type inference
+  taskFunction: async function() {
+    // TypeScript knows these step names!
+    this.notifyStep('build');
+    await buildApplication();
+    
+    this.notifyStep('test');
+    await runTests();
+    
+    this.notifyStep('deploy');
+    await deployToServer();
+    
+    this.notifyStep('verify');
+    await verifyDeployment();
+    
+    return 'Deployment successful!';
+  }
 });
 
-// Requests are queued and executed at 1/second
-// Prevents API rate limit violations
-```
-
-#### 3. **Priority Buffer** (Custom Implementation)
-Implement priority queuing with buffer management:
-
-```typescript
-class PriorityBufferedTask extends Task {
-  private priorityQueue: Array<{data: any, priority: number}> = [];
-  
-  constructor(options) {
-    super({
-      ...options,
-      taskFunction: async (item) => {
-        // Process based on priority
-        return await this.processByPriority(item);
-      }
-    });
-  }
-  
-  triggerWithPriority(data: any, priority: number) {
-    if (this.priorityQueue.length >= this.bufferMax) {
-      // Remove lowest priority item if buffer full
-      this.priorityQueue.sort((a, b) => b.priority - a.priority);
-      this.priorityQueue.pop();
-    }
-    this.priorityQueue.push({data, priority});
-    this.priorityQueue.sort((a, b) => b.priority - a.priority);
-    return this.trigger(this.priorityQueue.shift());
-  }
-}
+// Monitor progress
+console.log(deploymentTask.getProgress()); // 0-100
+console.log(deploymentTask.getStepsMetadata()); // Detailed step info
 ```
 
-### Buffer Monitoring
+## 🎯 Core Concepts
 
-Track buffer utilization and performance:
+### Task Buffering - Intelligent Request Management
 
-```typescript
-const monitoredTask = new Task({
-  name: 'MonitoredBuffer',
-  taskFunction: async (data) => {
-    const startTime = Date.now();
-    const result = await processData(data);
-    console.log(`Processing time: ${Date.now() - startTime}ms`);
-    console.log(`Buffer utilization: ${monitoredTask.bufferRunner.bufferCounter}/${monitoredTask.bufferMax}`);
-    return result;
-  },
-  buffered: true,
-  bufferMax: 20
-});
-
-// Monitor buffer saturation
-setInterval(() => {
-  const utilization = (monitoredTask.bufferRunner.bufferCounter / monitoredTask.bufferMax) * 100;
-  if (utilization > 80) {
-    console.warn(`Buffer near capacity: ${utilization.toFixed(1)}%`);
-  }
-}, 1000);
-```
-
-### Buffer Best Practices
-
-1. **Choose appropriate buffer sizes**: 
-   - I/O operations: 5-10 concurrent
-   - CPU-intensive: Number of cores
-   - API calls: Based on rate limits
-
-2. **Handle buffer overflow gracefully**:
-   ```typescript
-   const task = new Task({
-     taskFunction: async (data) => {
-       try {
-         return await process(data);
-       } catch (error) {
-         if (error.code === 'BUFFER_OVERFLOW') {
-           // Implement backoff strategy
-           await delay(1000);
-           return task.trigger(data);
-         }
-         throw error;
-       }
-     },
-     buffered: true,
-     bufferMax: 10
-   });
-   ```
-
-3. **Monitor and adjust dynamically**:
-   ```typescript
-   // Adjust buffer size based on system load
-   const adaptiveTask = new Task({
-     name: 'AdaptiveBuffer',
-     taskFunction: async (data) => {
-       const cpuLoad = await getSystemLoad();
-       if (cpuLoad > 0.8) {
-         adaptiveTask.bufferMax = Math.max(2, adaptiveTask.bufferMax - 1);
-       } else if (cpuLoad < 0.5) {
-         adaptiveTask.bufferMax = Math.min(20, adaptiveTask.bufferMax + 1);
-       }
-       return await process(data);
-     },
-     buffered: true,
-     bufferMax: 10
-   });
-   ```
-
-### Buffered Execution (Rate Limiting)
-
-Perfect for API calls or database operations that need throttling:
+TaskBuffer's buffering system prevents overwhelming your system with rapid-fire requests:
 
 ```typescript
 const apiTask = new Task({
-  name: 'APICall',
-  taskFunction: async (endpoint: string) => {
-    return await fetch(endpoint);
+  name: 'APIRequest',
+  taskFunction: async (endpoint) => {
+    return await fetch(endpoint).then(r => r.json());
   },
   buffered: true,
-  bufferMax: 3, // Maximum 3 concurrent executions
-  execDelay: 1000, // Wait 1 second between executions
+  bufferMax: 5,  // Maximum 5 concurrent executions
+  execDelay: 100 // Minimum 100ms between executions
 });
 
-// These will be automatically throttled
-for (let i = 0; i < 10; i++) {
+// Rapid fire 100 calls - only 5 will execute concurrently
+for (let i = 0; i < 100; i++) {
   apiTask.trigger(`/api/data/${i}`);
 }
 ```
 
+**Buffer Behavior:**
+- First `bufferMax` calls execute immediately
+- Additional calls are queued
+- When buffer is full, new calls overwrite the last queued item
+- Perfect for real-time data streams where only recent data matters
+
 ### Task Chains - Sequential Workflows
 
-Build complex workflows where each step depends on the previous:
+Build complex workflows with automatic data flow:
 
 ```typescript
 import { Task, Taskchain } from '@push.rocks/taskbuffer';
@@ -421,327 +125,345 @@ const fetchTask = new Task({
   taskFunction: async () => {
     const response = await fetch('/api/data');
     return response.json();
-  },
+  }
 });
 
 const transformTask = new Task({
   name: 'TransformData',
   taskFunction: async (data) => {
-    return data.map((item) => ({
+    return data.map(item => ({
       ...item,
-      processed: true,
-      timestamp: Date.now(),
+      transformed: true,
+      timestamp: Date.now()
     }));
-  },
+  }
 });
 
 const saveTask = new Task({
   name: 'SaveData',
   taskFunction: async (transformedData) => {
-    await database.bulkInsert(transformedData);
-    return { saved: transformedData.length };
-  },
+    await database.save(transformedData);
+    return transformedData.length;
+  }
 });
 
-const workflow = new Taskchain({
+// Create and execute chain
+const dataChain = new Taskchain({
   name: 'DataPipeline',
-  taskArray: [fetchTask, transformTask, saveTask],
+  tasks: [fetchTask, transformTask, saveTask]
 });
 
-// Execute the entire chain
-const result = await workflow.trigger();
-console.log(`Processed ${result.saved} items`);
+const savedCount = await dataChain.trigger();
+console.log(`Saved ${savedCount} items`);
 ```
 
-### Parallel Execution - Maximum Performance
+### Parallel Execution - Concurrent Processing
 
-Execute multiple independent tasks simultaneously:
+Execute multiple tasks simultaneously:
 
 ```typescript
-import { Task, Taskparallel } from '@push.rocks/taskbuffer';
-
-const tasks = ['user', 'posts', 'comments'].map(
-  (resource) =>
-    new Task({
-      name: `Fetch${resource}`,
-      taskFunction: async () => {
-        const data = await fetch(`/api/${resource}`);
-        return data.json();
-      },
-    }),
-);
-
-const parallelFetch = new Taskparallel({
-  taskArray: tasks,
+import { TaskParallel } from '@push.rocks/taskbuffer';
+
+const parallel = new TaskParallel({
+  name: 'ParallelProcessor',
+  tasks: [
+    emailTask,
+    smsTask,
+    pushNotificationTask,
+    webhookTask
+  ]
 });
 
-// All tasks execute simultaneously
-const [users, posts, comments] = await parallelFetch.trigger();
+// All tasks execute concurrently
+const results = await parallel.trigger(notificationData);
+// results = [emailResult, smsResult, pushResult, webhookResult]
 ```
 
-### Scheduled Tasks with TaskManager
+### TaskManager - Centralized Orchestration
 
-Run tasks on a schedule using cron expressions:
+Manage all your tasks from a single point:
 
 ```typescript
-import { Task, TaskManager } from '@push.rocks/taskbuffer';
-
-const backupTask = new Task({
-  name: 'DatabaseBackup',
-  taskFunction: async () => {
-    await performBackup();
-    console.log(`Backup completed at ${new Date().toISOString()}`);
-  },
-});
-
-const manager = new TaskManager();
-
-// Add and schedule tasks
-manager.addAndScheduleTask(backupTask, '0 0 * * *'); // Daily at midnight
-manager.addAndScheduleTask(healthCheck, '*/5 * * * *'); // Every 5 minutes
-
-// Start the scheduler
-manager.start();
+const taskManager = new TaskManager();
+
+// Add tasks
+taskManager.addTask(dataProcessor);
+taskManager.addTask(deploymentTask);
+
+// Schedule tasks with cron
+taskManager.addAndScheduleTask(backupTask, '0 2 * * *'); // Daily at 2 AM
+taskManager.addAndScheduleTask(healthCheck, '*/5 * * * *'); // Every 5 minutes
+
+// Get task metadata
+const metadata = taskManager.getTaskMetadata('DeployApplication');
+console.log(metadata);
+// {
+//   name: 'DeployApplication',
+//   status: 'idle' | 'running' | 'completed' | 'failed',
+//   steps: [...],
+//   currentProgress: 75,
+//   runCount: 12,
+//   lastRun: Date,
+//   buffered: false,
+//   bufferMax: undefined,
+//   version: '1.0.0',
+//   timeout: 30000
+// }
+
+// Get all scheduled tasks
+const scheduled = taskManager.getScheduledTasks();
+scheduled.forEach(task => {
+  console.log(`${task.name}: Next run at ${task.nextRun}`);
+});
+
+// Execute and remove pattern
+const report = await taskManager.addExecuteRemoveTask(temporaryTask, {
+  trackProgress: true
+});
+console.log(report);
+// {
+//   taskName: 'TempTask',
+//   startTime: Date,
+//   endTime: Date,
+//   duration: 1523,
+//   steps: [...],
+//   stepsCompleted: ['step1', 'step2'],
+//   progress: 100,
+//   result: any,
+//   error?: Error
+// }
+```
 
-// Later... stop if needed
-manager.stop();
+## 🎨 Web Component Dashboard
+
+Visualize your tasks in real-time with the included web component:
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <script type="module">
+    import { TaskManager } from '@push.rocks/taskbuffer';
+    import '@push.rocks/taskbuffer/dist_ts_web/taskbuffer-dashboard.js';
+    
+    const taskManager = new TaskManager();
+    
+    // Attach to dashboard
+    const dashboard = document.querySelector('taskbuffer-dashboard');
+    dashboard.taskManager = taskManager;
+    dashboard.refreshInterval = 500; // Update every 500ms
+  </script>
+</head>
+<body>
+  <taskbuffer-dashboard></taskbuffer-dashboard>
+</body>
+</html>
 ```
 
-### Debounced Tasks - Smart Throttling
+The dashboard provides:
+- 📊 Real-time progress bars with step indicators
+- 📈 Task execution history
+- ⏰ Scheduled task information
+- 🎯 Interactive task controls
+- 🌓 Light/dark theme support
 
-Prevent task spam with intelligent debouncing:
+## 🧩 Advanced Patterns
 
-```typescript
-import { TaskDebounced } from '@push.rocks/taskbuffer';
+### Dynamic Task Routing
 
-const saveTask = new TaskDebounced({
-  name: 'AutoSave',
-  taskFunction: async (content: string) => {
-    await saveToDatabase(content);
-    console.log('Content saved');
-  },
-  debounceTimeInMillis: 2000, // Wait 2 seconds of inactivity
-});
+Route tasks based on conditions:
 
-// Rapid calls will be debounced
-input.addEventListener('input', (e) => {
-  saveTask.trigger(e.target.value);
+```typescript
+const routerTask = new Task({
+  name: 'Router',
+  taskFunction: async (request) => {
+    if (request.priority === 'high') {
+      return await expressProcessor.trigger(request);
+    } else if (request.size > 1000000) {
+      return await bulkProcessor.trigger(request);
+    } else {
+      return await standardProcessor.trigger(request);
+    }
+  }
 });
 ```
 
-### One-Time Tasks - Initialize Once
+### Task Pools
 
-Ensure initialization code runs exactly once:
+Create reusable task pools for load distribution:
 
 ```typescript
-import { TaskOnce } from '@push.rocks/taskbuffer';
+class TaskPool {
+  private tasks: Task[] = [];
+  private currentIndex = 0;
+  
+  constructor(poolSize: number, taskConfig: any) {
+    for (let i = 0; i < poolSize; i++) {
+      this.tasks.push(new Task({
+        ...taskConfig,
+        name: `${taskConfig.name}_${i}`
+      }));
+    }
+  }
+  
+  async execute(data: any) {
+    const task = this.tasks[this.currentIndex];
+    this.currentIndex = (this.currentIndex + 1) % this.tasks.length;
+    return await task.trigger(data);
+  }
+}
 
-const initTask = new TaskOnce({
-  name: 'SystemInitialization',
-  taskFunction: async () => {
-    await database.connect();
-    await cache.initialize();
-    await loadConfiguration();
-    console.log('System initialized');
-  },
+const processorPool = new TaskPool(5, {
+  name: 'DataProcessor',
+  taskFunction: async (data) => processData(data)
 });
-
-// Safe to call multiple times - only runs once
-await initTask.trigger();
-await initTask.trigger(); // This won't run again
 ```
 
-## Advanced Features 🔥
-
-### Task Dependencies with Pre/Post Hooks
+### Error Recovery & Retry
 
-Create sophisticated task relationships:
+Implement robust error handling:
 
 ```typescript
-const validationTask = new Task({
-  name: 'ValidateInput',
-  taskFunction: async (data) => {
-    if (!isValid(data)) {
-      throw new Error('Validation failed');
+const resilientTask = new Task({
+  name: 'ResilientTask',
+  taskFunction: async (data, retryCount = 0) => {
+    try {
+      return await riskyOperation(data);
+    } catch (error) {
+      if (retryCount < 3) {
+        console.log(`Retry ${retryCount + 1}/3`);
+        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, retryCount)));
+        return await resilientTask.trigger(data, retryCount + 1);
+      }
+      throw error;
     }
-    return data;
-  },
-});
-
-const mainTask = new Task({
-  name: 'ProcessData',
-  taskFunction: async (data) => {
-    return await complexProcessing(data);
-  },
-  preTask: validationTask, // Runs before main task
-  afterTask: cleanupTask, // Runs after main task
+  }
 });
 ```
 
-### Task Runners - Distributed Execution
+### Task Composition
 
-The TaskRunner system enables distributed task execution across multiple workers:
+Compose complex behaviors from simple tasks:
 
 ```typescript
-import { TaskRunner } from '@push.rocks/taskbuffer';
-
-const runner = new TaskRunner({
-  name: 'WorkerNode1',
-  maxConcurrentTasks: 5,
+const compositeTask = new Task({
+  name: 'CompositeOperation',
+  steps: [
+    { name: 'validate', description: 'Validating input', percentage: 20 },
+    { name: 'process', description: 'Processing data', percentage: 60 },
+    { name: 'notify', description: 'Sending notifications', percentage: 20 }
+  ] as const,
+  taskFunction: async function(data) {
+    this.notifyStep('validate');
+    const validated = await validationTask.trigger(data);
+    
+    this.notifyStep('process');
+    const processed = await processingTask.trigger(validated);
+    
+    this.notifyStep('notify');
+    await notificationTask.trigger(processed);
+    
+    return processed;
+  }
 });
-
-// Register tasks this runner can handle
-runner.registerTask(dataProcessingTask);
-runner.registerTask(imageResizeTask);
-
-// Start processing
-runner.start();
 ```
 
-### Buffer Management Strategies
+## 🔧 Configuration
 
-Fine-tune concurrent execution behavior:
+### Task Options
 
 ```typescript
-const task = new Task({
-  name: 'ResourceIntensive',
-  taskFunction: async () => {
-    /* ... */
-  },
-  buffered: true,
-  bufferMax: 5, // Max 5 concurrent
-  execDelay: 100, // 100ms between starts
-  timeout: 30000, // 30 second timeout
-});
+interface TaskOptions<T = undefined, TSteps = []> {
+  name?: string;              // Task identifier
+  taskFunction: Function;     // Async function to execute
+  buffered?: boolean;         // Enable buffering
+  bufferMax?: number;         // Max concurrent executions
+  execDelay?: number;         // Min delay between executions
+  timeout?: number;           // Task timeout in ms
+  version?: string;           // Task version
+  steps?: TSteps;            // Progress steps configuration
+  taskSetup?: Function;       // One-time setup function
+  beforeTask?: Function;      // Runs before each execution
+  afterTask?: Function;       // Runs after each execution
+}
 ```
 
-### Cycle Detection and Prevention
-
-TaskBuffer automatically detects and prevents circular dependencies:
+### TaskManager Options
 
 ```typescript
-const taskA = new Task({
-  name: 'TaskA',
-  taskFunction: async () => {
-    /* ... */
-  },
-  preTask: taskB, // This would create a cycle
-});
-
-const taskB = new Task({
-  name: 'TaskB',
-  taskFunction: async () => {
-    /* ... */
-  },
-  preTask: taskA, // Circular dependency detected!
+const taskManager = new TaskManager({
+  maxConcurrentTasks: 10,    // Global concurrency limit
+  defaultTimeout: 30000,      // Default task timeout
+  logLevel: 'info'          // Logging verbosity
 });
 ```
 
-### Dynamic Task Creation
+## 📊 Monitoring & Observability
 
-Create tasks on-the-fly based on runtime conditions:
+### Task Events
 
 ```typescript
-const dynamicWorkflow = async (config: Config) => {
-  const tasks = config.steps.map(
-    (step) =>
-      new Task({
-        name: step.name,
-        taskFunction: async (input) => {
-          return await processStep(step, input);
-        },
-      }),
-  );
-
-  const chain = new Taskchain({
-    name: 'DynamicWorkflow',
-    taskArray: tasks,
-  });
-
-  return await chain.trigger();
-};
+task.on('started', () => console.log('Task started'));
+task.on('completed', (result) => console.log('Task completed:', result));
+task.on('failed', (error) => console.error('Task failed:', error));
+task.on('stepChange', (step) => console.log('Step:', step.name));
 ```
 
-## API Reference 📚
+### Execution Metrics
 
-### Task Options
+```typescript
+const metrics = task.getMetrics();
+console.log({
+  totalRuns: metrics.runCount,
+  averageDuration: metrics.avgDuration,
+  successRate: metrics.successRate,
+  lastError: metrics.lastError
+});
+```
 
-| Option         | Type       | Description                    |
-| -------------- | ---------- | ------------------------------ |
-| `name`         | `string`   | Unique identifier for the task |
-| `taskFunction` | `Function` | Async function to execute      |
-| `buffered`     | `boolean`  | Enable buffer management       |
-| `bufferMax`    | `number`   | Maximum concurrent executions  |
-| `execDelay`    | `number`   | Delay between executions (ms)  |
-| `timeout`      | `number`   | Task timeout (ms)              |
-| `preTask`      | `Task`     | Task to run before             |
-| `afterTask`    | `Task`     | Task to run after              |
-
-### TaskManager Methods
-
-| Method                          | Description              |
-| ------------------------------- | ------------------------ |
-| `addTask(task, cronExpression)` | Add and schedule a task  |
-| `removeTask(taskName)`          | Remove a scheduled task  |
-| `start()`                       | Start the scheduler      |
-| `stop()`                        | Stop the scheduler       |
-| `getStats()`                    | Get execution statistics |
-
-### Taskchain Methods
-
-| Method                  | Description            |
-| ----------------------- | ---------------------- |
-| `addTask(task)`         | Add task to chain      |
-| `removeTask(taskName)`  | Remove task from chain |
-| `trigger(initialValue)` | Execute the chain      |
-| `reset()`               | Reset chain state      |
-
-## Performance Tips 🏎️
-
-1. **Use buffering for I/O operations**: Prevents overwhelming external services
-2. **Leverage parallel execution**: When tasks are independent, run them simultaneously
-3. **Implement proper error handling**: Use try-catch in task functions
-4. **Monitor task execution**: Use the built-in stats and logging
-5. **Set appropriate timeouts**: Prevent hanging tasks from blocking your system
-
-## Error Handling 🛡️
+## 🧪 Testing
 
 ```typescript
-const robustTask = new Task({
-  name: 'RobustOperation',
-  taskFunction: async (input) => {
-    try {
-      return await riskyOperation(input);
-    } catch (error) {
-      // Log error
-      console.error(`Task failed: ${error.message}`);
-
-      // Optionally retry
-      if (error.retryable) {
-        return await riskyOperation(input);
-      }
+import { expect, tap } from '@git.zone/tstest';
+import { Task } from '@push.rocks/taskbuffer';
 
-      // Or return default value
-      return defaultValue;
+tap.test('Task should execute with progress tracking', async () => {
+  const task = new Task({
+    name: 'TestTask',
+    steps: [
+      { name: 'step1', description: 'Step 1', percentage: 50 },
+      { name: 'step2', description: 'Step 2', percentage: 50 }
+    ] as const,
+    taskFunction: async function() {
+      this.notifyStep('step1');
+      await new Promise(r => setTimeout(r, 100));
+      this.notifyStep('step2');
+      return 'done';
     }
-  },
-  timeout: 5000, // Fail if takes longer than 5 seconds
+  });
+  
+  const result = await task.trigger();
+  expect(result).toEqual('done');
+  expect(task.getProgress()).toEqual(100);
 });
 ```
 
-## Real-World Examples 🌍
+## 🌐 Real-World Examples
 
-### API Rate Limiting
+### API Rate Limiter
 
 ```typescript
-const apiClient = new Task({
-  name: 'RateLimitedAPI',
-  taskFunction: async (endpoint: string) => {
-    return await fetch(`https://api.example.com${endpoint}`);
-  },
+const apiLimiter = new Task({
+  name: 'APIRateLimiter',
   buffered: true,
-  bufferMax: 10, // 10 requests
-  execDelay: 100, // Per 100ms = 100 req/s max
+  bufferMax: 10,  // Max 10 requests per second
+  execDelay: 100, // 100ms between requests
+  taskFunction: async (endpoint, data) => {
+    return await fetch(endpoint, {
+      method: 'POST',
+      body: JSON.stringify(data)
+    });
+  }
 });
 ```
 
@@ -750,63 +472,119 @@ const apiClient = new Task({
 ```typescript
 const migrationChain = new Taskchain({
   name: 'DatabaseMigration',
-  taskArray: [
-    backupTask,
-    schemaUpdateTask,
-    dataTransformTask,
-    validationTask,
-    cleanupTask,
-  ],
-});
+  tasks: [
+    backupDatabaseTask,
+    validateSchemaTask,
+    runMigrationsTask,
+    verifyIntegrityTask,
+    updateIndexesTask
+  ]
+});
+
+// Execute with rollback on failure
+try {
+  await migrationChain.trigger();
+  console.log('Migration successful!');
+} catch (error) {
+  await rollbackTask.trigger();
+  throw error;
+}
 ```
 
-### Microservice Health Monitoring
+### Distributed Job Queue
 
 ```typescript
-const healthMonitor = new TaskManager();
-
-services.forEach((service) => {
-  const healthCheck = new Task({
-    name: `HealthCheck:${service.name}`,
-    taskFunction: async () => {
-      const healthy = await checkHealth(service.url);
-      if (!healthy) {
-        await alertOps(service);
-      }
-    },
-  });
+const jobQueue = new TaskManager();
 
-  healthMonitor.addAndScheduleTask(healthCheck, '*/1 * * * *'); // Every minute
+// Worker tasks
+const imageProcessor = new Task({
+  name: 'ImageProcessor',
+  buffered: true,
+  bufferMax: 5,
+  steps: [
+    { name: 'download', description: 'Downloading', percentage: 20 },
+    { name: 'resize', description: 'Resizing', percentage: 40 },
+    { name: 'optimize', description: 'Optimizing', percentage: 30 },
+    { name: 'upload', description: 'Uploading', percentage: 10 }
+  ] as const,
+  taskFunction: async function(job) {
+    this.notifyStep('download');
+    const image = await downloadImage(job.url);
+    
+    this.notifyStep('resize');
+    const resized = await resizeImage(image, job.dimensions);
+    
+    this.notifyStep('optimize');
+    const optimized = await optimizeImage(resized);
+    
+    this.notifyStep('upload');
+    return await uploadToCDN(optimized);
+  }
+});
+
+jobQueue.addTask(imageProcessor);
+
+// Process incoming jobs
+messageQueue.on('job', async (job) => {
+  const result = await jobQueue.getTaskByName('ImageProcessor').trigger(job);
+  await messageQueue.ack(job.id, result);
 });
 ```
 
-## Testing 🧪
+## 🚀 Performance Tips
+
+1. **Use Buffering Wisely** - Enable buffering for I/O-bound tasks
+2. **Set Appropriate Delays** - Use `execDelay` to prevent API rate limits
+3. **Leverage Task Pools** - Distribute load across multiple task instances
+4. **Monitor Progress** - Use step tracking for long-running operations
+5. **Clean Up** - Use `addExecuteRemoveTask` for one-time operations
+
+## 🔍 Debugging
+
+Enable detailed logging:
 
 ```typescript
-import { expect, tap } from '@git.zone/tstest';
-import { Task } from '@push.rocks/taskbuffer';
+import { logger } from '@push.rocks/smartlog';
 
-tap.test('should execute task successfully', async () => {
-  const result = await myTask.trigger();
-  expect(result).toEqual(expectedValue);
-});
+logger.enableConsole();
+logger.level = 'debug';
 
-tap.start();
+// Tasks will now output detailed execution logs
 ```
 
-## Contributing 🤝
+## 📚 API Reference
+
+### Core Classes
+
+- **`Task<T, TSteps>`** - Basic task unit with optional step tracking
+- **`TaskManager`** - Central orchestrator for task management
+- **`Taskchain`** - Sequential task executor
+- **`TaskParallel`** - Concurrent task executor
+- **`TaskOnce`** - Single-execution task
+- **`TaskLoop`** - Repeating task with conditions
 
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+### Key Methods
 
-## Support 💬
+#### Task Methods
+- `trigger(input?: T): Promise<any>` - Execute the task
+- `notifyStep(stepName: StepNames<TSteps>): void` - Update current step
+- `getProgress(): number` - Get progress percentage (0-100)
+- `getStepsMetadata(): ITaskStep[]` - Get detailed step information
+- `getMetadata(): ITaskMetadata` - Get complete task metadata
 
-- 📧 Email: [hello@task.vc](mailto:hello@task.vc)
-- 🐛 Issues: [GitHub Issues](https://github.com/push-rocks/taskbuffer/issues)
-- 📖 Docs: [Documentation](https://code.foss.global/push.rocks/taskbuffer)
+#### TaskManager Methods
+- `addTask(task: Task): void` - Register a task
+- `getTaskByName(name: string): Task | undefined` - Retrieve task by name
+- `addAndScheduleTask(task: Task, cronExpression: string): void` - Schedule task
+- `descheduleTaskByName(name: string): void` - Remove scheduling
+- `getTaskMetadata(name: string): ITaskMetadata | null` - Get task metadata
+- `getAllTasksMetadata(): ITaskMetadata[]` - Get all tasks metadata
+- `getScheduledTasks(): IScheduledTaskInfo[]` - List scheduled tasks
+- `addExecuteRemoveTask(task, options?): Promise<ITaskExecutionReport>` - Execute once
 
 ## License and Legal Information
 
-This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository.
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
 
 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
 
@@ -821,4 +599,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
 
 For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.