@pixagram/lacerta-db 0.6.2 → 0.7.1

package/readme.md

@@ -1,15 +1,15 @@
-# LacertaDB 0.6.2
+# LacertaDB 0.7.0
 ![](https://github.com/pixagram-blockchain/LacertaDB/blob/main/logo.webp?raw=true)
 
-> 🦎 **LacertaDB** - A powerful, feature-rich browser-based document database with encryption, compression, and advanced querying capabilities.
+> 🦎 **LacertaDB** - A sophisticated, feature-rich browser-based document database with encryption, compression, QuickStore, and advanced querying capabilities.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.6.2-blue.svg)]()
+[![Version](https://img.shields.io/badge/version-0.7.0-blue.svg)]()
 [![Browser Compatible](https://img.shields.io/badge/browser-compatible-green.svg)]()
 [![npm downloads](https://img.shields.io/npm/dm/lacertadb.svg)](https://www.npmjs.com/package/lacertadb)
 [![Bundle Size](https://img.shields.io/bundlephobia/minzip/lacertadb)](https://bundlephobia.com/package/lacertadb)
 
-[**🎮 PLAYGROUND**](https://codepen.io/Matias-Affolter/pen/ogjrQdB) 
+[**🎮 PLAYGROUND**](https://codepen.io/Matias-Affolter/pen/ogjrQdB)
 
 ---
 
@@ -21,162 +21,180 @@
 4. [Installation](#installation)
 5. [Core Concepts](#core-concepts)
 6. [API Reference](#api-reference)
-   - [LacertaDB Class](#lacertadb-class)
-   - [Database Class](#database-class)
-   - [Collection Class](#collection-class)
-   - [Document Class](#document-class)
-   - [Index Management](#index-management)
-   - [Encryption](#encryption)
+    - [LacertaDB Class](#lacertadb-class)
+    - [Database Class](#database-class)
+    - [Collection Class](#collection-class)
+    - [QuickStore](#quickstore)
+    - [Document Class](#document-class)
+    - [Index Management](#index-management)
+    - [Encryption](#encryption)
+    - [Connection Management](#connection-management)
 7. [Advanced Features](#advanced-features)
 8. [Real-World Examples](#real-world-examples)
 9. [Performance Optimization](#performance-optimization)
 10. [Migration Guide](#migration-guide)
-11. [Troubleshooting](#troubleshooting)
-12. [Error Handling](#error-handling)
-13. [Comparison](#comparison)
-14. [Contributing](#contributing)
-15. [Changelog](#changelog)
+11. [Architecture Deep Dive](#architecture-deep-dive)
+12. [Troubleshooting](#troubleshooting)
+13. [Error Handling](#error-handling)
+14. [Comparison](#comparison)
+15. [Contributing](#contributing)
+16. [Changelog](#changelog)
 
 ---
 
 ## Introduction
 
-LacertaDB is a high-performance, browser-based NoSQL database built on IndexedDB. It provides MongoDB-like query capabilities, automatic compression, encryption support, and advanced indexing strategies - all running entirely in the browser with zero backend dependencies.
+LacertaDB v0.7.0 represents a paradigmatic evolution in browser-based data persistence, architecting a sophisticated NoSQL database atop IndexedDB foundations. This iteration introduces QuickStore for ephemeral caching, implements rigorous encapsulation through private property conventions, and establishes connection pooling mechanisms for optimal resource utilization.
 
 ### ✨ Key Features
 
-- 🔐 **Database-level encryption** with AES-GCM-256
-- 🗜️ **Automatic compression** using native browser APIs (60-80% size reduction)
-- 🔍 **Multiple index types** (B-Tree, Hash, Text, Geo)
-- ⚡ **Smart caching strategies** (LRU, LFU, TTL)
-- 📊 **Aggregation pipeline** for complex queries
-- 🔄 **Atomic batch operations**
-- 📈 **Built-in performance monitoring**
-- 💾 **OPFS support** for attachments
-- 🌐 **Works offline** - no server required
-- 📦 **Small bundle size** (~45KB gzipped)
-
-### 🎯 Use Cases
-
-- **PWAs & Offline-First Apps** - Full database functionality without connectivity
-- **Client-Side Encryption** - Secure sensitive data before any network transmission
-- **Local Data Processing** - Complex queries and aggregations without server round-trips
-- **Browser Extensions** - Persistent storage with advanced querying
-- **Prototyping** - Rapid development without backend setup
+- 🚀 **QuickStore** - High-velocity localStorage-based caching with query capabilities
+- 🔐 **Database-level encryption** with AES-GCM-256 cryptographic primitives
+- 🗜️ **Automatic compression** leveraging native browser APIs (60-80% spatial reduction)
+- 🔍 **Multiple index architectures** (B-Tree, Hash, Text, Geo)
+- ⚡ **Sophisticated caching strategies** (LRU, LFU, TTL)
+- 📊 **Aggregation pipeline** for complex analytical queries
+- 🔄 **Atomic batch operations** with transactional guarantees
+- 🔌 **Connection pooling** for optimized resource management
+- 🔒 **Async mutex** for concurrent operation synchronization
+- 📈 **Built-in performance telemetry**
+- 💾 **OPFS support** for binary attachment persistence
+- 🌐 **Offline-first architecture** - zero backend dependencies
+- 📦 **Optimized bundle footprint** (~48KB gzipped)
+
+### 🎯 Architectural Use Cases
+
+- **Progressive Web Applications** - Complete database functionality in disconnected states
+- **Client-Side Cryptography** - Zero-knowledge encryption before network transmission
+- **Edge Computing** - Complex data processing at the browser periphery
+- **Browser Extensions** - Persistent storage with sophisticated querying semantics
+- **Rapid Prototyping** - Backend-agnostic development workflows
+- **Ephemeral Caching** - QuickStore for session-based data persistence
 
 ---
 
 ## Browser Compatibility
 
-| Browser | Minimum Version | Notes |
-|---------|----------------|--------|
-| Chrome | 88+ | Full support including compression |
-| Firefox | 90+ | Full support |
-| Safari | 15.4+ | Full support |
-| Edge | 88+ | Full support |
-| Opera | 74+ | Full support |
-| Chrome Mobile | 88+ | Full support |
-| Safari iOS | 15.4+ | Storage limits may apply |
+| Browser | Minimum Version | Architectural Notes |
+|---------|----------------|---------------------|
+| Chrome | 88+ | Full API surface including CompressionStream |
+| Firefox | 90+ | Complete implementation |
+| Safari | 15.4+ | Full support with OPFS |
+| Edge | 88+ | Chromium-based implementation |
+| Opera | 74+ | Complete feature parity |
+| Chrome Mobile | 88+ | Mobile-optimized performance |
+| Safari iOS | 15.4+ | Storage quotas may apply |
 
 ### Required Browser APIs
-- IndexedDB API
-- Web Crypto API
-- CompressionStream API (optional, falls back gracefully)
-- Origin Private File System (optional, for attachments)
+- **IndexedDB API** - Primary persistence layer
+- **Web Crypto API** - Cryptographic operations
+- **CompressionStream API** - Optional compression (graceful degradation)
+- **Origin Private File System** - Binary attachment storage
+- **LocalStorage API** - QuickStore implementation
 
 ---
 
 ## Quick Start
 
-### 🚀 5-Minute Setup
+### 🚀 Rapid Initialization Sequence
 
 ```javascript
 import { LacertaDB } from 'lacertadb';
 
-// 1. Initialize LacertaDB
+// 1. Instantiate LacertaDB orchestrator
 const lacerta = new LacertaDB();
 
-// 2. Get a database
-const db = await lacerta.getDatabase('my-app');
+// 2. Acquire database instance
+const db = await lacerta.getDatabase('application-nexus');
 
-// 3. Create a collection
+// 3. Initialize collection with QuickStore
 const users = await db.createCollection('users');
 
-// 4. Add documents
+// 4. Leverage QuickStore for ephemeral caching
+db.quickStore.add('session', { userId: 'usr_123', token: 'xyz' });
+const session = db.quickStore.get('session');
+
+// 5. Persist documents with compression
 await users.add({
   name: 'John Doe',
   email: 'john@example.com',
-  age: 30,
-  tags: ['developer', 'javascript']
+  metadata: { created: Date.now() }
 });
 
-// 5. Query documents
-const developers = await users.query({
-  tags: { $in: ['developer'] },
-  age: { $gte: 25 }
+// 6. Execute sophisticated queries
+const results = await users.query({
+  $and: [
+    { 'metadata.created': { $gte: Date.now() - 86400000 } },
+    { email: { $regex: '@example.com$' } }
+  ]
 });
-
-// 6. Use aggregation
-const stats = await users.aggregate([
-  { $match: { age: { $gte: 18 } } },
-  { $group: {
-    _id: null,
-    avgAge: { $avg: '$age' },
-    total: { $count: {} }
-  }}
-]);
 ```
 
-### 🔐 Encrypted Database Setup
+### 🔐 Cryptographically Secured Database
 
 ```javascript
-// Create an encrypted database
+// Initialize encrypted database with configurable parameters
 const secureDb = await lacerta.getSecureDatabase(
-  'secure-app',
-  'user-pin-123456'  // User's PIN
+  'classified-data',
+  'user-pin-entropy',
+  null,  // Auto-generate cryptographic salt
+  {
+    iterations: 200000,      // PBKDF2 iteration count
+    hashAlgorithm: 'SHA-512' // Hashing algorithm selection
+  }
 );
 
-// All operations are automatically encrypted
-const secrets = await secureDb.createCollection('secrets');
-await secrets.add({ apiKey: 'sk_live_...' });
+// Encrypted operations maintain transparency
+const secrets = await secureDb.createCollection('api-keys');
+await secrets.add({ 
+  service: 'stripe',
+  key: await secureDb.encryption.encryptPrivateKey('sk_live_...', 'stripe.com')
+});
 ```
 
 ---
 
 ## Installation
 
-### NPM
+### Package Manager Installation
+
 ```bash
+# NPM
 npm install lacertadb
-```
 
-### Yarn
-```bash
+# Yarn
 yarn add lacertadb
+
+# PNPM
+pnpm add lacertadb
 ```
 
-### CDN
+### CDN Integration
+
 ```html
 <script type="module">
-  import { LacertaDB } from 'https://cdn.jsdelivr.net/npm/lacertadb@latest/dist/index.min.js';
+  import { LacertaDB } from 'https://cdn.jsdelivr.net/npm/lacertadb@0.7.0/dist/index.min.js';
 </script>
 ```
 
-### Import Options
+### Import Paradigms
 
 ```javascript
-// ES6 Modules
-import { LacertaDB } from 'lacertadb';
+// ES6 Module Syntax
+import { LacertaDB, QuickStore } from 'lacertadb';
 
-// Import specific components
+// Selective Component Import
 import { 
   LacertaDB, 
   SecureDatabaseEncryption,
   PerformanceMonitor,
-  MigrationManager 
+  MigrationManager,
+  QuickStore,
+  BTreeIndex,
+  AsyncMutex
 } from 'lacertadb';
 
-// CommonJS (Node.js)
+// CommonJS Pattern
 const { LacertaDB } = require('lacertadb');
 ```
 
@@ -184,90 +202,84 @@ const { LacertaDB } = require('lacertadb');
 
 ## Core Concepts
 
-### Database Structure
+### Hierarchical Architecture
 
 ```
 LacertaDB Instance
+├── Connection Pool (Global)
+│   └── Database Connections (Reusable)
 ├── Database 1
+│   ├── QuickStore (LocalStorage Layer)
 │   ├── Collection A
-│   │   ├── Document 1
-│   │   ├── Document 2
-│   │   └── Indexes
+│   │   ├── Documents (IndexedDB)
+│   │   ├── Indexes (B-Tree/Hash/Text/Geo)
+│   │   └── Cache Strategy (LRU/LFU/TTL)
 │   └── Collection B
 └── Database 2
-    └── __private_keys__ (special collection for encrypted keys)
+    ├── QuickStore Instance
+    └── __private_keys__ (Encrypted Key Storage)
 ```
 
-### Document Structure
-
-Every document automatically includes:
+### Document Metadata Schema
 
 ```javascript
 {
-  _id: "doc_1234567890_abc",        // Auto-generated unique ID
+  _id: "doc_1234567890_abc",        // Unique identifier
   _created: 1234567890,              // Creation timestamp
-  _modified: 1234567890,             // Last modified timestamp
-  _permanent: false,                 // Protection from auto-cleanup
-  ...yourData                       // Your document fields
+  _modified: 1234567890,             // Modification timestamp
+  _permanent: false,                 // Cleanup immunity flag
+  _compressed: true,                 // Compression status
+  _encrypted: false,                 // Encryption status
+  _attachments: [],                  // OPFS attachment references
+  ...userDefinedFields               // Application data
 }
 ```
 
+### Private Property Convention
+
+Version 0.7.0 implements systematic encapsulation through underscore-prefixed private properties and methods, establishing clear API boundaries while optimizing memory through lazy initialization patterns.
+
 ---
 
 ## API Reference
 
 ### 📦 LacertaDB Class
 
-The main entry point for database operations.
+Primary orchestrator for database lifecycle management.
 
 | Method | Parameters | Returns | Description |
 |--------|------------|---------|-------------|
-| `getDatabase()` | `name: string`<br/>`options?: object` | `Promise<Database>` | Get or create a database |
-| `getSecureDatabase()` | `name: string`<br/>`pin: string`<br/>`salt?: string`<br/>`config?: object` | `Promise<Database>` | Get encrypted database |
-| `dropDatabase()` | `name: string` | `Promise<void>` | Delete a database |
-| `listDatabases()` | - | `string[]` | List all databases |
-| `createBackup()` | `password?: string` | `Promise<string>` | Create full backup |
+| `getDatabase()` | `name: string`<br/>`options?: object` | `Promise<Database>` | Acquire database instance |
+| `getSecureDatabase()` | `name: string`<br/>`pin: string`<br/>`salt?: string`<br/>`config?: object` | `Promise<Database>` | Initialize encrypted database |
+| `dropDatabase()` | `name: string` | `Promise<void>` | Destroy database and QuickStore |
+| `listDatabases()` | - | `string[]` | Enumerate databases |
+| `createBackup()` | `password?: string` | `Promise<string>` | Generate comprehensive backup |
 | `restoreBackup()` | `data: string`<br/>`password?: string` | `Promise<object>` | Restore from backup |
-| `destroy()` | - | `void` | Clean up all connections |
+| `destroy()` | - | `void` | Release all connections |
+| `performanceMonitor` | - | `PerformanceMonitor` | Access performance telemetry |
 
 <details>
-<summary><strong>Examples</strong></summary>
+<summary><strong>Implementation Examples</strong></summary>
 
 ```javascript
-// Initialize LacertaDB
 const lacerta = new LacertaDB();
 
-// Get a standard database
-const db = await lacerta.getDatabase('myapp');
-
-// Get an encrypted database with custom security
-const secureDb = await lacerta.getSecureDatabase(
-  'sensitive-data',
-  'my-secure-pin-123456',
-  null,  // Auto-generate salt
-  {
-    iterations: 200000,    // Higher = more secure but slower
-    keyLength: 256
-  }
-);
-
-// Create a full backup
-const backup = await lacerta.createBackup('backup-password');
-// Save to file or cloud
-await saveToCloud(backup);
+// Connection pooling automatically manages resources
+const db1 = await lacerta.getDatabase('app1');
+const db2 = await lacerta.getDatabase('app2');
+// Connections are pooled and reused efficiently
 
-// Restore from backup
-const backupData = await loadFromCloud();
-const result = await lacerta.restoreBackup(backupData, 'backup-password');
-console.log(`Restored: ${result.databases} databases, ${result.documents} documents`);
+// Access performance monitoring
+lacerta.performanceMonitor.startMonitoring();
+const metrics = lacerta.performanceMonitor.getStats();
 
-// List all databases
-const databases = lacerta.listDatabases();
-console.log('Available databases:', databases);
+// Comprehensive backup including QuickStore
+const backup = await lacerta.createBackup('encryption-key');
+localStorage.setItem('backup', backup);
 
-// Clean up when done (important for SPAs)
+// Cleanup with connection pool release
 window.addEventListener('beforeunload', () => {
-  lacerta.destroy();
+  lacerta.destroy(); // Releases all pooled connections
 });
 ```
 
@@ -277,76 +289,140 @@ window.addEventListener('beforeunload', () => {
 
 ### 🗄️ Database Class
 
-Manages collections and database-level operations.
+Database-level operations with QuickStore integration.
 
 | Method | Parameters | Returns | Description |
 |--------|------------|---------|-------------|
-| `createCollection()` | `name: string`<br/>`options?: object` | `Promise<Collection>` | Create a new collection |
-| `getCollection()` | `name: string` | `Promise<Collection>` | Get existing collection |
-| `dropCollection()` | `name: string` | `Promise<void>` | Delete a collection |
-| `listCollections()` | - | `string[]` | List all collections |
-| `getStats()` | - | `object` | Get database statistics |
-| `updateSettings()` | `settings: object` | `void` | Update database settings |
-| `export()` | `format: 'json'│'encrypted'`<br/>`password?: string` | `Promise<string>` | Export database |
+| `createCollection()` | `name: string`<br/>`options?: object` | `Promise<Collection>` | Initialize collection |
+| `getCollection()` | `name: string` | `Promise<Collection>` | Retrieve collection (lazy init) |
+| `dropCollection()` | `name: string` | `Promise<void>` | Remove collection |
+| `listCollections()` | - | `string[]` | Enumerate collections |
+| `getStats()` | - | `object` | Database metrics |
+| `updateSettings()` | `settings: object` | `void` | Configure database |
+| `export()` | `format: string`<br/>`password?: string` | `Promise<string>` | Export database |
 | `import()` | `data: string`<br/>`format: string`<br/>`password?: string` | `Promise<object>` | Import data |
-| `storePrivateKey()` | `name: string`<br/>`key: string`<br/>`auth?: string` | `Promise<boolean>` | Store encrypted key |
-| `getPrivateKey()` | `name: string`<br/>`auth?: string` | `Promise<string>` | Retrieve encrypted key |
-| `clearAll()` | - | `Promise<void>` | Clear all collections |
-
-#### Database Settings
-
-| Setting | Type | Default | Description |
-|---------|------|---------|-------------|
-| `sizeLimitKB` | `number` | `Infinity` | Maximum database size |
-| `bufferLimitKB` | `number` | `80% of limit` | Start cleanup threshold |
-| `freeSpaceEvery` | `number` | `10000` | Cleanup interval (ms) |
+| `storePrivateKey()` | `name: string`<br/>`key: string`<br/>`auth?: string` | `Promise<boolean>` | Secure key storage |
+| `getPrivateKey()` | `name: string`<br/>`auth?: string` | `Promise<string>` | Retrieve secured key |
+| `clearAll()` | - | `Promise<void>` | Purge all data |
+
+#### Database Properties (Getters)
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `quickStore` | `QuickStore` | LocalStorage-based cache |
+| `collections` | `Map<string, Collection>` | Collection registry |
+| `metadata` | `DatabaseMetadata` | Database metadata |
+| `settings` | `Settings` | Configuration parameters |
+| `encryption` | `SecureDatabaseEncryption│null` | Encryption instance |
+| `isEncrypted` | `boolean` | Encryption status |
+| `performanceMonitor` | `PerformanceMonitor` | Performance telemetry |
 
 <details>
-<summary><strong>Examples</strong></summary>
+<summary><strong>Advanced Usage Patterns</strong></summary>
 
 ```javascript
-// Create collections
-const users = await db.createCollection('users');
-const posts = await db.createCollection('posts', {
-  compressed: true
+// Lazy collection initialization
+const users = await db.getCollection('users');
+// Collection is initialized only on first access
+
+// QuickStore integration for session management
+db.quickStore.add('user_session', {
+  userId: 'usr_123',
+  loginTime: Date.now(),
+  permissions: ['read', 'write']
+});
+
+// Query QuickStore with same engine
+const activeSessions = db.quickStore.query({
+  loginTime: { $gte: Date.now() - 3600000 }
 });
 
-// Configure database limits
+// Configure with size management
 db.updateSettings({
-  sizeLimitKB: 100000,     // 100MB limit
-  bufferLimitKB: 80000,    // Start cleanup at 80MB
-  freeSpaceEvery: 30000    // Check every 30 seconds
+  sizeLimitKB: 100000,
+  bufferLimitKB: 80000,
+  freeSpaceEvery: 30000
+});
+
+// Export with QuickStore data
+const fullExport = await db.export('encrypted', 'password');
+```
+
+</details>
+
+---
+
+### 🚀 QuickStore
+
+High-performance localStorage-based caching layer with query capabilities.
+
+| Method | Parameters | Returns | Description |
+|--------|------------|---------|-------------|
+| `add()` | `docId: string`<br/>`data: object` | `boolean` | Store document |
+| `get()` | `docId: string` | `object│null` | Retrieve document |
+| `update()` | `docId: string`<br/>`data: object` | `boolean` | Update document |
+| `delete()` | `docId: string` | `void` | Remove document |
+| `getAll()` | - | `object[]` | Retrieve all documents |
+| `query()` | `filter: object` | `object[]` | Query documents |
+| `clear()` | - | `void` | Purge all data |
+| `size` | - | `number` | Document count |
+
+#### QuickStore Architecture
+
+QuickStore leverages localStorage for ephemeral data persistence, providing:
+- **Synchronous operations** for immediate data access
+- **Query engine integration** using identical syntax as main collections
+- **Automatic serialization** with TurboSerial
+- **Index management** for efficient lookups
+- **Size limitations** based on localStorage quotas (5-10MB)
+
+<details>
+<summary><strong>QuickStore Implementation Patterns</strong></summary>
+
+```javascript
+const db = await lacerta.getDatabase('app');
+const quickStore = db.quickStore;
+
+// Session management
+quickStore.add('current_user', {
+  id: 'usr_123',
+  name: 'John Doe',
+  loginTime: Date.now(),
+  preferences: {
+    theme: 'dark',
+    language: 'en'
+  }
 });
 
-// Get database statistics
-const stats = db.getStats();
-console.log(`Database: ${stats.name}`);
-console.log(`Size: ${(stats.totalSizeKB / 1024).toFixed(2)}MB`);
-console.log(`Documents: ${stats.totalDocuments}`);
-stats.collections.forEach(coll => {
-  console.log(`  ${coll.name}: ${coll.documents} docs, ${coll.sizeKB}KB`);
+// Shopping cart persistence
+quickStore.add('cart', {
+  items: [
+    { productId: 'prod_1', quantity: 2, price: 29.99 },
+    { productId: 'prod_2', quantity: 1, price: 49.99 }
+  ],
+  total: 109.97,
+  updated: Date.now()
 });
 
-// Export/Import database
-const exportData = await db.export('encrypted', 'export-password');
-await saveToFile(exportData, 'backup.lacerta');
+// Query capabilities with same syntax
+const recentActivity = quickStore.query({
+  loginTime: { $gte: Date.now() - 3600000 }
+});
 
-// Later...
-const importData = await loadFromFile('backup.lacerta');
-const result = await db.import(importData, 'encrypted', 'export-password');
+// Atomic updates
+quickStore.update('current_user', {
+  ...quickStore.get('current_user'),
+  lastActivity: Date.now()
+});
 
-// Store private keys (requires encrypted database)
-await secureDb.storePrivateKey(
-  'stripe-api',
-  'sk_live_abcd1234',
-  'myapp.com'  // Additional authentication
-);
+// Clear on logout
+function logout() {
+  quickStore.delete('current_user');
+  quickStore.delete('cart');
+}
 
-// Retrieve private key
-const apiKey = await secureDb.getPrivateKey(
-  'stripe-api',
-  'myapp.com'
-);
+// Full clear
+quickStore.clear();
 ```
 
 </details>
@@ -355,156 +431,102 @@ const apiKey = await secureDb.getPrivateKey(
 
 ### 📁 Collection Class
 
-Manages documents within a collection.
+Document management with advanced querying and indexing.
 
 #### Core Methods
 
 | Method | Parameters | Returns | Description |
 |--------|------------|---------|-------------|
-| `add()` | `data: object`<br/>`options?: object` | `Promise<string>` | Add a document |
-| `get()` | `id: string`<br/>`options?: object` | `Promise<object>` | Get a document |
-| `update()` | `id: string`<br/>`updates: object`<br/>`options?: object` | `Promise<string>` | Update a document |
-| `delete()` | `id: string`<br/>`options?: object` | `Promise<void>` | Delete a document |
-| `getAll()` | `options?: object` | `Promise<object[]>` | Get all documents |
-| `clear()` | `options?: object` | `Promise<void>` | Clear collection |
-| `count()` | `filter?: object` | `Promise<number>` | Count documents |
+| `add()` | `data: object`<br/>`options?: object` | `Promise<string>` | Insert document |
+| `get()` | `id: string`<br/>`options?: object` | `Promise<object>` | Retrieve document |
+| `update()` | `id: string`<br/>`updates: object`<br/>`options?: object` | `Promise<string>` | Modify document |
+| `delete()` | `id: string`<br/>`options?: object` | `Promise<void>` | Remove document |
+| `getAll()` | `options?: object` | `Promise<object[]>` | Retrieve all documents |
+| `clear()` | `options?: object` | `Promise<void>` | Purge collection |
 
-#### Query Methods
+#### Query and Aggregation
 
 | Method | Parameters | Returns | Description |
 |--------|------------|---------|-------------|
-| `query()` | `filter: object`<br/>`options?: object` | `Promise<object[]>` | Query documents |
-| `aggregate()` | `pipeline: object[]` | `Promise<object[]>` | Run aggregation pipeline |
-| `findOne()` | `filter: object` | `Promise<object│null>` | Find first matching document |
+| `query()` | `filter: object`<br/>`options?: object` | `Promise<object[]>` | Execute query |
+| `aggregate()` | `pipeline: object[]` | `Promise<object[]>` | Aggregation pipeline |
+| `findOne()` | `filter: object` | `Promise<object│null>` | First match |
+| `count()` | `filter?: object` | `Promise<number>` | Document count |
 
 #### Batch Operations
 
 | Method | Parameters | Returns | Description |
 |--------|------------|---------|-------------|
-| `batchAdd()` | `documents: object[]`<br/>`options?: object` | `Promise<object[]>` | Add multiple documents |
-| `batchUpdate()` | `updates: object[]`<br/>`options?: object` | `Promise<object[]>` | Update multiple documents |
-| `batchDelete()` | `items: string[]│object[]` | `Promise<object[]>` | Delete multiple documents |
-
-#### Event Methods
-
-| Method | Parameters | Returns | Description |
-|--------|------------|---------|-------------|
-| `on()` | `event: string`<br/>`callback: function` | `void` | Add event listener |
-| `off()` | `event: string`<br/>`callback: function` | `void` | Remove event listener |
+| `batchAdd()` | `documents: object[]`<br/>`options?: object` | `Promise<object[]>` | Bulk insert |
+| `batchUpdate()` | `updates: object[]`<br/>`options?: object` | `Promise<object[]>` | Bulk update |
+| `batchDelete()` | `items: string[]│object[]` | `Promise<object[]>` | Bulk delete |
 
-#### Cache Methods
+#### Event System
 
 | Method | Parameters | Returns | Description |
 |--------|------------|---------|-------------|
-| `configureCacheStrategy()` | `config: object` | `void` | Configure caching |
-| `clearCache()` | - | `void` | Clear query cache |
-
-#### Options Parameters
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `id` | `string` | auto-generated | Custom document ID |
-| `compressed` | `boolean` | `true` | Enable compression |
-| `permanent` | `boolean` | `false` | Prevent auto-deletion |
-| `includeAttachments` | `boolean` | `false` | Include file attachments |
-| `attachments` | `Array` | `[]` | File attachments to store |
-| `force` | `boolean` | `false` | Force delete permanent docs |
-| `limit` | `number` | - | Limit results |
-| `skip` | `number` | - | Skip results |
-| `sort` | `object` | - | Sort criteria |
-| `projection` | `object` | - | Field projection |
+| `on()` | `event: string`<br/>`callback: function` | `void` | Register listener |
+| `off()` | `event: string`<br/>`callback: function` | `void` | Unregister listener |
 
-<details>
-<summary><strong>Examples</strong></summary>
+#### Collection Properties
 
-```javascript
-const users = await db.getCollection('users');
+| Property | Type | Description |
+|----------|------|-------------|
+| `name` | `string` | Collection identifier |
+| `database` | `Database` | Parent database |
+| `settings` | `Settings` | Configuration |
+| `metadata` | `CollectionMetadata` | Collection metrics |
+| `initialized` | `boolean` | Initialization status |
 
-// Add document with custom ID
-const userId = await users.add({
-  name: 'John Doe',
-  email: 'john@example.com',
-  age: 30,
-  skills: ['JavaScript', 'TypeScript', 'React']
-}, {
-  id: 'user_john_doe',
-  permanent: true  // Protect from auto-cleanup
-});
+---
 
-// Find one document
-const john = await users.findOne({ email: 'john@example.com' });
+### 🔐 Connection Management
 
-// Query with multiple conditions
-const seniorDevs = await users.query(
-  { 
-    age: { $gte: 25, $lte: 45 },
-    skills: { $all: ['JavaScript', 'React'] }
-  },
-  { 
-    sort: { age: -1 },
-    limit: 10,
-    projection: { name: 1, email: 1, skills: 1 }
-  }
-);
+#### IndexedDBConnectionPool
 
-// Complex aggregation pipeline
-const skillStats = await users.aggregate([
-  { $match: { age: { $gte: 18 } } },
-  { $project: { skills: 1 } },
-  { $unwind: '$skills' },
-  { $group: {
-      _id: '$skills',
-      count: { $count: {} },
-      users: { $push: '$_id' }
-    }
-  },
-  { $sort: { count: -1 } },
-  { $limit: 5 }
-]);
+Global connection pool for optimized database connections.
 
-// Batch operations with error handling
-const newUsers = [
-  { name: 'Alice', email: 'alice@example.com' },
-  { name: 'Bob', email: 'bob@example.com' }
-];
+| Method | Parameters | Returns | Description |
+|--------|------------|---------|-------------|
+| `getConnection()` | `dbName: string`<br/>`version: number`<br/>`upgradeCallback?: function` | `Promise<IDBDatabase>` | Acquire connection |
+| `releaseConnection()` | `dbName: string`<br/>`version: number` | `void` | Release connection |
+| `closeAll()` | - | `void` | Close all connections |
 
-const results = await users.batchAdd(newUsers, {
-  compressed: true,
-  permanent: false
-});
+#### AsyncMutex
 
-results.forEach(result => {
-  if (result.success) {
-    console.log(`Added user: ${result.id}`);
-  } else {
-    console.error(`Failed to add user: ${result.error}`);
-  }
-});
+Synchronization primitive for concurrent operations.
 
-// Event listeners
-users.on('beforeAdd', (data) => {
-  console.log('Adding document:', data);
-});
+| Method | Parameters | Returns | Description |
+|--------|------------|---------|-------------|
+| `acquire()` | - | `Promise<function>` | Acquire lock |
+| `release()` | - | `void` | Release lock |
+| `runExclusive()` | `callback: function` | `Promise<any>` | Execute exclusively |
 
-users.on('afterDelete', (id) => {
-  console.log('Deleted document:', id);
-});
+<details>
+<summary><strong>Concurrency Control Patterns</strong></summary>
 
-// Add with file attachments
-const profile = await users.add({
-  name: 'User with Avatar'
-}, {
-  attachments: [
-    await OPFSUtility.prepareAttachment(avatarFile, 'avatar.jpg'),
-    await OPFSUtility.prepareAttachment(resumeFile, 'resume.pdf')
-  ]
-});
+```javascript
+// Connection pooling is automatic
+const db1 = await connectionPool.getConnection('db1', 1);
+const db2 = await connectionPool.getConnection('db1', 1); // Reuses connection
+
+// Mutex for critical sections
+const mutex = new AsyncMutex();
+
+async function criticalOperation() {
+  const release = await mutex.acquire();
+  try {
+    // Exclusive access guaranteed
+    await performCriticalWork();
+  } finally {
+    release();
+  }
+}
 
-// Retrieve with attachments
-const userWithFiles = await users.get(profile, {
-  includeAttachments: true
+// Or using runExclusive
+await mutex.runExclusive(async () => {
+  await performCriticalWork();
 });
-// userWithFiles._attachments will contain the file data
 ```
 
 </details>
@@ -513,182 +535,77 @@ const userWithFiles = await users.get(profile, {
 
 ### 🔍 Index Management
 
-Create indexes for optimized queries.
+Sophisticated indexing strategies for query optimization.
+
+#### Index Methods
 
 | Method | Parameters | Returns | Description |
 |--------|------------|---------|-------------|
-| `createIndex()` | `field: string`<br/>`options: object` | `Promise<string>` | Create an index |
-| `dropIndex()` | `name: string` | `Promise<void>` | Remove an index |
-| `getIndexes()` | - | `Promise<object>` | Get index statistics |
-| `verifyIndexes()` | - | `Promise<object>` | Verify and repair indexes |
-| `reindexCollection()` | - | `Promise<void>` | Rebuild all indexes |
-
-#### Index Types and Use Cases
-
-| Type | Use Case | Query Performance | Space Overhead |
-|------|----------|-------------------|----------------|
-| `btree` | Range queries, sorting | O(log n) | Medium |
-| `hash` | Exact match queries | O(1) | Low |
-| `text` | Full-text search | O(n) for terms | High |
-| `geo` | Spatial queries | O(n log n) | Medium |
-
-#### Index Options
-
-| Option | Type | Default | Values | Description |
-|--------|------|---------|--------|-------------|
-| `type` | `string` | `'btree'` | `'btree'`, `'hash'`, `'text'`, `'geo'` | Index type |
-| `unique` | `boolean` | `false` | - | Enforce uniqueness |
-| `sparse` | `boolean` | `false` | - | Skip null values |
-| `name` | `string` | field name | - | Custom index name |
-| `collation` | `object` | null | - | Collation rules |
+| `createIndex()` | `field: string`<br/>`options: object` | `Promise<string>` | Create index |
+| `dropIndex()` | `name: string` | `Promise<void>` | Remove index |
+| `getIndexes()` | - | `Promise<object>` | Index statistics |
+| `verifyIndexes()` | - | `Promise<object>` | Self-healing verification |
 
-<details>
-<summary><strong>Examples</strong></summary>
+#### Index Architectures
 
-```javascript
-// Create B-Tree index for range queries
-await users.createIndex('age', { 
-  type: 'btree',
-  name: 'age_index'
-});
-
-// Create compound index (nested fields)
-await users.createIndex('address.city', { 
-  type: 'hash',
-  name: 'city_index'
-});
-
-// Create unique index on email
-await users.createIndex('email', { 
-  unique: true,
-  sparse: true  // Allow multiple nulls
-});
-
-// Create text index for full-text search
-await posts.createIndex('content', { 
-  type: 'text',
-  name: 'content_search'
-});
-
-// Use text index
-const searchResults = await posts.query({
-  content: { $text: 'javascript tutorial' }
-});
-
-// Create geo index for location queries
-await stores.createIndex('location', { 
-  type: 'geo'
-});
+| Type | Algorithm | Use Case | Complexity | Space |
+|------|-----------|----------|------------|-------|
+| `btree` | B-Tree | Range queries, sorting | O(log n) | O(n) |
+| `hash` | Hash Table | Exact match | O(1) avg | O(n) |
+| `text` | Inverted Index | Full-text search | O(m) | O(n*m) |
+| `geo` | R-Tree variant | Spatial queries | O(log n) | O(n) |
 
-// Query using geo index - find nearby
-const nearbyStores = await stores.query({
-  location: {
-    $near: {
-      coordinates: { lat: 40.7128, lng: -74.0060 },
-      maxDistance: 5000  // 5km in meters
-    }
-  }
-});
+#### Self-Healing Indexes
 
-// Query using geo index - find within bounds
-const storesInArea = await stores.query({
-  location: {
-    $within: {
-      minLat: 40.7,
-      maxLat: 40.8,
-      minLng: -74.1,
-      maxLng: -74.0
-    }
-  }
-});
+B-Tree indexes include automatic verification and repair mechanisms:
 
-// Get index statistics
-const indexes = await users.getIndexes();
-Object.entries(indexes).forEach(([name, info]) => {
-  console.log(`Index: ${name}`);
-  console.log(`  Type: ${info.type}`);
-  console.log(`  Size: ${info.size} entries`);
-  console.log(`  Memory: ~${info.memoryUsage} bytes`);
-});
+```javascript
+// Automatic verification during operations
+const btreeIndex = new BTreeIndex();
+btreeIndex.insert(key, value); // Triggers periodic verification
 
-// Verify and auto-repair indexes
-const report = await users.verifyIndexes();
-if (!report.healthy) {
-  console.log('Indexes repaired:', report.repaired);
-}
+// Manual verification
+const report = await collection.verifyIndexes();
+// {
+//   'age_index': { healthy: true, issues: [] },
+//   'email_index': { healthy: false, issues: [...], repaired: 2 }
+// }
 ```
 
-</details>
-
 ---
 
 ### 🔐 Encryption
 
-Database-level encryption configuration.
-
-| Method | Parameters | Returns | Description |
-|--------|------------|---------|-------------|
-| `initialize()` | `pin: string`<br/>`salt?: Uint8Array` | `Promise<string>` | Initialize encryption |
-| `changePin()` | `oldPin: string`<br/>`newPin: string` | `Promise<string>` | Change encryption PIN |
-| `destroy()` | - | `void` | Clear encryption keys |
-| `exportMetadata()` | - | `object` | Export encryption config |
-| `importMetadata()` | `metadata: object` | `boolean` | Import encryption config |
-
-#### Encryption Configuration
-
-| Option | Type | Default | Range | Description |
-|--------|------|---------|-------|-------------|
-| `iterations` | `number` | `100000` | 10000-1000000 | PBKDF2 iterations |
-| `hashAlgorithm` | `string` | `'SHA-256'` | SHA-256/SHA-512 | Hash algorithm |
-| `keyLength` | `number` | `256` | 128/192/256 | Key length in bits |
-| `saltLength` | `number` | `32` | 16-64 | Salt length in bytes |
+Cryptographic subsystem with configurable parameters.
 
-#### Static Methods
+#### SecureDatabaseEncryption Class
 
 | Method | Parameters | Returns | Description |
 |--------|------------|---------|-------------|
-| `generateSecurePIN()` | `length: number` | `string` | Generate random PIN |
-
-<details>
-<summary><strong>Examples</strong></summary>
-
-```javascript
-// Initialize encrypted database with custom config
-const secureDb = await lacerta.getSecureDatabase(
-  'secure-app',
-  'user-pin-123456',
-  null,  // Auto-generate salt
-  {
-    iterations: 200000,     // Higher = more secure but slower
-    keyLength: 256,
-    hashAlgorithm: 'SHA-512'
-  }
-);
-
-// Change PIN
-const newSalt = await secureDb.changePin(
-  'old-pin-123456',
-  'new-pin-789012'
-);
-console.log('New salt (store securely):', newSalt);
-
-// Generate secure PIN
-const securePin = SecureDatabaseEncryption.generateSecurePIN(8);
-console.log('Generated PIN:', securePin);
-
-// Export encryption metadata (for backup)
-const encryptionMeta = secureDb.encryption.exportMetadata();
-// Store this securely with your backups
-
-// Restore encryption with same config
-const restoredDb = await lacerta.getSecureDatabase(
-  'secure-app',
-  userPin,
-  encryptionMeta.salt  // Use stored salt
-);
-```
-
-</details>
+| `initialize()` | `pin: string`<br/>`salt?: Uint8Array` | `Promise<string>` | Initialize encryption |
+| `encrypt()` | `data: any` | `Promise<Uint8Array>` | Encrypt data |
+| `decrypt()` | `data: Uint8Array` | `Promise<Uint8Array>` | Decrypt data |
+| `encryptPrivateKey()` | `key: string`<br/>`auth?: string` | `Promise<string>` | Secure key encryption |
+| `decryptPrivateKey()` | `encrypted: string`<br/>`auth?: string` | `Promise<string>` | Key decryption |
+| `changePin()` | `oldPin: string`<br/>`newPin: string` | `Promise<string>` | Rotate PIN |
+| `destroy()` | - | `void` | Clear keys |
+| `exportMetadata()` | - | `object` | Export config |
+| `importMetadata()` | `metadata: object` | `boolean` | Import config |
+
+#### Encryption Properties (Getters)
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `initialized` | `boolean` | Initialization status |
+
+#### Cryptographic Parameters
+
+| Parameter | Default | Range | Description |
+|-----------|---------|-------|-------------|
+| `iterations` | 100000 | 10000-1000000 | PBKDF2 iterations |
+| `hashAlgorithm` | SHA-256 | SHA-256/512 | Hash function |
+| `keyLength` | 256 | 128/192/256 | AES key size |
+| `saltLength` | 32 | 16-64 | Salt bytes |
 
 ---
 
@@ -697,415 +614,524 @@ const restoredDb = await lacerta.getSecureDatabase(
 ### 🎯 Query Operators
 
 #### Comparison Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `$eq` | Equals | `{ age: { $eq: 25 } }` |
-| `$ne` | Not equals | `{ status: { $ne: 'deleted' } }` |
-| `$gt` | Greater than | `{ price: { $gt: 100 } }` |
-| `$gte` | Greater than or equal | `{ age: { $gte: 18 } }` |
-| `$lt` | Less than | `{ score: { $lt: 50 } }` |
-| `$lte` | Less than or equal | `{ age: { $lte: 65 } }` |
-
-#### Array Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `$in` | Value in array | `{ category: { $in: ['A', 'B'] } }` |
-| `$nin` | Value not in array | `{ status: { $nin: ['banned'] } }` |
-| `$all` | Array contains all | `{ tags: { $all: ['js', 'node'] } }` |
-| `$elemMatch` | Array element match | `{ scores: { $elemMatch: { $gt: 80 } } }` |
-| `$size` | Array size | `{ items: { $size: 3 } }` |
+| Operator | Semantic | Example |
+|----------|----------|---------|
+| `$eq` | Equality | `{ status: { $eq: 'active' } }` |
+| `$ne` | Inequality | `{ deleted: { $ne: true } }` |
+| `$gt` | Greater than | `{ score: { $gt: 90 } }` |
+| `$gte` | Greater or equal | `{ age: { $gte: 18 } }` |
+| `$lt` | Less than | `{ price: { $lt: 100 } }` |
+| `$lte` | Less or equal | `{ quantity: { $lte: 10 } }` |
+
+#### Set Operations
+| Operator | Semantic | Example |
+|----------|----------|---------|
+| `$in` | Set membership | `{ role: { $in: ['admin', 'mod'] } }` |
+| `$nin` | Set exclusion | `{ status: { $nin: ['deleted'] } }` |
+
+#### Array Operations
+| Operator | Semantic | Example |
+|----------|----------|---------|
+| `$all` | Contains all | `{ tags: { $all: ['js', 'ts'] } }` |
+| `$elemMatch` | Element match | `{ scores: { $elemMatch: { $gt: 80 } } }` |
+| `$size` | Array length | `{ items: { $size: 5 } }` |
 
 #### Logical Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `$and` | Logical AND | `{ $and: [{ age: { $gte: 18 } }, { active: true }] }` |
-| `$or` | Logical OR | `{ $or: [{ role: 'admin' }, { role: 'moderator' }] }` |
-| `$not` | Logical NOT | `{ age: { $not: { $lt: 18 } } }` |
-| `$nor` | Logical NOR | `{ $nor: [{ expired: true }, { deleted: true }] }` |
-
-#### Element Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `$exists` | Field exists | `{ email: { $exists: true } }` |
-| `$type` | Field type | `{ age: { $type: 'number' } }` |
-
-#### String Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `$regex` | Regular expression | `{ name: { $regex: '^John' } }` |
-| `$text` | Text search | `{ bio: { $text: 'developer' } }` |
-
-### 📊 Aggregation Pipeline Stages
-
-| Stage | Description | Example |
-|-------|-------------|---------|
-| `$match` | Filter documents | `{ $match: { age: { $gte: 18 } } }` |
-| `$group` | Group by field | `{ $group: { _id: '$category', count: { $count: {} } } }` |
-| `$sort` | Sort results | `{ $sort: { createdAt: -1 } }` |
-| `$limit` | Limit results | `{ $limit: 10 }` |
-| `$skip` | Skip results | `{ $skip: 20 }` |
-| `$project` | Project fields | `{ $project: { name: 1, email: 1 } }` |
-| `$lookup` | Join collections | `{ $lookup: { from: 'posts', localField: '_id', foreignField: 'userId', as: 'userPosts' } }` |
-
-#### Aggregation Accumulator Operators
-
-| Operator | Description | Example |
-|----------|-------------|---------|
-| `$sum` | Sum values | `{ total: { $sum: '$amount' } }` |
-| `$avg` | Average values | `{ avgAge: { $avg: '$age' } }` |
-| `$min` | Minimum value | `{ minPrice: { $min: '$price' } }` |
-| `$max` | Maximum value | `{ maxScore: { $max: '$score' } }` |
-| `$count` | Count documents | `{ total: { $count: {} } }` |
+| Operator | Semantic | Example |
+|----------|----------|---------|
+| `$and` | Conjunction | `{ $and: [{ a: 1 }, { b: 2 }] }` |
+| `$or` | Disjunction | `{ $or: [{ a: 1 }, { b: 2 }] }` |
+| `$not` | Negation | `{ field: { $not: { $eq: 'value' } } }` |
+| `$nor` | Joint denial | `{ $nor: [{ a: 1 }, { b: 2 }] }` |
+
+#### Type and Existence
+| Operator | Semantic | Example |
+|----------|----------|---------|
+| `$exists` | Field existence | `{ optional: { $exists: false } }` |
+| `$type` | Type checking | `{ age: { $type: 'number' } }` |
+
+#### Pattern Matching
+| Operator | Semantic | Example |
+|----------|----------|---------|
+| `$regex` | Regular expression | `{ email: { $regex: '^[a-z]+@' } }` |
+| `$text` | Text search | `{ content: { $text: 'javascript' } }` |
+
+### 📊 Aggregation Pipeline
+
+#### Pipeline Stages
+
+| Stage | Function | Example |
+|-------|----------|---------|
+| `$match` | Filter documents | `{ $match: { status: 'active' } }` |
+| `$project` | Shape output | `{ $project: { name: 1, age: 1 } }` |
+| `$group` | Aggregate groups | `{ $group: { _id: '$category', total: { $sum: 1 } } }` |
+| `$sort` | Order results | `{ $sort: { createdAt: -1 } }` |
+| `$limit` | Limit count | `{ $limit: 100 }` |
+| `$skip` | Skip documents | `{ $skip: 20 }` |
+| `$lookup` | Join collections | `{ $lookup: { from: 'orders', localField: 'userId', foreignField: '_id', as: 'orders' } }` |
+
+#### Accumulator Operators
+
+| Operator | Function | Example |
+|----------|----------|---------|
+| `$sum` | Summation | `{ total: { $sum: '$amount' } }` |
+| `$avg` | Average | `{ avgScore: { $avg: '$score' } }` |
+| `$min` | Minimum | `{ lowest: { $min: '$price' } }` |
+| `$max` | Maximum | `{ highest: { $max: '$price' } }` |
+| `$count` | Count | `{ count: { $count: {} } }` |
 
 ### 💾 Cache Strategies
 
-| Strategy | Description | Best For | Configuration |
-|----------|-------------|----------|---------------|
-| `lru` | Least Recently Used | General purpose | `maxSize`, `ttl` |
-| `lfu` | Least Frequently Used | Repeated queries | `maxSize`, `ttl` |
-| `ttl` | Time To Live | Time-sensitive data | `ttl` |
-| `none` | No caching | Real-time data | - |
+#### Strategy Architectures
+
+| Strategy | Algorithm | Eviction Policy | Configuration |
+|----------|-----------|-----------------|---------------|
+| `lru` | Least Recently Used | Temporal locality | `maxSize`, `ttl` |
+| `lfu` | Least Frequently Used | Access frequency | `maxSize`, `ttl` |
+| `ttl` | Time To Live | Temporal expiry | `ttl` |
+| `none` | No caching | Immediate | - |
 
 <details>
-<summary><strong>Examples</strong></summary>
+<summary><strong>Cache Strategy Implementation</strong></summary>
 
 ```javascript
-// Configure LRU cache with TTL
-users.configureCacheStrategy({
+// LRU with TTL for balanced performance
+collection.configureCacheStrategy({
   type: 'lru',
-  maxSize: 200,        // Max 200 cached queries
-  ttl: 60000,         // Expire after 1 minute
+  maxSize: 200,
+  ttl: 60000,
   enabled: true
 });
 
-// Configure LFU for frequently accessed data
-products.configureCacheStrategy({
+// LFU for hot data
+hotCollection.configureCacheStrategy({
   type: 'lfu',
   maxSize: 500,
-  ttl: 300000        // 5 minutes
+  ttl: 300000
 });
 
-// TTL-only for session data
-sessions.configureCacheStrategy({
+// TTL-only for sessions
+sessionCollection.configureCacheStrategy({
   type: 'ttl',
-  ttl: 900000        // 15 minutes
-});
-
-// Disable caching for real-time data
-liveData.configureCacheStrategy({
-  type: 'none'
+  ttl: 900000
 });
 
-// Manual cache control
-users.clearCache();  // Clear all cached queries
+// Memory optimization through lazy initialization
+// Cache is created only when first accessed (getter pattern)
+const strategy = new CacheStrategy({ type: 'lru' });
+// Internal cache instantiated on first get() call
 ```
 
 </details>
 
 ---
 
+## Architecture Deep Dive
+
+### Memory Optimization Patterns
+
+Version 0.7.0 implements sophisticated memory management through:
+
+1. **Lazy Initialization**: Collections and caches instantiate on first access
+2. **Getter/Setter Patterns**: Document data uses accessors for memory efficiency
+3. **Connection Pooling**: Reuses database connections across operations
+4. **Private Property Convention**: Underscore prefix for encapsulation
+
+```javascript
+class Document {
+  constructor(data = {}) {
+    this._data = null;  // Private storage
+    // ... other initialization
+  }
+  
+  // Lazy getter for memory optimization
+  get data() {
+    return this._data || {};
+  }
+  
+  set data(value) {
+    this._data = value;
+  }
+}
+```
+
+### Concurrency Control
+
+AsyncMutex ensures atomic operations:
+
+```javascript
+class AsyncMutex {
+  async runExclusive(callback) {
+    const release = await this.acquire();
+    try {
+      return await callback();
+    } finally {
+      release();
+    }
+  }
+}
+```
+
+### Transaction Resilience
+
+Automatic retry mechanisms with exponential backoff:
+
+```javascript
+async performTransaction(db, storeNames, mode, callback, retries = 3) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await executeTransaction();
+    } catch (error) {
+      if (i < retries - 1) {
+        await new Promise(r => setTimeout(r, (2 ** i) * 100));
+      }
+    }
+  }
+}
+```
+
+---
+
 ## Real-World Examples
 
-### 💬 Chat Application
+### 🏥 Healthcare Data Management
 
 ```javascript
-// Initialize encrypted database for chat
+// HIPAA-compliant patient data storage
 const lacerta = new LacertaDB();
-const db = await lacerta.getSecureDatabase('chat-app', userPin);
-
-// Create collections
-const messages = await db.createCollection('messages');
-const conversations = await db.createCollection('conversations');
-
-// Create indexes for performance
-await messages.createIndex('conversationId', { type: 'hash' });
-await messages.createIndex('timestamp', { type: 'btree' });
-await messages.createIndex('content', { type: 'text' });
-
-// Store message with attachment
-const messageId = await messages.add({
-  conversationId: 'conv_123',
-  userId: 'user_456',
-  content: 'Check out this photo!',
-  timestamp: Date.now(),
-  read: false
-}, {
-  attachments: [imageFile],
-  permanent: false
+const healthDb = await lacerta.getSecureDatabase(
+  'patient-records',
+  await SecureDatabaseEncryption.generateSecurePIN(12),
+  null,
+  { iterations: 500000 }  // Enhanced security
+);
+
+const patients = await healthDb.createCollection('patients');
+const vitals = await healthDb.createCollection('vitals');
+
+// QuickStore for current session
+healthDb.quickStore.add('current_patient', {
+  id: 'pat_123',
+  name: 'John Doe',
+  sessionStart: Date.now()
 });
 
-// Get recent messages with pagination
-const recentMessages = await messages.query(
-  { conversationId: 'conv_123' },
-  { 
-    sort: { timestamp: -1 },
-    limit: 20,
-    skip: 0
-  }
-);
+// Create indexes for efficient queries
+await patients.createIndex('mrn', { unique: true });  // Medical Record Number
+await vitals.createIndex('patientId', { type: 'hash' });
+await vitals.createIndex('timestamp', { type: 'btree' });
 
-// Search messages
-const searchResults = await messages.query({
-  content: { $text: 'photo' }
+// Store patient with encryption
+await patients.add({
+  mrn: 'MRN123456',
+  name: 'John Doe',
+  dob: '1980-01-15',
+  allergies: ['penicillin'],
+  conditions: ['hypertension']
+}, { permanent: true });
+
+// Record vitals
+await vitals.add({
+  patientId: 'pat_123',
+  timestamp: Date.now(),
+  bloodPressure: { systolic: 120, diastolic: 80 },
+  heartRate: 72,
+  temperature: 98.6
 });
 
-// Mark messages as read
-await messages.batchUpdate(
-  unreadMessages.map(msg => ({
-    id: msg._id,
-    data: { read: true }
-  }))
-);
+// Aggregate patient statistics
+const stats = await vitals.aggregate([
+  { $match: { patientId: 'pat_123' } },
+  { $sort: { timestamp: -1 } },
+  { $limit: 100 },
+  { $group: {
+    _id: '$patientId',
+    avgHeartRate: { $avg: '$heartRate' },
+    avgSystolic: { $avg: '$bloodPressure.systolic' },
+    readingCount: { $count: {} }
+  }}
+]);
 ```
 
-### 🛒 E-Commerce Cart
+### 🎮 Real-Time Gaming State
 
 ```javascript
-// Shopping cart with product management
-const db = await lacerta.getDatabase('shop');
-const cart = await db.createCollection('cart');
-const products = await db.createCollection('products');
-
-// Add product to cart
-await cart.add({
-  productId: 'prod_123',
-  quantity: 2,
-  price: 29.99,
-  addedAt: Date.now()
+// Game state management with QuickStore
+const gameDb = await lacerta.getDatabase('game-state');
+const quickStore = gameDb.quickStore;
+
+// Immediate state updates via QuickStore
+quickStore.add('player_state', {
+  position: { x: 100, y: 200, z: 50 },
+  health: 100,
+  inventory: ['sword', 'potion'],
+  score: 5000
 });
 
-// Calculate cart total with aggregation
-const cartTotal = await cart.aggregate([
-  { $lookup: {
-      from: 'products',
-      localField: 'productId',
-      foreignField: '_id',
-      as: 'product'
-    }
-  },
-  { $project: {
-      quantity: 1,
-      price: 1,
-      total: { $multiply: ['$quantity', '$price'] }
-    }
-  },
-  { $group: {
-      _id: null,
-      subtotal: { $sum: '$total' },
-      items: { $sum: '$quantity' }
-    }
-  }
-]);
+// Persistent game saves
+const saves = await gameDb.createCollection('saves');
+await saves.createIndex('timestamp', { type: 'btree' });
+
+async function saveGame() {
+  const state = quickStore.get('player_state');
+  await saves.add({
+    ...state,
+    savePoint: 'checkpoint_3',
+    timestamp: Date.now()
+  }, { compressed: true });
+}
 
-// Clear old cart items
-const oneWeekAgo = Date.now() - (7 * 24 * 60 * 60 * 1000);
-await cart.query(
-  { addedAt: { $lt: oneWeekAgo } }
-).then(oldItems => 
-  cart.batchDelete(oldItems.map(item => item._id))
+// Load recent saves
+const recentSaves = await saves.query(
+  { timestamp: { $gte: Date.now() - 86400000 } },
+  { sort: { timestamp: -1 }, limit: 10 }
 );
 ```
 
-### 📝 Note-Taking App
+### 📊 Analytics Dashboard
 
 ```javascript
-// Note app with full-text search
-const db = await lacerta.getDatabase('notes');
-const notes = await db.createCollection('notes');
-
-// Create search index
-await notes.createIndex('content', { type: 'text' });
-await notes.createIndex('tags', { type: 'hash' });
-
-// Save note with auto-save
-let noteId;
-const autoSave = async (content) => {
-  if (noteId) {
-    await notes.update(noteId, { 
-      content,
-      lastModified: Date.now()
-    });
-  } else {
-    noteId = await notes.add({
-      title: 'New Note',
-      content,
-      tags: [],
-      createdAt: Date.now()
-    }, { permanent: true });
+// Real-time analytics with caching strategies
+const analyticsDb = await lacerta.getDatabase('analytics');
+const events = await analyticsDb.createCollection('events');
+
+// Configure aggressive caching for dashboards
+events.configureCacheStrategy({
+  type: 'lfu',  // Frequently accessed metrics
+  maxSize: 1000,
+  ttl: 300000  // 5-minute cache
+});
+
+// Create performance indexes
+await events.createIndex('eventType', { type: 'hash' });
+await events.createIndex('timestamp', { type: 'btree' });
+await events.createIndex('userId', { type: 'hash' });
+
+// Store events with batch operations
+const eventBatch = Array.from({ length: 1000 }, (_, i) => ({
+  eventType: ['click', 'view', 'purchase'][i % 3],
+  userId: `user_${i % 100}`,
+  timestamp: Date.now() - (i * 1000),
+  metadata: { source: 'web', version: '2.0' }
+}));
+
+await events.batchAdd(eventBatch, { compressed: true });
+
+// Complex analytics aggregation
+const metrics = await events.aggregate([
+  { $match: { 
+    timestamp: { $gte: Date.now() - 3600000 }  // Last hour
+  }},
+  { $group: {
+    _id: '$eventType',
+    count: { $count: {} },
+    uniqueUsers: { $addToSet: '$userId' }
+  }},
+  { $project: {
+    eventType: '$_id',
+    count: 1,
+    uniqueUserCount: { $size: '$uniqueUsers' }
+  }},
+  { $sort: { count: -1 } }
+]);
+
+// Store computed metrics in QuickStore for instant access
+analyticsDb.quickStore.add('dashboard_metrics', {
+  computed: Date.now(),
+  metrics,
+  summary: {
+    totalEvents: metrics.reduce((sum, m) => sum + m.count, 0),
+    eventTypes: metrics.length
   }
-};
-
-// Search notes
-const searchNotes = async (query) => {
-  return await notes.query({
-    $or: [
-      { content: { $text: query } },
-      { title: { $regex: query } },
-      { tags: { $in: [query] } }
-    ]
-  });
-};
+});
 ```
 
 ---
 
 ## Performance Optimization
 
-### 📈 Performance Monitoring
+### 📈 Advanced Performance Monitoring
 
 ```javascript
-// Enable performance monitoring
-lacerta.performanceMonitor.startMonitoring();
-
-// Get real-time statistics
-const stats = lacerta.performanceMonitor.getStats();
-console.log(`Operations/sec: ${stats.opsPerSec}`);
-console.log(`Avg latency: ${stats.avgLatency}ms`);
-console.log(`Cache hit rate: ${stats.cacheHitRate}%`);
-console.log(`Memory usage: ${stats.memoryUsageMB}MB`);
+// Initialize comprehensive monitoring
+const monitor = lacerta.performanceMonitor;
+monitor.startMonitoring();
+
+// Custom performance tracking
+class PerformanceTracker {
+  constructor(monitor) {
+    this.monitor = monitor;
+    this.thresholds = {
+      query: 50,      // ms
+      write: 100,     // ms
+      aggregate: 200  // ms
+    };
+  }
+  
+  async track(operation, type) {
+    const start = performance.now();
+    try {
+      const result = await operation();
+      const duration = performance.now() - start;
+      
+      this.monitor.recordOperation(type, duration);
+      
+      if (duration > this.thresholds[type]) {
+        console.warn(`Slow ${type}: ${duration}ms`);
+      }
+      
+      return result;
+    } catch (error) {
+      this.monitor.recordOperation(`${type}_error`, 0);
+      throw error;
+    }
+  }
+}
 
-// Get optimization recommendations
-const tips = lacerta.performanceMonitor.getOptimizationTips();
-tips.forEach(tip => console.log('💡', tip));
+const tracker = new PerformanceTracker(monitor);
 
-// Monitor specific operations
-const startTime = performance.now();
-await users.query({ age: { $gte: 18 } });
-console.log(`Query took: ${performance.now() - startTime}ms`);
+// Track operations
+const results = await tracker.track(
+  () => users.query({ age: { $gte: 18 } }),
+  'query'
+);
 
-// Stop monitoring
-lacerta.performanceMonitor.stopMonitoring();
+// Optimization recommendations
+const tips = monitor.getOptimizationTips();
+// Analyzes cache hit rates, latency patterns, memory trends
 ```
 
-### ⚡ Best Practices
+### ⚡ Optimization Strategies
 
-#### 1. **Indexing Strategy**
+#### 1. **Index Architecture Selection**
 ```javascript
-// Index frequently queried fields
-await users.createIndex('email', { unique: true });
-await users.createIndex('createdAt', { type: 'btree' });
+// B-Tree for range queries and sorting
+await orders.createIndex('createdAt', { type: 'btree' });
+await products.createIndex('price', { type: 'btree' });
 
-// Use compound indexes for complex queries
-await orders.createIndex('userId', { type: 'hash' });
-await orders.createIndex('status', { type: 'hash' });
-```
+// Hash for exact matches
+await users.createIndex('email', { type: 'hash', unique: true });
+await sessions.createIndex('token', { type: 'hash' });
 
-#### 2. **Compression Settings**
-```javascript
-// Enable compression for large documents
-await logs.add(largeLogData, { compressed: true });
+// Text index for search
+await articles.createIndex('content', { type: 'text' });
 
-// Disable for frequently accessed small docs
-await config.add(settings, { compressed: false });
+// Geo index for spatial queries
+await stores.createIndex('location', { type: 'geo' });
 ```
 
-#### 3. **Batch Operations**
+#### 2. **QuickStore vs Collection Strategy**
 ```javascript
-// Good: Single batch operation
-await users.batchAdd(thousandUsers);
+// QuickStore for ephemeral, frequently accessed data
+db.quickStore.add('ui_state', { theme: 'dark', sidebar: true });
+db.quickStore.add('form_draft', { title: 'Unsaved', content: '...' });
 
-// Bad: Individual adds in loop
-for (const user of thousandUsers) {
-  await users.add(user);  // Slow!
-}
+// Collections for persistent, structured data
+await documents.add({ title: 'Report', content: '...' });
 ```
 
-#### 4. **Memory Management**
+#### 3. **Connection Pool Optimization**
 ```javascript
-// Configure size limits
-db.updateSettings({
-  sizeLimitKB: 50000,      // 50MB limit
-  bufferLimitKB: 40000,    // Start cleanup at 40MB
-  freeSpaceEvery: 10000    // Check every 10 seconds
-});
+// Connections are automatically pooled and reused
+const db1 = await lacerta.getDatabase('app');  // New connection
+const db2 = await lacerta.getDatabase('app');  // Reuses connection
 
-// Mark important docs as permanent
-await users.add(adminUser, { permanent: true });
+// Manual cleanup when necessary
+connectionPool.releaseConnection('app');
 ```
 
-#### 5. **Query Optimization**
+#### 4. **Memory-Conscious Patterns**
 ```javascript
-// Use projection to reduce data transfer
-const names = await users.query(
-  { active: true },
-  { projection: { name: 1, email: 1 } }
+// Use projection to minimize memory footprint
+const summaries = await posts.query(
+  { published: true },
+  { 
+    projection: { title: 1, excerpt: 1 },  // Only needed fields
+    limit: 100
+  }
 );
 
-// Use indexes for sorting
-await messages.createIndex('timestamp', { type: 'btree' });
-const recent = await messages.query({}, { sort: { timestamp: -1 } });
+// Clear caches periodically
+setInterval(() => {
+  posts.clearCache();
+}, 300000);  // Every 5 minutes
+
+// Configure appropriate cache sizes
+posts.configureCacheStrategy({
+  type: 'lru',
+  maxSize: 50  // Limit cache entries
+});
 ```
 
 ---
 
 ## Migration Guide
 
-### Schema Migrations
+### Version 0.6.x to 0.7.0
+
+```javascript
+// 1. Export existing data
+const oldDb = await getOldDatabase();
+const backup = await oldDb.export('json');
+
+// 2. Initialize new version
+const newLacerta = new LacertaDB();
+const newDb = await newLacerta.getDatabase('migrated');
+
+// 3. Import with QuickStore preservation
+await newDb.import(backup, 'json');
+
+// 4. Migrate to QuickStore where appropriate
+const sessions = await newDb.getCollection('sessions');
+const allSessions = await sessions.getAll();
+
+// Move active sessions to QuickStore
+for (const session of allSessions) {
+  if (session.active) {
+    newDb.quickStore.add(`session_${session.userId}`, session);
+    await sessions.delete(session._id);
+  }
+}
+
+// 5. Update indexes for new architecture
+const collections = newDb.listCollections();
+for (const name of collections) {
+  const coll = await newDb.getCollection(name);
+  await coll.verifyIndexes();  // Self-healing verification
+}
+```
+
+### Schema Evolution with Migrations
 
 ```javascript
 const migrationManager = new MigrationManager(db);
 
-// Add a migration
+// Migration to add QuickStore references
 migrationManager.addMigration({
-  version: '2.0.0',
-  name: 'Add user roles',
+  version: '0.7.0',
+  name: 'Add QuickStore support',
   up: async (doc) => {
-    if (doc.type === 'user' && !doc.role) {
-      return { ...doc, role: 'member' };
+    if (doc.sessionId && !doc.quickStoreKey) {
+      // Move session data to QuickStore
+      db.quickStore.add(`session_${doc.sessionId}`, {
+        userId: doc.userId,
+        created: doc._created
+      });
+      return { ...doc, quickStoreKey: `session_${doc.sessionId}` };
     }
     return null;
   },
   down: async (doc) => {
-    if (doc.type === 'user') {
-      const { role, ...rest } = doc;
+    if (doc.quickStoreKey) {
+      db.quickStore.delete(doc.quickStoreKey);
+      const { quickStoreKey, ...rest } = doc;
       return rest;
     }
     return null;
   }
 });
 
-// Add another migration
-migrationManager.addMigration({
-  version: '2.1.0',
-  name: 'Add timestamps',
-  up: async (doc) => {
-    if (!doc.updatedAt) {
-      return { ...doc, updatedAt: doc._modified };
-    }
-    return null;
-  }
-});
-
-// Run all migrations up to version
-await migrationManager.runMigrations('2.1.0');
-
-// Rollback if needed
-await migrationManager.rollback('1.0.0');
-```
-
-### Upgrading from v0.5.x to v0.6.x
-
-```javascript
-// Export data from old version
-const oldDb = await getOldDatabase();
-const backup = await oldDb.export('json');
-
-// Import to new version
-const newLacerta = new LacertaDB();
-const newDb = await newLacerta.getDatabase('upgraded-db');
-await newDb.import(backup, 'json');
-
-// Update indexes for better performance
-const collections = newDb.listCollections();
-for (const collName of collections) {
-  const coll = await newDb.getCollection(collName);
-  await coll.verifyIndexes();
-}
+await migrationManager.runMigrations('0.7.0');
 ```
 
 ---
@@ -1114,190 +1140,177 @@ for (const collName of collections) {
 
 ### Common Issues and Solutions
 
-#### 🔴 **QuotaExceededError**
+#### 🔴 **QuickStore Quota Exceeded**
 
-**Problem:** Browser storage limit reached
+**Problem:** LocalStorage limit reached (5-10MB)
 
 **Solutions:**
 ```javascript
-// 1. Check current usage
-const stats = db.getStats();
-console.log(`Using ${stats.totalSizeKB}KB`);
-
-// 2. Clear old data
-await logs.clear();
-
-// 3. Enable automatic cleanup
-db.updateSettings({
-  sizeLimitKB: 45000,
-  bufferLimitKB: 40000
-});
-
-// 4. Use compression
-await collection.add(data, { compressed: true });
-```
-
-#### 🔴 **Slow Query Performance**
-
-**Problem:** Queries taking too long
-
-**Solutions:**
-```javascript
-// 1. Add appropriate indexes
-await collection.createIndex('fieldName', { type: 'btree' });
-
-// 2. Use query projection
-const results = await collection.query(
-  filter,
-  { projection: { needed: 1, fields: 1 } }
-);
-
-// 3. Enable caching
-collection.configureCacheStrategy({
-  type: 'lru',
-  maxSize: 100
-});
+// 1. Monitor QuickStore usage
+console.log(`QuickStore entries: ${db.quickStore.size}`);
+
+// 2. Implement rotation policy
+function rotateQuickStore(maxEntries = 100) {
+  const all = db.quickStore.getAll();
+  if (all.length > maxEntries) {
+    const toDelete = all
+      .sort((a, b) => a._modified - b._modified)
+      .slice(0, all.length - maxEntries);
+    
+    toDelete.forEach(doc => db.quickStore.delete(doc._id));
+  }
+}
 
-// 4. Check index health
-const report = await collection.verifyIndexes();
+// 3. Move to collections for larger data
+if (data.length > 1000) {  // Large dataset
+  await collection.add(data);
+} else {
+  db.quickStore.add('small_data', data);
+}
 ```
 
-#### 🔴 **Memory Leaks in SPAs**
+#### 🔴 **Connection Pool Exhaustion**
 
-**Problem:** Memory usage growing over time
+**Problem:** Too many concurrent database operations
 
 **Solutions:**
 ```javascript
-// 1. Clean up on component unmount
-componentWillUnmount() {
-  this.collection.off('update', this.handleUpdate);
-  this.db.destroy();
+// 1. Use batch operations
+await users.batchAdd(documents);  // Single transaction
+
+// 2. Implement operation queuing
+class OperationQueue {
+  constructor(concurrency = 10) {
+    this.queue = [];
+    this.running = 0;
+    this.concurrency = concurrency;
+  }
+  
+  async add(operation) {
+    if (this.running >= this.concurrency) {
+      await new Promise(resolve => this.queue.push(resolve));
+    }
+    this.running++;
+    try {
+      return await operation();
+    } finally {
+      this.running--;
+      if (this.queue.length > 0) {
+        this.queue.shift()();
+      }
+    }
+  }
 }
-
-// 2. Use destroy method
-window.addEventListener('beforeunload', () => {
-  lacerta.destroy();
-});
-
-// 3. Clear caches periodically
-setInterval(() => {
-  collection.clearCache();
-}, 300000);  // Every 5 minutes
 ```
 
-#### 🔴 **Encryption Issues**
+#### 🔴 **Memory Leaks with Private Properties**
 
-**Problem:** Cannot access encrypted database
+**Problem:** References to private properties preventing garbage collection
 
 **Solutions:**
 ```javascript
-// 1. Verify PIN is correct
-try {
-  const db = await lacerta.getSecureDatabase('app', pin);
-} catch (error) {
-  if (error.code === 'ENCRYPTION_FAILED') {
-    console.error('Invalid PIN');
+// 1. Proper cleanup in destroy methods
+class Collection {
+  destroy() {
+    clearInterval(this._cleanupInterval);
+    this._events.clear();
+    this._cacheStrategy = null;
+    this._indexManager = null;
+    // Release connection
+    if (this._db) {
+      connectionPool.releaseConnection(this.database.name);
+    }
   }
 }
 
-// 2. Check if salt is preserved
-const metadata = db.encryption.exportMetadata();
-localStorage.setItem('app-salt', metadata.salt);
-
-// 3. Use same encryption config
-const db = await lacerta.getSecureDatabase('app', pin, salt, {
-  iterations: 100000,  // Must match original
-  keyLength: 256
-});
-```
-
-### Debug Mode
-
-```javascript
-// Enable debug logging
-window.LACERTA_DEBUG = true;
-
-// Log all operations
-const originalAdd = collection.add;
-collection.add = async function(...args) {
-  console.log('Adding document:', args);
-  const result = await originalAdd.apply(this, args);
-  console.log('Document added:', result);
-  return result;
-};
+// 2. WeakMap for external references
+const privateData = new WeakMap();
+privateData.set(instance, { sensitive: 'data' });
 ```
 
 ---
 
 ## Error Handling
 
-### Error Types
-
-| Error Code | Description | Resolution |
-|------------|-------------|------------|
-| `DATABASE_OPEN_FAILED` | Cannot open database | Check browser support, clear browser data |
-| `DOCUMENT_NOT_FOUND` | Document doesn't exist | Verify document ID exists |
-| `COLLECTION_NOT_FOUND` | Collection doesn't exist | Create collection first |
-| `COLLECTION_EXISTS` | Collection already exists | Use getCollection instead |
-| `UNIQUE_CONSTRAINT` | Unique index violation | Use different value or update existing |
-| `QUOTA_EXCEEDED` | Storage limit reached | Clear old data or increase limit |
-| `ENCRYPTION_NOT_INITIALIZED` | Encryption required | Use getSecureDatabase |
-| `ENCRYPTION_FAILED` | Decryption failed | Check PIN and salt |
-| `PERMANENT_DOCUMENT_PROTECTION` | Cannot delete permanent | Use force: true option |
-| `TRANSACTION_FAILED` | Transaction aborted | Retry operation |
-| `INVALID_FORMAT` | Invalid data format | Check data structure |
+### Comprehensive Error Taxonomy
+
+| Error Code | Semantic Context | Resolution Strategy |
+|------------|------------------|---------------------|
+| `DATABASE_OPEN_FAILED` | IndexedDB initialization failure | Verify browser compatibility, clear data |
+| `DOCUMENT_NOT_FOUND` | Non-existent document reference | Validate document existence |
+| `COLLECTION_NOT_FOUND` | Undefined collection | Initialize collection first |
+| `COLLECTION_EXISTS` | Duplicate collection | Use getCollection() |
+| `UNIQUE_CONSTRAINT` | Index uniqueness violation | Modify value or update |
+| `QUOTA_EXCEEDED` | Storage capacity exceeded | Implement cleanup strategy |
+| `ENCRYPTION_NOT_INITIALIZED` | Missing encryption context | Use getSecureDatabase() |
+| `ENCRYPTION_FAILED` | Cryptographic operation failure | Verify credentials |
+| `PERMANENT_DOCUMENT_PROTECTION` | Protected document deletion | Apply force option |
+| `TRANSACTION_FAILED` | Transaction abort | Retry with backoff |
+| `QUICKSTORE_QUOTA_EXCEEDED` | LocalStorage limit | Rotate QuickStore data |
 
 <details>
-<summary><strong>Example Error Handling</strong></summary>
+<summary><strong>Error Handling Patterns</strong></summary>
 
 ```javascript
-// Comprehensive error handling
-class DatabaseService {
-  async safeOperation(operation) {
-    try {
-      return await operation();
-    } catch (error) {
-      switch (error.code) {
-        case 'UNIQUE_CONSTRAINT':
-          console.error('Duplicate entry:', error.message);
-          // Handle duplicate
-          break;
-          
-        case 'QUOTA_EXCEEDED':
-          console.warn('Storage full, cleaning up...');
-          await this.cleanup();
-          // Retry operation
+class ResilientDatabaseService {
+  constructor(lacerta) {
+    this.lacerta = lacerta;
+    this.mutex = new AsyncMutex();
+  }
+  
+  async executeWithRetry(operation, maxRetries = 3) {
+    return this.mutex.runExclusive(async () => {
+      let lastError;
+      
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
           return await operation();
+        } catch (error) {
+          lastError = error;
           
-        case 'DOCUMENT_NOT_FOUND':
-          console.error('Document not found');
-          return null;
-          
-        case 'ENCRYPTION_FAILED':
-          console.error('Invalid credentials');
-          throw new Error('Authentication failed');
-          
-        default:
-          console.error('Database error:', error);
-          throw error;
+          // Categorize and handle errors
+          switch (error.code) {
+            case 'QUOTA_EXCEEDED':
+              await this.handleQuotaExceeded();
+              break;
+              
+            case 'TRANSACTION_FAILED':
+              await this.delay((2 ** attempt) * 100);
+              break;
+              
+            case 'ENCRYPTION_FAILED':
+              throw new Error('Authentication required');
+              
+            default:
+              if (attempt === maxRetries - 1) throw error;
+          }
+        }
       }
+      
+      throw lastError;
+    });
+  }
+  
+  async handleQuotaExceeded() {
+    // Clear QuickStore
+    const db = await this.lacerta.getDatabase('app');
+    db.quickStore.clear();
+    
+    // Clear old collection data
+    const collections = db.listCollections();
+    for (const name of collections) {
+      const coll = await db.getCollection(name);
+      const oldDocs = await coll.query({
+        _modified: { $lt: Date.now() - 86400000 }
+      });
+      await coll.batchDelete(oldDocs.map(d => d._id));
     }
   }
   
-  async cleanup() {
-    const logs = await db.getCollection('logs');
-    const oldLogs = await logs.query({
-      timestamp: { $lt: Date.now() - 86400000 }
-    });
-    await logs.batchDelete(oldLogs.map(log => log._id));
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
   }
 }
-
-// Usage
-const service = new DatabaseService();
-const result = await service.safeOperation(async () => {
-  return await users.add({ email: 'test@example.com' });
-});
 ```
 
 </details>
@@ -1306,59 +1319,74 @@ const result = await service.safeOperation(async () => {
 
 ## Comparison
 
-### LacertaDB vs Alternatives
-
-| Feature | LacertaDB | LocalStorage | IndexedDB (Raw) | PouchDB | Dexie.js |
-|---------|-----------|--------------|-----------------|---------|----------|
-| **Size Limit** | ~2GB* | 5-10MB | ~2GB* | ~2GB* | ~2GB* |
-| **Encryption** | ✅ Built-in | ❌ | ❌ | ⚠️ Plugin | ❌ |
-| **Compression** | ✅ Automatic | ❌ | ❌ | ❌ | ❌ |
-| **Query Language** | ✅ MongoDB-like | ❌ | ❌ | ✅ Map/Reduce | ⚠️ Limited |
-| **Indexes** | ✅ Multiple types | ❌ | ⚠️ Basic | ✅ | ✅ |
-| **Aggregation** | ✅ Full pipeline | ❌ | ❌ | ⚠️ Views | ❌ |
-| **File Attachments** | ✅ OPFS | ❌ | ❌ | ✅ | ❌ |
-| **Performance Monitor** | ✅ Built-in | ❌ | ❌ | ❌ | ❌ |
-| **Bundle Size** | ~45KB | 0KB | 0KB | ~140KB | ~90KB |
-| **TypeScript** | ✅ | ✅ | ✅ | ✅ | ✅ |
-| **Learning Curve** | Medium | Low | High | Medium | Low |
-
-*Actual limit varies by browser and available disk space
-
-### When to Use LacertaDB
-
-✅ **Use LacertaDB when you need:**
-- Client-side encryption for sensitive data
-- Complex queries and aggregations
-- Automatic compression to save space
-- MongoDB-like query syntax
-- Built-in performance monitoring
-- File attachment support
-
-❌ **Consider alternatives when:**
-- You need < 1MB storage (use localStorage)
-- You need server synchronization (use PouchDB)
-- You need minimal bundle size (use raw IndexedDB)
-- You only need key-value storage (use localStorage)
+### LacertaDB v0.7.0 vs Alternatives
+
+| Feature | LacertaDB 0.7 | LocalStorage | IndexedDB | PouchDB | Dexie.js | LokiJS |
+|---------|---------------|--------------|-----------|---------|----------|---------|
+| **Storage Limit** | ~2GB + 10MB* | 5-10MB | ~2GB | ~2GB | ~2GB | Memory/5MB |
+| **QuickStore** | ✅ Built-in | ≈ | ❌ | ❌ | ❌ | ❌ |
+| **Encryption** | ✅ AES-GCM | ❌ | ❌ | ⚠️ Plugin | ❌ | ❌ |
+| **Compression** | ✅ Native | ❌ | ❌ | ❌ | ❌ | ❌ |
+| **Connection Pool** | ✅ | N/A | ❌ | ❌ | ❌ | ❌ |
+| **Query Language** | ✅ MongoDB | ❌ | ❌ | ✅ MapReduce | ⚠️ Limited | ✅ |
+| **Indexes** | ✅ 4 types | ❌ | ⚠️ Basic | ✅ | ✅ | ✅ |
+| **Aggregation** | ✅ Pipeline | ❌ | ❌ | ⚠️ Views | ❌ | ⚠️ |
+| **Self-Healing** | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| **Bundle Size** | ~48KB | 0KB | 0KB | ~140KB | ~90KB | ~70KB |
+| **Concurrency** | ✅ Mutex | ❌ | ⚠️ | ⚠️ | ⚠️ | ❌ |
+
+*IndexedDB (2GB) + QuickStore LocalStorage (10MB)
+
+### Architectural Selection Criteria
+
+**Deploy LacertaDB when requiring:**
+- Dual-layer storage (persistent + ephemeral)
+- Zero-knowledge client-side encryption
+- Self-healing index structures
+- Connection pooling for scalability
+- MongoDB-compatible query semantics
+- Integrated performance telemetry
+
+**Consider alternatives for:**
+- Minimal storage needs (< 1MB): LocalStorage
+- Server synchronization priority: PouchDB/CouchDB
+- Memory-only operations: LokiJS
+- Simple key-value patterns: LocalStorage/SessionStorage
 
 ---
 
-## 📝 License
-
-MIT © 2024 LacertaDB Contributors
+## Changelog
+
+### Version 0.7.0 (Latest)
+- **Added:** QuickStore for localStorage-based ephemeral caching
+- **Added:** Connection pooling for optimized resource management
+- **Added:** AsyncMutex for concurrent operation synchronization
+- **Improved:** Private property conventions with underscore prefix
+- **Improved:** Memory optimization through lazy initialization
+- **Improved:** Self-healing B-Tree indexes with automatic verification
+- **Enhanced:** Export/import includes QuickStore data
+- **Fixed:** Connection leaks in collection destruction
+- **Fixed:** Memory optimization in Document class
+
+### Version 0.6.2
+- Database-level encryption
+- Compression support
+- Multiple index types
+- Aggregation pipeline
+- Performance monitoring
 
 ---
 
-## 🙏 Acknowledgments
+## Contributing
 
-Special thanks to all contributors and the open-source community.
+LacertaDB embraces collaborative development. Contribution vectors include:
 
-Built with ❤️ using:
-- [TurboSerial](https://github.com/pixagram/turboserial) for serialization
-- [TurboBase64](https://github.com/pixagram/turbobase64) for encoding
+1. **Architecture Enhancement**: Propose algorithmic improvements
+2. **Index Strategies**: Implement novel index structures
+3. **Performance Optimization**: Profile and optimize critical paths
+4. **Documentation**: Expand architectural documentation
+5. **Test Coverage**: Strengthen test suites
 
----
----
+## 📝 License
 
-<p align="center">
-  <strong>Star ⭐ this repository if you find it helpful!</strong>
-</p>
+MIT © 2024 LacertaDB Contributors