@pixagram/lacerta-db 0.1.0 → 0.2.0

package/index.js

@@ -1,2091 +1,2462 @@
-/*
-The MIT License (MIT)
-Copyright (c) 2024 Matias Affolter
-*/
-"use strict";
-import TurboSerial from "@pixagram/turboserial";
-const TURBO = new TurboSerial({
-                compression: false,           // Enable compression
-                deduplication: true,          // Enable reference deduplication
-                shareArrayBuffers: true,      // Share ArrayBuffer references
-                simdOptimization: true,       // Enable SIMD optimizations
-                detectCircular: true,         // Detect circular references
-                memoryPoolSize: 65536        // Initial memory pool size
+/**
+ * LacertaDB V4 - Complete Core Library (Refactored)
+ * A powerful browser-based document database with encryption, compression, and OPFS support
+ * @version 4.0.0
+ * @license MIT
+ */
+'use strict';
+
+(function(global) {
+    var TurboSerial = require("@pixagram/turboserial");
+    var TurboBase64 = require("@pixagram/turbobase64");
+
+    var serializer = new TurboSerial({
+        compression: true,
+        deduplication: true,
+        shareArrayBuffers: true,
+        simdOptimization: true,
+        detectCircular: true
+    });
+    var base64 = new TurboBase64();
+
+    /**
+     * Async Mutex for managing concurrent operations
+     */
+    class AsyncMutex {
+        constructor() {
+            this._queue = [];
+            this._locked = false;
+        }
+
+        acquire() {
+            var self = this;
+            return new Promise(function(resolve) {
+                self._queue.push(resolve);
+                self._dispatch();
             });
-            
-// Utility function for nested object access
-function getNestedValue(obj, path) {
-    return path.split('.').reduce((curr, prop) => (curr || {})[prop], obj);
-}
-
-class OPFSUtility {
-    static async saveAttachments(dbName, collectionName, documentId, attachments) {
-        const attachmentPaths = [];
-        const rootHandle = await navigator.storage.getDirectory();
-        const pathParts = [dbName, collectionName, documentId];
+        }
 
-        let dirHandle = rootHandle;
-        for (const part of pathParts) {
-            dirHandle = await dirHandle.getDirectoryHandle(part, { create: true });
+        release() {
+            this._locked = false;
+            this._dispatch();
         }
 
-        for (let i = 0; i < attachments.length; i++) {
-            const fileId = i.toString();
-            const fileHandle = await dirHandle.getFileHandle(fileId, { create: true });
-            const writable = await fileHandle.createWritable();
-            await writable.write(attachments[i].data);
-            await writable.close();
+        async runExclusive(callback) {
+            var release = await this.acquire();
+            try {
+                return await callback();
+            } finally {
+                release();
+            }
+        }
 
-            const filePath = `${dbName}/${collectionName}/${documentId}/${fileId}`;
-            attachmentPaths.push(filePath);
+        _dispatch() {
+            if (this._locked || this._queue.length === 0) {
+                return;
+            }
+            this._locked = true;
+            var resolve = this._queue.shift();
+            var self = this;
+            resolve(function() {
+                self.release();
+            });
         }
+    }
 
-        return attachmentPaths;
+    /**
+     * Custom error class for LacertaDB
+     */
+    class LacertaDBError extends Error {
+        constructor(message, code, originalError) {
+            super(message);
+            this.name = 'LacertaDBError';
+            this.code = code;
+            this.originalError = originalError || null;
+            this.timestamp = new Date().toISOString();
+        }
     }
 
-    static async getAttachments(attachmentPaths) {
-        const attachments = [];
-        const rootHandle = await navigator.storage.getDirectory();
+    // ========================
+    // Compression Utility
+    // ========================
 
-        for (const path of attachmentPaths) {
+    class BrowserCompressionUtility {
+        async compress(input) {
             try {
-                const pathParts = path.split('/');
-                let dirHandle = rootHandle;
-                for (let i = 0; i < pathParts.length - 1; i++) {
-                    dirHandle = await dirHandle.getDirectoryHandle(pathParts[i]);
-                }
-                const fileHandle = await dirHandle.getFileHandle(pathParts[pathParts.length - 1]);
-                const file = await fileHandle.getFile();
-
-                attachments.push({
-                    path: path,
-                    data: file,
-                });
+                var stream = new Response(input).body
+                    .pipeThrough(new CompressionStream('deflate'));
+                var compressed = await new Response(stream).arrayBuffer();
+                return new Uint8Array(compressed);
             } catch (error) {
-                console.error(`Error retrieving attachment at "${path}": ${error.message}`);
+                throw new LacertaDBError('Compression failed', 'COMPRESSION_FAILED', error);
             }
         }
 
-        return attachments;
-    }
-
-    static async deleteAttachments(dbName, collectionName, documentId) {
-        const rootHandle = await navigator.storage.getDirectory();
-        const pathParts = [dbName, collectionName, documentId];
-
-        let dirHandle = rootHandle;
-        for (let i = 0; i < pathParts.length - 1; i++) {
-            dirHandle = await dirHandle.getDirectoryHandle(pathParts[i]);
+        async decompress(compressedData) {
+            try {
+                var stream = new Response(compressedData).body
+                    .pipeThrough(new DecompressionStream('deflate'));
+                var decompressed = await new Response(stream).arrayBuffer();
+                return new Uint8Array(decompressed);
+            } catch (error) {
+                throw new LacertaDBError('Decompression failed', 'DECOMPRESSION_FAILED', error);
+            }
         }
 
-        try {
-            await dirHandle.removeEntry(pathParts[pathParts.length - 1], { recursive: true });
-        } catch (error) {
-            console.error(`Error deleting attachments for document "${documentId}": ${error.message}`);
+        compressSync(input) {
+            return new TextEncoder().encode(base64.encode(input));
         }
-    }
 
-    toString() {
-        return '[OPFSUtility]';
+        decompressSync(compressedData) {
+            return base64.decode(new TextDecoder().decode(compressedData));
+        }
     }
-}
 
-class BrowserCompressionUtility {
-    static async compress(input) {
-        const data = typeof input === "string" ? new TextEncoder().encode(input) : input;
-        const stream = new CompressionStream('deflate');
-        const writer = stream.writable.getWriter();
+    // ========================
+    // Encryption Utility
+    // ========================
 
-        writer.write(data);
-        writer.close();
-
-        return await this._streamToUint8Array(stream.readable);
-    }
+    class BrowserEncryptionUtility {
+        async encrypt(data, password) {
+            try {
+                var salt = crypto.getRandomValues(new Uint8Array(16));
+                var iv = crypto.getRandomValues(new Uint8Array(12));
 
-    static async decompress(compressedData) {
-        const stream = new DecompressionStream('deflate');
-        const writer = stream.writable.getWriter();
+                var keyMaterial = await crypto.subtle.importKey(
+                    'raw',
+                    new TextEncoder().encode(password),
+                    'PBKDF2',
+                    false,
+                    ['deriveKey']
+                );
 
-        writer.write(compressedData);
-        writer.close();
+                var key = await crypto.subtle.deriveKey({
+                        name: 'PBKDF2',
+                        salt: salt,
+                        iterations: 600000,
+                        hash: 'SHA-512'
+                    },
+                    keyMaterial, {
+                        name: 'AES-GCM',
+                        length: 256
+                    },
+                    false,
+                    ['encrypt']
+                );
 
-        return await this._streamToUint8Array(stream.readable);
-    }
+                var encrypted = await crypto.subtle.encrypt({
+                        name: 'AES-GCM',
+                        iv: iv
+                    },
+                    key,
+                    data
+                );
 
-    static async _streamToUint8Array(readableStream) {
-        const reader = readableStream.getReader();
-        const chunks = [];
-        let totalLength = 0;
+                var checksum = await crypto.subtle.digest('SHA-256', data);
+                var checksumArray = new Uint8Array(checksum);
 
-        while (true) {
-            const { value, done } = await reader.read();
-            if (done) break;
-            chunks.push(value);
-            totalLength += value.length;
-        }
+                var result = new Uint8Array(
+                    salt.length + iv.length + checksumArray.length + encrypted.byteLength
+                );
+                result.set(salt, 0);
+                result.set(iv, salt.length);
+                result.set(checksumArray, salt.length + iv.length);
+                result.set(new Uint8Array(encrypted), salt.length + iv.length + checksumArray.length);
 
-        const result = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const chunk of chunks) {
-            result.set(chunk, offset);
-            offset += chunk.length;
+                return result;
+            } catch (error) {
+                throw new LacertaDBError('Encryption failed', 'ENCRYPTION_FAILED', error);
+            }
         }
 
-        return result;
-    }
-
-    toString() {
-        return '[BrowserCompressionUtility]';
-    }
-}
-
-class BrowserEncryptionUtility {
-    static async encrypt(data, password) {
-        const salt = crypto.getRandomValues(new Uint8Array(16));
-        const key = await this._deriveKey(password, salt);
-        const iv = crypto.getRandomValues(new Uint8Array(12));
-        const checksum = await this._generateChecksum(data);
-        const combinedData = this._combineDataAndChecksum(data, checksum);
-
-        const encryptedData = await crypto.subtle.encrypt(
-            { name: "AES-GCM", iv: iv },
-            key,
-            combinedData
-        );
-
-        return this._wrapIntoUint8Array(salt, iv, new Uint8Array(encryptedData));
-    }
-
-    static async decrypt(wrappedData, password) {
-        const { salt, iv, encryptedData } = this._unwrapUint8Array(wrappedData);
-        const key = await this._deriveKey(password, salt);
+        async decrypt(wrappedData, password) {
+            try {
+                var salt = wrappedData.slice(0, 16);
+                var iv = wrappedData.slice(16, 28);
+                var checksum = wrappedData.slice(28, 60);
+                var encryptedData = wrappedData.slice(60);
+
+                var keyMaterial = await crypto.subtle.importKey(
+                    'raw',
+                    new TextEncoder().encode(password),
+                    'PBKDF2',
+                    false,
+                    ['deriveKey']
+                );
 
-        const decryptedData = await crypto.subtle.decrypt(
-            { name: "AES-GCM", iv: iv },
-            key,
-            encryptedData
-        );
+                var key = await crypto.subtle.deriveKey({
+                        name: 'PBKDF2',
+                        salt: salt,
+                        iterations: 600000,
+                        hash: 'SHA-512'
+                    },
+                    keyMaterial, {
+                        name: 'AES-GCM',
+                        length: 256
+                    },
+                    false,
+                    ['decrypt']
+                );
 
-        const decryptedUint8Array = new Uint8Array(decryptedData);
-        const { data, checksum } = this._separateDataAndChecksum(decryptedUint8Array);
+                var decrypted = await crypto.subtle.decrypt({
+                        name: 'AES-GCM',
+                        iv: iv
+                    },
+                    key,
+                    encryptedData
+                );
 
-        const validChecksum = await this._generateChecksum(data);
-        if (!this._verifyChecksum(validChecksum, checksum)) {
-            throw new Error("Data integrity check failed. The data has been tampered with.");
-        }
+                var newChecksum = await crypto.subtle.digest('SHA-256', decrypted);
+                var newChecksumArray = new Uint8Array(newChecksum);
 
-        return data;
-    }
-
-    static async _deriveKey(password, salt) {
-        const encoder = new TextEncoder();
-        const keyMaterial = await crypto.subtle.importKey(
-            "raw",
-            encoder.encode(password),
-            { name: "PBKDF2" },
-            false,
-            ["deriveKey"]
-        );
-
-        return await crypto.subtle.deriveKey(
-            {
-                name: "PBKDF2",
-                salt: salt,
-                iterations: 600000,
-                hash: "SHA-512"
-            },
-            keyMaterial,
-            {
-                name: "AES-GCM",
-                length: 256
-            },
-            false,
-            ["encrypt", "decrypt"]
-        );
-    }
+                var isValid = true;
+                for (var i = 0; i < checksum.length; i++) {
+                    if (checksum[i] !== newChecksumArray[i]) {
+                        isValid = false;
+                        break;
+                    }
+                }
 
-    static async _generateChecksum(data) {
-        return new Uint8Array(
-            await crypto.subtle.digest("SHA-256", data)
-        );
-    }
+                if (!isValid) {
+                    throw new Error('Checksum verification failed');
+                }
 
-    static _verifyChecksum(generatedChecksum, originalChecksum) {
-        if (generatedChecksum.length !== originalChecksum.length) return false;
-        for (let i = 0; i < generatedChecksum.length; i++) {
-            if (generatedChecksum[i] !== originalChecksum[i]) {
-                return false;
+                return new Uint8Array(decrypted);
+            } catch (error) {
+                throw new LacertaDBError('Decryption failed', 'DECRYPTION_FAILED', error);
             }
         }
-        return true;
-    }
-
-    static _combineDataAndChecksum(data, checksum) {
-        const combined = new Uint8Array(data.length + checksum.length);
-        combined.set(data);
-        combined.set(checksum, data.length);
-        return combined;
-    }
-
-    static _separateDataAndChecksum(combinedData) {
-        const dataLength = combinedData.length - 32;
-        const data = combinedData.slice(0, dataLength);
-        const checksum = combinedData.slice(dataLength);
-        return { data, checksum };
-    }
-
-    static _wrapIntoUint8Array(salt, iv, encryptedData) {
-        const result = new Uint8Array(salt.length + iv.length + encryptedData.length);
-        result.set(salt, 0);
-        result.set(iv, salt.length);
-        result.set(encryptedData, salt.length + iv.length);
-        return result;
-    }
-
-    static _unwrapUint8Array(wrappedData) {
-        const salt = wrappedData.slice(0, 16);
-        const iv = wrappedData.slice(16, 28);
-        const encryptedData = wrappedData.slice(28);
-        return { salt, iv, encryptedData };
     }
 
-    toString() {
-        return '[BrowserEncryptionUtility]';
-    }
-}
-
-class IndexedDBUtility {
-    static openDatabase(dbName, version = null, upgradeCallback = null) {
-        return new Promise((resolve, reject) => {
-            let request;
+    // ========================
+    // OPFS (Origin Private File System) Utility
+    // ========================
 
-            if (version) {
-                request = indexedDB.open(dbName, version);
-            } else {
-                request = indexedDB.open(dbName);
-            }
+    class OPFSUtility {
+        async saveAttachments(dbName, collectionName, documentId, attachments) {
+            var attachmentPaths = [];
+            var root = await navigator.storage.getDirectory();
 
-            request.onupgradeneeded = (event) => {
-                const db = event.target.result;
-                const oldVersion = event.oldVersion;
-                const newVersion = event.newVersion;
-                console.log(`Upgrading database "${dbName}" from version ${oldVersion} to ${newVersion}`);
+            try {
+                var dbDir = await root.getDirectoryHandle(dbName, {
+                    create: true
+                });
+                var collDir = await dbDir.getDirectoryHandle(collectionName, {
+                    create: true
+                });
+                var docDir = await collDir.getDirectoryHandle(documentId, {
+                    create: true
+                });
 
-                if (upgradeCallback) {
-                    upgradeCallback(db, oldVersion, newVersion);
+                for (var i = 0; i < attachments.length; i++) {
+                    var attachment = attachments[i];
+                    var fileHandle = await docDir.getFileHandle(String(i), {
+                        create: true
+                    });
+                    var writable = await fileHandle.createWritable();
+
+                    var blob = new Blob([attachment.data], {
+                        type: attachment.type
+                    });
+                    await writable.write(blob);
+                    await writable.close();
+
+                    var path = '/' + dbName + '/' + collectionName + '/' + documentId + '/' + i;
+                    attachmentPaths.push({
+                        path: path,
+                        name: attachment.name,
+                        type: attachment.type,
+                        size: attachment.data.byteLength
+                    });
                 }
-            };
-
-            request.onsuccess = (event) => {
-                const db = event.target.result;
 
-                db.onclose = () => {
-                    console.log(`Database "${dbName}" connection is closing.`);
-                };
+                return attachmentPaths;
+            } catch (error) {
+                throw new LacertaDBError('Failed to save attachments', 'ATTACHMENT_SAVE_FAILED', error);
+            }
+        }
 
-                resolve(db);
-            };
+        async getAttachments(attachmentPaths) {
+            var attachments = [];
+            var root = await navigator.storage.getDirectory();
 
-            request.onerror = (event) => {
-                reject(new Error(`Failed to open database "${dbName}": ${event.target.error.message}`));
-            };
-        });
-    }
+            for (var i = 0; i < attachmentPaths.length; i++) {
+                var attachmentInfo = attachmentPaths[i];
+                try {
+                    var pathParts = attachmentInfo.path.split('/').filter(function(p) {
+                        return p;
+                    });
+                    var currentDir = root;
 
-    // Improved transaction handling with better retry logic
-    static async performTransaction(db, storeNames, mode, callback, retries = 3, operationId = null) {
-        let lastError = null;
+                    for (var j = 0; j < pathParts.length - 1; j++) {
+                        currentDir = await currentDir.getDirectoryHandle(pathParts[j]);
+                    }
 
-        for (let attempt = 0; attempt <= retries; attempt++) {
-            try {
-                if (!db || db.readyState !== 'done') {
-                    throw new Error('Database connection is not available or ready.');
+                    var fileHandle = await currentDir.getFileHandle(pathParts[pathParts.length - 1]);
+                    var file = await fileHandle.getFile();
+                    var data = await file.arrayBuffer();
+
+                    attachments.push({
+                        name: attachmentInfo.name,
+                        type: attachmentInfo.type,
+                        data: new Uint8Array(data),
+                        size: attachmentInfo.size
+                    });
+                } catch (error) {
+                    console.error('Failed to get attachment:', attachmentInfo.path, error);
                 }
+            }
 
-                const tx = db.transaction(Array.isArray(storeNames) ? storeNames : [storeNames], mode);
-                const stores = Array.isArray(storeNames)
-                    ? storeNames.map(name => tx.objectStore(name))
-                    : [tx.objectStore(storeNames)];
-
-                // Add transaction timeout
-                const timeoutId = setTimeout(() => {
-                    tx.abort();
-                }, 30000); // 30 second timeout
-
-                const result = await callback(...stores, operationId);
+            return attachments;
+        }
 
-                return new Promise((resolve, reject) => {
-                    tx.oncomplete = () => {
-                        clearTimeout(timeoutId);
-                        resolve(result);
-                    };
-                    tx.onerror = () => {
-                        clearTimeout(timeoutId);
-                        lastError = new Error(`Transaction failed: ${tx.error ? tx.error.message : 'unknown error'}`);
-                        reject(lastError);
-                    };
-                    tx.onabort = () => {
-                        clearTimeout(timeoutId);
-                        lastError = new Error(`Transaction aborted: ${tx.error ? tx.error.message : 'timeout or abort'}`);
-                        reject(lastError);
-                    };
+        async deleteAttachments(dbName, collectionName, documentId) {
+            try {
+                var root = await navigator.storage.getDirectory();
+                var dbDir = await root.getDirectoryHandle(dbName);
+                var collDir = await dbDir.getDirectoryHandle(collectionName);
+                await collDir.removeEntry(documentId, {
+                    recursive: true
                 });
             } catch (error) {
-                lastError = error;
-                if (attempt < retries) {
-                    console.warn(`Transaction failed, retrying... (${retries - attempt} attempts left): ${error.message}`);
-                    // Exponential backoff with jitter
-                    const delay = Math.pow(2, attempt) * 100 + Math.random() * 100;
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                }
+                console.error('Failed to delete attachments:', error);
             }
         }
-
-        throw new Error(`Transaction ultimately failed after ${retries + 1} attempts: ${lastError.message}`);
-    }
-
-    static add(store, record) {
-        return new Promise((resolve, reject) => {
-            const request = store.add(record);
-            request.onsuccess = () => resolve();
-            request.onerror = event => reject(`Failed to insert record: ${event.target.error.message}`);
-        });
     }
 
-    static put(store, record) {
-        return new Promise((resolve, reject) => {
-            const request = store.put(record);
-            request.onsuccess = () => resolve();
-            request.onerror = event => reject(`Failed to put record: ${event.target.error.message}`);
-        });
-    }
+    // ========================
+    // IndexedDB Utility
+    // ========================
 
-    static delete(store, key) {
-        return new Promise((resolve, reject) => {
-            const request = store.delete(key);
-            request.onsuccess = () => resolve();
-            request.onerror = event => reject(`Failed to delete record: ${event.target.error.message}`);
-        });
-    }
+    class IndexedDBUtility {
+        constructor() {
+            this.transactionQueue = [];
+            this.isProcessing = false;
+            this.mutex = new AsyncMutex();
+        }
 
-    static get(store, key) {
-        return new Promise((resolve, reject) => {
-            const request = store.get(key);
-            request.onsuccess = event => resolve(event.target.result);
-            request.onerror = event => reject(`Failed to retrieve record with key ${key}: ${event.target.error.message}`);
-        });
-    }
+        openDatabase(dbName, version, upgradeCallback) {
+            version = version || 1;
+            return new Promise(function(resolve, reject) {
+                var request = indexedDB.open(dbName, version);
 
-    static getAll(store) {
-        return new Promise((resolve, reject) => {
-            const request = store.getAll();
-            request.onsuccess = event => resolve(event.target.result);
-            request.onerror = event => reject(`Failed to retrieve records: ${event.target.error.message}`);
-        });
-    }
+                request.onerror = function() {
+                    reject(new LacertaDBError(
+                        'Failed to open database',
+                        'DATABASE_OPEN_FAILED',
+                        request.error
+                    ));
+                };
 
-    static count(store) {
-        return new Promise((resolve, reject) => {
-            const request = store.count();
-            request.onsuccess = event => resolve(event.target.result);
-            request.onerror = event => reject(`Failed to count records: ${event.target.error.message}`);
-        });
-    }
+                request.onsuccess = function() {
+                    resolve(request.result);
+                };
 
-    static clear(store) {
-        return new Promise((resolve, reject) => {
-            const request = store.clear();
-            request.onsuccess = () => resolve();
-            request.onerror = event => reject(`Failed to clear store: ${event.target.error.message}`);
-        });
-    }
+                request.onupgradeneeded = function(event) {
+                    var db = event.target.result;
+                    if (upgradeCallback) {
+                        upgradeCallback(db, event.oldVersion, event.newVersion);
+                    }
+                };
+            });
+        }
 
-    static deleteDatabase(dbName) {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.deleteDatabase(dbName);
-            request.onsuccess = () => resolve();
-            request.onerror = event => reject(`Failed to delete database: ${event.target.error.message}`);
-        });
-    }
+        async performTransaction(db, storeNames, mode, callback, retries, operationId) {
+            retries = retries || 3;
+            operationId = operationId || null;
+            return this.mutex.runExclusive(async function() {
+                var lastError;
 
-    static iterateCursor(store, processCallback) {
-        return new Promise((resolve, reject) => {
-            const request = store.openCursor();
-            request.onsuccess = event => {
-                const cursor = event.target.result;
-                if (cursor) {
-                    processCallback(cursor.value, cursor.key);
-                    cursor.continue();
-                } else {
-                    resolve();
-                }
-            };
-            request.onerror = event => reject(`Cursor iteration failed: ${event.target.error.message}`);
-        });
-    }
-    
-    static iterateCursorSafe(store, processCallback, options = {}) {
-        return new Promise((resolve, reject) => {
-            const {
-                index = null,
-                direction = 'next',
-                range = null
-            } = options;
-
-            let source = store;
-            if (index && store.indexNames.contains(index)) {
-                source = store.index(index);
-            }
-
-            const request = source.openCursor(range, direction);
-            const results = [];
-            
-            request.onsuccess = (event) => {
-                const cursor = event.target.result;
-                
-                if (cursor) {
-                    // FIXED: No async operations in cursor callback
-                    const shouldContinue = processCallback(cursor.value, cursor.key, results);
-                    
-                    if (shouldContinue !== false) {
-                        cursor.continue();
-                    } else {
-                        resolve(results);
+                for (var i = 0; i < retries; i++) {
+                    try {
+                        return await new Promise(function(resolve, reject) {
+                            var transaction = db.transaction(storeNames, mode);
+                            var result;
+
+                            transaction.oncomplete = function() {
+                                resolve(result);
+                            };
+                            transaction.onerror = function() {
+                                reject(transaction.error);
+                            };
+                            transaction.onabort = function() {
+                                reject(new Error('Transaction aborted'));
+                            };
+
+                            try {
+                                result = callback(transaction);
+                                if (result instanceof Promise) {
+                                    result.then(function(res) {
+                                        result = res;
+                                    }).catch(reject);
+                                }
+                            } catch (error) {
+                                reject(error);
+                            }
+                        });
+                    } catch (error) {
+                        lastError = error;
+                        if (i < retries - 1) {
+                            await new Promise(function(resolve) {
+                                setTimeout(resolve, Math.pow(2, i) * 100);
+                            });
+                        }
                     }
-                } else {
-                    resolve(results);
                 }
-            };
-            
-            request.onerror = () => reject(request.error);
-        });
-    }
-
-    toString() {
-        return '[IndexedDBUtility]';
-    }
-}
-
-class LocalStorageUtility {
-    static getItem(key) {
-        const value = localStorage.getItem(key);
-        return value ? TURBO.serialize(value) : null;
-    }
-
-    static setItem(key, value) {
-        localStorage.setItem(key, TURBO.serialize(value));
-    }
-
-    static removeItem(key) {
-        localStorage.removeItem(key);
-    }
-
-    static clear() {
-        localStorage.clear();
-    }
-
-    toString() {
-        return '[LocalStorageUtility]';
-    }
-}
-
-class AsyncMutex {
-    constructor() {
-        this.queue = [];
-        this.locked = false;
-    }
 
-    async acquire() {
-        return new Promise((resolve) => {
-            if (!this.locked) {
-                this.locked = true;
-                resolve();
-            } else {
-                this.queue.push(resolve);
-            }
-        });
-    }
-
-    release() {
-        if (this.queue.length > 0) {
-            const next = this.queue.shift();
-            next();
-        } else {
-            this.locked = false;
+                throw new LacertaDBError(
+                    'Transaction failed after retries',
+                    'TRANSACTION_FAILED',
+                    lastError
+                );
+            });
         }
-    }
 
-    async runExclusive(callback) {
-        await this.acquire();
-        try {
-            return await callback();
-        } finally {
-            this.release();
+        add(db, storeName, value, key) {
+            key = key === undefined ? undefined : key;
+            return this.performTransaction(db, [storeName], 'readwrite', function(tx) {
+                return new Promise(function(resolve, reject) {
+                    var request = key ?
+                        tx.objectStore(storeName).add(value, key) :
+                        tx.objectStore(storeName).add(value);
+                    request.onsuccess = function() {
+                        resolve(request.result);
+                    };
+                    request.onerror = function() {
+                        reject(request.error);
+                    };
+                });
+            });
         }
-    }
-
-    toString() {
-        return `[AsyncMutex locked:${this.locked} queue:${this.queue.length}]`;
-    }
-}
-
-class DatabaseMetadata {
-    constructor(dbName) {
-        this._dbName = dbName;
-        this._metadataKey = `lacertadb_${this._dbName}_metadata`;
-        this._collections = new Map();
-        this._metadata = this._loadMetadata();
-        this._mutex = new AsyncMutex();
-    }
-
-    async saveMetadata() {
-        return await this._mutex.runExclusive(() => {
-            LocalStorageUtility.setItem(this.metadataKey, this.getRawMetadata());
-        });
-    }
-
-    async adjustTotals(sizeKBChange, lengthChange) {
-        return await this._mutex.runExclusive(() => {
-            this.data.totalSizeKB += sizeKBChange;
-            this.data.totalLength += lengthChange;
-            this.data.modifiedAt = Date.now();
-        });
-    }
 
-    _loadMetadata() {
-        const metadata = LocalStorageUtility.getItem(this.metadataKey);
-        if (metadata) {
-            for (const collectionName in metadata.collections) {
-                const collectionData = metadata.collections[collectionName];
-                const collectionMetadata = new CollectionMetadata(collectionName, this, collectionData);
-                this.collections.set(collectionName, collectionMetadata);
-            }
-            return metadata;
-        } else {
-            return {
-                name: this._dbName,
-                collections: {},
-                totalSizeKB: 0,
-                totalLength: 0,
-                modifiedAt: Date.now(),
-            };
+        put(db, storeName, value, key) {
+            key = key === undefined ? undefined : key;
+            return this.performTransaction(db, [storeName], 'readwrite', function(tx) {
+                return new Promise(function(resolve, reject) {
+                    var request = key ?
+                        tx.objectStore(storeName).put(value, key) :
+                        tx.objectStore(storeName).put(value);
+                    request.onsuccess = function() {
+                        resolve(request.result);
+                    };
+                    request.onerror = function() {
+                        reject(request.error);
+                    };
+                });
+            });
         }
-    }
-
-    get data() {
-        return this._metadata;
-    }
-
-    set data(d) {
-        this._metadata = d;
-    }
-
-    get name() {
-        return this.data.name;
-    }
 
-    get metadataKey() {
-        return this._metadataKey;
-    }
-
-    get collections() {
-        return this._collections;
-    }
-
-    set collections(c) {
-        this._collections = c;
-    }
-
-    get totalSizeKB() {
-        return this.data.totalSizeKB;
-    }
-
-    get totalLength() {
-        return this.data.totalLength;
-    }
-
-    get modifiedAt() {
-        return this.data.modifiedAt;
-    }
-
-    getCollectionMetadata(collectionName) {
-        if (!this.collections.has(collectionName)) {
-            const collectionMetadata = new CollectionMetadata(collectionName, this);
-            this.collections.set(collectionName, collectionMetadata);
-            this.data.collections[collectionName] = collectionMetadata.getRawMetadata();
-            this.data.modifiedAt = Date.now();
+        get(db, storeName, key) {
+            return this.performTransaction(db, [storeName], 'readonly', function(tx) {
+                return new Promise(function(resolve, reject) {
+                    var request = tx.objectStore(storeName).get(key);
+                    request.onsuccess = function() {
+                        resolve(request.result);
+                    };
+                    request.onerror = function() {
+                        reject(request.error);
+                    };
+                });
+            });
         }
-        return this.collections.get(collectionName);
-    }
-
-    getCollectionMetadataData(collectionName) {
-        const metadata = this.getCollectionMetadata(collectionName);
-        return metadata ? metadata.getRawMetadata(): {}
-    }
 
-    removeCollectionMetadata(collectionName) {
-        const collectionMetadata = this.collections.get(collectionName);
-        if (collectionMetadata) {
-            this.data.totalSizeKB -= collectionMetadata.sizeKB;
-            this.data.totalLength -= collectionMetadata.length;
-            this.collections.delete(collectionName);
-            delete this.data.collections[collectionName];
-            this.data.modifiedAt = Date.now();
+        getAll(db, storeName, query, count) {
+            query = query === undefined ? undefined : query;
+            count = count === undefined ? undefined : count;
+            return this.performTransaction(db, [storeName], 'readonly', function(tx) {
+                return new Promise(function(resolve, reject) {
+                    var request = tx.objectStore(storeName).getAll(query, count);
+                    request.onsuccess = function() {
+                        resolve(request.result);
+                    };
+                    request.onerror = function() {
+                        reject(request.error);
+                    };
+                });
+            });
         }
-    }
 
-    getCollectionNames() {
-        return Array.from(this.collections.keys());
-    }
-
-    getRawMetadata() {
-        for (const [collectionName, collectionMetadata] of this._collections.entries()) {
-            this.data.collections[collectionName] = collectionMetadata.getRawMetadata();
+        delete(db, storeName, key) {
+            return this.performTransaction(db, [storeName], 'readwrite', function(tx) {
+                return new Promise(function(resolve, reject) {
+                    var request = tx.objectStore(storeName).delete(key);
+                    request.onsuccess = function() {
+                        resolve();
+                    };
+                    request.onerror = function() {
+                        reject(request.error);
+                    };
+                });
+            });
         }
-        return this.data;
-    }
 
-    setRawMetadata(metadata) {
-        this._metadata = metadata;
-        this._collections.clear();
-        for (const collectionName in metadata.collections) {
-            const collectionData = metadata.collections[collectionName];
-            const collectionMetadata = new CollectionMetadata(collectionName, this, collectionData);
-            this._collections.set(collectionName, collectionMetadata);
+        clear(db, storeName) {
+            return this.performTransaction(db, [storeName], 'readwrite', function(tx) {
+                return new Promise(function(resolve, reject) {
+                    var request = tx.objectStore(storeName).clear();
+                    request.onsuccess = function() {
+                        resolve();
+                    };
+                    request.onerror = function() {
+                        reject(request.error);
+                    };
+                });
+            });
         }
-    }
-
-    get dbName() {
-        return this._dbName;
-    }
-
-    get key() {
-        return this._metadataKey;
-    }
 
-    toString() {
-        return `[DatabaseMetadata: ${this.name} | Collections: ${this.collections.size} | Size: ${this.totalSizeKB.toFixed(2)}KB | Documents: ${this.totalLength}]`;
-    }
-}
-
-class LacertaDBError extends Error {
-    constructor(message, code, originalError = null) {
-        super(message);
-        this.name = 'LacertaDBError';
-        this.code = code;
-        this.originalError = originalError;
-        this.timestamp = Date.now();
-    }
-
-    toString() {
-        return `[LacertaDBError ${this.code}: ${this.message} at ${new Date(this.timestamp).toISOString()}]`;
-    }
-}
-
-const ErrorCodes = {
-    ATTACHMENT_DELETE_FAILED: 'ATTACHMENT_DELETE_FAILED',
-    METADATA_SYNC_FAILED: 'METADATA_SYNC_FAILED',
-    TRANSACTION_FAILED: 'TRANSACTION_FAILED',
-    ENCRYPTION_FAILED: 'ENCRYPTION_FAILED',
-    QUOTA_EXCEEDED: 'QUOTA_EXCEEDED',
-    INVALID_OPERATION: 'INVALID_OPERATION',
-    DOCUMENT_NOT_FOUND: 'DOCUMENT_NOT_FOUND',
-    COLLECTION_NOT_FOUND: 'COLLECTION_NOT_FOUND',
-    COLLECTION_EXISTS: 'COLLECTION_EXISTS'
-};
-
-class CollectionMetadata {
-    constructor(collectionName, databaseMetadata, existingMetadata = null) {
-        this._collectionName = collectionName;
-        this._databaseMetadata = databaseMetadata;
-
-        if (existingMetadata) {
-            this._metadata = existingMetadata;
-        } else {
-            this._metadata = {
-                name: collectionName,
-                sizeKB: 0,
-                length: 0,
-                createdAt: Date.now(),
-                modifiedAt: Date.now(),
-                documentSizes: {},
-                documentModifiedAt: {},
-                documentPermanent: {},
-                documentAttachments: {},
-            };
-            this._databaseMetadata.data.collections[collectionName] = this._metadata;
-            this._databaseMetadata.data.modifiedAt = Date.now();
+        count(db, storeName, query) {
+            query = query === undefined ? undefined : query;
+            return this.performTransaction(db, [storeName], 'readonly', function(tx) {
+                return new Promise(function(resolve, reject) {
+                    var request = tx.objectStore(storeName).count(query);
+                    request.onsuccess = function() {
+                        resolve(request.result);
+                    };
+                    request.onerror = function() {
+                        reject(request.error);
+                    };
+                });
+            });
         }
-    }
-
-    get name() {
-        return this._collectionName;
-    }
 
-    get keys() {
-        return Object.keys(this.documentSizes);
-    }
+        iterateCursorSafe(db, storeName, callback, direction, query) {
+            direction = direction || 'next';
+            query = query === undefined ? undefined : query;
+            return this.performTransaction(db, [storeName], 'readonly', function(tx) {
+                return new Promise(function(resolve, reject) {
+                    var results = [];
+                    var request = tx.objectStore(storeName).openCursor(query, direction);
+
+                    request.onsuccess = function(event) {
+                        var cursor = event.target.result;
+                        if (cursor) {
+                            try {
+                                var result = callback(cursor.value, cursor.key);
+                                if (result !== false) {
+                                    results.push(result);
+                                    cursor.continue();
+                                } else {
+                                    resolve(results);
+                                }
+                            } catch (error) {
+                                reject(error);
+                            }
+                        } else {
+                            resolve(results);
+                        }
+                    };
 
-    get collectionName() {
-        return this.name;
+                    request.onerror = function() {
+                        reject(request.error);
+                    };
+                });
+            });
+        }
     }
 
-    get sizeKB() {
-        return this._metadata.sizeKB;
-    }
 
-    get length() {
-        return this._metadata.length;
-    }
+    // ========================
+    // Document Class
+    // ========================
 
-    get modifiedAt() {
-        return this._metadata.modifiedAt;
-    }
+    class Document {
+        constructor(data, options) {
+            data = data || {};
+            options = options || {};
+            this._id = data._id || this.generateId();
+            this._created = data._created || Date.now();
+            this._modified = data._modified || Date.now();
+            this._permanent = data._permanent || options.permanent || false;
+            this._encrypted = data._encrypted || options.encrypted || false;
+            this._compressed = data._compressed || options.compressed || false;
+            this._attachments = data._attachments || [];
+            this.data = data.data || {};
+            this.packedData = data.packedData || null;
+
+            this.serializer = new TurboSerial({
+                compression: true,
+                deduplication: true,
+                shareArrayBuffers: true,
+                simdOptimization: true,
+                detectCircular: true
+            });
+            this.compression = new BrowserCompressionUtility();
+            this.encryption = new BrowserEncryptionUtility();
+            this.password = options.password || null;
+        }
 
-    get metadata() {
-        return this._metadata;
-    }
+        generateId() {
+            return 'doc_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+        }
 
-    set metadata(m) {
-        return this._metadata = m;
-    }
+        async pack() {
+            try {
+                var packed = this.serializer.serialize(this.data);
 
-    get data() {
-        return this.metadata;
-    }
+                if (this._compressed) {
+                    packed = await this.compression.compress(packed);
+                }
 
-    set data(m) {
-        this.metadata = m;
-    }
+                if (this._encrypted && this.password) {
+                    packed = await this.encryption.encrypt(packed, this.password);
+                }
 
-    get databaseMetadata() {
-        return this._databaseMetadata;
-    }
+                this.packedData = packed;
+                return packed;
+            } catch (error) {
+                throw new LacertaDBError('Failed to pack document', 'PACK_FAILED', error);
+            }
+        }
 
-    set databaseMetadata(m) {
-        this._databaseMetadata = m;
-    }
+        async unpack() {
+            try {
+                var unpacked = this.packedData;
 
-    get documentSizes(){return this.metadata.documentSizes;}
-    get documentModifiedAt(){return this.metadata.documentModifiedAt;}
-    get documentPermanent(){return this.metadata.documentPermanent;}
-    get documentAttachments(){return this.metadata.documentAttachments;}
+                if (this._encrypted && this.password) {
+                    unpacked = await this.encryption.decrypt(unpacked, this.password);
+                }
 
-    set documentSizes(v){ this.metadata.documentSizes = v;}
-    set documentModifiedAt(v){ this.metadata.documentModifiedAt = v;}
-    set documentPermanent(v){ this.metadata.documentPermanent = v;}
-    set documentAttachments(v){ this.metadata.documentAttachments = v;}
+                if (this._compressed) {
+                    unpacked = await this.compression.decompress(unpacked);
+                }
 
-    updateDocument(docId, docSizeKB, isPermanent = false, attachmentCount = 0) {
-        const isNewDocument = !this.keys.includes(docId);
-        const previousDocSizeKB = this.documentSizes[docId] || 0;
-        const sizeKBChange = docSizeKB - previousDocSizeKB;
-        const lengthChange = isNewDocument ? 1 : 0;
+                this.data = this.serializer.deserialize(unpacked);
+                return this.data;
+            } catch (error) {
+                throw new LacertaDBError('Failed to unpack document', 'UNPACK_FAILED', error);
+            }
+        }
 
-        this.documentSizes[docId] = docSizeKB;
-        this.documentModifiedAt[docId] = Date.now();
-        this.documentPermanent[docId] = isPermanent ? 1 : 0;
-        this.documentAttachments[docId] = attachmentCount;
+        packSync() {
+            var packed = this.serializer.serialize(this.data);
 
-        this.metadata.sizeKB += sizeKBChange;
-        this.metadata.length += lengthChange;
-        this.metadata.modifiedAt = Date.now();
+            if (this._compressed) {
+                packed = this.compression.compressSync(packed);
+            }
 
-        this.databaseMetadata.adjustTotals(sizeKBChange, lengthChange);
-    }
+            if (this._encrypted && this.password) {
+                throw new LacertaDBError('Synchronous encryption not supported', 'SYNC_ENCRYPT_NOT_SUPPORTED');
+            }
 
-    deleteDocument(docId) {
-        const docExists = docId in this.documentSizes;
-        if (!docExists) {
-            return false;
+            this.packedData = packed;
+            return packed;
         }
 
-        const docSizeKB = this.documentSizes[docId];
+        unpackSync() {
+            var unpacked = this.packedData;
 
-        delete this.documentSizes[docId];
-        delete this.documentModifiedAt[docId];
-        delete this.documentPermanent[docId];
-        delete this.documentAttachments[docId];
-
-        this.metadata.sizeKB -= docSizeKB;
-        this.metadata.length -= 1;
-        this.metadata.modifiedAt = Date.now();
-
-        this.databaseMetadata.adjustTotals(-docSizeKB, -1);
+            if (this._encrypted && this.password) {
+                throw new LacertaDBError('Synchronous decryption not supported', 'SYNC_DECRYPT_NOT_SUPPORTED');
+            }
 
-        return true;
-    }
+            if (this._compressed) {
+                unpacked = this.compression.decompressSync(unpacked);
+            }
 
-    updateDocuments(updates) {
-        for (const { docId, docSizeKB, isPermanent, attachmentCount } of updates) {
-            this.updateDocument(docId, docSizeKB, isPermanent, attachmentCount || 0);
+            this.data = this.serializer.deserialize(unpacked);
+            return this.data;
         }
-    }
 
-    getRawMetadata() {
-        return this.metadata;
-    }
-
-    setRawMetadata(metadata) {
-        this.metadata = metadata;
-    }
+        objectOutput(includeAttachments) {
+            includeAttachments = includeAttachments || false;
+            var output = {
+                _id: this._id,
+                _created: this._created,
+                _modified: this._modified,
+                _permanent: this._permanent
+            };
 
-    toString() {
-        return `[CollectionMetadata: ${this.name} | Size: ${this.sizeKB.toFixed(2)}KB | Documents: ${this.length}]`;
-    }
-}
+            for (var key in this.data) {
+                if (Object.prototype.hasOwnProperty.call(this.data, key)) {
+                    output[key] = this.data[key];
+                }
+            }
 
-class LacertaDBResult {
-    constructor(success, data = null, error = null) {
-        this.success = success;
-        this.data = data;
-        this.error = error;
-    }
+            if (includeAttachments && this._attachments.length > 0) {
+                output._attachments = this._attachments;
+            }
 
-    toString() {
-        return `[LacertaDBResult success:${this.success} ${this.error ? 'error:' + this.error : ''}]`;
-    }
-}
-
-class QuickStore {
-    constructor(dbName) {
-        this._dbName = dbName;
-        this._metadataKey = `lacertadb_${this._dbName}_quickstore_metadata`;
-        this._documentKeyPrefix = `lacertadb_${this._dbName}_quickstore_data_`;
-        this._metadata = this._loadMetadata();
-    }
+            return output;
+        }
 
-    _loadMetadata() {
-        const metadata = LocalStorageUtility.getItem(this._metadataKey);
-        if (metadata) {
-            return metadata;
-        } else {
+        databaseOutput() {
             return {
-                totalSizeKB: 0,
-                totalLength: 0,
-                documentSizesKB: {},
-                documentModificationTime: {},
-                documentPermanent: {},
+                _id: this._id,
+                _created: this._created,
+                _modified: this._modified,
+                _permanent: this._permanent,
+                _encrypted: this._encrypted,
+                _compressed: this._compressed,
+                _attachments: this._attachments,
+                packedData: this.packedData
             };
         }
     }
 
-    _saveMetadata() {
-        LocalStorageUtility.setItem(this._metadataKey, this._metadata);
-    }
-
-    setDocumentSync(documentData, encryptionKey = null) {
-        const document = new Document(documentData, encryptionKey);
-        const packedData = document.packSync();
-        const docId = document._id;
-        const isPermanent = document._permanent || false;
 
-        const dataToStore = TURBO.serialize({
-            _id: document._id,
-            _created: document._created,
-            _modified: document._modified,
-            _permanent: isPermanent,
-            _encrypted: document._encrypted,
-            _compressed: document._compressed,
-            packedData: packedData,
-        });
+    // ========================
+    // Metadata Classes
+    // ========================
 
-        const key = this._documentKeyPrefix + docId;
-        localStorage.setItem(key, dataToStore);
-
-        const dataSizeKB = dataToStore.length / 1024;
-
-        const isNewDocument = !(docId in this._metadata.documentSizesKB);
-
-        if (isNewDocument) {
-            this._metadata.totalLength += 1;
-        } else {
-            this._metadata.totalSizeKB -= this._metadata.documentSizesKB[docId];
+    class CollectionMetadata {
+        constructor(name, data) {
+            data = data || {};
+            this.name = name;
+            this.sizeKB = data.sizeKB || 0;
+            this.length = data.length || 0;
+            this.createdAt = data.createdAt || Date.now();
+            this.modifiedAt = data.modifiedAt || Date.now();
+            this.documentSizes = data.documentSizes || {};
+            this.documentModifiedAt = data.documentModifiedAt || {};
+            this.documentPermanent = data.documentPermanent || {};
+            this.documentAttachments = data.documentAttachments || {};
         }
 
-        this._metadata.documentSizesKB[docId] = dataSizeKB;
-        this._metadata.documentModificationTime[docId] = document._modified;
-        this._metadata.documentPermanent[docId] = isPermanent;
+        addDocument(docId, sizeKB, isPermanent, attachmentCount) {
+            this.documentSizes[docId] = sizeKB;
+            this.documentModifiedAt[docId] = Date.now();
+            if (isPermanent) {
+                this.documentPermanent[docId] = true;
+            }
+            if (attachmentCount > 0) {
+                this.documentAttachments[docId] = attachmentCount;
+            }
+            this.sizeKB += sizeKB;
+            this.length++;
+            this.modifiedAt = Date.now();
+        }
 
-        this._metadata.totalSizeKB += dataSizeKB;
+        updateDocument(docId, newSizeKB, isPermanent, attachmentCount) {
+            var oldSize = this.documentSizes[docId] || 0;
+            this.sizeKB = this.sizeKB - oldSize + newSizeKB;
+            this.documentSizes[docId] = newSizeKB;
+            this.documentModifiedAt[docId] = Date.now();
 
-        this._saveMetadata();
+            if (isPermanent) {
+                this.documentPermanent[docId] = true;
+            } else {
+                delete this.documentPermanent[docId];
+            }
 
-        return isNewDocument;
-    }
+            if (attachmentCount > 0) {
+                this.documentAttachments[docId] = attachmentCount;
+            } else {
+                delete this.documentAttachments[docId];
+            }
 
-    deleteDocumentSync(docId, force = false) {
-        const isPermanent = this._metadata.documentPermanent[docId] || false;
-        if (isPermanent && !force) {
-            return false;
+            this.modifiedAt = Date.now();
+        }
+
+        removeDocument(docId) {
+            var sizeKB = this.documentSizes[docId] || 0;
+            delete this.documentSizes[docId];
+            delete this.documentModifiedAt[docId];
+            delete this.documentPermanent[docId];
+            delete this.documentAttachments[docId];
+            this.sizeKB -= sizeKB;
+            this.length--;
+            this.modifiedAt = Date.now();
+        }
+
+        getOldestNonPermanentDocuments(count) {
+            var self = this;
+            var docs = Object.entries(this.documentModifiedAt)
+                .filter(function(entry) {
+                    var docId = entry[0];
+                    return !self.documentPermanent[docId];
+                })
+                .sort(function(a, b) {
+                    return a[1] - b[1];
+                })
+                .slice(0, count)
+                .map(function(entry) {
+                    return entry[0];
+                });
+            return docs;
+        }
+    }
+
+    class DatabaseMetadata {
+        constructor(name, data) {
+            data = data || {};
+            this.name = name;
+            this.collections = data.collections || {};
+            this.totalSizeKB = data.totalSizeKB || 0;
+            this.totalLength = data.totalLength || 0;
+            this.modifiedAt = data.modifiedAt || Date.now();
+        }
+
+        static load(dbName) {
+            var key = 'lacertadb_' + dbName + '_metadata';
+            var stored = localStorage.getItem(key);
+            if (stored) {
+                try {
+                    var decoded = base64.decode(stored);
+                    var data = serializer.deserialize(decoded);
+                    return new DatabaseMetadata(dbName, data);
+                } catch (e) {
+                    console.error('Failed to load metadata:', e);
+                }
+            }
+            return new DatabaseMetadata(dbName);
         }
 
-        const key = this._documentKeyPrefix + docId;
-        const docSizeKB = this._metadata.documentSizesKB[docId] || 0;
-
-        if (localStorage.getItem(key)) {
-            localStorage.removeItem(key);
-
-            delete this._metadata.documentSizesKB[docId];
-            delete this._metadata.documentModificationTime[docId];
-            delete this._metadata.documentPermanent[docId];
-
-            this._metadata.totalSizeKB -= docSizeKB;
-            this._metadata.totalLength -= 1;
+        save() {
+            var key = 'lacertadb_' + this.name + '_metadata';
+            try {
+                var dataToStore = {
+                    collections: this.collections,
+                    totalSizeKB: this.totalSizeKB,
+                    totalLength: this.totalLength,
+                    modifiedAt: this.modifiedAt
+                };
+                var serializedData = serializer.serialize(dataToStore);
+                var encodedData = base64.encode(serializedData);
+                localStorage.setItem(key, encodedData);
+            } catch (e) {
+                if (e.name === 'QuotaExceededError') {
+                    throw new LacertaDBError('Storage quota exceeded', 'QUOTA_EXCEEDED', e);
+                }
+                throw new LacertaDBError('Failed to save metadata', 'METADATA_SAVE_FAILED', e);
+            }
+        }
 
-            this._saveMetadata();
+        addCollection(collectionMetadata) {
+            this.collections[collectionMetadata.name] = {
+                sizeKB: collectionMetadata.sizeKB,
+                length: collectionMetadata.length,
+                createdAt: collectionMetadata.createdAt,
+                modifiedAt: collectionMetadata.modifiedAt,
+                documentSizes: collectionMetadata.documentSizes,
+                documentModifiedAt: collectionMetadata.documentModifiedAt,
+                documentPermanent: collectionMetadata.documentPermanent,
+                documentAttachments: collectionMetadata.documentAttachments
+            };
+            this.recalculate();
+            this.save();
+        }
+
+        updateCollection(collectionMetadata) {
+            this.collections[collectionMetadata.name] = {
+                sizeKB: collectionMetadata.sizeKB,
+                length: collectionMetadata.length,
+                createdAt: collectionMetadata.createdAt,
+                modifiedAt: collectionMetadata.modifiedAt,
+                documentSizes: collectionMetadata.documentSizes,
+                documentModifiedAt: collectionMetadata.documentModifiedAt,
+                documentPermanent: collectionMetadata.documentPermanent,
+                documentAttachments: collectionMetadata.documentAttachments
+            };
+            this.recalculate();
+            this.save();
+        }
 
-            return true;
-        } else {
-            return false;
+        removeCollection(collectionName) {
+            delete this.collections[collectionName];
+            this.recalculate();
+            this.save();
         }
-    }
 
-    getAllKeys() {
-        return Object.keys(this._metadata.documentSizesKB);
+        recalculate() {
+            this.totalSizeKB = 0;
+            this.totalLength = 0;
+            for (var collName in this.collections) {
+                if (Object.prototype.hasOwnProperty.call(this.collections, collName)) {
+                    var coll = this.collections[collName];
+                    this.totalSizeKB += coll.sizeKB;
+                    this.totalLength += coll.length;
+                }
+            }
+            this.modifiedAt = Date.now();
+        }
     }
 
-    getDocumentSync(docId, encryptionKey = null) {
-        const key = this._documentKeyPrefix + docId;
-        const dataString = localStorage.getItem(key);
-
-        if (dataString) {
-            const docData = TURBO.serialize(dataString);
-            const document = new Document(docData, encryptionKey);
-            return document.unpackSync();
-        } else {
-            return null;
+    class Settings {
+        constructor(dbName, data) {
+            data = data || {};
+            this.dbName = dbName;
+            this.sizeLimitKB = data.sizeLimitKB || Infinity;
+            this.bufferLimitKB = data.bufferLimitKB || (this.sizeLimitKB === Infinity ? 0 : this.sizeLimitKB * 0.8);
+            this.freeSpaceEvery = data.freeSpaceEvery || 10000;
         }
-    }
 
-    toString() {
-        return `[QuickStore: ${this._dbName} | Size: ${this._metadata.totalSizeKB.toFixed(2)}KB | Documents: ${this._metadata.totalLength}]`;
-    }
-}
+        static load(dbName) {
+            var key = 'lacertadb_' + dbName + '_settings';
+            var stored = localStorage.getItem(key);
+            if (stored) {
+                try {
+                    var decoded = base64.decode(stored);
+                    var data = serializer.deserialize(decoded);
+                    return new Settings(dbName, data);
+                } catch (e) {
+                    console.error('Failed to load settings:', e);
+                }
+            }
+            return new Settings(dbName);
+        }
 
-class TransactionManager {
-    constructor() {
-        this.queue = [];
-        this.processing = false;
-    }
+        save() {
+            var key = 'lacertadb_' + this.dbName + '_settings';
+            var dataToStore = {
+                sizeLimitKB: this.sizeLimitKB,
+                bufferLimitKB: this.bufferLimitKB,
+                freeSpaceEvery: this.freeSpaceEvery
+            };
+            var serializedData = serializer.serialize(dataToStore);
+            var encodedData = base64.encode(serializedData);
+            localStorage.setItem(key, encodedData);
+        }
 
-    async execute(operation) {
-        return new Promise((resolve, reject) => {
-            this.queue.push({ operation, resolve, reject });
-            this.process();
-        });
+        updateSettings(newSettings) {
+            Object.assign(this, newSettings);
+            this.save();
+        }
     }
 
-    async process() {
-        if (this.processing || this.queue.length === 0) return;
+    // ========================
+    // Quick Store (localStorage based)
+    // ========================
 
-        this.processing = true;
-
-        while (this.queue.length > 0) {
-            const { operation, resolve, reject } = this.queue.shift();
+    class QuickStore {
+        constructor(dbName) {
+            this.dbName = dbName;
+            this.keyPrefix = 'lacertadb_' + dbName + '_quickstore_';
+        }
 
+        add(docId, data) {
+            var key = this.keyPrefix + 'data_' + docId;
             try {
-                const result = await operation();
-                resolve(result);
-            } catch (error) {
-                reject(error);
+                var serializedData = serializer.serialize(data);
+                var encodedData = base64.encode(serializedData);
+                localStorage.setItem(key, encodedData);
+                this.updateIndex(docId, 'add');
+                return true;
+            } catch (e) {
+                if (e.name === 'QuotaExceededError') {
+                    throw new LacertaDBError('QuickStore quota exceeded', 'QUOTA_EXCEEDED', e);
+                }
+                return false;
             }
         }
 
-        this.processing = false;
-    }
-
-    toString() {
-        return `[TransactionManager processing:${this.processing} queue:${this.queue.length}]`;
-    }
-}
-
-class Observer {
-    constructor() {
-        this._listeners = {
-            'beforeAdd': [],
-            'afterAdd': [],
-            'beforeDelete': [],
-            'afterDelete': [],
-            'beforeGet': [],
-            'afterGet': [],
-        };
-    }
+        get(docId) {
+            var key = this.keyPrefix + 'data_' + docId;
+            var stored = localStorage.getItem(key);
+            if (stored) {
+                try {
+                    var decoded = base64.decode(stored);
+                    return serializer.deserialize(decoded);
+                } catch (e) {
+                    console.error('Failed to parse QuickStore data:', e);
+                }
+            }
+            return null;
+        }
 
-    on(event, callback) {
-        if (this._listeners[event]) {
-            this._listeners[event].push(callback);
-        } else {
-            throw new Error(`Event "${event}" is not supported.`);
+        update(docId, data) {
+            return this.add(docId, data);
         }
-    }
 
-    off(event, callback) {
-        if (this._listeners[event]) {
-            const index = this._listeners[event].indexOf(callback);
-            if (index > -1) {
-                this._listeners[event].splice(index, 1);
+        delete(docId) {
+            var key = this.keyPrefix + 'data_' + docId;
+            localStorage.removeItem(key);
+            this.updateIndex(docId, 'delete');
+        }
+
+        getAll() {
+            var indexKey = this.keyPrefix + 'index';
+            var indexStr = localStorage.getItem(indexKey);
+            var index = [];
+            if (indexStr) {
+                try {
+                    var decoded = base64.decode(indexStr);
+                    index = serializer.deserialize(decoded);
+                } catch (e) {
+                    index = [];
+                }
             }
-        }
-    }
 
-    _emit(event, ...args) {
-        if (this._listeners[event]) {
-            for (const callback of this._listeners[event]) {
-                callback(...args);
+            var documents = [];
+            for (var i = 0; i < index.length; i++) {
+                var docId = index[i];
+                var doc = this.get(docId);
+                if (doc) {
+                    var docWithId = {
+                        _id: docId
+                    };
+                    for (var key in doc) {
+                        if (Object.prototype.hasOwnProperty.call(doc, key)) {
+                            docWithId[key] = doc[key];
+                        }
+                    }
+                    documents.push(docWithId);
+                }
+            }
+            return documents;
+        }
+
+        clear() {
+            var indexKey = this.keyPrefix + 'index';
+            var indexStr = localStorage.getItem(indexKey);
+            var index = [];
+            if (indexStr) {
+                try {
+                    var decoded = base64.decode(indexStr);
+                    index = serializer.deserialize(decoded);
+                } catch (e) {
+                    index = [];
+                }
             }
-        }
-    }
 
-    // FIXED: Add cleanup method
-    _cleanup() {
-        for (const event in this._listeners) {
-            this._listeners[event] = [];
-        }
-    }
+            for (var i = 0; i < index.length; i++) {
+                this.delete(index[i]);
+            }
 
-    toString() {
-        const counts = Object.entries(this._listeners)
-            .map(([event, listeners]) => `${event}:${listeners.length}`)
-            .join(' ');
-        return `[Observer listeners:{${counts}}]`;
-    }
-}
-
-export class Database {
-    constructor(dbName, settings = {}) {
-        this._dbName = dbName;
-        this._db = null;
-        this._collections = new Map();
-        this._metadata = new DatabaseMetadata(dbName);
-        this._settings = new Settings(dbName, settings);
-        this._quickStore = new QuickStore(this._dbName);
-        this._settings.init();
-    }
+            localStorage.removeItem(indexKey);
+        }
 
-    get quickStore() {
-        return this._quickStore;
-    }
+        updateIndex(docId, operation) {
+            var indexKey = this.keyPrefix + 'index';
+            var indexStr = localStorage.getItem(indexKey);
+            var index = [];
+            if (indexStr) {
+                try {
+                    var decoded = base64.decode(indexStr);
+                    index = serializer.deserialize(decoded);
+                } catch (e) {
+                    index = [];
+                }
+            }
 
-    async init() {
-        this.db = await IndexedDBUtility.openDatabase(this.name, undefined, (db, oldVersion, newVersion) => {
-            this._upgradeDatabase(db, oldVersion, newVersion);
-        });
 
-        const collectionNames = this.data.getCollectionNames();
-        for (const collectionName of collectionNames) {
-            const collection = new Collection(this, collectionName, this.settings);
-            await collection.init();
-            this.collections.set(collectionName, collection);
-        }
-    }
+            if (operation === 'add' && !index.includes(docId)) {
+                index.push(docId);
+            } else if (operation === 'delete') {
+                index = index.filter(function(id) {
+                    return id !== docId;
+                });
+            }
 
-    _createDataStores(db) {
-        for (const collectionName of this.collections.keys()) {
-            this._createDataStore(db, collectionName);
+            var serializedIndex = serializer.serialize(index);
+            var encodedIndex = base64.encode(serializedIndex);
+            localStorage.setItem(indexKey, encodedIndex);
+        }
+    }
+
+
+    // ========================
+    // Query Operators
+    // ========================
+
+    class QueryOperators {}
+    QueryOperators.operators = {
+        // Comparison
+        '$eq': function(a, b) {
+            return a === b;
+        },
+        '$ne': function(a, b) {
+            return a !== b;
+        },
+        '$gt': function(a, b) {
+            return a > b;
+        },
+        '$gte': function(a, b) {
+            return a >= b;
+        },
+        '$lt': function(a, b) {
+            return a < b;
+        },
+        '$lte': function(a, b) {
+            return a <= b;
+        },
+        '$in': function(a, b) {
+            return Array.isArray(b) && b.includes(a);
+        },
+        '$nin': function(a, b) {
+            return Array.isArray(b) && !b.includes(a);
+        },
+
+        // Logical
+        '$and': function(doc, conditions) {
+            return conditions.every(function(cond) {
+                return QueryOperators.evaluate(doc, cond);
+            });
+        },
+        '$or': function(doc, conditions) {
+            return conditions.some(function(cond) {
+                return QueryOperators.evaluate(doc, cond);
+            });
+        },
+        '$not': function(doc, condition) {
+            return !QueryOperators.evaluate(doc, condition);
+        },
+        '$nor': function(doc, conditions) {
+            return !conditions.some(function(cond) {
+                return QueryOperators.evaluate(doc, cond);
+            });
+        },
+
+        // Element
+        '$exists': function(value, exists) {
+            return (value !== undefined) === exists;
+        },
+        '$type': function(value, type) {
+            return typeof value === type;
+        },
+
+        // Array
+        '$all': function(arr, values) {
+            return Array.isArray(arr) && values.every(function(v) {
+                return arr.includes(v);
+            });
+        },
+        '$elemMatch': function(arr, condition) {
+            return Array.isArray(arr) && arr.some(function(elem) {
+                return QueryOperators.evaluate({
+                    value: elem
+                }, {
+                    value: condition
+                });
+            });
+        },
+        '$size': function(arr, size) {
+            return Array.isArray(arr) && arr.length === size;
+        },
+
+        // String
+        '$regex': function(str, pattern) {
+            if (typeof str !== 'string') return false;
+            var regex = new RegExp(pattern);
+            return regex.test(str);
+        },
+        '$text': function(str, search) {
+            if (typeof str !== 'string') return false;
+            return str.toLowerCase().includes(search.toLowerCase());
+        }
+    };
+
+    QueryOperators.evaluate = function(doc, query) {
+        for (var key in query) {
+            if (Object.prototype.hasOwnProperty.call(query, key)) {
+                var value = query[key];
+                if (key.startsWith('$')) {
+                    // Logical operator at root level
+                    var operator = this.operators[key];
+                    if (!operator) return false;
+                    if (!operator(doc, value)) return false;
+                } else {
+                    // Field-level query
+                    var fieldValue = this.getFieldValue(doc, key);
+
+                    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                        // Operator-based comparison
+                        for (var op in value) {
+                            if (Object.prototype.hasOwnProperty.call(value, op)) {
+                                var opValue = value[op];
+                                if (op.startsWith('$')) {
+                                    var operatorFn = this.operators[op];
+                                    if (!operatorFn || !operatorFn(fieldValue, opValue)) {
+                                        return false;
+                                    }
+                                } else {
+                                    if (fieldValue !== value) return false;
+                                }
+                            }
+                        }
+                    } else {
+                        // Direct equality comparison
+                        if (fieldValue !== value) return false;
+                    }
+                }
+            }
         }
-    }
+        return true;
+    }.bind(QueryOperators);
 
-    _createDataStore(db, collectionName) {
-        if (!db.objectStoreNames.contains(collectionName)) {
-            db.createObjectStore(collectionName, { keyPath: '_id' });
+    QueryOperators.getFieldValue = function(doc, path) {
+        var parts = path.split('.');
+        var value = doc;
+        for (var i = 0; i < parts.length; i++) {
+            var part = parts[i];
+            if (value == null) return undefined;
+            value = value[part];
         }
-    }
+        return value;
+    };
 
-    _upgradeDatabase(db, oldVersion, newVersion) {
-        console.log(`Upgrading database "${this.name}" from version ${oldVersion} to ${newVersion}`);
-        if (!db.objectStoreNames.contains('_metadata')) {
-            db.createObjectStore('_metadata', { keyPath: '_id' });
-        }
-    }
 
-    async createCollection(collectionName) {
-        if (this.collections.has(collectionName)) {
-            console.log(`Collection "${collectionName}" already exists.`);
-            return new LacertaDBResult(
-                false, 
-                this.collections.get(collectionName), 
-                new LacertaDBError(
-                    `Collection "${collectionName}" already exists`,
-                    ErrorCodes.COLLECTION_EXISTS
-                )
-            );
-        }
+    // ========================
+    // Aggregation Pipeline
+    // ========================
 
-        if (!this.db.objectStoreNames.contains(collectionName)) {
-            const newVersion = this.db.version + 1;
-            this.db.close();
-            this.db = await IndexedDBUtility.openDatabase(this.name, newVersion, (db, oldVersion, newVersion) => {
-                this._createDataStore(db, collectionName);
+    class AggregationPipeline {}
+    AggregationPipeline.stages = {
+        '$match': function(docs, condition) {
+            return docs.filter(function(doc) {
+                return QueryOperators.evaluate(doc, condition);
             });
-        }
-
-        const collection = new Collection(this, collectionName, this.settings);
-        await collection.init();
-        this.collections.set(collectionName, collection);
+        },
+
+        '$project': function(docs, projection) {
+            var self = this;
+            return docs.map(function(doc) {
+                var projected = {};
+                for (var key in projection) {
+                    if (Object.prototype.hasOwnProperty.call(projection, key)) {
+                        var value = projection[key];
+                        if (value === 1 || value === true) {
+                            projected[key] = QueryOperators.getFieldValue(doc, key);
+                        } else if (typeof value === 'object') {
+                            projected[key] = self.computeField(doc, value);
+                        }
+                    }
+                }
+                return projected;
+            });
+        },
+
+        '$sort': function(docs, sortSpec) {
+            var sorted = docs.slice(); // Create a shallow copy
+            sorted.sort(function(a, b) {
+                for (var key in sortSpec) {
+                    if (Object.prototype.hasOwnProperty.call(sortSpec, key)) {
+                        var order = sortSpec[key];
+                        var aVal = QueryOperators.getFieldValue(a, key);
+                        var bVal = QueryOperators.getFieldValue(b, key);
+                        if (aVal < bVal) return order === 1 ? -1 : 1;
+                        if (aVal > bVal) return order === 1 ? 1 : -1;
+                    }
+                }
+                return 0;
+            });
+            return sorted;
+        },
+
+        '$limit': function(docs, limit) {
+            return docs.slice(0, limit);
+        },
+
+        '$skip': function(docs, skip) {
+            return docs.slice(skip);
+        },
+
+        '$group': function(docs, groupSpec) {
+            var groups = {};
+            var idField = groupSpec._id;
+
+            for (var i = 0; i < docs.length; i++) {
+                var doc = docs[i];
+                var groupKey = typeof idField === 'string' ?
+                    QueryOperators.getFieldValue(doc, idField.replace('$', '')) :
+                    JSON.stringify(idField); // JSON for key generation is acceptable here
+
+                if (!groups[groupKey]) {
+                    groups[groupKey] = {
+                        _id: groupKey,
+                        docs: []
+                    };
+                }
+                groups[groupKey].docs.push(doc);
+            }
 
-        this.data.getCollectionMetadata(collectionName);
-        await this.data.saveMetadata();
+            var results = [];
+            for (var key in groups) {
+                if (Object.prototype.hasOwnProperty.call(groups, key)) {
+                    var group = groups[key];
+                    var result = {
+                        _id: group._id
+                    };
 
-        return new LacertaDBResult(true, collection);
-    }
+                    for (var fieldKey in groupSpec) {
+                        if (Object.prototype.hasOwnProperty.call(groupSpec, fieldKey)) {
+                            if (fieldKey === '_id') continue;
+                            var accumulator = groupSpec[fieldKey];
+
+                            if (accumulator.$sum) {
+                                result[fieldKey] = group.docs.reduce(function(sum, doc) {
+                                    var val = typeof accumulator.$sum === 'string' ?
+                                        QueryOperators.getFieldValue(doc, accumulator.$sum.replace('$', '')) :
+                                        accumulator.$sum;
+                                    return sum + (val || 0);
+                                }, 0);
+                            } else if (accumulator.$avg) {
+                                var sumVal = group.docs.reduce(function(sum, doc) {
+                                    var val = QueryOperators.getFieldValue(doc, accumulator.$avg.replace('$', ''));
+                                    return sum + (val || 0);
+                                }, 0);
+                                result[fieldKey] = sumVal / group.docs.length;
+                            } else if (accumulator.$count) {
+                                result[fieldKey] = group.docs.length;
+                            } else if (accumulator.$max) {
+                                result[fieldKey] = Math.max.apply(null, group.docs.map(function(doc) {
+                                    return QueryOperators.getFieldValue(doc, accumulator.$max.replace('$', ''));
+                                }));
+                            } else if (accumulator.$min) {
+                                result[fieldKey] = Math.min.apply(null, group.docs.map(function(doc) {
+                                    return QueryOperators.getFieldValue(doc, accumulator.$min.replace('$', ''));
+                                }));
+                            }
+                        }
+                    }
+                    results.push(result);
+                }
+            }
+            return results;
+        },
+
+        '$lookup': async function(docs, lookupSpec, db) {
+            var results = [];
+            var foreignCollection = await db.getCollection(lookupSpec.from);
+
+            for (var i = 0; i < docs.length; i++) {
+                var doc = docs[i];
+                var localValue = QueryOperators.getFieldValue(doc, lookupSpec.localField);
+                var query = {};
+                query[lookupSpec.foreignField] = localValue;
+                var foreignDocs = await foreignCollection.query(query);
+
+                var newDoc = {};
+                for (var key in doc) {
+                    if (Object.prototype.hasOwnProperty.call(doc, key)) {
+                        newDoc[key] = doc[key];
+                    }
+                }
+                newDoc[lookupSpec.as] = foreignDocs;
+                results.push(newDoc);
+            }
 
-    // FIXED: Add proper cleanup for observers
-    async deleteCollection(collectionName) {
-        if (!this.collections.has(collectionName)) {
-            return new LacertaDBResult(
-                false,
-                null,
-                new LacertaDBError(
-                    `Collection "${collectionName}" does not exist`,
-                    ErrorCodes.COLLECTION_NOT_FOUND
-                )
-            );
+            return results;
         }
+    };
 
-        const collection = this.collections.get(collectionName);
-        
-        // Clean up collection resources
-        await collection.close();
-        collection.observer._cleanup();
+    AggregationPipeline.computeField = function(doc, spec) {
+        if (typeof spec === 'string' && spec.startsWith('$')) {
+            return QueryOperators.getFieldValue(doc, spec.replace('$', ''));
+        }
+        return spec;
+    };
 
-        await IndexedDBUtility.performTransaction(this.db, collectionName, 'readwrite', (store) => {
-            return IndexedDBUtility.clear(store);
-        });
+    AggregationPipeline.execute = async function(docs, pipeline, db) {
+        var result = docs;
 
-        this.collections.delete(collectionName);
-        this.data.removeCollectionMetadata(collectionName);
-        await this.data.saveMetadata();
+        for (var i = 0; i < pipeline.length; i++) {
+            var stage = pipeline[i];
+            var stageName = Object.keys(stage)[0];
+            var stageSpec = stage[stageName];
+            var stageFunction = this.stages[stageName];
 
-        return new LacertaDBResult(true, null);
-    }
+            if (!stageFunction) {
+                throw new Error('Unknown aggregation stage: ' + stageName);
+            }
 
-    async getCollection(collectionName) {
-        if (this.collections.has(collectionName)) {
-            return new LacertaDBResult(true, this.collections.get(collectionName));
-        } else {
-            if (this.db.objectStoreNames.contains(collectionName)) {
-                const collection = new Collection(this, collectionName, this.settings);
-                await collection.init();
-                this.collections.set(collectionName, collection);
-                return new LacertaDBResult(true, collection);
+            if (stageName === '$lookup') {
+                result = await stageFunction(result, stageSpec, db);
             } else {
-                return new LacertaDBResult(
-                    false,
-                    null,
-                    new LacertaDBError(
-                        `Collection "${collectionName}" does not exist`,
-                        ErrorCodes.COLLECTION_NOT_FOUND
-                    )
-                );
+                result = stageFunction.call(this, result, stageSpec);
             }
         }
-    }
 
-    async close() {
-        const collections = this.collectionsArray;
+        return result;
+    }.bind(AggregationPipeline);
 
-        for (const collection of collections) {
-            await collection.close();
-        }
+    // ========================
+    // Migration Manager
+    // ========================
 
-        if (this.db) {
-            this.db.close();
-            this.db = null;
+    class MigrationManager {
+        constructor(database) {
+            this.database = database;
+            this.migrations = [];
+            this.currentVersion = this.loadVersion();
         }
-    }
-
-    async deleteDatabase() {
-        await this.close();
-        await IndexedDBUtility.deleteDatabase(this.name);
-        LocalStorageUtility.removeItem(this.data.metadataKey);
-        this.settings.clear();
-        this.data = null;
-    }
 
-    get name() {
-        return this._dbName;
-    }
+        loadVersion() {
+            return localStorage.getItem('lacertadb_' + this.database.name + '_version') || '1.0.0';
+        }
 
-    get db() {
-        return this._db;
-    }
+        saveVersion(version) {
+            localStorage.setItem('lacertadb_' + this.database.name + '_version', version);
+            this.currentVersion = version;
+        }
 
-    set db(db) {
-        this._db = db;
-    }
+        addMigration(migration) {
+            this.migrations.push(migration);
+        }
 
-    get data() {
-        return this.metadata;
-    }
+        async runMigrations(targetVersion) {
+            var self = this;
+            var applicableMigrations = this.migrations.filter(function(m) {
+                return self.compareVersions(m.version, self.currentVersion) > 0 &&
+                    self.compareVersions(m.version, targetVersion) <= 0;
+            });
 
-    set data(d) {
-        this.metadata = d;
-    }
+            applicableMigrations.sort(function(a, b) {
+                return self.compareVersions(a.version, b.version);
+            });
 
-    get collectionsArray() {
-        return Array.from(this.collections.values());
-    }
+            for (var i = 0; i < applicableMigrations.length; i++) {
+                var migration = applicableMigrations[i];
+                await this.runMigration(migration);
+                this.saveVersion(migration.version);
+            }
+        }
 
-    get collections() {
-        return this._collections;
-    }
+        async runMigration(migration) {
+            console.log('Running migration: ' + migration.name + ' (v' + migration.version + ')');
+            var collections = await this.database.listCollections();
+            for (var i = 0; i < collections.length; i++) {
+                var collectionName = collections[i];
+                var coll = await this.database.getCollection(collectionName);
+                var docs = await coll.getAll();
 
-    get metadata() {
-        return this._metadata;
-    }
+                for (var j = 0; j < docs.length; j++) {
+                    var doc = docs[j];
+                    var updated = await migration.up(doc);
+                    if (updated) {
+                        await coll.update(doc._id, updated);
+                    }
+                }
+            }
+        }
 
-    set metadata(d) {
-        this._metadata = d;
-    }
+        async rollback(targetVersion) {
+            var self = this;
+            var applicableMigrations = this.migrations.filter(function(m) {
+                return self.compareVersions(m.version, targetVersion) > 0 &&
+                    self.compareVersions(m.version, self.currentVersion) <= 0;
+            });
 
-    get totalSizeKB() {
-        return this.data.totalSizeKB;
-    }
+            applicableMigrations.sort(function(a, b) {
+                return self.compareVersions(b.version, a.version);
+            });
 
-    get totalLength() {
-        return this.data.totalLength;
-    }
+            for (var i = 0; i < applicableMigrations.length; i++) {
+                var migration = applicableMigrations[i];
+                if (migration.down) {
+                    await this.runRollback(migration);
+                }
+            }
 
-    get modifiedAt() {
-        return this.data.modifiedAt;
-    }
+            this.saveVersion(targetVersion);
+        }
 
-    get settings() {
-        return this._settings;
-    }
+        async runRollback(migration) {
+            console.log('Rolling back migration: ' + migration.name + ' (v' + migration.version + ')');
+            var collections = await this.database.listCollections();
+            for (var i = 0; i < collections.length; i++) {
+                var collectionName = collections[i];
+                var coll = await this.database.getCollection(collectionName);
+                var docs = await coll.getAll();
 
-    get settingsData() {
-        return this.settings.data;
-    }
+                for (var j = 0; j < docs.length; j++) {
+                    var doc = docs[j];
+                    var updated = await migration.down(doc);
+                    if (updated) {
+                        await coll.update(doc._id, updated);
+                    }
+                }
+            }
+        }
 
-    toString() {
-        return `[Database: ${this.name} | Collections: ${this.collections.size} | Size: ${this.totalSizeKB.toFixed(2)}KB | Documents: ${this.totalLength}]`;
-    }
-}
+        compareVersions(a, b) {
+            var partsA = a.split('.').map(Number);
+            var partsB = b.split('.').map(Number);
 
-export class Document {
-    constructor(data, encryptionKey = null) {
-        this._id = data._id || this._generateId();
-        this._created = data._created || Date.now();
-        this._permanent = data._permanent ? true : false;
-        this._encrypted = data._encrypted || (encryptionKey ? true : false);
-        this._compressed = data._compressed || false;
+            for (var i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+                var partA = partsA[i] || 0;
+                var partB = partsB[i] || 0;
 
-        this._attachments = data._attachments || data.attachments || [];
+                if (partA > partB) return 1;
+                if (partA < partB) return -1;
+            }
 
-        if (data.packedData) {
-            this._packedData = data.packedData;
-            this._modified = data._modified || Date.now();
-            this._data = null;
-        } else {
-            this._data = data.data || {};
-            this._modified = Date.now();
-            this._packedData = new Uint8Array(0);
+            return 0;
         }
-
-        this._encryptionKey = encryptionKey || "";
     }
 
-    get attachments() {
-        return this._attachments;
-    }
+    // ========================
+    // Performance Monitor
+    // ========================
 
-    set attachments(value) {
-        this._attachments = value;
-    }
+    class PerformanceMonitor {
+        constructor() {
+            this.metrics = {
+                operations: [],
+                latencies: [],
+                cacheHits: 0,
+                cacheMisses: 0,
+                memoryUsage: []
+            };
+            this.monitoring = false;
+            this.monitoringInterval = null;
+        }
 
-    get data() {
-        return this._data;
-    }
+        startMonitoring() {
+            this.monitoring = true;
+            this.monitoringInterval = setInterval(this.collectMetrics.bind(this), 1000);
+        }
 
-    get packedData() {
-        return this._packedData;
-    }
+        stopMonitoring() {
+            this.monitoring = false;
+            if (this.monitoringInterval) {
+                clearInterval(this.monitoringInterval);
+                this.monitoringInterval = null;
+            }
+        }
 
-    get encryptionKey() {
-        return this._encryptionKey;
-    }
+        recordOperation(type, duration) {
+            if (!this.monitoring) return;
 
-    set data(d) {
-        this._data = d;
-    }
+            this.metrics.operations.push({
+                type: type,
+                duration: duration,
+                timestamp: Date.now()
+            });
 
-    set packedData(d) {
-        this._packedData = d;
-    }
+            this.metrics.latencies.push(duration);
 
-    set encryptionKey(d) {
-        this._encryptionKey = d;
-    }
+            if (this.metrics.operations.length > 100) {
+                this.metrics.operations.shift();
+            }
+            if (this.metrics.latencies.length > 100) {
+                this.metrics.latencies.shift();
+            }
+        }
 
-    static hasAttachments(documentData) {
-        return (documentData._attachments && documentData._attachments.length > 0) ||
-            (documentData.attachments && documentData.attachments.length > 0);
-    }
+        recordCacheHit() {
+            this.metrics.cacheHits++;
+        }
 
-    static async getAttachments(documentData, dbName, collectionName) {
-        if (!Document.hasAttachments(documentData)) {
-            return [];
+        recordCacheMiss() {
+            this.metrics.cacheMisses++;
         }
 
-        const attachmentPaths = documentData._attachments || documentData.attachments;
-        documentData.attachments = await OPFSUtility.getAttachments(attachmentPaths);
-        return Promise.resolve(documentData);
-    }
+        collectMetrics() {
+            if (typeof performance !== 'undefined' && performance.memory) {
+                this.metrics.memoryUsage.push({
+                    used: performance.memory.usedJSHeapSize,
+                    total: performance.memory.totalJSHeapSize,
+                    limit: performance.memory.jsHeapSizeLimit,
+                    timestamp: Date.now()
+                });
 
-    static isEncrypted(documentData) {
-        return documentData._encrypted && documentData.packedData;
-    }
+                if (this.metrics.memoryUsage.length > 60) {
+                    this.metrics.memoryUsage.shift();
+                }
+            }
+        }
 
-    static async decryptDocument(documentData, encryptionKey) {
-        if (!Document.isEncrypted(documentData)) {
-            throw new Error('Document is not encrypted.');
-        }
-        const decryptedData = await BrowserEncryptionUtility.decrypt(documentData.packedData, encryptionKey);
-        const unpackedData = TURBO.deserialize(decryptedData);
-
-        return {
-            _id: documentData._id,
-            _created: documentData._created,
-            _modified: documentData._modified,
-            _encrypted: true,
-            _compressed: documentData._compressed,
-            _permanent: documentData._permanent ? true: false,
-            attachments: documentData.attachments,
-            data: unpackedData
-        };
-    }
+        getStats() {
+            var opsPerSec = this.metrics.operations.filter(function(op) {
+                return Date.now() - op.timestamp < 1000;
+            }).length;
 
-    async pack() {
-        if (!this.data) {
-            throw new Error('No data to pack');
-        }
+            var avgLatency = this.metrics.latencies.length > 0 ?
+                this.metrics.latencies.reduce(function(a, b) {
+                    return a + b;
+                }, 0) / this.metrics.latencies.length :
+                0;
 
-        let packedData = TURBO.serialize(this.data);
-        if (this._compressed) {
-            packedData = await this._compressData(packedData);
-        }
-        if (this._encrypted) {
-            packedData = await this._encryptData(packedData);
-        }
-        this.packedData = packedData;
-        return packedData;
-    }
+            var cacheHitRate = this.metrics.cacheHits + this.metrics.cacheMisses > 0 ?
+                (this.metrics.cacheHits / (this.metrics.cacheHits + this.metrics.cacheMisses)) * 100 :
+                0;
 
-    packSync() {
-        if (!this.data) {
-            throw new Error('No data to pack');
-        }
+            var memoryUsage = this.metrics.memoryUsage.length > 0 ?
+                this.metrics.memoryUsage[this.metrics.memoryUsage.length - 1].used / (1024 * 1024) :
+                0;
 
-        if (this._encrypted) {
-            throw new Error("Packing synchronously a document being encrypted is impossible.")
-        }
-        if (this._compressed) {
-            throw new Error("Packing synchronously a document being compressed is impossible.")
+            return {
+                opsPerSec: opsPerSec,
+                avgLatency: avgLatency.toFixed(2),
+                cacheHitRate: cacheHitRate.toFixed(1),
+                memoryUsage: memoryUsage.toFixed(2)
+            };
         }
 
-        let packedData = TURBO.serialize(this.data);
-        this.packedData = packedData;
-        return packedData;
-    }
+        getOptimizationTips() {
+            var tips = [];
 
-    async unpack() {
-        if (!this.data && this.packedData.length > 0) {
-            let unpackedData = this.packedData;
-            if (this._encrypted) {
-                unpackedData = await this._decryptData(unpackedData);
+            if (this.metrics.latencies.length > 0) {
+                var avgLatency = this.metrics.latencies.reduce(function(a, b) {
+                    return a + b;
+                }, 0) / this.metrics.latencies.length;
+                if (avgLatency > 100) {
+                    tips.push('High average latency detected. Consider enabling compression and indexing frequently queried fields.');
+                }
             }
-            if (this._compressed) {
-                unpackedData = await this._decompressData(unpackedData);
+
+            var cacheHitRate = this.metrics.cacheHits + this.metrics.cacheMisses > 0 ?
+                (this.metrics.cacheHits / (this.metrics.cacheHits + this.metrics.cacheMisses)) * 100 :
+                0;
+
+            if (cacheHitRate < 50) {
+                tips.push('Low cache hit rate. Consider increasing cache size or optimizing query patterns.');
             }
-            this.data = TURBO.deserialize(unpackedData);
-        }
-        return this.data;
-    }
 
-    unpackSync() {
-        if (!this.data && this.packedData.length > 0) {
-            if (this._encrypted) {
-                throw new Error("Unpacking synchronously a document being encrypted is impossible.")
+            if (this.metrics.memoryUsage.length > 10) {
+                var recent = this.metrics.memoryUsage.slice(-10);
+                var trend = recent[recent.length - 1].used - recent[0].used;
+                if (trend > 10 * 1024 * 1024) {
+                    tips.push('Memory usage is increasing rapidly. Check for memory leaks or consider batch processing.');
+                }
             }
-            if (this._compressed) {
-                throw new Error("Unpacking synchronously a document being compressed is impossible.")
+
+            if (tips.length === 0) {
+                tips.push('Performance is optimal. No issues detected.');
             }
-            this.data = TURBO.deserialize(this.packedData);
+
+            return tips;
         }
-        return this.data;
     }
 
-    async _encryptData(data) {
-        const encryptionKey = this.encryptionKey;
-        return await BrowserEncryptionUtility.encrypt(data, encryptionKey);
-    }
 
-    async _decryptData(data) {
-        const encryptionKey = this.encryptionKey;
-        return await BrowserEncryptionUtility.decrypt(data, encryptionKey);
-    }
+    // ========================
+    // Collection Class
+    // ========================
 
-    async _compressData(data) {
-        return await BrowserCompressionUtility.compress(data);
-    }
+    class Collection {
+        constructor(name, database) {
+            this.name = name;
+            this.database = database;
+            this.db = null;
+            this.metadata = null;
+            this.settings = database.settings;
+            this.indexedDB = new IndexedDBUtility();
+            this.opfs = new OPFSUtility();
+            this.cleanupInterval = null;
+            this.events = {
+                beforeAdd: [],
+                afterAdd: [],
+                beforeGet: [],
+                afterGet: [],
+                beforeUpdate: [],
+                afterUpdate: [],
+                beforeDelete: [],
+                afterDelete: []
+            };
+            this.queryCache = new Map();
+            this.cacheTimeout = 60000;
+        }
+
+        async init() {
+            var dbName = this.database.name + '_' + this.name;
+            this.db = await this.indexedDB.openDatabase(dbName, 1, function(db) {
+                if (!db.objectStoreNames.contains('documents')) {
+                    var store = db.createObjectStore('documents', {
+                        keyPath: '_id'
+                    });
+                    store.createIndex('created', '_created', {
+                        unique: false
+                    });
+                    store.createIndex('modified', '_modified', {
+                        unique: false
+                    });
+                    store.createIndex('permanent', '_permanent', {
+                        unique: false
+                    });
+                }
+            });
 
-    async _decompressData(data) {
-        return await BrowserCompressionUtility.decompress(data);
-    }
+            var metadataData = this.database.metadata.collections[this.name];
+            this.metadata = new CollectionMetadata(this.name, metadataData);
 
-    _generateId() {
-        return 'xxxx-xxxx-xxxx'.replace(/[x]/g, () => (Math.random() * 16 | 0).toString(16));
-    }
+            if (this.settings.freeSpaceEvery > 0) {
+                this.cleanupInterval = setInterval(this.freeSpace.bind(this), this.settings.freeSpaceEvery);
+            }
 
-    async objectOutput(includeAttachments = false) {
-        if (!this.data) {
-            await this.unpack();
+            return this;
         }
 
-        const output = {
-            _id: this._id,
-            _created: this._created,
-            _modified: this._modified,
-            _permanent: this._permanent,
-            _encrypted: this._encrypted,
-            _compressed: this._compressed,
-            attachments: this.attachments,
-            data: this.data,
-        };
+        async add(documentData, options) {
+            options = options || {};
+            await this.trigger('beforeAdd', documentData);
 
-        if (includeAttachments && this.attachments.length > 0) {
-            const attachments = await OPFSUtility.getAttachments(this.attachments);
-            output.attachments = attachments;
-        }
+            var doc = new Document({
+                data: documentData,
+                _id: options.id
+            }, {
+                encrypted: options.encrypted || false,
+                compressed: options.compressed !== false,
+                permanent: options.permanent || false,
+                password: options.password
+            });
 
-        return output;
-    }
+            if (options.attachments && options.attachments.length > 0) {
+                var attachmentPaths = await this.opfs.saveAttachments(
+                    this.database.name,
+                    this.name,
+                    doc._id,
+                    options.attachments
+                );
+                doc._attachments = attachmentPaths;
+            }
 
-    async databaseOutput() {
-        if (!this.packedData || this.packedData.length === 0) {
-            await this.pack();
-        }
-
-        return {
-            _id: this._id,
-            _created: this._created,
-            _modified: this._modified,
-            _permanent: this._permanent ? true : false,
-            _compressed: this._compressed,
-            _encrypted: this._encrypted,
-            attachments: this.attachments,
-            packedData: this.packedData,
-        };
-    }
+            await doc.pack();
+            var dbOutput = doc.databaseOutput();
 
-    toString() {
-        return `[Document: ${this._id} | Created: ${new Date(this._created).toISOString()} | Encrypted: ${this._encrypted} | Compressed: ${this._compressed} | Permanent: ${this._permanent}]`;
-    }
-}
-
-class Settings {
-    constructor(dbName, newSettings = {}) {
-        this._dbName = dbName;
-        this._settingsKey = `lacertadb_${this._dbName}_settings`;
-        this._data = this._loadSettings();
-        this._mergeSettings(newSettings);
-    }
+            await this.indexedDB.add(this.db, 'documents', dbOutput);
 
-    init() {
-        this.set('sizeLimitKB', this.get('sizeLimitKB') || Infinity);
-        this.set('bufferLimitKB', this.get('bufferLimitKB') || -(this.get('sizeLimitKB') * 0.2));
+            var sizeKB = new Blob([dbOutput.packedData]).size / 1024;
+            this.metadata.addDocument(
+                doc._id,
+                sizeKB,
+                doc._permanent,
+                doc._attachments.length
+            );
+            this.database.metadata.updateCollection(this.metadata);
 
-        if (this.get('bufferLimitKB') < -0.8 * this.get('sizeLimitKB')) {
-            throw new Error("Buffer limit cannot be below -80% of the size limit.");
-        }
+            await this.checkSpaceLimit();
+            await this.trigger('afterAdd', doc);
 
-        this.set('freeSpaceEvery', this._validateFreeSpaceSetting(this.get('freeSpaceEvery')));
-    }
+            this.queryCache.clear();
 
-    _validateFreeSpaceSetting(value = 10000) {
-        if (value === undefined || value === false || value === 0) {
-            return Infinity;
-        }
-        if (value < 1000 && value !== 0) {
-            throw new Error("Invalid freeSpaceEvery value. It must be 0, Infinity, or above 1000.");
+            return doc._id;
         }
-        if (value >= 1000 && value < 10000) {
-            console.warn("Warning: freeSpaceEvery value is between 1000 and 10000, which may lead to frequent freeing.");
-        }
-        return value;
-    }
 
-    _loadSettings() {
-        const settings = LocalStorageUtility.getItem(this.settingsKey);
-        return settings ? settings : {};
-    }
+        async get(docId, options) {
+            options = options || {};
+            await this.trigger('beforeGet', docId);
 
-    _saveSettings() {
-        LocalStorageUtility.setItem(this.settingsKey, this.data);
-    }
+            var stored = await this.indexedDB.get(this.db, 'documents', docId);
+            if (!stored) {
+                throw new LacertaDBError('Document not found', 'DOCUMENT_NOT_FOUND');
+            }
 
-    _mergeSettings(newSettings) {
-        this.data = Object.assign(this.data, newSettings);
-        this._saveSettings();
-    }
+            var doc = new Document(stored, {
+                password: options.password,
+                encrypted: stored._encrypted,
+                compressed: stored._compressed
+            });
 
-    get(key) {
-        return this.data[key];
-    }
+            if (stored.packedData) {
+                await doc.unpack();
+            }
 
-    set(key, value) {
-        this.data[key] = value;
-        this._saveSettings();
-    }
+            if (options.includeAttachments && doc._attachments.length > 0) {
+                var attachments = await this.opfs.getAttachments(doc._attachments);
+                doc.data._attachments = attachments;
+            }
 
-    remove(key) {
-        delete this.data[key];
-        this._saveSettings();
-    }
+            await this.trigger('afterGet', doc);
 
-    clear() {
-        this.data = {};
-        this._saveSettings();
-    }
+            return doc.objectOutput(options.includeAttachments);
+        }
 
-    get dbName() {
-        return this._dbName;
-    }
+        async getAll(options) {
+            options = options || {};
+            var stored = await this.indexedDB.getAll(
+                this.db,
+                'documents',
+                undefined,
+                options.limit
+            );
 
-    get data() {
-        return this._data;
-    }
+            var documents = [];
+            for (var i = 0; i < stored.length; i++) {
+                var docData = stored[i];
+                try {
+                    var doc = new Document(docData, {
+                        password: options.password,
+                        encrypted: docData._encrypted,
+                        compressed: docData._compressed
+                    });
+
+                    if (docData.packedData) {
+                        await doc.unpack();
+                    }
 
-    set data(s) {
-        this._data = s;
-    }
+                    documents.push(doc.objectOutput());
+                } catch (error) {
+                    console.error('Failed to unpack document:', error);
+                }
+            }
 
-    get settingsKey() {
-        return this._settingsKey;
-    }
+            return documents;
+        }
 
-    toString() {
-        return `[Settings: ${this.dbName} | SizeLimit: ${this.get('sizeLimitKB')}KB | BufferLimit: ${this.get('bufferLimitKB')}KB]`;
-    }
-}
-
-export class Collection {
-    constructor(database, collectionName, settings) {
-        this._database = database;
-        this._collectionName = collectionName;
-        this._settings = settings;
-        this._metadata = null;
-        this._lastFreeSpaceTime = 0;
-        this._observer = new Observer();
-        this._transactionManager = new TransactionManager();
-        this._freeSpaceInterval = null;
-        this._freeSpaceHandler = null;
-    }
+        async update(docId, updates, options) {
+            options = options || {};
+            await this.trigger('beforeUpdate', {
+                docId: docId,
+                updates: updates
+            });
 
-    get observer() {
-        return this._observer;
-    }
+            var existing = await this.get(docId, {
+                password: options.password
+            });
 
-    async createIndex(fieldPath, options = {}) {
-        const indexName = options.name || fieldPath.replace(/\./g, '_');
-        const newVersion = this.database.db.version + 1;
-        this.database.db.close();
-
-        this.database.db = await IndexedDBUtility.openDatabase(
-            this.database.name,
-            newVersion,
-            (db) => {
-                if (db.objectStoreNames.contains(this.name)) {
-                    const tx = db.transaction([this.name]);
-                    const store = tx.objectStore(this.name);
-                    if (!store.indexNames.contains(indexName)) {
-                        store.createIndex(indexName, fieldPath, {
-                            unique: options.unique || false,
-                            multiEntry: options.multiEntry || false
-                        });
-                    }
+            var updatedData = {};
+            for (var key in existing) {
+                if (Object.prototype.hasOwnProperty.call(existing, key)) {
+                    updatedData[key] = existing[key];
                 }
             }
-        );
-    }
+            for (var updateKey in updates) {
+                if (Object.prototype.hasOwnProperty.call(updates, updateKey)) {
+                    updatedData[updateKey] = updates[updateKey];
+                }
+            }
+            delete updatedData._id;
+            delete updatedData._created;
+            delete updatedData._modified;
+            delete updatedData._permanent;
+
+            var doc = new Document({
+                _id: docId,
+                _created: existing._created,
+                data: updatedData
+            }, {
+                encrypted: options.encrypted || false,
+                compressed: options.compressed !== false,
+                permanent: options.permanent || existing._permanent,
+                password: options.password
+            });
+
+            if (options.attachments && options.attachments.length > 0) {
+                await this.opfs.deleteAttachments(this.database.name, this.name, docId);
+                var attachmentPaths = await this.opfs.saveAttachments(
+                    this.database.name,
+                    this.name,
+                    doc._id,
+                    options.attachments
+                );
+                doc._attachments = attachmentPaths;
+            }
+
+            await doc.pack();
+            var dbOutput = doc.databaseOutput();
 
-    async init() {
-        // FIXED: Ensure metadata is always accessed through database metadata
-        this.metadata = this.database.metadata.getCollectionMetadata(this.name);
+            await this.indexedDB.put(this.db, 'documents', dbOutput);
 
-        if (this.settingsData.freeSpaceEvery !== Infinity) {
-            this._freeSpaceHandler = () => this._maybeFreeSpace();
-            this._freeSpaceInterval = setInterval(
-                this._freeSpaceHandler,
-                this.settingsData.freeSpaceEvery
+            var sizeKB = new Blob([dbOutput.packedData]).size / 1024;
+            this.metadata.updateDocument(
+                doc._id,
+                sizeKB,
+                doc._permanent,
+                doc._attachments.length
             );
-        }
-    }
+            this.database.metadata.updateCollection(this.metadata);
 
-    get name() {
-        return this._collectionName;
-    }
+            await this.trigger('afterUpdate', doc);
 
-    get sizes() {
-        return this.metadataData.documentSizes || {};
-    }
+            this.queryCache.clear();
 
-    get modifications() {
-        return this.metadataData.documentModifiedAt || {};
-    }
+            return doc._id;
+        }
 
-    get attachments() {
-        return this.metadataData.documentAttachments || {};
-    }
+        async delete(docId) {
+            await this.trigger('beforeDelete', docId);
 
-    get permanents() {
-        return this.metadataData.documentPermanent || {};
-    }
+            var doc = await this.indexedDB.get(this.db, 'documents', docId);
+            if (!doc) {
+                throw new LacertaDBError('Document not found', 'DOCUMENT_NOT_FOUND');
+            }
 
-    get keys() {
-        return Object.keys(this.sizes);
-    }
+            if (doc._permanent) {
+                throw new LacertaDBError('Cannot delete permanent document', 'INVALID_OPERATION');
+            }
 
-    get documentsMetadata() {
-        var keys = this.keys;
-        var sizes = this.sizes;
-        var modifications = this.modifications;
-        var permanents = this.permanents;
-        var attachments = this.attachments;
-        var metadata = new Array(keys.length);
-        var i = 0;
-        for(const key of keys){
-            metadata[i++] = {
-                id: key,
-                size: sizes[key],
-                modified: modifications[key],
-                permanent: permanents[key],
-                attachment: attachments[key]
-            };
-        }
+            await this.indexedDB.delete(this.db, 'documents', docId);
 
-        return metadata;
-    }
+            if (doc._attachments && doc._attachments.length > 0) {
+                await this.opfs.deleteAttachments(this.database.name, this.name, docId);
+            }
 
-    get settings() {
-        return this._settings;
-    }
+            this.metadata.removeDocument(docId);
+            this.database.metadata.updateCollection(this.metadata);
 
-    get settingsData() {
-        return this.settings.data;
-    }
+            await this.trigger('afterDelete', docId);
 
-    set settings(d) {
-        this._settings = d;
-    }
+            this.queryCache.clear();
+        }
 
-    get lastFreeSpaceTime() {
-        return this._lastFreeSpaceTime;
-    }
+        async query(filter, options) {
+            filter = filter || {};
+            options = options || {};
 
-    set lastFreeSpaceTime(t) {
-        this._lastFreeSpaceTime = t;
-    }
+            var cacheKeyData = {
+                filter: filter,
+                options: options
+            };
+            var serializedKey = serializer.serialize(cacheKeyData);
+            var cacheKey = base64.encode(serializedKey);
 
-    get database() {
-        return this._database;
-    }
+            var cached = this.queryCache.get(cacheKey);
 
-    get metadata() {
-        // FIXED: Always access through database metadata for consistency
-        return this.database.metadata.getCollectionMetadata(this.name);
-    }
+            if (cached && Date.now() - cached.timestamp < this.cacheTimeout) {
+                if (global.performanceMonitor) {
+                    global.performanceMonitor.recordCacheHit();
+                }
+                return cached.data;
+            }
 
-    get metadataData() {
-        return this.metadata.getRawMetadata();
-    }
+            if (global.performanceMonitor) {
+                global.performanceMonitor.recordCacheMiss();
+            }
 
-    set metadata(m) {
-        this._metadata = m;
-    }
+            var startTime = performance.now();
 
-    get sizeKB() {
-        return this.metadataData.sizeKB;
-    }
+            var allDocs = await this.getAll(options);
+            var filtered = allDocs.filter(function(doc) {
+                return QueryOperators.evaluate(doc, filter);
+            });
 
-    get length() {
-        return this.metadataData.length;
-    }
+            var result = filtered;
+            if (options.projection) {
+                result = AggregationPipeline.stages.$project(filtered, options.projection);
+            }
+            if (options.sort) {
+                result = AggregationPipeline.stages.$sort(result, options.sort);
+            }
+            if (options.skip) {
+                result = AggregationPipeline.stages.$skip(result, options.skip);
+            }
+            if (options.limit) {
+                result = AggregationPipeline.stages.$limit(result, options.limit);
+            }
 
-    get totalSizeKB() {
-        return this.sizeKB;
-    }
+            var duration = performance.now() - startTime;
+            if (global.performanceMonitor) {
+                global.performanceMonitor.recordOperation('query', duration);
+            }
 
-    get totalLength() {
-        return this.length;
-    }
+            this.queryCache.set(cacheKey, {
+                data: result,
+                timestamp: Date.now()
+            });
 
-    get modifiedAt() {
-        return this.metadataData.modifiedAt;
-    }
+            if (this.queryCache.size > 100) {
+                var oldestKey = this.queryCache.keys().next().value;
+                this.queryCache.delete(oldestKey);
+            }
 
-    get isFreeSpaceEnabled() {
-        return this.settingsData.freeSpaceEvery !== Infinity;
-    }
+            return result;
+        }
 
-    get shouldRunFreeSpaceSize() {
-        return (this.totalSizeKB > this.settingsData.sizeLimitKB + this.settingsData.bufferLimitKB);
-    }
+        async aggregate(pipeline) {
+            var startTime = performance.now();
+            var docs = await this.getAll();
+            var result = await AggregationPipeline.execute(docs, pipeline, this.database);
 
-    get shouldRunFreeSpaceTime() {
-        return (this.isFreeSpaceEnabled && (Date.now() - this.lastFreeSpaceTime >= this.settingsData.freeSpaceEvery));
-    }
+            var duration = performance.now() - startTime;
+            if (global.performanceMonitor) {
+                global.performanceMonitor.recordOperation('aggregate', duration);
+            }
+
+            return result;
+        }
+
+        async batchAdd(documents, options) {
+            options = options || {};
+            var results = [];
+            var startTime = performance.now();
+
+            for (var i = 0; i < documents.length; i++) {
+                var doc = documents[i];
+                try {
+                    var id = await this.add(doc, options);
+                    results.push({
+                        success: true,
+                        id: id
+                    });
+                } catch (error) {
+                    results.push({
+                        success: false,
+                        error: error.message
+                    });
+                }
+            }
 
-    async _maybeFreeSpace() {
-        if(this.shouldRunFreeSpaceSize || this.shouldRunFreeSpaceTime){
-            return this.freeSpace(this.settingsData.sizeLimitKB);
+            var duration = performance.now() - startTime;
+            if (global.performanceMonitor) {
+                global.performanceMonitor.recordOperation('batchAdd', duration);
+            }
+
+            return results;
         }
-    }
 
-    async addDocument(documentData, encryptionKey = null) {
-        return await this._transactionManager.execute(async () => {
-            this.observer._emit('beforeAdd', documentData);
+        async batchUpdate(updates, options) {
+            options = options || {};
+            var results = [];
+
+            for (var i = 0; i < updates.length; i++) {
+                var update = updates[i];
+                try {
+                    await this.update(update.id, update.data, options);
+                    results.push({
+                        success: true,
+                        id: update.id
+                    });
+                } catch (error) {
+                    results.push({
+                        success: false,
+                        id: update.id,
+                        error: error.message
+                    });
+                }
+            }
 
-            const document = new Document(documentData, encryptionKey);
+            return results;
+        }
 
-            const attachmentPaths = [];
-            if (Document.hasAttachments(documentData)) {
-                const attachments = documentData._attachments || documentData.attachments;
-                for (let i = 0; i < attachments.length; i++) {
-                    attachmentPaths.push(
-                        `${this.database.name}/${this.name}/${document._id}/${i}`
-                    );
+        async batchDelete(ids) {
+            var results = [];
+
+            for (var i = 0; i < ids.length; i++) {
+                var id = ids[i];
+                try {
+                    await this.delete(id);
+                    results.push({
+                        success: true,
+                        id: id
+                    });
+                } catch (error) {
+                    results.push({
+                        success: false,
+                        id: id,
+                        error: error.message
+                    });
                 }
-                document._attachments = attachmentPaths;
             }
 
-            const docData = await document.databaseOutput();
-            const docId = docData._id;
-            const isPermanent = docData._permanent || false;
-            const docSizeKB = docData.packedData.byteLength / 1024;
-            let isNewDocument = !(docId in this.metadataData.documentSizes);
+            return results;
+        }
 
-            try {
-                await IndexedDBUtility.performTransaction(
-                    this.database.db,
-                    this.name,
-                    'readwrite',
-                    (store) => {
-                        if (isNewDocument) {
-                            return IndexedDBUtility.add(store, docData);
-                        } else {
-                            return IndexedDBUtility.put(store, docData);
-                        }
-                    }
-                );
+        async clear() {
+            await this.indexedDB.clear(this.db, 'documents');
+            this.metadata = new CollectionMetadata(this.name);
+            this.database.metadata.updateCollection(this.metadata);
+            this.queryCache.clear();
+        }
 
-                if (attachmentPaths.length > 0) {
-                    const attachments = documentData._attachments || documentData.attachments;
-                    await OPFSUtility.saveAttachments(
-                        this.database.name,
-                        this.name,
-                        document._id,
-                        attachments
-                    );
-                }
+        async checkSpaceLimit() {
+            if (this.settings.sizeLimitKB !== Infinity &&
+                this.metadata.sizeKB > this.settings.bufferLimitKB) {
+                await this.freeSpace();
+            }
+        }
 
-                this.metadata.updateDocument(
-                    docId,
-                    docSizeKB,
-                    isPermanent,
-                    attachmentPaths.length
-                );
+        async freeSpace() {
+            var targetSize = this.settings.bufferLimitKB * 0.8;
 
-                await this.database.metadata.saveMetadata();
+            while (this.metadata.sizeKB > targetSize) {
+                var oldestDocs = this.metadata.getOldestNonPermanentDocuments(10);
+                if (oldestDocs.length === 0) break;
 
-            } catch (error) {
-                if (attachmentPaths.length > 0) {
+                for (var i = 0; i < oldestDocs.length; i++) {
+                    var docId = oldestDocs[i];
                     try {
-                        await OPFSUtility.deleteAttachments(
-                            this.database.name,
-                            this.name,
-                            document._id
-                        );
-                    } catch (e) {
-                        // Ignore cleanup errors
+                        await this.delete(docId);
+                    } catch (error) {
+                        console.error('Failed to delete document during cleanup:', error);
                     }
                 }
-                throw error;
             }
+        }
 
-            await this._maybeFreeSpace();
-
-            this.observer._emit('afterAdd', documentData);
-
-            return isNewDocument;
-        });
-    }
-
-    async getDocument(docId, encryptionKey = null, includeAttachments = false) {
-        this.observer._emit('beforeGet', docId);
+        createIndex(fieldName, options) {
+            console.log('Index for ' + fieldName + ' would be created on next database upgrade');
+        }
 
-        if (!(docId in this.metadataData.documentSizes)) {
-            return false;
+        on(event, callback) {
+            if (this.events[event]) {
+                this.events[event].push(callback);
+            }
         }
 
-        const docData = await IndexedDBUtility.performTransaction(
-            this.database.db,
-            this.name,
-            'readonly',
-            (store) => {
-                return IndexedDBUtility.get(store, docId);
+        off(event, callback) {
+            if (this.events[event]) {
+                this.events[event] = this.events[event].filter(function(cb) {
+                    return cb !== callback;
+                });
             }
-        );
+        }
 
-        if (docData) {
-            let document;
-            if (Document.isEncrypted(docData)) {
-                if (encryptionKey) {
-                    document = new Document(docData, encryptionKey);
-                } else {
-                    return false;
+        async trigger(event, data) {
+            if (this.events[event]) {
+                var callbacks = this.events[event];
+                for (var i = 0; i < callbacks.length; i++) {
+                    await callbacks[i](data);
                 }
-            } else {
-                document = new Document(docData);
             }
+        }
 
-            const output = await document.objectOutput(includeAttachments);
-
-            this.observer._emit('afterGet', output);
+        clearCache() {
+            this.queryCache.clear();
+        }
 
-            return output;
-        } else {
-            return false;
+        destroy() {
+            if (this.cleanupInterval) {
+                clearInterval(this.cleanupInterval);
+                this.cleanupInterval = null;
+            }
+            if (this.db) {
+                this.db.close();
+                this.db = null;
+            }
         }
     }
 
-    async getDocuments(ids, encryptionKey = null, withAttachments = false) {
-        const results = [];
-        const existingIds = ids.filter(id => id in this.metadataData.documentSizes);
 
-        if (existingIds.length === 0) {
-            return results;
+    // ========================
+    // Database Class
+    // ========================
+
+    class Database {
+        constructor(name) {
+            this.name = name;
+            this.collections = new Map();
+            this.metadata = null;
+            this.settings = null;
+            this.quickStore = null;
         }
 
-        await IndexedDBUtility.performTransaction(
-            this.database.db,
-            this.name,
-            'readonly',
-            async (store) => {
-                const getPromises = existingIds.map(id => IndexedDBUtility.get(store, id));
-                const docsData = await Promise.all(getPromises);
-
-                for (const docData of docsData) {
-                    if (docData) {
-                        let document;
-                        if (Document.isEncrypted(docData)) {
-                            if (encryptionKey) {
-                                document = new Document(docData, encryptionKey);
-                            } else {
-                                continue;
-                            }
-                        } else {
-                            document = new Document(docData);
-                        }
+        async init() {
+            this.metadata = DatabaseMetadata.load(this.name);
+            this.settings = Settings.load(this.name);
+            this.quickStore = new QuickStore(this.name);
+            return this;
+        }
 
-                        const output = await document.objectOutput(withAttachments);
-                        results.push(output);
-                    }
-                }
+        async createCollection(name, options) {
+            if (this.collections.has(name)) {
+                throw new LacertaDBError('Collection already exists', 'COLLECTION_EXISTS');
             }
-        );
 
-        return results;
-    }
+            var collection = new Collection(name, this);
+            await collection.init();
+
+            this.collections.set(name, collection);
+
+            if (!this.metadata.collections[name]) {
+                var collMetadata = new CollectionMetadata(name);
+                this.metadata.addCollection(collMetadata);
+            }
 
-    async deleteDocument(docId, force = false) {
-        this.observer._emit('beforeDelete', docId);
+            return collection;
+        }
+
+        async getCollection(name) {
+            if (!this.collections.has(name)) {
+                if (this.metadata.collections[name]) {
+                    var collection = new Collection(name, this);
+                    await collection.init();
+                    this.collections.set(name, collection);
+                } else {
+                    throw new LacertaDBError('Collection not found', 'COLLECTION_NOT_FOUND');
+                }
+            }
 
-        const isPermanent = this.permanents[docId] || false;
-        if (isPermanent && !force) {
-            return false;
+            return this.collections.get(name);
         }
 
-        const docExists = docId in this.sizes;
+        async dropCollection(name) {
+            var collection = await this.getCollection(name);
+            await collection.clear();
+            collection.destroy();
+
+            this.collections.delete(name);
+            this.metadata.removeCollection(name);
 
-        if (!docExists) {
-            return false;
+            var dbName = this.name + '_' + name;
+            await new Promise(function(resolve, reject) {
+                var deleteReq = indexedDB.deleteDatabase(dbName);
+                deleteReq.onsuccess = resolve;
+                deleteReq.onerror = reject;
+            });
         }
 
-        const attachmentCount = this.metadata.documentAttachments[docId] || 0;
-        if (attachmentCount > 0) {
-            await OPFSUtility.deleteAttachments(
-                this.database.name,
-                this.name,
-                docId
-            );
+        async listCollections() {
+            return Object.keys(this.metadata.collections);
         }
 
-        await IndexedDBUtility.performTransaction(
-            this.database.db,
-            this.name,
-            'readwrite',
-            (store) => {
-                return IndexedDBUtility.delete(store, docId);
+        getStats() {
+            var collectionStats = [];
+            var collectionsMeta = this.metadata.collections;
+            for (var name in collectionsMeta) {
+                if (Object.prototype.hasOwnProperty.call(collectionsMeta, name)) {
+                    var data = collectionsMeta[name];
+                    collectionStats.push({
+                        name: name,
+                        sizeKB: data.sizeKB,
+                        documents: data.length,
+                        createdAt: new Date(data.createdAt).toISOString(),
+                        modifiedAt: new Date(data.modifiedAt).toISOString()
+                    });
+                }
             }
-        );
-
-        this.metadata.deleteDocument(docId);
 
-        await this.database.metadata.saveMetadata();
+            return {
+                name: this.name,
+                totalSizeKB: this.metadata.totalSizeKB,
+                totalDocuments: this.metadata.totalLength,
+                collections: collectionStats
+            };
+        }
 
-        this.observer._emit('afterDelete', docId);
+        updateSettings(newSettings) {
+            this.settings.updateSettings(newSettings);
+        }
 
-        return true;
-    }
+        async export (format, password) {
+            format = format || 'json';
+            password = password || null;
+            var data = {
+                version: '4.0.0',
+                database: this.name,
+                timestamp: Date.now(),
+                collections: {}
+            };
 
-    async freeSpace(size) {
-        let spaceToFree;
-        this.lastFreeSpaceTime = Date.now();
-        const currentSize = this.sizeKB;
+            var collectionNames = await this.listCollections();
+            for (var i = 0; i < collectionNames.length; i++) {
+                var collName = collectionNames[i];
+                var collection = await this.getCollection(collName);
+                var docs = await collection.getAll({
+                    password: password
+                });
+                data.collections[collName] = docs;
+            }
 
-        if (size >= 0) {
-            if (currentSize <= size) {
-                return 0;
-            } else {
-                spaceToFree = currentSize - size;
+            if (format === 'json') {
+                var serialized = serializer.serialize(data);
+                return base64.encode(serialized);
+            } else if (format === 'encrypted' && password) {
+                var encryption = new BrowserEncryptionUtility();
+                var serializedData = serializer.serialize(data);
+                var encrypted = await encryption.encrypt(serializedData, password);
+                return base64.encode(encrypted);
+            } else if (format === 'csv') {
+                var csv = '';
+                for (var collName in data.collections) {
+                    if (Object.prototype.hasOwnProperty.call(data.collections, collName)) {
+                        var docs = data.collections[collName];
+                        if (docs.length > 0) {
+                            var keys = Object.keys(docs[0]);
+                            csv += 'Collection: ' + collName + '\n';
+                            csv += keys.join(',') + '\n';
+                            for (var j = 0; j < docs.length; j++) {
+                                var doc = docs[j];
+                                csv += keys.map(function(k) {
+                                    return JSON.stringify(doc[k] || '');
+                                }).join(',') + '\n';
+                            }
+                            csv += '\n';
+                        }
+                    }
+                }
+                return csv;
             }
-        } else {
-            spaceToFree = -size;
-            size = currentSize - spaceToFree;
+
+            return data;
         }
 
-        const docEntries = Object.entries(this.metadataData.documentModifiedAt)
-            .filter(([docId]) => !this.metadataData.documentPermanent[docId])
-            .sort((a, b) => a[1] - b[1]);
 
-        let totalFreed = 0;
+        async import (data, format, password) {
+            format = format || 'json';
+            password = password || null;
+            var parsed;
+
+            try {
+                if (format === 'encrypted' && password) {
+                    var encryption = new BrowserEncryptionUtility();
+                    var encrypted = base64.decode(data);
+                    var decrypted = await encryption.decrypt(encrypted, password);
+                    parsed = serializer.deserialize(decrypted);
+                } else {
+                    var decoded = base64.decode(data);
+                    parsed = serializer.deserialize(decoded);
+                }
+            } catch (e) {
+                throw new LacertaDBError('Failed to parse import data', 'IMPORT_PARSE_FAILED', e);
+            }
+
+            var self = this;
+            for (var collName in parsed.collections) {
+                if (Object.prototype.hasOwnProperty.call(parsed.collections, collName)) {
+                    var docs = parsed.collections[collName];
+                    var collection = await this.createCollection(collName).catch(function() {
+                        return self.getCollection(collName);
+                    });
 
-        for (const [docId] of docEntries) {
-            if(this.sizeKB > size){
-                const docSize = this.metadataData.documentSizes[docId];
-                totalFreed += docSize;
-                await this.deleteDocument(docId, true);
-                if (totalFreed >= spaceToFree) {
-                    break;
+                    for (var i = 0; i < docs.length; i++) {
+                        await collection.add(docs[i]);
+                    }
+                }
+            }
+            var docCount = 0;
+            for(var c in parsed.collections){
+                if (Object.prototype.hasOwnProperty.call(parsed.collections, c)) {
+                   docCount += parsed.collections[c].length;
                 }
             }
+
+            return {
+                collections: Object.keys(parsed.collections).length,
+                documents: docCount
+            };
+        }
+
+
+        async clearAll() {
+            var self = this;
+            this.collections.forEach(async function(collection, name) {
+                await collection.clear();
+                collection.destroy();
+            });
+            this.collections.clear();
+            this.metadata = new DatabaseMetadata(this.name);
+            this.metadata.save();
+            this.quickStore.clear();
         }
 
-        return totalFreed;
+        destroy() {
+            this.collections.forEach(function(collection) {
+                collection.destroy();
+            });
+            this.collections.clear();
+        }
     }
 
-    async query(filter = {}, options = {}) {
-        const {
-            encryptionKey = null,
-            limit = Infinity,
-            offset = 0,
-            orderBy = null,
-            index = null
-        } = options;
-
-        // FIXED: Collect raw document data first, then process async operations after transaction
-        const rawDocuments = [];
-        
-        await IndexedDBUtility.performTransaction(
-            this.database.db,
-            this.name,
-            'readonly',
-            async (store) => {
-                let source = store;
-
-                if (index && store.indexNames.contains(index)) {
-                    source = store.index(index);
-                }
 
-                const request = orderBy
-                    ? source.openCursor(null, orderBy === 'asc' ? 'next' : 'prev')
-                    : source.openCursor();
+    // ========================
+    // Main LacertaDB Class
+    // ========================
 
-                return new Promise((resolve, reject) => {
-                    let count = 0;
-                    let skipped = 0;
+    class LacertaDB {
+        constructor() {
+            this.databases = new Map();
+            this.performanceMonitor = new PerformanceMonitor();
 
-                    request.onsuccess = (event) => {
-                        const cursor = event.target.result;
+            if (typeof global !== 'undefined') {
+                global.performanceMonitor = this.performanceMonitor;
+            }
+        }
 
-                        if (!cursor || count >= limit) {
-                            resolve();
-                            return;
-                        }
+        async getDatabase(name) {
+            if (!this.databases.has(name)) {
+                var db = new Database(name);
+                await db.init();
+                this.databases.set(name, db);
+            }
+            return this.databases.get(name);
+        }
 
-                        if (skipped < offset) {
-                            skipped++;
-                            cursor.continue();
-                            return;
-                        }
+        async dropDatabase(name) {
+            if (this.databases.has(name)) {
+                var db = this.databases.get(name);
+                await db.clearAll();
+                db.destroy();
+                this.databases.delete(name);
 
-                        // FIXED: Just collect raw data, no async operations here
-                        const docData = cursor.value;
-                        rawDocuments.push(docData);
-                        count++;
-                        
-                        cursor.continue();
-                    };
+                localStorage.removeItem('lacertadb_' + name + '_metadata');
+                localStorage.removeItem('lacertadb_' + name + '_settings');
+                localStorage.removeItem('lacertadb_' + name + '_version');
 
-                    request.onerror = () => reject(request.error);
-                });
+                var quickStore = new QuickStore(name);
+                quickStore.clear();
             }
-        );
+        }
 
-        // FIXED: Process documents after transaction is complete
-        const results = [];
-        
-        for (const docData of rawDocuments) {
-            let document;
-            if (Document.isEncrypted(docData)) {
-                if (!encryptionKey) {
-                    continue; // Skip encrypted documents without key
+        listDatabases() {
+            var dbs = [];
+            for (var i = 0; i < localStorage.length; i++) {
+                var key = localStorage.key(i);
+                if (key && key.startsWith('lacertadb_') && key.endsWith('_metadata')) {
+                    var dbName = key.replace('lacertadb_', '').replace('_metadata', '');
+                    dbs.push(dbName);
                 }
-                document = new Document(docData, encryptionKey);
-            } else {
-                document = new Document(docData);
             }
+            return dbs;
+        }
 
-            // Apply filters if any
-            if (Object.keys(filter).length > 0) {
-                const object = await document.objectOutput();
-                let match = true;
+        async createBackup(password) {
+            password = password || null;
+            var backup = {
+                version: '4.0.0',
+                timestamp: Date.now(),
+                databases: {}
+            };
 
-                for (const key in filter) {
-                    const value = key.includes('.')
-                        ? getNestedValue(object.data, key)
-                        : object.data[key];
+            var dbNames = this.listDatabases();
+            for (var i = 0; i < dbNames.length; i++) {
+                var dbName = dbNames[i];
+                var db = await this.getDatabase(dbName);
+                var exported = await db.export('json'); // Exports as turboserial/base64
+                var decoded = base64.decode(exported);
+                backup.databases[dbName] = serializer.deserialize(decoded);
+            }
 
-                    if (value !== filter[key]) {
-                        match = false;
-                        break;
-                    }
-                }
+            var serializedBackup = serializer.serialize(backup);
+            if (password) {
+                var encryption = new BrowserEncryptionUtility();
+                var encrypted = await encryption.encrypt(serializedBackup, password);
+                return base64.encode(encrypted);
+            }
+
+            return base64.encode(serializedBackup);
+        }
 
-                if (!match) {
-                    continue;
+        async restoreBackup(backupData, password) {
+            password = password || null;
+            var backup;
+
+            try {
+                var decodedData = base64.decode(backupData);
+                if (password) {
+                    var encryption = new BrowserEncryptionUtility();
+                    var decrypted = await encryption.decrypt(decodedData, password);
+                    backup = serializer.deserialize(decrypted);
+                } else {
+                    backup = serializer.deserialize(decodedData);
                 }
+            } catch (e) {
+                throw new LacertaDBError('Failed to parse backup data', 'BACKUP_PARSE_FAILED', e);
             }
 
-            results.push(await document.objectOutput());
-        }
+            var results = {
+                databases: 0,
+                collections: 0,
+                documents: 0
+            };
 
-        return results;
-    }
+            for (var dbName in backup.databases) {
+                if (Object.prototype.hasOwnProperty.call(backup.databases, dbName)) {
+                    var dbData = backup.databases[dbName];
+                    var db = await this.getDatabase(dbName);
+
+                    var serializedDbData = serializer.serialize(dbData);
+                    var encodedDbData = base64.encode(serializedDbData);
+
+                    var importResult = await db.import(encodedDbData);
 
-    async close() {
-        if (this._freeSpaceInterval) {
-            clearInterval(this._freeSpaceInterval);
-            this._freeSpaceInterval = null;
-            this._freeSpaceHandler = null;
+                    results.databases++;
+                    results.collections += importResult.collections;
+                    results.documents += importResult.documents;
+                }
+            }
+
+            return results;
         }
     }
 
-    toString() {
-        return `[Collection: ${this.name} | Database: ${this.database.name} | Size: ${this.sizeKB.toFixed(2)}KB | Documents: ${this.length}]`;
-    }
-}
 
+    // ========================
+    // Export
+    // ========================
+
+    var LacertaDBExport = {
+        LacertaDB: LacertaDB,
+        Database: Database,
+        Collection: Collection,
+        Document: Document,
+        QueryOperators: QueryOperators,
+        AggregationPipeline: AggregationPipeline,
+        MigrationManager: MigrationManager,
+        PerformanceMonitor: PerformanceMonitor,
+        LacertaDBError: LacertaDBError
+    };
+
+    module.exports = LacertaDBExport;
+
+})((typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : this) || {});