queen-mq 0.1.0 → 0.1.2

package/README.md

@@ -1,40 +1,123 @@
-# Queen - High-Performance Message Queue System
+# Queen - PostgreSQL-backed Message Queue System
 
-A modern, high-performance message queue system built with PostgreSQL and uWebSockets.js, featuring priority-based processing, advanced scheduling, and real-time monitoring.
+<div align="center">
 
-![Queen Dashboard](assets/dashboard.png)
+**A modern, high-performance message queue system built on PostgreSQL**
 
-## 🚀 Features
+[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE.md)
+[![Node](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen.svg)](https://nodejs.org/)
 
-- **🏗️ Flexible Architecture**: Queues → Partitions → Messages with optional namespace/task grouping
-- **⚡ Priority Processing**: Queue and partition-level priorities with FIFO within partitions
-- **🕒 Advanced Scheduling**: Delayed processing and window buffering
-- **🔄 Reliable Processing**: Lease-based processing with automatic retry and dead letter queues
-- **📊 Real-time Monitoring**: WebSocket dashboard with live metrics and analytics
-- **🔒 Message Guarantees**: ACID transactions, idempotency, and no message loss
-- **🚄 High Performance**: 10,000+ messages/second with sub-10ms latency
-- **🌐 Long Polling**: Event-driven optimization for real-time message consumption
-- **📦 Batch Operations**: Efficient bulk message processing with individual and batch consumer modes
-- **🛠️ Client SDK**: Full-featured JavaScript client with retry logic and helpers
+[Quick Start](#-quick-start) • [Client Examples](#-client-examples) • [Server Setup](#-server-setup) • [Core Concepts](#-core-concepts) • [API Reference](#-http-api-reference) • [Dashboard](#-dashboard)
+
+<p align="center">
+  <img src="assets/queen-logo.svg" alt="Queen Logo" width="120" />
+</p>
+
+</div>
+
+---
+
+## 🎯 Introduction
+
+**Queen** is a production-ready message queue system that combines the reliability of PostgreSQL with the performance of modern async architectures. Built with uWebSockets.js for blazing-fast HTTP handling and designed for real-world workloads.
+
+### Why Queen?
+
+**🚀 Developer-First API**
+- **4 core methods, infinite patterns**: `queue()`, `push()`, `take()`, `ack()`
+- **Async iteration**: Process messages with familiar `for await` syntax
+- **Batch processing**: Use `takeBatch()` for 250k+ msg/sec throughput on millions of messages
+- **Smart addressing**: `orders/urgent@workers` - queue, partition, and consumer group in one
+
+**⚡ Production-Ready Performance**
+- **100,000+ msg/sec** throughput with cursor-based consumption
+- **Constant-time batch operations** - O(batch_size) regardless of queue depth
+- **Long polling** for event-driven, real-time message delivery
+- **Partition locking** prevents duplicate processing across consumers
+- **Connection pooling** and optimized batch operations
+
+**🏗️ Flexible Architecture**
+- **Queue Mode**: Competitive consumption (traditional work queue)
+- **Bus Mode**: Pub/sub with consumer groups (event streaming)
+- **Mixed Mode**: Combine both patterns in the same system
+- **Partitions**: FIFO ordering with parallel processing
+
+**🔒 Enterprise Features**
+- **AES-256-GCM Encryption**: Protect sensitive data at rest
+- **Message Retention**: Automatic cleanup policies
+- **Message Eviction**: SLA enforcement for time-sensitive tasks
+- **Dead Letter Queue**: Handle failed messages gracefully
+
+**📊 Built-in Observability**
+- **Real-time Dashboard**: WebSocket-powered monitoring
+- **Rich Analytics**: Throughput, lag, queue depth metrics
+- **Message Browser**: Search, inspect, and retry messages
+- **System Health**: Database, memory, and performance metrics
+- **Cursor Tracking**: Monitor consumption progress per consumer group
+
+### Use Cases
+
+- **Task Queues**: Background jobs, email sending, data processing
+- **Event Streaming**: Audit logs, analytics, multi-service event handling
+- **Workflow Orchestration**: Multi-stage pipelines, saga patterns
+- **Rate Limiting**: Throttle and batch time-sensitive operations
+- **Priority Processing**: Handle urgent tasks before routine ones
+
+---
 
 ## 📋 Table of Contents
 
-- [Quick Start](#quick-start)
-- [Architecture](#architecture)
-- [Core Concepts](#core-concepts)
-- [API Reference](#api-reference)
-- [Client SDK](#client-sdk)
-- [Dashboard](#dashboard)
-- [Examples](#examples)
-- [Performance](#performance)
-- [Configuration](#configuration)
+- [First Queue](#-first-queue)
+- [Quick Start](#-quick-start)
+- [Client Examples](#-client-examples)
+- [Server Setup](#-server-setup)
+- [Core Concepts](#-core-concepts)
+- [Cursor-Based Consumption Strategy](#-cursor-based-consumption-strategy)
+- [HTTP API Reference](#-http-api-reference)
+- [Dashboard](#-dashboard)
+- [Configuration](#-configuration)
+- [Full Examples](#-full-examples)
+- [Testing](#-testing)
+- [Contributing](#-contributing)
+
+---
+
+## First Queue
+
+```javascript
+import { Queen } from 'queen-mq';
+
+const client = new Queen({
+  baseUrls: ['http://localhost:6632']
+});
+
+// Configure queue
+await client.queue('tasks', {
+  leaseTime: 300,
+  retryLimit: 3
+});
+
+// Push a message
+await client.push('tasks', { 
+  action: 'send-email',
+  to: 'user@example.com' 
+});
+
+// Process messages
+for await (const message of client.take('tasks')) {
+  console.log('Processing:', message.data);
+  await client.ack(message);
+}
+```
+
+That's it! You now have a working message queue system.
 
 ## 🏃 Quick Start
 
 ### Prerequisites
 
-- Node.js 22+
-- PostgreSQL 12+
+- **Node.js 22+**
+- **PostgreSQL 12+**
 
 ### Installation
 
@@ -47,556 +130,1001 @@ cd queen
 nvm use 22
 npm install
 
-# Set up environment (optional)
+# Initialize database schema
+node init-db.js
+```
+
+### Set Environment (Optional)
+
+```bash
+# Database connection
 export PG_USER=postgres
 export PG_HOST=localhost
 export PG_DB=postgres
 export PG_PASSWORD=postgres
 export PG_PORT=5432
+
+# Enable encryption (optional)
+export QUEEN_ENCRYPTION_KEY=$(openssl rand -hex 32)
 ```
 
-### Database Setup
+### Start the Server
 
 ```bash
-# Initialize the database schema
-node init-db.js
+npm start
+# Server starts on http://localhost:6632
 ```
 
-### Start the Server
+---
 
-```bash
-# Optional: Enable encryption
-export QUEEN_ENCRYPTION_KEY=$(openssl rand -hex 32)
+## 💻 Client Examples
 
-# Start the Queen server
-npm start
-# Or use the startup script
-./start.sh
+The Queen client provides a minimalist API with just 4 methods that compose into any messaging pattern you need.
 
-# Server starts on http://localhost:6632
+### Installation
+
+```bash
+npm install queen-mq
 ```
 
 ### Basic Usage
 
+#### 1. Configure a Queue
+
 ```javascript
-import { createQueenClient } from '@dev.smartpricing/queen'
+import { Queen } from 'queen-mq';
 
-const client = createQueenClient({
-  baseUrl: 'http://localhost:6632'
+const client = new Queen({
+  baseUrls: ['http://localhost:6632'],
+  timeout: 30000,
+  retryAttempts: 3
 });
 
-// Push a message
-await client.push({
-  items: [{
-    queue: 'email-queue',
-    partition: 'urgent',
-    payload: { to: 'user@example.com', subject: 'Hello!' }
-  }]
+// Configure with options
+await client.queue('orders', {
+  priority: 10,          // Higher priority queues processed first
+  leaseTime: 600,        // 10 minutes to process each message
+  retryLimit: 3,         // Retry up to 3 times
+  delayedProcessing: 0,  // No delay (immediate processing)
 });
 
-// Pop and process messages
-const result = await client.pop({
-  queue: 'email-queue',
-  batch: 10,
-  wait: true
+// Configure with namespace and task for grouping
+await client.queue('order-processing', {
+  priority: 10
+}, {
+  namespace: 'ecommerce',
+  task: 'checkout'
 });
-
-for (const message of result.messages) {
-  console.log('Processing:', message.data);
-  await client.ack(message.transactionId, 'completed');
-}
 ```
 
-## 🏗️ Architecture
+#### 2. Push Messages
 
-### System Overview
+```javascript
+// Single message
+await client.push('orders', { 
+  orderId: 12345, 
+  amount: 99.99 
+});
 
-```
-┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
-│   Client SDK    │───▶│   Queen Server   │───▶│   PostgreSQL    │
-└─────────────────┘    └──────────────────┘    └─────────────────┘
-                              │
-                              ▼
-                       ┌──────────────────┐
-                       │   Dashboard UI   │
-                       └──────────────────┘
-```
+// To a specific partition
+await client.push('orders/urgent', { 
+  orderId: 12346, 
+  amount: 999.99,
+  priority: 'high'
+});
 
-### Data Model
+// Batch messages
+await client.push('orders', [
+  { orderId: 12347, amount: 49.99 },
+  { orderId: 12348, amount: 79.99 },
+  { orderId: 12349, amount: 29.99 }
+]);
 
-```
-Queues (with optional namespace/task grouping)
-  └── Partitions (FIFO ordering, priority-based selection)
-       └── Messages (lease-based processing)
+// With message properties
+await client.push('orders', {
+  orderId: 12350,
+  amount: 199.99
+}, {
+  transactionId: 'txn-12350',  // For idempotency
+  traceId: '550e8400-e29b-41d4-a716-446655440000'  // Valid UUID for tracing
+});
 ```
 
-**Database Schema:**
-- `queen.queues` - Top-level message containers with optional grouping
-- `queen.partitions` - Subdivisions within queues where FIFO is maintained
-- `queen.messages` - Individual messages with processing state
+#### 3. Take Messages (Async Iterator)
 
-### Key Components
+```javascript
+// Process continuously with long polling
+for await (const message of client.take('orders', { 
+  wait: true,      // Enable long polling
+  timeout: 30000,  // 30 second timeout
+  batch: 10        // Fetch up to 10 at once
+})) {
+  try {
+    await processOrder(message.data);
+    await client.ack(message);  // Success
+  } catch (error) {
+    await client.ack(message, false, { error: error.message });  // Failure
+  }
+}
 
-- **uWebSockets.js Server**: High-performance HTTP/WebSocket server
-- **Queue Manager**: Core message processing logic with optimizations
-- **Resource Cache**: In-memory caching for queue/partition lookups
-- **Event Manager**: Real-time notifications for long polling
-- **WebSocket Server**: Live dashboard updates and monitoring
+// Process limited messages
+for await (const message of client.take('orders', { limit: 100 })) {
+  await processOrder(message.data);
+  await client.ack(message);
+}
 
-## 💡 Core Concepts
+// Take from specific partition
+for await (const message of client.take('orders/urgent')) {
+  await processUrgentOrder(message.data);
+  await client.ack(message);
+}
 
-### Queues and Partitions
+// Use takeBatch to get arrays of messages (higher throughput)
+for await (const messages of client.takeBatch('orders', { 
+  batch: 1000,     // Fetch 1000 at a time
+  wait: true 
+})) {
+  // messages is an array of up to 1000 messages
+  console.log(`Processing batch of ${messages.length} messages`);
+  
+  try {
+    // Process entire batch
+    await processBatch(messages.map(m => m.data));
+    
+    // Acknowledge entire batch at once (efficient!)
+    await client.ack(messages);  // Pass array for batch ack
+  } catch (error) {
+    // Mark entire batch as failed
+    await client.ack(messages, false, { error: error.message });
+  }
+}
+```
 
-**Queues** are the top-level organizational units. Each queue automatically gets a "Default" partition, and you can create additional partitions for different processing priorities or logical separation.
+#### 4. Acknowledge Messages
 
 ```javascript
-// Messages go to "Default" partition if not specified
-await client.push({
-  items: [{ queue: 'orders', payload: { orderId: 123 } }]
-});
+// Acknowledge success
+await client.ack(message);
+// or
+await client.ack(message, true);
+
+// Acknowledge failure (will retry based on retryLimit)
+await client.ack(message, false);
 
-// Explicit partition specification
-await client.push({
-  items: [{ 
-    queue: 'orders', 
-    partition: 'high-priority',
-    payload: { orderId: 456, urgent: true } 
-  }]
+// Acknowledge with error context
+await client.ack(message, false, { 
+  error: 'Payment gateway timeout' 
 });
-```
 
-### Priority Processing
+// Acknowledge using transaction ID
+await client.ack('4dfb0478-655b-4c91-bcd9-b7acacf0400f', true);
 
-The system supports two levels of priority:
+// Request explicit retry
+await client.ack(message, 'retry');
+```
+
+### Address Notation
 
-1. **Queue Priority**: Higher priority queues are processed first
-2. **FIFO Within Partitions**: Messages within the same partition are always processed in order
-3. **Partitions**: Partitions are now simple FIFO containers - all configuration is at the queue level
+Queen uses a simple addressing scheme that encodes queue, partition, and consumer group:
 
 ```javascript
-// Configure queue with priority
-await client.configure({
-  queue: 'orders',
-  options: { priority: 10 } // Higher number = higher priority
-});
+// Basic addresses
+'orders'                    // Queue (Default partition)
+'orders/urgent'             // Queue with specific partition
+'orders@workers'            // Queue with consumer group (bus mode)
+'orders/urgent@workers'     // Full address: queue + partition + group
+
+// Namespace/task filtering (cross-queue consumption)
+'namespace:ecommerce'                      // All queues in namespace
+'task:checkout'                            // All queues with task
+'namespace:ecommerce/task:checkout'        // Combined filter
+'namespace:ecommerce/task:checkout@audit'  // With consumer group
 ```
 
-### Message Lifecycle
+### Consumer Patterns
 
-```
-pending → processing → completed/failed → (retry) → dead_letter
+#### Continuous Processing (Long Polling)
+
+```javascript
+// Efficient real-time processing
+for await (const message of client.take('tasks', {
+  wait: true,      // Long polling - waits for messages
+  timeout: 30000   // Server timeout
+})) {
+  await processTask(message.data);
+  await client.ack(message);
+}
 ```
 
-1. **Pending**: Message is queued and waiting to be processed
-2. **Processing**: Message is leased to a worker (with timeout)
-3. **Completed**: Message was successfully processed
-4. **Failed**: Message processing failed (may retry based on configuration)
-5. **Dead Letter**: Message exceeded retry limits
+#### Batch Processing
 
-### Lease-Based Processing
+```javascript
+// Method 1: Manual batching with take()
+const batch = [];
+for await (const message of client.take('analytics', { batch: 100 })) {
+  batch.push(message);
+  
+  if (batch.length >= 100) {
+    await processBatch(batch.map(m => m.data));
+    
+    // Acknowledge all
+    for (const msg of batch) {
+      await client.ack(msg);
+    }
+    batch.length = 0;
+  }
+}
+
+// Method 2: Direct batch processing with takeBatch() (RECOMMENDED)
+for await (const messages of client.takeBatch('analytics', { batch: 1000 })) {
+  // messages is already an array!
+  await processBatch(messages.map(m => m.data));
+  
+  // Single batch acknowledgment (much faster!)
+  await client.ack(messages);
+}
+```
 
-Messages are "leased" to workers for a specific duration. If not acknowledged within the lease time, they automatically return to pending status for retry.
+#### Parallel Processing with Partitions
 
 ```javascript
-// Configure lease time (default: 300 seconds)
-await client.configure({
-  queue: 'long-tasks',
-  options: { leaseTime: 600 } // 10 minutes
-});
-```
+// Create workers for parallel processing
+const partitions = ['worker-1', 'worker-2', 'worker-3', 'worker-4'];
 
-## 🔐 Advanced Concepts
+// Distribute messages across partitions
+for (let i = 0; i < messages.length; i++) {
+  const partition = partitions[i % partitions.length];
+  await client.push(`tasks/${partition}`, messages[i]);
+}
 
-### Partition Locking
+// Each worker processes its own partition (in parallel)
+async function worker(partition) {
+  for await (const msg of client.take(`tasks/${partition}`)) {
+    await processTask(msg.data);
+    await client.ack(msg);
+  }
+}
+
+// Start all workers
+await Promise.all(partitions.map(p => worker(p)));
+```
+
+#### Consumer Groups (Bus Mode)
 
-Partition locking is a critical mechanism that ensures message processing isolation and prevents duplicate processing. When a consumer retrieves messages from a partition, that partition becomes "locked" to that consumer for the duration of the lease.
+```javascript
+// Multiple services process the same messages independently
 
-#### How Partition Locking Works
+// Analytics service
+for await (const event of client.take('events@analytics')) {
+  await updateAnalytics(event.data);
+  await client.ack(event, true, { group: 'analytics' });
+}
 
-1. **Lock Acquisition**: When a consumer calls `pop()`, the system:
-   - Checks for available messages in unlocked partitions
-   - Acquires a lease on the partition(s) containing those messages
-   - Records the lease with an expiration time based on the queue's `leaseTime`
+// Monitoring service (gets same messages)
+for await (const event of client.take('events@monitoring')) {
+  await checkThresholds(event.data);
+  await client.ack(event, true, { group: 'monitoring' });
+}
 
-2. **Lock Duration**: The partition remains locked until:
-   - The consumer acknowledges all messages (releases the lock)
-   - The lease expires (automatic release after `leaseTime` seconds)
-   - The consumer explicitly releases the partition
+// Audit service (also gets same messages)
+for await (const event of client.take('events@audit')) {
+  await logToAudit(event.data);
+  await client.ack(event, true, { group: 'audit' });
+}
+```
 
-3. **Lock Scope**: 
-   - In **Queue Mode**: Each consumer gets a unique session, preventing any other consumer from accessing the same partition
-   - In **Bus Mode**: Locks are per consumer group, allowing different groups to process the same messages independently
+#### Subscription Modes
 
 ```javascript
-// Example: Two consumers in queue mode
-const consumer1 = await client.pop({ queue: 'orders' }); 
-// Consumer 1 gets messages from partition A and locks it
+// Start from all existing messages (replay)
+for await (const event of client.take('events@replay-service', {
+  subscriptionMode: 'all'
+})) {
+  await replayEvent(event.data);
+  await client.ack(event);
+}
 
-const consumer2 = await client.pop({ queue: 'orders' }); 
-// Consumer 2 gets messages from partition B (A is locked)
+// Start from new messages only (real-time)
+for await (const event of client.take('events@realtime', {
+  subscriptionMode: 'new'
+})) {
+  await processEvent(event.data);
+  await client.ack(event);
+}
 
-// After Consumer 1 acknowledges:
-await client.ack(consumer1.messages[0].transactionId, 'completed');
-// Partition A is now unlocked and available
+// Start from specific timestamp
+for await (const event of client.take('events@historical', {
+  subscriptionMode: 'from',
+  subscriptionFrom: '2024-01-01T00:00:00Z'
+})) {
+  await processHistoricalEvent(event.data);
+  await client.ack(event);
+}
 ```
 
-### FIFO Ordering Guarantees
-
-Queen provides strong FIFO (First-In-First-Out) ordering guarantees **within each partition**. This means:
+#### Error Handling
 
-#### Partition-Level FIFO
+```javascript
+// Robust error handling with retries
+for await (const message of client.take('critical-tasks')) {
+  let retries = 3;
+  
+  while (retries > 0) {
+    try {
+      await processTask(message.data);
+      await client.ack(message);
+      break;
+    } catch (error) {
+      retries--;
+      if (retries === 0) {
+        console.error('Task failed after retries:', error);
+        await client.ack(message, false, { error: error.message });
+      } else {
+        await new Promise(r => setTimeout(r, 1000 * (4 - retries)));
+      }
+    }
+  }
+}
+```
 
-Messages within the same partition are always processed in the exact order they were received:
+#### Graceful Shutdown
 
 ```javascript
-// These messages will be processed in order 1, 2, 3
-await client.push({
-  items: [
-    { queue: 'tasks', partition: 'user-123', payload: { step: 1 } },
-    { queue: 'tasks', partition: 'user-123', payload: { step: 2 } },
-    { queue: 'tasks', partition: 'user-123', payload: { step: 3 } }
-  ]
+let running = true;
+
+process.on('SIGTERM', () => {
+  console.log('Shutting down gracefully...');
+  running = false;
 });
 
-// Consumer will always receive them in order 1, 2, 3
-const result = await client.pop({ queue: 'tasks', partition: 'user-123' });
+for await (const message of client.take('orders')) {
+  if (!running) break;
+  
+  await processOrder(message.data);
+  await client.ack(message);
+}
+
+await client.close();
+console.log('Shutdown complete');
 ```
 
-#### Cross-Partition Ordering
+---
 
-Messages in different partitions can be processed in parallel and have no ordering guarantees relative to each other:
+## 🖥️ Server Setup
 
-```javascript
-// These can be processed in any order relative to each other
-await client.push({
-  items: [
-    { queue: 'tasks', partition: 'user-123', payload: { data: 'A' } },
-    { queue: 'tasks', partition: 'user-456', payload: { data: 'B' } }
-  ]
-});
-```
+### Single Server
 
-#### Use Cases for Partitioning
+```bash
+# Start the server
+npm start
 
-- **Per-User Processing**: Use user ID as partition to ensure all user operations are processed in order
-- **Per-Resource Processing**: Use resource ID to maintain operation order for specific resources
-- **Priority Lanes**: Use different partitions for different priority levels
+# Or with custom configuration
+PORT=6632 \
+DB_POOL_SIZE=20 \
+QUEEN_ENCRYPTION_KEY=$(openssl rand -hex 32) \
+npm start
+```
 
-### Consumer Groups (Bus Mode)
+### Multi-Server (Load Balanced)
 
-Consumer groups enable pub-sub messaging patterns where multiple independent consumers can process the same messages. This is ideal for scenarios like event streaming, audit logging, and analytics.
+Queen supports running multiple servers for high availability and load distribution:
 
-#### How Consumer Groups Work
+```bash
+# Server 1
+PORT=6632 WORKER_ID=server-1 npm start
 
-1. **Independent Processing**: Each consumer group maintains its own:
-   - Message status tracking
-   - Partition leases
-   - Retry counters
-   - Processing state
+# Server 2
+PORT=6633 WORKER_ID=server-2 npm start
 
-2. **Message Visibility**: All consumer groups see all messages, but each group tracks which messages it has processed independently
+# Server 3
+PORT=6634 WORKER_ID=server-3 npm start
+```
 
-3. **Partition Locking per Group**: Within a consumer group, partition locking still applies to prevent duplicate processing
+Client configuration:
 
 ```javascript
-// Analytics service (Group A)
-const analyticsResult = await client.pop({
-  queue: 'events',
-  consumerGroup: 'analytics-service'
+const client = new Queen({
+  baseUrls: [
+    'http://localhost:6632',
+    'http://localhost:6633',
+    'http://localhost:6634'
+  ],
+  loadBalancingStrategy: 'ROUND_ROBIN',  // or 'RANDOM', 'LEAST_CONNECTIONS'
+  enableFailover: true
 });
+```
 
-// Audit service (Group B) - gets the same messages
-const auditResult = await client.pop({
-  queue: 'events',
-  consumerGroup: 'audit-service'
-});
+### Docker Deployment
 
-// Billing service (Group C) - also gets the same messages
-const billingResult = await client.pop({
-  queue: 'events',
-  consumerGroup: 'billing-service'
-});
+```dockerfile
+FROM node:22-alpine
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --production
+
+COPY . .
+
+EXPOSE 6632
+CMD ["node", "src/server.js"]
 ```
 
-#### Consumer Group Subscription Modes
+```yaml
+# docker-compose.yml
+version: '3.8'
 
-When a consumer group is created, it can specify when to start consuming messages:
+services:
+  postgres:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: queen
+      POSTGRES_USER: queen
+      POSTGRES_PASSWORD: queen
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
 
-```javascript
-// Start from all existing messages
-await client.pop({
-  queue: 'events',
-  consumerGroup: 'replay-service',
-  subscriptionMode: 'all'
-});
+  queen:
+    build: .
+    ports:
+      - "6632:6632"
+    environment:
+      PG_HOST: postgres
+      PG_DB: queen
+      PG_USER: queen
+      PG_PASSWORD: queen
+      DB_POOL_SIZE: 20
+      QUEEN_ENCRYPTION_KEY: ${QUEEN_ENCRYPTION_KEY}
+    depends_on:
+      - postgres
 
-// Start from messages created after joining
-await client.pop({
-  queue: 'events',
-  consumerGroup: 'realtime-service',
-  subscriptionMode: 'new'
-});
+volumes:
+  postgres_data:
+```
 
-// Start from a specific timestamp
-await client.pop({
-  queue: 'events',
-  consumerGroup: 'batch-processor',
-  subscriptionFrom: '2024-01-01T00:00:00Z'
-});
+### Environment Variables
+
+See the [Configuration](#-configuration) section for a complete list of environment variables.
+
+### Database Schema
+
+The database schema is automatically created when you run:
+
+```bash
+node init-db.js
 ```
 
-### Namespace and Task Filtering
+This creates:
+- `queen.queues` - Top-level message containers
+- `queen.partitions` - Subdivisions within queues (FIFO ordering)
+- `queen.messages` - Individual messages with processing state
+
+---
+
+## 💡 Core Concepts
+
+### Architecture
+
+Queen uses a two-tier architecture:
 
-Queen supports cross-queue message consumption through namespace and task filtering, with full partition locking support:
+```
+Queues (optional namespace/task grouping)
+  └── Partitions (FIFO ordering, parallel processing)
+       └── Messages (lease-based processing)
+```
+
+**Key Principles:**
+- **Configuration at queue level**: All settings (priority, lease time, retries) apply to the entire queue
+- **FIFO within partitions**: Messages in the same partition are always processed in order
+- **Partition locking**: Prevents duplicate processing across consumers
+- **Lease-based processing**: Messages automatically return to pending if not acknowledged
 
-#### Namespace-Based Routing
+### Queues and Partitions
 
-Group related queues under a namespace and consume from all of them:
+**Queues** are top-level organizational units. Each queue automatically gets a "Default" partition, and you can create additional partitions for logical separation or parallel processing.
 
 ```javascript
-// Configure multiple queues with the same namespace
-await client.configure({
-  queue: 'orders-processing',
-  namespace: 'ecommerce',
-  task: 'process',
-  options: { leaseTime: 30 }
-});
+// Messages go to "Default" partition
+await client.push('orders', { orderId: 123 });
 
-await client.configure({
-  queue: 'inventory-updates',
-  namespace: 'ecommerce',
-  task: 'update',
-  options: { leaseTime: 30 }
-});
+// Push to specific partition
+await client.push('orders/high-priority', { orderId: 456 });
 
-// Consume from all queues in the namespace
-const messages = await client.pop({
-  namespace: 'ecommerce'
-}, { batch: 10 });
-// Gets messages from both queues, with partition locking across all
+// Take from specific partition
+for await (const order of client.take('orders/high-priority')) {
+  await processUrgentOrder(order.data);
+  await client.ack(order);
+}
 ```
 
-#### Task-Based Routing
+**Partitions enable:**
+- **Parallel processing**: Different consumers can process different partitions simultaneously
+- **Ordered processing**: FIFO guarantees within each partition
+- **Logical separation**: Different priorities, teams, or workflow stages
+- **Resource isolation**: Lock contention is per-partition
 
-Filter messages by specific tasks across namespaces:
+### Message Lifecycle
 
-```javascript
-// Consume only 'process' tasks from the ecommerce namespace
-const messages = await client.pop({
-  namespace: 'ecommerce',
-  task: 'process'
-}, { batch: 5 });
 ```
+pending → processing → completed/failed → (retry) → dead_letter
+```
+
+1. **Pending**: Message queued, waiting to be processed
+2. **Processing**: Leased to a worker (with timeout)
+3. **Completed**: Successfully processed
+4. **Failed**: Processing failed (may retry based on `retryLimit`)
+5. **Dead Letter**: Exceeded retry limits
 
-#### Partition Locking with Filters
+### Partition Locking
+
+**Partition locking ensures message processing isolation** - when a consumer retrieves messages from a partition, that partition is locked to prevent other consumers from accessing it until:
 
-When using namespace/task filtering:
-- The system locks all partitions from which messages are retrieved
-- Different consumers cannot access the same partitions until locks are released
-- Consumer groups maintain independent locks
+- The consumer acknowledges all messages (releases lock)
+- The lease expires (automatic release)
+- The consumer explicitly releases the partition
+
+**Lock Scope:**
+- **Queue Mode**: Each consumer session is unique - locks prevent any other consumer from accessing the partition
+- **Bus Mode**: Locks are per consumer group - different groups can process the same partition independently
 
 ```javascript
-// Consumer 1: Gets messages and locks partitions A, B, C
-const result1 = await client.pop({ namespace: 'ecommerce' });
+// Example: Partition locking in action
 
-// Consumer 2: Gets messages from different partitions D, E (A, B, C are locked)
-const result2 = await client.pop({ namespace: 'ecommerce' });
+// Consumer 1 takes from partition A (locks it)
+for await (const msg of client.take('orders', { limit: 5 })) {
+  // Processing partition A - no other consumer can access it
+  await client.ack(msg);
+  // Partition A unlocked after all 5 messages acknowledged
+}
 
-// No partition overlap between consumers
+// Consumer 2 gets messages from partition B (A was locked)
+for await (const msg of client.take('orders', { limit: 5 })) {
+  // Processing partition B instead
+  await client.ack(msg);
+}
 ```
 
-### Concurrency Control
+### FIFO Ordering
+
+Queen provides **strong FIFO guarantees within each partition**:
+
+```javascript
+// These messages will be processed in order 1, 2, 3
+await client.push('tasks/user-123', [
+  { step: 1, action: 'create' },
+  { step: 2, action: 'update' },
+  { step: 3, action: 'complete' }
+]);
+
+// Consumer will always receive them in order
+for await (const task of client.take('tasks/user-123')) {
+  console.log(task.data.step);  // Prints: 1, then 2, then 3
+  await client.ack(task);
+}
+```
 
-Queen provides several mechanisms for controlling concurrent message processing:
+**Use cases:**
+- **Per-user operations**: Use user ID as partition for ordered processing
+- **Per-resource operations**: Use resource ID to maintain operation order
+- **Workflow stages**: Use partition to represent different stages
 
-#### 1. Partition-Based Concurrency
+### Consumer Groups (Bus Mode)
 
-Control parallelism by the number of partitions:
+Consumer groups enable **pub-sub messaging** where multiple independent consumers process the same messages:
 
 ```javascript
-// Create multiple partitions for parallel processing
-const partitions = ['worker-1', 'worker-2', 'worker-3', 'worker-4'];
+// Push once
+await client.push('events', { type: 'order.created', orderId: 123 });
+
+// Multiple services consume independently
+// Service 1: Analytics
+for await (const event of client.take('events@analytics')) {
+  await updateAnalytics(event.data);
+  await client.ack(event);
+}
 
-// Distribute messages across partitions
-await client.push({
-  items: messages.map((msg, i) => ({
-    queue: 'tasks',
-    partition: partitions[i % partitions.length],
-    payload: msg
-  }))
-});
+// Service 2: Notification (gets same message)
+for await (const event of client.take('events@notification')) {
+  await sendNotification(event.data);
+  await client.ack(event);
+}
 
-// Each worker processes one partition
-const worker1 = await client.pop({ queue: 'tasks', partition: 'worker-1' });
-const worker2 = await client.pop({ queue: 'tasks', partition: 'worker-2' });
-// Workers process in parallel without interference
+// Service 3: Audit (also gets same message)
+for await (const event of client.take('events@audit')) {
+  await logEvent(event.data);
+  await client.ack(event);
+}
 ```
 
-#### 2. Lease-Based Concurrency
+**Each consumer group maintains:**
+- Independent message status tracking
+- Separate partition leases
+- Individual retry counters
+- Isolated processing state
 
-Automatic concurrency control through lease timeouts:
+### Queue Mode vs Bus Mode
 
+**Queue Mode** (default - competitive consumption):
 ```javascript
-// Configure short leases for quick tasks
-await client.configure({
-  queue: 'quick-tasks',
-  options: { 
-    leaseTime: 30,  // 30 seconds per message
-    retryLimit: 3   // Retry up to 3 times
-  }
-});
+// Without consumer group - messages distributed
+await client.push('tasks', { id: 1 });
+await client.push('tasks', { id: 2 });
 
-// Long-running tasks need longer leases
-await client.configure({
-  queue: 'heavy-processing',
-  options: { 
-    leaseTime: 600,  // 10 minutes per message
-    retryLimit: 1    // Retry only once
-  }
-});
+// Worker 1 gets message 1
+for await (const msg of client.take('tasks')) { }
+
+// Worker 2 gets message 2 (different message)
+for await (const msg of client.take('tasks')) { }
 ```
 
-#### 3. Batch Size Control
+**Bus Mode** (pub-sub with consumer groups):
+```javascript
+// With consumer groups - all groups see all messages
+await client.push('events', { id: 1 });
+
+// Group 1 gets message 1
+for await (const msg of client.take('events@group1')) { }
 
-Limit concurrent processing per consumer:
+// Group 2 also gets message 1 (same message)
+for await (const msg of client.take('events@group2')) { }
+```
 
+**Mixed Mode** (combine both):
 ```javascript
-// Each consumer processes max 5 messages at a time
-const batch = await client.pop({ 
-  queue: 'tasks' 
-}, { 
-  batch: 5  // Limit to 5 concurrent messages
-});
+// Competitive workers process jobs
+for await (const job of client.take('jobs')) {
+  await processJob(job.data);
+  await client.ack(job);
+}
 
-// Process batch
-for (const message of batch.messages) {
-  await processMessage(message);
-  await client.ack(message.transactionId, 'completed');
+// Monitoring sees all jobs (bus mode)
+for await (const job of client.take('jobs@monitoring')) {
+  await monitorJob(job.data);
+  await client.ack(job);
 }
 ```
 
-### Message Visibility and Isolation
-
-#### Queue Mode (Default)
+### Priority Processing
 
-In queue mode, messages are consumed competitively - once a consumer gets a message, no other consumer can see it:
+Configure priority at the **queue level**:
 
 ```javascript
-// Without consumer group - competitive consumption
-const consumer1 = await client.pop({ queue: 'tasks' });
-const consumer2 = await client.pop({ queue: 'tasks' });
-// Each consumer gets different messages
+await client.queue('urgent-orders', { priority: 100 });
+await client.queue('normal-orders', { priority: 50 });
+await client.queue('batch-jobs', { priority: 10 });
+
+// Urgent orders processed first, then normal, then batch
 ```
 
-#### Bus Mode (Consumer Groups)
+### Lease-Based Processing
 
-In bus mode, all consumer groups see all messages:
+Messages are "leased" to workers for a specific duration. If not acknowledged within the lease time, they automatically return to pending status:
 
 ```javascript
-// With consumer groups - broadcast consumption
-const service1 = await client.pop({ 
-  queue: 'events',
-  consumerGroup: 'service-1'
+// Configure lease time
+await client.queue('long-tasks', { 
+  leaseTime: 600  // 10 minutes to process
 });
 
-const service2 = await client.pop({ 
-  queue: 'events',
-  consumerGroup: 'service-2'
-});
-// Both services get the same messages
+// If worker crashes or takes too long:
+// - After 10 minutes, lease expires
+// - Message returns to pending
+// - Another worker can pick it up
 ```
 
-#### Mixed Mode
+### Delayed Processing
 
-You can combine both patterns in the same system:
+Schedule messages for future processing:
 
 ```javascript
-// Competitive workers for processing
-const worker = await client.pop({ queue: 'jobs' });
-
-// Broadcast to monitoring services
-const monitor = await client.pop({ 
-  queue: 'jobs',
-  consumerGroup: 'monitoring'
+await client.queue('scheduled-jobs', {
+  delayedProcessing: 3600  // 1 hour delay
 });
 
-const analytics = await client.pop({ 
-  queue: 'jobs',
-  consumerGroup: 'analytics'
+await client.push('scheduled-jobs', { 
+  reportType: 'daily-sales' 
 });
+// Message won't be available for processing until 1 hour later
 ```
 
-### Best Practices
+### Window Buffering
 
-#### 1. Partition Strategy
+Batch messages within a time window:
 
-- **User-based**: Use user IDs as partitions for per-user ordering
-- **Resource-based**: Use resource IDs for ordered operations on resources
-- **Round-robin**: Use rotating partition names for load distribution
-- **Priority-based**: Use separate partitions for different priority levels
+```javascript
+await client.queue('analytics', {
+  windowBuffer: 60  // Wait 60 seconds to accumulate messages
+});
 
-#### 2. Consumer Group Design
+// Messages held for 60 seconds to allow efficient batching
+```
 
-- **Single Responsibility**: Each consumer group should have one clear purpose
-- **Independent Processing**: Design groups to be independent of each other
-- **Idempotent Operations**: Ensure operations can be safely retried
+### Retry and Dead Letter Queue
 
-#### 3. Lease Management
+```javascript
+await client.queue('payments', {
+  retryLimit: 3,              // Retry up to 3 times
+  dlqAfterMaxRetries: true    // Move to DLQ after max retries
+});
 
-- **Right-size Leases**: Set lease times slightly longer than expected processing time
-- **Handle Timeouts**: Implement proper timeout handling and retries
-- **Release Early**: Acknowledge messages as soon as processing completes
+// Failed messages automatically retry
+await client.ack(message, false);  // Will retry if retries < 3
 
-#### 4. Error Handling
+// After 3 failures, message moves to dead_letter status
+```
 
-```javascript
-try {
-  const messages = await client.pop({ queue: 'tasks' });
-  
-  for (const message of messages.messages) {
-    try {
-      await processMessage(message);
-      await client.ack(message.transactionId, 'completed');
-    } catch (error) {
-      // Log error but don't ack - message will retry
-      console.error('Processing failed:', error);
-      await client.ack(message.transactionId, 'failed', error.message);
-    }
-  }
-} catch (error) {
-  console.error('Pop failed:', error);
+### Enterprise Features
+
+#### 1. Encryption (AES-256-GCM)
+
+```bash
+# Generate encryption key
+export QUEEN_ENCRYPTION_KEY=$(openssl rand -hex 32)
+```
+
+```javascript
+await client.queue('sensitive-data', {
+  encryptionEnabled: true
+});
+
+// Messages encrypted at rest in database
+await client.push('sensitive-data', { ssn: '123-45-6789' });
+```
+
+#### 2. Message Retention
+
+```javascript
+await client.queue('temp-queue', {
+  retentionSeconds: 3600,           // Delete pending after 1 hour
+  completedRetentionSeconds: 300,   // Delete completed after 5 minutes
+  retentionEnabled: true
+});
+```
+
+#### 3. Message Eviction (SLA Enforcement)
+
+```javascript
+await client.queue('time-sensitive', {
+  maxWaitTimeSeconds: 60  // Evict messages older than 1 minute
+});
+```
+
+### Best Practices
+
+**1. Partition Strategy**
+- Use user IDs for per-user ordering
+- Use resource IDs for per-resource ordering
+- Use round-robin for load distribution
+- Keep partition counts manageable (10-100s, not 1000s)
+
+**2. Lease Management**
+- Set lease time slightly longer than expected processing time
+- Handle timeouts gracefully
+- Acknowledge messages as soon as processing completes
+
+**3. Consumer Group Design**
+- One clear purpose per consumer group
+- Design groups to be independent
+- Ensure operations are idempotent
+
+**4. Error Handling**
+- Always wrap processing in try-catch
+- Provide meaningful error messages in ack
+- Use retry limits appropriately
+- Monitor dead letter queue
+
+---
+
+## 🚀 Cursor-Based Consumption Strategy
+
+Queen uses a **cursor-based consumption model** for optimal performance at scale, providing O(batch_size) constant-time operations regardless of queue depth.
+
+### How It Works
+
+Traditional message queues scan through all messages to find pending ones, leading to performance degradation as messages accumulate. Queen's cursor-based approach maintains a position marker (cursor) for each consumer, allowing direct access to the next batch of messages.
+
+**Partition Cursors:**
+
+Each partition maintains a cursor position per consumer group:
+- `last_consumed_created_at`: Timestamp of last consumed message
+- `last_consumed_id`: UUID of last consumed message (tie-breaker for same timestamp)
+- `total_messages_consumed`: Running count of consumed messages
+
+The cursor always moves **forward** in time, ensuring strict FIFO ordering.
+
+### The takeBatch Method
+
+Queen provides two consumption methods:
+
+**1. `take()` - Individual message iterator:**
+```javascript
+// Processes messages one at a time
+for await (const message of client.take('orders', { batch: 1000 })) {
+  await processOrder(message.data);
+  await client.ack(message);
 }
 ```
 
-## 🔌 API Reference
+**2. `takeBatch()` - Array iterator (HIGH PERFORMANCE):**
+```javascript
+// Yields arrays of messages - achieves 100k+ msg/s throughput
+for await (const messages of client.takeBatch('orders', { batch: 1000 })) {
+  // messages is an array of up to 1000 message objects
+  await processBatch(messages.map(m => m.data));
+  
+  // Batch acknowledge - single DB transaction for all messages
+  await client.ack(messages);
+}
+```
+
+**Under the hood**, both methods use cursor-based batch retrieval:
+
+```sql
+-- Cursor-based query (simplified)
+SELECT * FROM messages 
+WHERE partition_id = $1 
+  AND id > $2::uuid  -- Start after last cursor position
+ORDER BY created_at ASC, id ASC
+LIMIT $3  -- Batch size
+FOR UPDATE SKIP LOCKED
+```
+
+**Key characteristics:**
+1. **Constant-time**: Performance stays consistent whether you've consumed 0% or 99% of messages
+2. **FIFO guarantee**: Messages always returned in creation order
+3. **Lock-free scanning**: `SKIP LOCKED` prevents contention between consumers
+4. **Efficient**: No table scans - direct cursor-based access using UUIDv7 (time-ordered)
+
+**Performance tip:** Use `takeBatch()` with large batch sizes (1,000-10,000) for maximum throughput. The server fetches messages in batches regardless, but `takeBatch()` gives you the array directly, allowing bulk processing and batch acknowledgment in a single operation.
+
+### Batch Acknowledgment Semantics
+
+Queen handles batch acknowledgments intelligently:
+
+**Partial Success** (some messages succeed, some fail):
+```javascript
+// Batch: 10,000 messages
+// Success: 9,999 messages
+// Failed: 1 message
+
+// Behavior:
+// ✅ Cursor advances past all 10,000 messages
+// ✅ Failed message moved to Dead Letter Queue
+// ✅ Next take() starts from message 10,001
+// ✅ FIFO maintained, no redelivery of successful messages
+```
+
+**Total Batch Failure** (all messages fail):
+```javascript
+// Batch: 10,000 messages
+// Success: 0 messages
+// Failed: 10,000 messages
+
+// Behavior:
+// ❌ Cursor DOES NOT advance
+// ❌ Messages NOT moved to DLQ
+// ✅ Lease released
+// ✅ Next take() gets SAME batch (retry)
+// ✅ Allows recovery from transient failures
+```
+
+This design handles transient failures (network issues, service outages) gracefully while preventing poison messages from blocking the queue.
+
+### Performance Comparison
 
-### Base URL
+| Operation | Traditional Approach | Cursor Approach | Improvement |
+|-----------|---------------------|-----------------|-------------|
+| Pop @ 0% consumed | O(partition_size) | O(batch_size) | Same |
+| Pop @ 50% consumed | O(partition_size) | O(batch_size) | **10-100x faster** |
+| Pop @ 99% consumed | O(partition_size) | O(batch_size) | **100-1000x faster** |
+
+**Real-world benchmark** (1M messages):
+```
+Traditional:
+  Early batches: 300ms per pop
+  Late batches:  3500ms per pop (10x degradation)
+  
+Cursor-based:
+  Early batches: 150ms per pop
+  Late batches:  200ms per pop (constant!)
 ```
-http://localhost:6632/api/v1
+
+### Dead Letter Queue
+
+Individual message failures are moved to the Dead Letter Queue for inspection and manual intervention:
+
+```javascript
+// Monitor DLQ
+const response = await fetch('http://localhost:6632/api/v1/analytics/dlq');
+const dlqMessages = await response.json();
+
+// Inspect failed messages
+for (const msg of dlqMessages) {
+  console.log(`Failed: ${msg.error_message}`);
+  
+  // After fixing issue, can re-push if needed
+  await client.push(msg.queue, fixedPayload);
+}
+```
+
+**DLQ Query:**
+```sql
+SELECT * FROM queen.dead_letter_queue
+WHERE consumer_group = 'my-group'
+ORDER BY failed_at DESC
+LIMIT 100;
+```
+
+### Batch Size Guidelines
+
+Choose batch sizes based on your workload:
+
+**Smaller batches (100-1,000):**
+- ✅ Faster individual batch processing
+- ✅ Less impact if entire batch fails
+- ✅ Lower memory footprint
+- ❌ More network round-trips
+
+**Larger batches (5,000-10,000):**
+- ✅ Higher throughput (100,000+ msg/sec achievable)
+- ✅ Fewer network round-trips
+- ✅ Better database efficiency
+- ❌ More messages retry if entire batch fails
+- ❌ Higher memory usage
+
+**Recommendation:** Start with 1,000-2,000 for balanced performance. Increase to 5,000-10,000 for maximum throughput with reliable processing.
+
+### Monitoring Cursor Progress
+
+Track consumption progress via SQL:
+
+```sql
+-- View cursor positions
+SELECT 
+  p.name as partition,
+  pc.consumer_group,
+  pc.total_messages_consumed,
+  pc.total_batches_consumed,
+  pc.last_consumed_at,
+  EXTRACT(EPOCH FROM (NOW() - pc.last_consumed_at)) as seconds_since_last_consume
+FROM queen.partition_cursors pc
+JOIN queen.partitions p ON p.id = pc.partition_id
+ORDER BY pc.last_consumed_at DESC;
+
+-- Monitor DLQ
+SELECT COUNT(*) as failed_count, consumer_group
+FROM queen.dead_letter_queue
+GROUP BY consumer_group;
 ```
 
+---
+
+## 🔌 HTTP API Reference
+
+Base URL: `http://localhost:6632/api/v1`
+
 ### Push Messages
 
 **Endpoint:** `POST /api/v1/push`
 
-```javascript
+**Request:**
+```json
 {
   "items": [
     {
-      "queue": "email-queue",           // Required
-      "partition": "urgent",            // Optional (defaults to "Default")
-      "payload": {                      // Required: message data
-        "to": "user@example.com",
-        "subject": "Hello"
-      },
-      "transactionId": "uuid-here"      // Optional: for idempotency
+      "queue": "orders",
+      "partition": "urgent",
+      "payload": { "orderId": 123, "amount": 99.99 },
+      "transactionId": "optional-idempotency-key",
+      "traceId": "550e8400-e29b-41d4-a716-446655440000"
     }
   ]
 }
 ```
 
 **Response:**
-```javascript
+```json
 {
   "messages": [
     {
@@ -610,35 +1138,40 @@ http://localhost:6632/api/v1
 
 ### Pop Messages
 
-**From Specific Partition:**
+**From specific partition:**
 ```
 GET /api/v1/pop/queue/{queue}/partition/{partition}?wait=true&timeout=30000&batch=10
 ```
 
-**From Any Partition in Queue:**
+**From any partition in queue:**
 ```
 GET /api/v1/pop/queue/{queue}?wait=true&timeout=30000&batch=10
 ```
 
-**With Namespace/Task Filter:**
+**With namespace/task filter:**
 ```
-GET /api/v1/pop?namespace=my-app&task=emails&wait=true&timeout=30000&batch=10
+GET /api/v1/pop?namespace=ecommerce&task=checkout&wait=true&timeout=30000&batch=10
+```
+
+**With consumer group (bus mode):**
+```
+GET /api/v1/pop/queue/{queue}?consumerGroup=analytics&subscriptionMode=all&wait=true&timeout=30000
 ```
 
 **Response:**
-```javascript
+```json
 {
   "messages": [
     {
       "id": "018e63b7-6165-453f-88ae-56effa177605",
       "transactionId": "4dfb0478-655b-4c91-bcd9-b7acacf0400f",
-      "queue": "email-queue",
+      "queue": "orders",
       "partition": "urgent",
-      "data": { "to": "user@example.com", "subject": "Hello" },
+      "data": { "orderId": 123, "amount": 99.99 },
       "retryCount": 0,
       "priority": 10,
-      "createdAt": "2023-10-08T12:00:00.000Z",
-      "options": { "leaseTime": 300 }
+      "createdAt": "2024-10-08T12:00:00.000Z",
+      "options": { "leaseTime": 300, "retryLimit": 3 }
     }
   ]
 }
@@ -646,850 +1179,971 @@ GET /api/v1/pop?namespace=my-app&task=emails&wait=true&timeout=30000&batch=10
 
 ### Acknowledge Messages
 
-**Single Acknowledgment:**
-```javascript
+**Single:**
+```json
 POST /api/v1/ack
 {
-  "transactionId": "uuid",
-  "status": "completed",        // "completed" or "failed"
-  "error": "optional error"     // Required if status is "failed"
+  "transactionId": "4dfb0478-655b-4c91-bcd9-b7acacf0400f",
+  "status": "completed",
+  "consumerGroup": "analytics",
+  "error": null
 }
 ```
 
-**Batch Acknowledgment:**
-```javascript
+**Batch:**
+```json
 POST /api/v1/ack/batch
 {
   "acknowledgments": [
-    { "transactionId": "uuid1", "status": "completed" },
-    { "transactionId": "uuid2", "status": "failed", "error": "Processing error" }
+    { "transactionId": "uuid-1", "status": "completed" },
+    { "transactionId": "uuid-2", "status": "failed", "error": "Processing error" }
   ]
 }
 ```
 
-### Queue Configuration
+### Configure Queue
 
-```javascript
+```json
 POST /api/v1/configure
 {
-  "queue": "email-queue",
-  "partition": "urgent",        // Optional (defaults to "Default")
+  "queue": "orders",
+  "namespace": "ecommerce",
+  "task": "checkout",
   "options": {
-    "leaseTime": 600,           // Seconds before lease expires
-    "retryLimit": 5,            // Max retry attempts
-    "priority": 10,             // Partition priority (higher = first)
-    "delayedProcessing": 60,    // Delay before message becomes available
-    "windowBuffer": 30          // Buffer messages for batch processing
+    "leaseTime": 600,
+    "retryLimit": 5,
+    "priority": 10,
+    "maxSize": 10000,
+    "ttl": 3600,
+    "dlqAfterMaxRetries": true,
+    "delayedProcessing": 0,
+    "windowBuffer": 0,
+    "retentionSeconds": 0,
+    "completedRetentionSeconds": 0,
+    "retentionEnabled": false,
+    "encryptionEnabled": false,
+    "maxWaitTimeSeconds": 0
   }
 }
 ```
 
 ### Analytics
 
-```javascript
-// Get all queues overview
-GET /api/v1/analytics/queues
+**Queue statistics:**
+```
+GET /api/v1/analytics/queue/{queue}
+```
 
-// Get queue statistics
-GET /api/v1/analytics/queue/{queueName}
+**All queues overview:**
+```
+GET /api/v1/analytics/queues
+```
 
-// Get namespace statistics
-GET /api/v1/analytics?namespace={namespace}
+**Queue depths:**
+```
+GET /api/v1/analytics/queue-depths
+```
 
-// Get throughput metrics
+**Throughput metrics:**
+```
 GET /api/v1/analytics/throughput
+```
 
-// Get queue depths
-GET /api/v1/analytics/queue-depths
+**Queue lag analysis:**
+```
+GET /api/v1/analytics/queue-lag?queue=orders
 ```
 
-## 📱 Client SDK
+### Message Management
 
-### Installation
+**List messages:**
+```
+GET /api/v1/messages?queue=orders&status=pending&limit=100
+```
 
-```javascript
-import { createQueenClient } from './src/client/queenClient.js';
+**Get single message:**
+```
+GET /api/v1/messages/{transactionId}
+```
 
-const client = createQueenClient({
-  baseUrl: 'http://localhost:6632',
-  timeout: 30000,
-  retryAttempts: 3,
-  retryDelay: 1000
-});
+**Delete message:**
+```
+DELETE /api/v1/messages/{transactionId}
+```
+
+**Retry failed message:**
+```
+POST /api/v1/messages/{transactionId}/retry
+```
+
+**Move to dead letter queue:**
+```
+POST /api/v1/messages/{transactionId}/dlq
+```
+
+**Clear queue:**
+```
+DELETE /api/v1/queues/{queue}/clear
+```
+
+**Delete queue:**
+```
+DELETE /api/v1/resources/queues/{queue}
+```
+_Note: Deletes the queue and all its partitions, messages, and related data._
+
+### System Health
+
+**Health check:**
+```
+GET /health
+```
+
+**Detailed metrics:**
+```
+GET /metrics
 ```
 
-### Basic Operations
+### WebSocket (Real-time Updates)
 
+**Connect:**
 ```javascript
-// Configure a queue
-await client.configure({
-  queue: 'orders',
-  options: {
-    priority: 10,
-    leaseTime: 600,
-    retryLimit: 3
-  }
-});
+const ws = new WebSocket('ws://localhost:6632/ws/dashboard');
 
-// Push single message
-await client.push({
-  items: [{
-    queue: 'orders',
-    partition: 'high-priority',
-    payload: { orderId: 123, amount: 99.99 }
-  }]
-});
+ws.onmessage = (event) => {
+  const { event: eventType, data } = JSON.parse(event.data);
+  // Handle events: message.pushed, message.completed, queue.depth, etc.
+};
+```
 
-// Push batch of messages
-await client.push({
-  items: [
-    { queue: 'orders', payload: { orderId: 124 } },
-    { queue: 'orders', payload: { orderId: 125 } },
-    { queue: 'orders', payload: { orderId: 126 } }
-  ]
-});
+**Events:**
+- `message.pushed` - New message added
+- `message.processing` - Message being processed
+- `message.completed` - Message completed
+- `message.failed` - Message failed
+- `queue.created` - New queue created
+- `queue.depth` - Queue depth update (every 5s)
+- `system.stats` - System statistics (every 10s)
 
-// Pop messages with long polling
-const result = await client.pop({
-  queue: 'orders',
-  wait: true,
-  timeout: 30000,
-  batch: 10
-});
+See [API.md](API.md) for complete API documentation.
 
-// Process messages
-for (const message of result.messages) {
-  try {
-    await processOrder(message.data);
-    await client.ack(message.transactionId, 'completed');
-  } catch (error) {
-    await client.ack(message.transactionId, 'failed', error.message);
-  }
-}
+---
+
+## 📊 Dashboard
+
+Queen includes a comprehensive web dashboard for monitoring and management.
+
+[Dashboard](/assets/dashboard-01.png)
+
+### Access
+
+1. Start the server: `npm start`
+2. Open browser: `http://localhost:4000`
+3. WebSocket connection provides real-time updates
+
+### Features
+
+**System Overview**
+- Real-time metrics: total messages, processing rate, system health
+- Queue summary with pending/processing/completed counts
+- Performance indicators: throughput, latency, error rates
+
+**Queue Management**
+- Queue list with status and message counts
+- Partition view with priority indicators
+- Message browser with search and filter
+- Retry and DLQ management
+
+**Real-time Monitoring**
+- Live updates via WebSocket
+- Throughput charts (messages per second over time)
+- Queue depth graphs with trend analysis
+- Lag monitoring (processing time and backlog)
+
+**Analytics Dashboard**
+- Performance metrics per queue
+- Historical trends and patterns
+- System health monitoring
+- Database connections and memory usage
+
+**Message Browser**
+- Search by queue, partition, status, time range
+- View full payload and metadata
+- Manually retry failed messages
+- Dead letter queue management
+
+### Dashboard Development
+
+The dashboard is built with Vue.js and located in the `dashboard/` directory:
+
+```bash
+cd dashboard
+npm install
+npm run dev    # Development mode
+npm run build  # Production build
 ```
 
-### Consumer Pattern
+---
 
-The SDK provides a convenient consumer helper for continuous message processing with two modes:
+## ⚙️ Configuration
 
-#### Individual Message Processing
+All configuration uses environment variables with sensible defaults. Configuration is centralized in `src/config.js`.
 
-Process messages one by one (default behavior):
+### Server Configuration
 
-```javascript
-const stopConsumer = client.consume({
-  queue: 'orders',
-  partition: 'high-priority',
-  handler: async (message) => {
-    console.log('Processing order:', message.data.orderId);
-    await processOrder(message.data);
-    // Message is automatically acknowledged on success
-  },
-  options: {
-    batch: 5,
-    wait: true,
-    timeout: 30000,
-    stopOnError: false
-  }
-});
+```bash
+PORT=6632                      # Server port (default: 6632)
+HOST=0.0.0.0                   # Server host (default: 0.0.0.0)
+WORKER_ID=worker-1             # Worker identifier
+APP_NAME=queen-mq              # Application name
 
-// Stop the consumer when needed
-// stopConsumer();
+# CORS
+CORS_MAX_AGE=86400
+CORS_ALLOWED_ORIGINS=*
+CORS_ALLOWED_METHODS=GET,POST,PUT,DELETE,OPTIONS
+CORS_ALLOWED_HEADERS=Content-Type,Authorization
 ```
 
-#### Batch Message Processing
+### Database Configuration
 
-Process entire batches of messages at once for better performance:
+```bash
+# Connection
+PG_USER=postgres
+PG_HOST=localhost
+PG_DB=postgres
+PG_PASSWORD=postgres
+PG_PORT=5432
 
-```javascript
-const stopConsumer = client.consume({
-  queue: 'orders',
-  partition: 'high-priority',
-  handlerBatch: async (messages) => {
-    console.log(`Processing batch of ${messages.length} orders`);
-    
-    // Process all messages in parallel
-    await Promise.all(messages.map(async (message) => {
-      console.log('Processing order:', message.data.orderId);
-      await processOrder(message.data);
-    }));
-    
-    // Or process sequentially if needed
-    // for (const message of messages) {
-    //   await processOrder(message.data);
-    // }
-    
-    // All messages are automatically batch-acknowledged on success
-  },
-  options: {
-    batch: 10,  // Larger batches for better throughput
-    wait: true,
-    timeout: 30000,
-    stopOnError: false
-  }
-});
+# Connection pool
+DB_POOL_SIZE=20                # Max connections
+DB_IDLE_TIMEOUT=30000          # Idle timeout (ms)
+DB_CONNECTION_TIMEOUT=2000     # Connection timeout (ms)
+DB_STATEMENT_TIMEOUT=30000     # Statement timeout (ms)
+DB_QUERY_TIMEOUT=30000         # Query timeout (ms)
+DB_MAX_RETRIES=3               # Max retry attempts
 ```
 
-**Key Benefits of Batch Processing:**
-- **Higher Throughput**: Process multiple messages simultaneously
-- **Efficient Acknowledgments**: Single batch ACK instead of individual ACKs
-- **Atomic Processing**: Either the entire batch succeeds or fails together
-- **Reduced Network Overhead**: Fewer round trips to the server
+### Queue Processing
 
-**Important Notes:**
-- Use either `handler` OR `handlerBatch`, not both
-- In batch mode, if processing fails, all messages in the batch are marked as failed
-- Batch size is controlled by the `batch` option (default: 1)
+```bash
+# Pop defaults
+DEFAULT_TIMEOUT=30000          # Default pop timeout (ms)
+MAX_TIMEOUT=60000              # Maximum pop timeout (ms)
+DEFAULT_BATCH_SIZE=1           # Default batch size
+BATCH_INSERT_SIZE=1000         # Batch size for bulk inserts
 
-### Advanced Features
+# Long polling
+QUEUE_POLL_INTERVAL=100        # Poll interval (ms)
+QUEUE_POLL_INTERVAL_FILTERED=1000  # Poll interval for filtered pops (ms)
 
-```javascript
-// Pop with namespace filter (cross-queue priority)
-const result = await client.pop({
-  namespace: 'ecommerce',
-  batch: 10,
-  wait: true
-});
+# Queue defaults
+DEFAULT_LEASE_TIME=300         # Lease time (seconds)
+DEFAULT_RETRY_LIMIT=3          # Retry limit
+DEFAULT_RETRY_DELAY=1000       # Retry delay (ms)
+DEFAULT_MAX_SIZE=10000         # Max queue size
+DEFAULT_TTL=3600               # TTL (seconds)
+DEFAULT_PRIORITY=0             # Priority
+DEFAULT_DELAYED_PROCESSING=0   # Delayed processing (seconds)
+DEFAULT_WINDOW_BUFFER=0        # Window buffer (seconds)
+```
 
-// Batch acknowledgment
-await client.ackBatch([
-  { transactionId: 'uuid1', status: 'completed' },
-  { transactionId: 'uuid2', status: 'failed', error: 'Invalid data' }
-]);
+### Background Jobs
 
-// Message management
-const messages = await client.messages.list({
-  queue: 'orders',
-  status: 'failed',
-  limit: 100
-});
+```bash
+LEASE_RECLAIM_INTERVAL=5000    # Lease reclamation (ms)
+RETENTION_INTERVAL=300000      # Retention checks (ms)
+RETENTION_BATCH_SIZE=1000      # Retention batch size
+PARTITION_CLEANUP_DAYS=7       # Days before cleaning empty partitions
+EVICTION_INTERVAL=60000        # Eviction checks (ms)
+EVICTION_BATCH_SIZE=1000       # Eviction batch size
+```
 
-await client.messages.retry('transaction-id');
-await client.messages.moveToDLQ('transaction-id');
+### WebSocket
+
+```bash
+WS_COMPRESSION=0               # Compression level
+WS_MAX_PAYLOAD_LENGTH=16384    # Max payload (bytes)
+WS_IDLE_TIMEOUT=60             # Idle timeout (seconds)
+WS_MAX_CONNECTIONS=1000        # Max connections
+WS_HEARTBEAT_INTERVAL=30000    # Heartbeat (ms)
 ```
 
-## 📊 Dashboard
+### Encryption
 
-The Queen system includes a comprehensive web dashboard for monitoring and management.
-
-### Accessing the Dashboard
-
-1. **Start the server**: `npm start`
-2. **Open dashboard**: Navigate to `http://localhost:6632` in your browser
-3. **WebSocket connection**: The dashboard connects via WebSocket for real-time updates
-
-### Dashboard Features
-
-#### 1. **System Overview**
-- **Real-time Metrics**: Total messages, processing rate, system health
-- **Queue Summary**: Active queues, pending messages, processing status
-- **Performance Indicators**: Throughput, latency, error rates
-
-#### 2. **Queue Management**
-- **Queue List**: All queues with current status and message counts
-- **Partition View**: Partitions within each queue with priority indicators
-- **Message Counts**: Pending, processing, completed, failed, and dead letter counts
-- **Priority Visualization**: Color-coded priority levels
-
-#### 3. **Real-time Monitoring**
-- **Live Updates**: WebSocket-powered real-time data updates
-- **Throughput Charts**: Messages per second over time
-- **Queue Depth Graphs**: Pending message counts with trend analysis
-- **Lag Monitoring**: Processing time and queue lag metrics
-
-#### 4. **Message Browser**
-- **Message Search**: Filter by queue, partition, status, or time range
-- **Message Details**: Full payload, metadata, and processing history
-- **Retry Management**: Manually retry failed messages
-- **Dead Letter Queue**: View and manage messages that exceeded retry limits
-
-#### 5. **Analytics Dashboard**
-- **Performance Metrics**: Detailed throughput and latency statistics
-- **Queue Analytics**: Per-queue performance and usage patterns
-- **Historical Data**: Trends and patterns over time
-- **System Health**: Database connections, memory usage, error rates
-
-#### 6. **Configuration Management**
-- **Queue Configuration**: View and modify queue settings
-- **Partition Settings**: Priority, lease time, retry limits
-- **System Settings**: Global configuration options
-
-### Dashboard Components
-
-The dashboard is built with Vue.js and includes:
-
-```
-dashboard/
-├── src/
-│   ├── components/
-│   │   ├── charts/           # Chart components
-│   │   │   ├── QueueDepthChart.vue
-│   │   │   ├── QueueLagChart.vue
-│   │   │   └── ThroughputChart.vue
-│   │   ├── cards/            # Metric cards
-│   │   │   └── MetricCard.vue
-│   │   ├── common/           # Shared components
-│   │   │   └── ActivityFeed.vue
-│   │   └── layout/           # Layout components
-│   │       ├── AppHeader.vue
-│   │       ├── AppLayout.vue
-│   │       └── AppSidebar.vue
-│   ├── views/                # Main pages
-│   │   ├── Dashboard.vue     # System overview
-│   │   ├── Queues.vue        # Queue management
-│   │   ├── QueueDetail.vue   # Individual queue details
-│   │   ├── Messages.vue      # Message browser
-│   │   └── Analytics.vue     # Analytics dashboard
-│   └── services/
-│       ├── api.js            # API client
-│       └── websocket.js      # WebSocket connection
-```
-
-### WebSocket API
-
-The dashboard connects via WebSocket for real-time updates:
+```bash
+# Generate key: openssl rand -hex 32
+QUEEN_ENCRYPTION_KEY=<64-hex-chars>  # AES-256-GCM encryption key
+```
 
-```javascript
-// Connect to dashboard WebSocket
-const ws = new WebSocket('ws://localhost:6632/ws/dashboard');
+### Client SDK
 
-// Receive real-time updates
-ws.onmessage = (event) => {
-  const { event: eventType, data } = JSON.parse(event.data);
+```bash
+QUEEN_BASE_URL=http://localhost:6632
+CLIENT_RETRY_ATTEMPTS=3
+CLIENT_RETRY_DELAY=1000
+CLIENT_RETRY_BACKOFF=2
+CLIENT_POOL_SIZE=10
+CLIENT_REQUEST_TIMEOUT=30000
+```
+
+### Queue Options
+
+```javascript
+{
+  // Processing
+  leaseTime: 300,              // Seconds before lease expires
+  retryLimit: 3,               // Max retry attempts
+  priority: 0,                 // Queue priority (higher = first)
+  delayedProcessing: 0,        // Delay in seconds
+  windowBuffer: 0,             // Buffer time for batching
+  dlqAfterMaxRetries: true,    // Move to DLQ after max retries
   
-  switch (eventType) {
-    case 'queue.depth.updated':
-      updateQueueDepth(data);
-      break;
-    case 'message.processed':
-      updateThroughput(data);
-      break;
-    case 'system.stats':
-      updateSystemStats(data);
-      break;
-  }
-};
+  // Encryption (Queue-level)
+  encryptionEnabled: false,    // Enable AES-256-GCM encryption
+  
+  // Retention (Partition-level)
+  retentionSeconds: 0,                // Delete pending messages after X seconds
+  completedRetentionSeconds: 0,       // Delete completed/failed after X seconds
+  partitionRetentionSeconds: 0,       // Delete empty partitions after X seconds
+  retentionEnabled: false,            // Enable retention
+  
+  // Eviction (Queue-level)
+  maxWaitTimeSeconds: 0        // Evict messages older than X seconds
+}
 ```
 
-## 📚 Examples
+---
+
+## 📚 Full Examples
 
-### Basic Email Queue
+### Example 1: Email Queue with Priority
 
 ```javascript
-// Configure email queue with priority
-await client.configure({
-  queue: 'emails-urgent',
-  options: { priority: 10, leaseTime: 300 }
-});
+import { Queen } from 'queen-mq';
 
-await client.configure({
-  queue: 'emails-normal',
-  options: { priority: 5, leaseTime: 300 }
+const client = new Queen({
+  baseUrls: ['http://localhost:6632']
 });
 
-// Send urgent email
-await client.push({
-  items: [{
-    queue: 'emails',
-    partition: 'urgent',
-    payload: {
-      to: 'admin@company.com',
-      subject: 'System Alert',
-      body: 'Critical system issue detected'
-    }
-  }]
+// Configure queues with different priorities
+await client.queue('emails-urgent', { 
+  priority: 10, 
+  leaseTime: 300,
+  retryLimit: 5
 });
 
-// Process emails (urgent emails processed first)
-const result = await client.pop({
-  queue: 'emails',
-  batch: 10,
-  wait: true
+await client.queue('emails-normal', { 
+  priority: 5, 
+  leaseTime: 300,
+  retryLimit: 3
 });
+
+// Producer: Send emails
+async function sendEmails() {
+  // Urgent email
+  await client.push('emails-urgent', {
+    to: 'admin@company.com',
+    subject: 'Critical Alert',
+    body: 'System issue detected',
+    timestamp: Date.now()
+  });
+
+  // Normal email
+  await client.push('emails-normal', {
+    to: 'user@example.com',
+    subject: 'Welcome',
+    body: 'Thanks for signing up',
+    timestamp: Date.now()
+  });
+}
+
+// Consumer: Process emails
+async function processEmails() {
+  // Urgent emails processed first (higher priority)
+  for await (const email of client.take('emails-urgent', { 
+    wait: true,
+    timeout: 30000
+  })) {
+    try {
+      console.log('Sending urgent email:', email.data.to);
+      await sendEmail(email.data);
+      await client.ack(email);
+    } catch (error) {
+      console.error('Failed to send email:', error);
+      await client.ack(email, false, { error: error.message });
+    }
+  }
+}
+
+// Send batch of emails
+await sendEmails();
+
+// Start processing
+processEmails().catch(console.error);
 ```
 
-### Delayed Job Processing
+### Example 2: Task Pipeline
 
 ```javascript
-// Configure queue with delayed processing
-await client.configure({
-  queue: 'scheduled-jobs',
-  options: {
-    delayedProcessing: 3600, // 1 hour delay
-    priority: 5
-  }
+import { Queen } from 'queen-mq';
+
+const client = new Queen({
+  baseUrls: ['http://localhost:6632']
 });
 
-// Schedule a job for later processing
-await client.push({
-  items: [{
-    queue: 'scheduled-jobs',
-    partition: 'daily-reports',
-    payload: {
-      reportType: 'daily-sales',
-      date: '2023-10-08',
-      recipients: ['manager@company.com']
+// Configure pipeline stages
+await client.queue('stage-1-validate', { priority: 10 });
+await client.queue('stage-2-process', { priority: 9 });
+await client.queue('stage-3-finalize', { priority: 8 });
+
+// Stage 1: Validate
+async function validateStage() {
+  for await (const msg of client.take('stage-1-validate', { wait: true })) {
+    try {
+      const validated = await validate(msg.data);
+      await client.ack(msg);
+      
+      // Pass to next stage
+      await client.push('stage-2-process', validated);
+    } catch (error) {
+      await client.ack(msg, false, { error: error.message });
     }
-  }]
-});
+  }
+}
 
-// Job will not be available for processing until 1 hour later
+// Stage 2: Process
+async function processStage() {
+  for await (const msg of client.take('stage-2-process', { wait: true })) {
+    try {
+      const processed = await process(msg.data);
+      await client.ack(msg);
+      
+      // Pass to next stage
+      await client.push('stage-3-finalize', processed);
+    } catch (error) {
+      await client.ack(msg, false, { error: error.message });
+    }
+  }
+}
+
+// Stage 3: Finalize
+async function finalizeStage() {
+  for await (const msg of client.take('stage-3-finalize', { wait: true })) {
+    try {
+      await finalize(msg.data);
+      await client.ack(msg);
+      console.log('Pipeline complete:', msg.data.id);
+    } catch (error) {
+      await client.ack(msg, false, { error: error.message });
+    }
+  }
+}
+
+// Start pipeline
+Promise.all([
+  validateStage(),
+  processStage(),
+  finalizeStage()
+]);
+
+// Add work to pipeline
+await client.push('stage-1-validate', { id: 1, data: 'raw data' });
 ```
 
-### Batch Processing with Window Buffer
+### Example 3: Event Streaming (Bus Mode)
 
 ```javascript
-// Configure for batch processing
-await client.configure({
-  queue: 'analytics',
-  options: {
-    windowBuffer: 60,  // Wait 60 seconds to batch messages
-    priority: 3
-  }
+import { Queen } from 'queen-mq';
+
+const client = new Queen({
+  baseUrls: ['http://localhost:6632']
 });
 
-// Send multiple events
-for (let i = 0; i < 100; i++) {
-  await client.push({
-    items: [{
-      queue: 'analytics',
-      partition: 'events',
-      payload: { userId: i, action: 'page_view', timestamp: Date.now() }
-    }]
+// Configure event queue
+await client.queue('events', { 
+  priority: 10,
+  leaseTime: 60
+});
+
+// Producer: Emit events
+async function emitEvents() {
+  await client.push('events', {
+    type: 'order.created',
+    orderId: 12345,
+    userId: 789,
+    amount: 99.99,
+    timestamp: Date.now()
   });
 }
 
-// Messages will be held for 60 seconds to allow batching
-// Then all messages become available at once for efficient processing
-```
+// Consumer 1: Analytics Service
+async function analyticsService() {
+  for await (const event of client.take('events@analytics', {
+    subscriptionMode: 'all',  // Replay all messages
+    wait: true
+  })) {
+    console.log('[Analytics] Processing event:', event.data.type);
+    await updateAnalytics(event.data);
+    await client.ack(event, true, { group: 'analytics' });
+  }
+}
 
-### Multi-Queue Processing with Priorities
+// Consumer 2: Notification Service
+async function notificationService() {
+  for await (const event of client.take('events@notifications', {
+    subscriptionMode: 'new',  // Only new messages
+    wait: true
+  })) {
+    console.log('[Notifications] Processing event:', event.data.type);
+    await sendNotification(event.data);
+    await client.ack(event, true, { group: 'notifications' });
+  }
+}
 
-```javascript
-// Set up multiple queues with different priorities
-const queues = [
-  { name: 'critical-alerts', priority: 100 },
-  { name: 'user-notifications', priority: 50 },
-  { name: 'background-tasks', priority: 10 }
-];
-
-for (const queue of queues) {
-  await client.configure({
-    queue: queue.name,
-    options: { priority: queue.priority }
-  });
+// Consumer 3: Audit Service
+async function auditService() {
+  for await (const event of client.take('events@audit', {
+    subscriptionMode: 'all',  // Log everything
+    wait: true
+  })) {
+    console.log('[Audit] Logging event:', event.data.type);
+    await logToAudit(event.data);
+    await client.ack(event, true, { group: 'audit' });
+  }
 }
 
-// Consumer that processes all queues by priority
-const stopConsumer = client.consume({
-  namespace: 'my-app', // Process all queues in namespace by priority
-  handler: async (message) => {
-    console.log(`Processing ${message.queue}: ${message.data.type}`);
-    await processMessage(message);
-  },
-  options: { batch: 5, wait: true }
-});
+// Start all services (they all see the same events)
+Promise.all([
+  analyticsService(),
+  notificationService(),
+  auditService()
+]);
+
+// Emit events
+await emitEvents();
 ```
 
-### High-Throughput Batch Processing
+### Example 4: Batch Processing (High Throughput)
 
 ```javascript
-// Configure queue for high-throughput batch processing
-await client.configure({
-  queue: 'data-processing',
-  options: {
-    priority: 5,
-    leaseTime: 600, // 10 minutes for batch processing
-    windowBuffer: 30 // Buffer messages for 30 seconds
-  }
+import { Queen } from 'queen-mq';
+
+const client = new Queen({
+  baseUrls: ['http://localhost:6632']
 });
 
-// High-performance batch consumer
-const stopConsumer = client.consume({
-  queue: 'data-processing',
-  partition: 'analytics',
-  handlerBatch: async (messages) => {
-    const startTime = Date.now();
-    console.log(`Processing batch of ${messages.length} analytics events`);
-    
+// Configure for batch processing
+await client.queue('data-processing', {
+  priority: 5,
+  leaseTime: 600,        // 10 minutes for batch
+  windowBuffer: 30       // Buffer for 30 seconds
+});
+
+// Producer: Send data
+async function sendData() {
+  const records = [];
+  for (let i = 0; i < 100000; i++) {
+    records.push({ id: i, value: Math.random() });
+  }
+  
+  // Push in batches
+  await client.push('data-processing/analytics', records);
+}
+
+// Consumer: HIGH PERFORMANCE batch processor using takeBatch()
+async function batchProcessor() {
+  const BATCH_SIZE = 5000;  // Large batches for 100k+ msg/s throughput
+  
+  // takeBatch() yields arrays directly - no manual batching needed!
+  for await (const messages of client.takeBatch('data-processing/analytics', {
+    batch: BATCH_SIZE,
+    wait: true,
+    timeout: 30000
+  })) {
     try {
-      // Extract all payloads for batch processing
-      const events = messages.map(msg => ({
-        id: msg.transactionId,
-        ...msg.data
-      }));
+      console.log(`Processing batch of ${messages.length} records`);
+      
+      // Extract data
+      const records = messages.map(m => m.data);
       
-      // Process entire batch efficiently
-      await processAnalyticsBatch(events);
+      // Bulk process (single DB operation)
+      await bulkInsertToDatabase(records);
       
-      const processingTime = Date.now() - startTime;
-      console.log(`✅ Batch processed in ${processingTime}ms`);
+      // Batch acknowledge (single DB transaction!)
+      await client.ack(messages);
       
+      console.log(`✓ Batch complete in single transaction`);
     } catch (error) {
       console.error('Batch processing failed:', error);
-      throw error; // Will mark all messages as failed
+      
+      // Mark entire batch as failed (single transaction)
+      await client.ack(messages, false, { error: error.message });
     }
-  },
-  options: {
-    batch: 50,     // Process up to 50 messages at once
-    wait: true,    // Use long polling
-    timeout: 30000,
-    stopOnError: false
   }
-});
-
-async function processAnalyticsBatch(events) {
-  // Example: Bulk insert to database
-  await database.analytics.insertMany(events);
-  
-  // Example: Send to external analytics service
-  await analyticsService.sendBatch(events);
-  
-  // Example: Update aggregated metrics
-  await updateMetrics(events);
 }
+
+// Run
+await sendData();
+await batchProcessor();
+
+// Performance characteristics:
+// - Batch size 5000: ~100,000 messages/second
+// - Single DB transaction per batch (fetch + ack)
+// - Constant memory usage
+// - No performance degradation as queue grows
 ```
 
-## ⚡ Performance
+### Example 5: Scheduled Jobs
 
-### Benchmarks
+```javascript
+import { Queen } from 'queen-mq';
 
-- **Throughput**: 10,000+ messages/second
-- **Latency**: < 10ms for immediate pop operations
-- **Concurrent Connections**: 1,000+ long polling connections
-- **Database**: Optimized for PostgreSQL with proper indexing
+const client = new Queen({
+  baseUrls: ['http://localhost:6632']
+});
 
-### Optimization Features
+// Configure with delayed processing
+await client.queue('scheduled-jobs', {
+  delayedProcessing: 3600,  // 1 hour delay
+  priority: 5
+});
 
-- **Connection Pooling**: Efficient database connection management
-- **Resource Caching**: In-memory cache for queue/partition lookups
-- **Batch Operations**: Bulk insert/update for high throughput
-- **Optimized Queries**: Carefully crafted SQL with proper indexes
-- **Event-Driven Architecture**: Minimal polling overhead
+// Schedule a job
+async function scheduleReport() {
+  await client.push('scheduled-jobs/daily-reports', {
+    reportType: 'daily-sales',
+    date: new Date().toISOString().split('T')[0],
+    recipients: ['manager@company.com'],
+    scheduledAt: Date.now()
+  });
+  
+  console.log('Report scheduled for processing in 1 hour');
+}
 
-### Performance Tuning
+// Process scheduled jobs
+async function processScheduledJobs() {
+  for await (const job of client.take('scheduled-jobs/daily-reports', {
+    wait: true
+  })) {
+    try {
+      console.log('Generating report:', job.data.reportType);
+      await generateReport(job.data);
+      await client.ack(job);
+    } catch (error) {
+      await client.ack(job, false, { error: error.message });
+    }
+  }
+}
 
-```javascript
-// Environment variables for performance tuning
-export DB_POOL_SIZE=20              // Database connection pool size
-export DB_IDLE_TIMEOUT=30000        // Connection idle timeout
-export DB_CONNECTION_TIMEOUT=2000   // Connection establishment timeout
+await scheduleReport();
+processScheduledJobs().catch(console.error);
 ```
 
-## 🔒 Enterprise Features
-
-Queen includes three powerful enterprise features for production deployments:
+### Example 6: Rate Limiting
 
-### 1. Encryption
-Protect sensitive data with AES-256-GCM encryption at the queue level.
+```javascript
+import { Queen } from 'queen-mq';
 
-**Setup:**
-```bash
-# Set encryption key (64 hex characters = 32 bytes)
-export QUEEN_ENCRYPTION_KEY=$(openssl rand -hex 32)
-```
+const client = new Queen({
+  baseUrls: ['http://localhost:6632']
+});
 
-**Configuration:**
-```javascript
-await client.configure({
-  queue: 'sensitive-data',
-  options: {
-    encryptionEnabled: true
-  }
+await client.queue('api-calls', { 
+  priority: 5,
+  leaseTime: 60
 });
-```
 
-### 2. Message Retention
-Automatically clean up old messages to prevent storage bloat.
+// Producer: Queue API calls
+async function queueApiCalls(calls) {
+  await client.push('api-calls', calls);
+}
 
-**Configuration:**
-```javascript
-await client.configure({
-  queue: 'temp-queue',
-  options: {
-    retentionSeconds: 3600,          // Delete pending after 1 hour
-    completedRetentionSeconds: 300,  // Delete completed after 5 minutes
-    retentionEnabled: true
+// Consumer: Rate-limited processor (10 calls per second max)
+async function rateLimitedProcessor() {
+  const RATE_LIMIT = 10;  // calls per second
+  const INTERVAL = 1000;  // 1 second
+  
+  let callsThisInterval = 0;
+  let intervalStart = Date.now();
+  
+  for await (const call of client.take('api-calls', { wait: true })) {
+    // Check if we need to wait
+    if (callsThisInterval >= RATE_LIMIT) {
+      const elapsed = Date.now() - intervalStart;
+      if (elapsed < INTERVAL) {
+        await new Promise(r => setTimeout(r, INTERVAL - elapsed));
+      }
+      callsThisInterval = 0;
+      intervalStart = Date.now();
+    }
+    
+    try {
+      await makeApiCall(call.data);
+      await client.ack(call);
+      callsThisInterval++;
+    } catch (error) {
+      await client.ack(call, false, { error: error.message });
+    }
   }
-});
-```
+}
 
-**Environment:**
-```bash
-export RETENTION_INTERVAL=300000  # Cleanup interval in milliseconds
+// Generate calls
+const calls = Array.from({ length: 100 }, (_, i) => ({
+  id: i,
+  endpoint: '/api/data',
+  method: 'GET'
+}));
+
+await queueApiCalls(calls);
+rateLimitedProcessor().catch(console.error);
 ```
 
-### 3. Message Eviction
-Enforce SLAs by automatically evicting messages that wait too long.
+### Example 7: Enterprise Features
 
-**Configuration:**
 ```javascript
-await client.configure({
-  queue: 'time-sensitive',
-  options: {
-    maxWaitTimeSeconds: 60  // Evict messages older than 1 minute
-  }
+import { Queen } from 'queen-mq';
+
+const client = new Queen({
+  baseUrls: ['http://localhost:6632']
 });
-```
 
-**Environment:**
-```bash
-export EVICTION_INTERVAL=60000  # Check interval in milliseconds
-```
+// Configure with all enterprise features
+await client.queue('production-queue', {
+  // Encryption
+  encryptionEnabled: true,
+  
+  // Retention
+  retentionSeconds: 86400,              // Delete pending after 24 hours
+  completedRetentionSeconds: 3600,      // Delete completed after 1 hour
+  retentionEnabled: true,
+  
+  // Eviction (SLA enforcement)
+  maxWaitTimeSeconds: 600,              // Evict messages older than 10 minutes
+  
+  // Standard options
+  priority: 10,
+  leaseTime: 300,
+  retryLimit: 3,
+  dlqAfterMaxRetries: true
+});
 
-### Combined Example
-```javascript
-await client.configure({
-  queue: 'production-queue',
-  options: {
-    // Encryption
-    encryptionEnabled: true,
-    
-    // Retention
-    retentionSeconds: 86400,
-    completedRetentionSeconds: 3600,
-    retentionEnabled: true,
-    
-    // Eviction
-    maxWaitTimeSeconds: 600,
-    
-    // Standard options
-    priority: 10,
-    leaseTime: 300
-  }
+// Push sensitive data (will be encrypted)
+await client.push('production-queue', {
+  userId: 123,
+  creditCard: '4111-1111-1111-1111',
+  amount: 99.99,
+  timestamp: Date.now()
 });
+
+// Process (data decrypted automatically)
+for await (const message of client.take('production-queue', { wait: true })) {
+  console.log('Processing encrypted data:', message.data.userId);
+  await processPayment(message.data);
+  await client.ack(message);
+}
 ```
 
-## ⚙️ Configuration
+---
 
-### Environment Variables
+## 🧪 Testing
 
-All configuration values have sensible defaults and can be overridden using environment variables. Configuration is centralized in `src/config.js`.
+Queen includes a comprehensive test suite covering all features.
 
-#### Server Configuration
+### Run Tests
 
 ```bash
-# Server basics
-PORT=6632                      # Server port (default: 6632)
-HOST=0.0.0.0                   # Server host (default: 0.0.0.0)
-WORKER_ID=worker-1             # Worker identifier (default: worker-${process.pid})
-APP_NAME=queen-uws             # Application name for database connections
-
-# CORS settings
-CORS_MAX_AGE=86400             # CORS max age in seconds (default: 86400 = 24 hours)
-CORS_ALLOWED_ORIGINS=*         # Allowed origins (default: *)
-CORS_ALLOWED_METHODS=GET,POST,PUT,DELETE,OPTIONS  # Allowed methods
-CORS_ALLOWED_HEADERS=Content-Type,Authorization   # Allowed headers
-```
+# Start the server first
+npm start
 
-#### Database Configuration
+# Run all tests
+node src/test/test-new.js
 
-```bash
-# Connection settings
-PG_USER=postgres               # PostgreSQL user (default: postgres)
-PG_HOST=localhost              # PostgreSQL host (default: localhost)
-PG_DB=postgres                 # PostgreSQL database (default: postgres)
-PG_PASSWORD=postgres           # PostgreSQL password (default: postgres)
-PG_PORT=5432                   # PostgreSQL port (default: 5432)
+# Run specific test categories
+node src/test/test-new.js core        # Core features
+node src/test/test-new.js partition   # Partition locking
+node src/test/test-new.js enterprise  # Enterprise features
+node src/test/test-new.js bus         # Bus mode
+node src/test/test-new.js edge        # Edge cases
+node src/test/test-new.js advanced    # Advanced patterns
 
-# Connection pool settings
-DB_POOL_SIZE=20                # Max pool size (default: 20)
-DB_IDLE_TIMEOUT=30000          # Idle connection timeout in ms (default: 30000)
-DB_CONNECTION_TIMEOUT=2000     # Connection timeout in ms (default: 2000)
-DB_STATEMENT_TIMEOUT=30000     # Statement timeout in ms (default: 30000)
-DB_QUERY_TIMEOUT=30000         # Query timeout in ms (default: 30000)
-DB_MAX_RETRIES=3               # Max retry attempts for queries (default: 3)
+# Show help
+node src/test/test-new.js help
 ```
 
-#### Queue Processing Configuration
-
-```bash
-# Pop operation defaults
-DEFAULT_TIMEOUT=30000          # Default pop timeout in ms (default: 30000)
-MAX_TIMEOUT=60000              # Maximum pop timeout in ms (default: 60000)
-DEFAULT_BATCH_SIZE=1           # Default batch size for pop (default: 1)
-BATCH_INSERT_SIZE=1000         # Batch size for bulk inserts (default: 1000)
-
-# Long polling
-QUEUE_POLL_INTERVAL=100        # Poll interval in ms (default: 100)
-QUEUE_POLL_INTERVAL_FILTERED=1000  # Poll interval for filtered pops (default: 1000)
+### Test Coverage
 
-# Queue defaults
-DEFAULT_LEASE_TIME=300         # Default lease time in seconds (default: 300 = 5 minutes)
-DEFAULT_RETRY_LIMIT=3          # Default retry limit (default: 3)
-DEFAULT_RETRY_DELAY=1000       # Default retry delay in ms (default: 1000)
-DEFAULT_MAX_SIZE=10000         # Default max queue size (default: 10000)
-DEFAULT_TTL=3600               # Default TTL in seconds (default: 3600 = 1 hour)
-DEFAULT_PRIORITY=0             # Default queue priority (default: 0)
-DEFAULT_DELAYED_PROCESSING=0   # Default delayed processing in seconds (default: 0)
-DEFAULT_WINDOW_BUFFER=0        # Default window buffer in seconds (default: 0)
+The test suite verifies:
 
-# Dead Letter Queue
-DEFAULT_DLQ_ENABLED=false      # Enable DLQ by default (default: false)
-DEFAULT_DLQ_AFTER_MAX_RETRIES=false  # Move to DLQ after max retries (default: false)
+**Core Features:**
+- Queue creation and configuration
+- Single and batch message push
+- Message take and acknowledgment
+- Delayed processing
+- Partition FIFO ordering
+
+**Partition Locking:**
+- Lock acquisition and release
+- Bus mode partition locking
+- Specific partition locking
+- Namespace/task filtering with locking
+
+**Enterprise Features:**
+- AES-256-GCM encryption
+- Message retention policies
+- Message eviction
+- Combined enterprise features
+
+**Bus Mode:**
+- Consumer groups
+- Subscription modes (all, new, from)
+- Consumer group isolation
+- Mixed mode (queue + bus)
+
+**Edge Cases:**
+- Empty and null payloads
+- Very large payloads
+- Concurrent operations
+- Lease expiration
+- SQL injection prevention
+- XSS prevention
+
+**Advanced Patterns:**
+- Multi-stage pipelines
+- Fan-out/fan-in
+- Priority scenarios
+- Dead letter queue
+- Circuit breaker
+- Message deduplication
+- Event sourcing
 
-# Retention
-DEFAULT_RETENTION_SECONDS=0    # Default retention for all messages (default: 0 = disabled)
-DEFAULT_COMPLETED_RETENTION_SECONDS=0  # Retention for completed messages (default: 0)
-DEFAULT_RETENTION_ENABLED=false  # Enable retention by default (default: false)
+### Test Results
 
-# Eviction
-DEFAULT_MAX_WAIT_TIME_SECONDS=0  # Max wait time before eviction (default: 0 = disabled)
+Example output:
 ```
+🚀 Starting Queen Message Queue Test Suite
+   Using the new minimalist Queen client interface
+================================================================================
 
-#### Background Jobs Configuration
+📦 CORE FEATURES
+----------------------------------------
+✅ Queue Creation Policy
+✅ Single Message Push
+✅ Batch Message Push
+✅ Queue Configuration
+✅ Take and Acknowledgment
+✅ Delayed Processing
+✅ Partition FIFO Ordering
 
-```bash
-# Job intervals
-LEASE_RECLAIM_INTERVAL=5000    # Lease reclamation interval in ms (default: 5000)
-RETENTION_INTERVAL=300000      # Retention check interval in ms (default: 300000 = 5 minutes)
-RETENTION_BATCH_SIZE=1000      # Retention batch size (default: 1000)
-PARTITION_CLEANUP_DAYS=7       # Days before cleaning empty partitions (default: 7)
-EVICTION_INTERVAL=60000        # Eviction check interval in ms (default: 60000 = 1 minute)
-EVICTION_BATCH_SIZE=1000       # Eviction batch size (default: 1000)
+🔒 PARTITION LOCKING
+----------------------------------------
+✅ Partition Locking
+✅ Bus Partition Locking
+✅ Specific Partition Locking
+✅ Namespace Task Filtering
+✅ Namespace Task Bus Mode
 
-# WebSocket updates
-QUEUE_DEPTH_UPDATE_INTERVAL=5000    # Queue depth update interval (default: 5000)
-SYSTEM_STATS_UPDATE_INTERVAL=10000  # System stats update interval (default: 10000)
+📈 Test Summary
+================================================================================
+Total: 42 | Passed: 42 | Failed: 0 | Duration: 45.2s
 ```
 
-#### WebSocket Configuration
+---
 
-```bash
-# WebSocket settings
-WS_COMPRESSION=0               # Compression level (default: 0 = disabled)
-WS_MAX_PAYLOAD_LENGTH=16384    # Max payload length in bytes (default: 16384 = 16KB)
-WS_IDLE_TIMEOUT=60             # Idle timeout in seconds (default: 60)
-WS_MAX_CONNECTIONS=1000        # Max concurrent connections (default: 1000)
-WS_HEARTBEAT_INTERVAL=30000    # Heartbeat interval in ms (default: 30000)
-```
+## 🤝 Contributing
 
-#### Encryption Configuration
+We welcome contributions! Here's how to get started:
 
-```bash
-# Encryption settings
-QUEEN_ENCRYPTION_KEY=<64-hex>  # 32-byte key as 64 hex characters
-                                # Generate with: openssl rand -hex 32
-                                # Required for encryption features
-```
+1. **Fork the repository**
+2. **Create a feature branch**: `git checkout -b feature/amazing-feature`
+3. **Make your changes**
+4. **Run the test suite**: `node src/test/test-new.js`
+5. **Commit your changes**: `git commit -m 'Add amazing feature'`
+6. **Push to the branch**: `git push origin feature/amazing-feature`
+7. **Open a Pull Request**
 
-#### Client SDK Configuration
+### Development Setup
 
 ```bash
-# Client defaults
-QUEEN_BASE_URL=http://localhost:6632  # Default server URL
-CLIENT_RETRY_ATTEMPTS=3        # Default retry attempts (default: 3)
-CLIENT_RETRY_DELAY=1000        # Default retry delay in ms (default: 1000)
-CLIENT_RETRY_BACKOFF=2         # Retry backoff multiplier (default: 2)
-CLIENT_POOL_SIZE=10            # Client connection pool size (default: 10)
-CLIENT_REQUEST_TIMEOUT=30000   # Request timeout in ms (default: 30000)
-```
+# Clone your fork
+git clone https://github.com/your-username/queen
+cd queen
 
-#### API Configuration
+# Install dependencies
+nvm use 22
+npm install
 
-```bash
-# Pagination
-API_DEFAULT_LIMIT=100          # Default page size (default: 100)
-API_MAX_LIMIT=1000             # Maximum page size (default: 1000)
-API_DEFAULT_OFFSET=0           # Default offset (default: 0)
-```
+# Initialize database
+node init-db.js
 
-#### Analytics Configuration
+# Start server
+npm start
 
-```bash
-# Analytics settings
-ANALYTICS_RECENT_HOURS=24      # Hours to consider for recent stats (default: 24)
-ANALYTICS_MIN_COMPLETED=5      # Min completed messages for stats (default: 5)
-RECENT_MESSAGE_WINDOW=60       # Recent message window in seconds (default: 60)
-RELATED_MESSAGE_WINDOW=3600    # Related message window in seconds (default: 3600)
-MAX_RELATED_MESSAGES=10        # Max related messages to return (default: 10)
+# Run tests
+node src/test/test-new.js
 ```
 
-#### Monitoring Configuration
+### Code Style
 
-```bash
-# Performance monitoring
-ENABLE_REQUEST_COUNTING=true   # Enable request counting (default: true)
-ENABLE_MESSAGE_COUNTING=true   # Enable message counting (default: true)
-METRICS_ENDPOINT_ENABLED=true  # Enable /metrics endpoint (default: true)
-HEALTH_CHECK_ENABLED=true      # Enable /health endpoint (default: true)
-```
+- Use ES6+ features
+- Follow existing code style
+- Add comments for complex logic
+- Write tests for new features
 
-#### Logging Configuration
+---
 
-```bash
-# Logging settings
-ENABLE_LOGGING=true            # Enable logging (default: true)
-LOG_LEVEL=info                 # Log level (default: info)
-LOG_FORMAT=json                # Log format (default: json)
-LOG_TIMESTAMP=true             # Include timestamps (default: true)
-```
+## 📄 License
 
-### Queue Options
+Apache License 2.0 - see [LICENSE.md](LICENSE.md) for details.
 
-```javascript
-{
-  // Standard Options
-  "leaseTime": 300,           // Seconds before message lease expires
-  "retryLimit": 3,            // Maximum retry attempts
-  "priority": 0,              // Queue/partition priority (higher = first)
-  "delayedProcessing": 0,     // Delay in seconds before message is available
-  "windowBuffer": 0,          // Buffer time in seconds for batching
-  "dlqAfterMaxRetries": true, // Move to dead letter queue after max retries
-  
-  // Encryption (Queue-level)
-  "encryptionEnabled": false,  // Enable AES-256-GCM encryption for this queue
-  
-  // Retention (Partition-level)
-  "retentionSeconds": 0,              // Delete pending messages after X seconds (0 = disabled)
-  "completedRetentionSeconds": 0,     // Delete completed/failed messages after X seconds
-  "partitionRetentionSeconds": 0,     // Delete empty partitions after X seconds
-  "retentionEnabled": false,          // Enable retention for this partition
-  
-  // Eviction (Queue-level)
-  "maxWaitTimeSeconds": 0     // Evict messages older than X seconds (0 = disabled)
-}
-```
+---
 
-## 🧪 Testing
+## 🔗 Links
 
-### Run Core Feature Tests
+- **Repository**: [github.com/smartpricing/queen](https://github.com/smartpricing/queen)
+- **Documentation**: See `docs/` directory
+- **Issues**: [GitHub Issues](https://github.com/smartpricing/queen/issues)
+- **API Reference**: [API.md](API.md)
 
-```bash
-# Start the server
-npm start
+---
 
-# Run comprehensive test suite
-node src/test/core-features-test.js
+## 📈 Performance
 
-# Run full test suite (more detailed)
-node src/test/comprehensive-test.js
-```
+**Benchmarks** (PostgreSQL 16, Node.js 22, cursor-based consumption):
+- **Throughput**: 100,000+ messages/second with batch operations
+- **Latency**: < 10ms for immediate pop operations
+- **Constant-time consumption**: O(batch_size) regardless of queue depth
+- **Concurrent Connections**: 1,000+ long polling connections
+- **Database**: Optimized with proper indexing and connection pooling
+
+**Cursor-Based Architecture Benefits:**
+- **No performance degradation**: Consistent speed whether queue has 1K or 1B messages
+- **Predictable latency**: 150-200ms per batch throughout entire queue lifecycle
+- **Efficient batch processing**: Direct cursor access eliminates table scans
+- **Scalable to billions**: UUIDv7-based cursor positioning
+
+**Additional Optimization Features:**
+- Connection pooling with configurable size
+- Resource caching for queue/partition lookups
+- Batch operations for bulk inserts/updates (up to 10,000 messages per batch)
+- Optimized SQL queries with proper indexes
+- Event-driven architecture for minimal polling overhead
+- Long polling for real-time message delivery
+- SKIP LOCKED for lock-free concurrent consumption
 
-### Test Results
+---
 
-The test suite verifies:
-- ✅ Single and batch message push
-- ✅ Queue configuration and options
-- ✅ Pop operations (specific partition and queue-level)
-- ✅ Delayed processing (2+ second delays)
-- ✅ Partition priority ordering
-- ✅ Consumer pattern with automatic acknowledgment
-- ✅ Message acknowledgment and retry logic
-- ✅ FIFO ordering within partitions
+## 🎯 Roadmap
 
-## 🤝 Contributing
+- [ ] **Message Scheduling**: Cron-like scheduling for recurring jobs
+- [ ] **Client Libraries**: Python, Go, Java clients
+- [ ] **Kubernetes Operator**: Native K8s support
 
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Run the test suite
-5. Submit a pull request
+---
 
-## 📄 License
+<div align="center">
 
-MIT License - see LICENSE file for details.
+**Queen Message Queue System** - Built for performance, reliability, and developer happiness 🚀
 
----
+Made with ❤️ by [Smartness](https://github.com/smartpricing)
 
-**Queen Message Queue System** - Built for performance, reliability, and scalability. 🚀
+</div>