@pixagram/lacerta-db 0.11.3 → 0.11.4

package/index.js

@@ -1,7 +1,7 @@
 /**
- * LacertaDB V0.11.3 - Production Library
+ * LacertaDB V0.11.1 - Production Library
  * @module LacertaDB
- * @version 0.11.3
+ * @version 0.11.1
  * @license MIT
  * @author Pixagram SA
  */
@@ -28,15 +28,15 @@ import TurboBase64 from "@pixagram/turbobase64";
 
 // Default TurboSerial configuration (overridable via LacertaDB constructor)
 const TURBO_SERIAL_DEFAULTS = {
-    compression: false,
-    preservePropertyDescriptors: false,
+    compression: true,
+    preservePropertyDescriptors: true,
     deduplication: false,
     simdOptimization: true,
-    detectCircular: false,
-    shareArrayBuffers: false,
+    detectCircular: true,
+    shareArrayBuffers: true,
     allowFunction: false,
     serializeFunctions: false,
-    memoryPoolSize: 65536
+    memoryPoolSize: 65536 * 16
 };
 
 // ========================
@@ -418,9 +418,11 @@ class LFUCache {
     constructor(maxSize = 100, ttl = null) {
         this._maxSize = maxSize;
         this._ttl = ttl;
-        this._cache = new Map();
-        this._frequencies = new Map();
-        this._timestamps = new Map();
+        this._cache = new Map();          // key → value
+        this._frequencies = new Map();    // key → frequency
+        this._timestamps = new Map();     // key → insertion timestamp
+        this._buckets = new Map();        // frequency → Set<key>
+        this._minFreq = 0;
     }
 
     get(key) {
@@ -436,36 +438,63 @@ class LFUCache {
             }
         }
 
-        this._frequencies.set(key, (this._frequencies.get(key) || 0) + 1);
+        // Promote: remove from old bucket, add to new bucket
+        const oldFreq = this._frequencies.get(key) || 1;
+        const newFreq = oldFreq + 1;
+        this._frequencies.set(key, newFreq);
+
+        const oldBucket = this._buckets.get(oldFreq);
+        if (oldBucket) {
+            oldBucket.delete(key);
+            if (oldBucket.size === 0) {
+                this._buckets.delete(oldFreq);
+                if (this._minFreq === oldFreq) this._minFreq = newFreq;
+            }
+        }
+
+        if (!this._buckets.has(newFreq)) this._buckets.set(newFreq, new Set());
+        this._buckets.get(newFreq).add(key);
+
         return this._cache.get(key);
     }
 
     set(key, value) {
+        if (this._maxSize <= 0) return;
+
         if (this._cache.has(key)) {
             this._cache.set(key, value);
-            this._frequencies.set(key, (this._frequencies.get(key) || 0) + 1);
-        } else {
-            if (this._cache.size >= this._maxSize) {
-                let minFreq = Infinity;
-                let evictKey = null;
-                for (const [k, freq] of this._frequencies) {
-                    if (freq < minFreq) {
-                        minFreq = freq;
-                        evictKey = k;
-                    }
-                }
-                if (evictKey) {
-                    this.delete(evictKey);
-                }
-            }
+            this.get(key); // triggers frequency promotion
+            return;
+        }
 
-            this._cache.set(key, value);
-            this._frequencies.set(key, 1);
-            this._timestamps.set(key, Date.now());
+        if (this._cache.size >= this._maxSize) {
+            // O(1) eviction: grab any key from the lowest-frequency bucket
+            const minBucket = this._buckets.get(this._minFreq);
+            if (minBucket && minBucket.size > 0) {
+                const evictKey = minBucket.values().next().value;
+                this.delete(evictKey);
+            }
         }
+
+        this._cache.set(key, value);
+        this._frequencies.set(key, 1);
+        this._timestamps.set(key, Date.now());
+
+        if (!this._buckets.has(1)) this._buckets.set(1, new Set());
+        this._buckets.get(1).add(key);
+        this._minFreq = 1;
     }
 
     delete(key) {
+        if (!this._cache.has(key)) return false;
+
+        const freq = this._frequencies.get(key) || 1;
+        const bucket = this._buckets.get(freq);
+        if (bucket) {
+            bucket.delete(key);
+            if (bucket.size === 0) this._buckets.delete(freq);
+        }
+
         this._frequencies.delete(key);
         this._timestamps.delete(key);
         return this._cache.delete(key);
@@ -475,6 +504,8 @@ class LFUCache {
         this._cache.clear();
         this._frequencies.clear();
         this._timestamps.clear();
+        this._buckets.clear();
+        this._minFreq = 0;
     }
 
     has(key) {
@@ -493,56 +524,63 @@ class LFUCache {
 class TTLCache {
     constructor(ttl = 60000) {
         this._ttl = ttl;
-        this._cache = new Map();
-        this._timers = new Map();
+        this._cache = new Map();       // key → { value, ts }
+        this._sweepTimer = null;
+        this._sweepInterval = Math.min(ttl, 30000); // sweep at most every 30s
+
+        // Start periodic sweep
+        if (typeof globalThis !== 'undefined') {
+            this._sweepTimer = setInterval(() => this._sweep(), this._sweepInterval);
+        }
     }
 
     get(key) {
-        return this._cache.get(key) || null;
-    }
+        const entry = this._cache.get(key);
+        if (!entry) return null;
 
-    set(key, value) {
-        if (this._timers.has(key)) {
-            clearTimeout(this._timers.get(key));
+        // Lazy eviction: check TTL on read
+        if (Date.now() - entry.ts > this._ttl) {
+            this._cache.delete(key);
+            return null;
         }
+        return entry.value;
+    }
 
-        this._cache.set(key, value);
-
-        const timer = setTimeout(() => {
-            this.delete(key);
-        }, this._ttl);
-        this._timers.set(key, timer);
+    set(key, value) {
+        this._cache.set(key, { value, ts: Date.now() });
     }
 
     delete(key) {
-        if (this._timers.has(key)) {
-            clearTimeout(this._timers.get(key));
-            this._timers.delete(key);
-        }
         return this._cache.delete(key);
     }
 
     clear() {
-        for (const timer of this._timers.values()) {
-            clearTimeout(timer);
-        }
-        this._timers.clear();
         this._cache.clear();
     }
 
     has(key) {
-        return this._cache.has(key);
+        return this.get(key) !== null;
     }
 
     get size() {
         return this._cache.size;
     }
 
+    /** Periodic sweep: remove all expired entries in one pass */
+    _sweep() {
+        const now = Date.now();
+        for (const [key, entry] of this._cache) {
+            if (now - entry.ts > this._ttl) {
+                this._cache.delete(key);
+            }
+        }
+    }
+
     destroy() {
-        for (const timer of this._timers.values()) {
-            clearTimeout(timer);
+        if (this._sweepTimer) {
+            clearInterval(this._sweepTimer);
+            this._sweepTimer = null;
         }
-        this._timers.clear();
         this._cache.clear();
     }
 }
@@ -680,6 +718,9 @@ class BrowserCompressionUtility {
     }
 }
 
+// Shared singleton — BrowserCompressionUtility is stateless
+const _sharedCompression = new BrowserCompressionUtility();
+
 // ========================
 // Browser Encryption Utility
 // ========================
@@ -1193,9 +1234,40 @@ class QuadTree {
 }
 
 // ========================
-// B-Tree Index Implementation
+// B-Tree Index Implementation (Hardened)
 // ========================
 
+/**
+ * Safe total-order comparison for B-Tree keys.
+ * JavaScript's >, <, === do NOT provide a total order when
+ * types are mixed or special values (undefined, null, NaN) appear.
+ * This function guarantees a consistent -1/0/+1 for ANY input.
+ *
+ * Ordering: numbers < strings (within same type, natural order)
+ * @param {*} a
+ * @param {*} b
+ * @returns {number} -1 if a<b, 0 if a===b, 1 if a>b
+ */
+function _btreeCmp(a, b) {
+    // Identical references (covers same-value primitives and same object)
+    if (a === b) return 0;
+
+    const ta = typeof a;
+    const tb = typeof b;
+
+    // Same type — fast path (99% of real usage)
+    if (ta === tb) {
+        if (ta === 'number') return a < b ? -1 : 1;
+        if (ta === 'string') return a < b ? -1 : (a > b ? 1 : 0);
+        // Fallback: coerce to string for other types
+        const sa = String(a), sb = String(b);
+        return sa < sb ? -1 : (sa > sb ? 1 : 0);
+    }
+
+    // Different types — sort by type name for a stable total order
+    return ta < tb ? -1 : 1;
+}
+
 class BTreeNode {
     constructor(order, leaf) {
         this.keys = new Array(2 * order - 1);
@@ -1208,11 +1280,11 @@ class BTreeNode {
 
     search(key) {
         let i = 0;
-        while (i < this.n && key > this.keys[i]) {
+        while (i < this.n && _btreeCmp(key, this.keys[i]) > 0) {
             i++;
         }
 
-        if (i < this.n && key === this.keys[i]) {
+        if (i < this.n && _btreeCmp(key, this.keys[i]) === 0) {
             return this.values[i];
         }
 
@@ -1223,28 +1295,18 @@ class BTreeNode {
         return this.children[i] ? this.children[i].search(key) : null;
     }
 
-    // Optimized range search with subtree pruning (O(log n + k) instead of O(n))
-    // excludeMin/excludeMax: when true, boundary values are excluded from results
     rangeSearch(min, max, results, excludeMin = false, excludeMax = false) {
-        // Skip keys strictly below the min bound
         let i = 0;
         if (min !== null) {
-            while (i < this.n && this.keys[i] < min) {
+            while (i < this.n && _btreeCmp(this.keys[i], min) < 0) {
                 i++;
             }
-            // If min is exclusive, also skip keys equal to min
-            if (excludeMin) {
-                // But first descend into the child at boundary — it may have keys > min
-                // that are relevant. We handle this below in the loop.
-            }
         }
 
-        // Process keys from i onward
         for (; i < this.n; i++) {
-            // Early exit: if current key exceeds max (or equals max when exclusive),
-            // descend into left child then stop — no further keys can match
             if (max !== null) {
-                const pastMax = excludeMax ? this.keys[i] >= max : this.keys[i] > max;
+                const cmpMax = _btreeCmp(this.keys[i], max);
+                const pastMax = excludeMax ? cmpMax >= 0 : cmpMax > 0;
                 if (pastMax) {
                     if (!this.leaf && this.children[i]) {
                         this.children[i].rangeSearch(min, max, results, excludeMin, excludeMax);
@@ -1253,21 +1315,20 @@ class BTreeNode {
                 }
             }
 
-            // Descend into left child of current key
             if (!this.leaf && this.children[i]) {
                 this.children[i].rangeSearch(min, max, results, excludeMin, excludeMax);
             }
 
-            // Check current key against bounds
-            const meetsMin = min === null || (excludeMin ? this.keys[i] > min : this.keys[i] >= min);
-            const meetsMax = max === null || (excludeMax ? this.keys[i] < max : this.keys[i] <= max);
+            const cmpMin = min === null ? 1 : _btreeCmp(this.keys[i], min);
+            const cmpMaxCheck = max === null ? -1 : _btreeCmp(this.keys[i], max);
+            const meetsMin = min === null || (excludeMin ? cmpMin > 0 : cmpMin >= 0);
+            const meetsMax = max === null || (excludeMax ? cmpMaxCheck < 0 : cmpMaxCheck <= 0);
 
             if (meetsMin && meetsMax && this.values[i]) {
                 this.values[i].forEach(v => results.push(v));
             }
         }
 
-        // Descend into rightmost child
         if (!this.leaf && this.children[i]) {
             this.children[i].rangeSearch(min, max, results, excludeMin, excludeMax);
         }
@@ -1277,13 +1338,13 @@ class BTreeNode {
         let i = this.n - 1;
 
         if (this.leaf) {
-            while (i >= 0 && this.keys[i] > key) {
+            while (i >= 0 && _btreeCmp(this.keys[i], key) > 0) {
                 this.keys[i + 1] = this.keys[i];
                 this.values[i + 1] = this.values[i];
                 i--;
             }
 
-            if (i >= 0 && this.keys[i] === key) {
+            if (i >= 0 && _btreeCmp(this.keys[i], key) === 0) {
                 if (!this.values[i]) {
                     this.values[i] = new Set();
                 }
@@ -1294,11 +1355,11 @@ class BTreeNode {
                 this.n++;
             }
         } else {
-            while (i >= 0 && this.keys[i] > key) {
+            while (i >= 0 && _btreeCmp(this.keys[i], key) > 0) {
                 i--;
             }
 
-            if (i >= 0 && this.keys[i] === key) {
+            if (i >= 0 && _btreeCmp(this.keys[i], key) === 0) {
                 if (!this.values[i]) {
                     this.values[i] = new Set();
                 }
@@ -1310,18 +1371,13 @@ class BTreeNode {
             if (this.children[i] && this.children[i].n === 2 * this.order - 1) {
                 this.splitChild(i, this.children[i]);
 
-                // FIX: After split, the promoted median may equal key.
-                // If so, add value to it directly instead of descending
-                // (which would create a duplicate entry in the child).
-                if (this.keys[i] === key) {
-                    if (!this.values[i]) {
-                        this.values[i] = new Set();
-                    }
+                const cmp = _btreeCmp(this.keys[i], key);
+                if (cmp === 0) {
+                    if (!this.values[i]) this.values[i] = new Set();
                     this.values[i].add(value);
                     return;
                 }
-
-                if (this.keys[i] < key) {
+                if (cmp < 0) {
                     i++;
                 }
             }
@@ -1346,9 +1402,14 @@ class BTreeNode {
             }
         }
 
+        // CRITICAL: Save the median BEFORE cleaning stale slots.
+        // The clean loop covers index (order-1) which IS the median position.
+        const medianKey = y.keys[this.order - 1];
+        const medianValue = y.values[this.order - 1];
+
         y.n = this.order - 1;
 
-        // Clean stale slots in y after split
+        // Clean all stale slots in y (median + right half)
         for (let j = this.order - 1; j < 2 * this.order - 1; j++) {
             y.keys[j] = undefined;
             y.values[j] = undefined;
@@ -1359,28 +1420,26 @@ class BTreeNode {
             }
         }
 
+        // Shift parent's children right to make room
         for (let j = this.n; j >= i + 1; j--) {
             this.children[j + 1] = this.children[j];
         }
-
         this.children[i + 1] = z;
 
+        // Shift parent's keys/values right to make room
         for (let j = this.n - 1; j >= i; j--) {
             this.keys[j + 1] = this.keys[j];
             this.values[j + 1] = this.values[j];
         }
 
-        this.keys[i] = y.keys[this.order - 1];
-        this.values[i] = y.values[this.order - 1];
-        // Clear the promoted median from y (it's now in the parent)
-        y.keys[this.order - 1] = undefined;
-        y.values[this.order - 1] = undefined;
+        // Promote the saved median
+        this.keys[i] = medianKey;
+        this.values[i] = medianValue;
         this.n++;
     }
 
-    // ---- Deletion helpers (proper B-tree delete with rebalancing) ----
+    // ---- Deletion helpers ----
 
-    // Get the predecessor: rightmost key in the left subtree of keys[idx]
     _getPredecessor(idx) {
         let node = this.children[idx];
         while (!node.leaf) {
@@ -1389,7 +1448,6 @@ class BTreeNode {
         return { key: node.keys[node.n - 1], value: node.values[node.n - 1] };
     }
 
-    // Get the successor: leftmost key in the right subtree of keys[idx]
     _getSuccessor(idx) {
         let node = this.children[idx + 1];
         while (!node.leaf) {
@@ -1398,23 +1456,19 @@ class BTreeNode {
         return { key: node.keys[0], value: node.values[0] };
     }
 
-    // Merge children[idx+1] into children[idx], pulling keys[idx] down as separator
     _merge(idx) {
         const child = this.children[idx];
         const sibling = this.children[idx + 1];
         const t = this.order;
 
-        // Pull separator key down into child
         child.keys[t - 1] = this.keys[idx];
         child.values[t - 1] = this.values[idx];
 
-        // Copy keys/values from sibling into child
         for (let j = 0; j < sibling.n; j++) {
             child.keys[t + j] = sibling.keys[j];
             child.values[t + j] = sibling.values[j];
         }
 
-        // Copy children from sibling
         if (!child.leaf) {
             for (let j = 0; j <= sibling.n; j++) {
                 child.children[t + j] = sibling.children[j];
@@ -1423,18 +1477,15 @@ class BTreeNode {
 
         child.n += sibling.n + 1;
 
-        // Shift keys/values left in this node to fill the gap
         for (let j = idx; j < this.n - 1; j++) {
             this.keys[j] = this.keys[j + 1];
             this.values[j] = this.values[j + 1];
         }
 
-        // Shift children left in this node
         for (let j = idx + 1; j < this.n; j++) {
             this.children[j] = this.children[j + 1];
         }
 
-        // Clean stale trailing slots
         this.keys[this.n - 1] = undefined;
         this.values[this.n - 1] = undefined;
         this.children[this.n] = undefined;
@@ -1442,12 +1493,10 @@ class BTreeNode {
         this.n--;
     }
 
-    // Borrow the last key from children[idx-1] through the parent
     _borrowFromPrev(idx) {
         const child = this.children[idx];
         const sibling = this.children[idx - 1];
 
-        // Shift everything in child right by 1
         for (let j = child.n - 1; j >= 0; j--) {
             child.keys[j + 1] = child.keys[j];
             child.values[j + 1] = child.values[j];
@@ -1458,21 +1507,17 @@ class BTreeNode {
             }
         }
 
-        // Move separator from parent down to child[0]
         child.keys[0] = this.keys[idx - 1];
         child.values[0] = this.values[idx - 1];
 
-        // Move last child of sibling to child
         if (!child.leaf) {
             child.children[0] = sibling.children[sibling.n];
             sibling.children[sibling.n] = undefined;
         }
 
-        // Move last key of sibling up to parent
         this.keys[idx - 1] = sibling.keys[sibling.n - 1];
         this.values[idx - 1] = sibling.values[sibling.n - 1];
 
-        // Clean stale slots in sibling
         sibling.keys[sibling.n - 1] = undefined;
         sibling.values[sibling.n - 1] = undefined;
 
@@ -1480,25 +1525,20 @@ class BTreeNode {
         sibling.n--;
     }
 
-    // Borrow the first key from children[idx+1] through the parent
     _borrowFromNext(idx) {
         const child = this.children[idx];
         const sibling = this.children[idx + 1];
 
-        // Move separator from parent down to end of child
         child.keys[child.n] = this.keys[idx];
         child.values[child.n] = this.values[idx];
 
-        // Move first child of sibling to child
         if (!child.leaf) {
             child.children[child.n + 1] = sibling.children[0];
         }
 
-        // Move first key of sibling up to parent
         this.keys[idx] = sibling.keys[0];
         this.values[idx] = sibling.values[0];
 
-        // Shift sibling's keys/values left
         for (let j = 0; j < sibling.n - 1; j++) {
             sibling.keys[j] = sibling.keys[j + 1];
             sibling.values[j] = sibling.values[j + 1];
@@ -1510,7 +1550,6 @@ class BTreeNode {
             sibling.children[sibling.n] = undefined;
         }
 
-        // Clean stale trailing slots in sibling
         sibling.keys[sibling.n - 1] = undefined;
         sibling.values[sibling.n - 1] = undefined;
 
@@ -1518,8 +1557,6 @@ class BTreeNode {
         sibling.n--;
     }
 
-    // Ensure children[idx] has at least `order` keys (minimum degree)
-    // so we can safely descend into it during deletion
     _fill(idx) {
         const t = this.order;
         if (idx > 0 && this.children[idx - 1] && this.children[idx - 1].n >= t) {
@@ -1527,7 +1564,6 @@ class BTreeNode {
         } else if (idx < this.n && this.children[idx + 1] && this.children[idx + 1].n >= t) {
             this._borrowFromNext(idx);
         } else {
-            // Merge with a sibling
             if (idx < this.n) {
                 this._merge(idx);
             } else {
@@ -1536,7 +1572,6 @@ class BTreeNode {
         }
     }
 
-    // Remove a leaf-level key entry (shift keys, values left)
     _removeFromLeaf(idx) {
         for (let j = idx; j < this.n - 1; j++) {
             this.keys[j] = this.keys[j + 1];
@@ -1547,42 +1582,33 @@ class BTreeNode {
         this.n--;
     }
 
-    // Remove an internal key entry using predecessor/successor replacement
     _removeFromInternal(idx) {
         const t = this.order;
         const key = this.keys[idx];
 
         if (this.children[idx] && this.children[idx].n >= t) {
-            // Left child has enough keys: replace with predecessor
             const pred = this._getPredecessor(idx);
             this.keys[idx] = pred.key;
             this.values[idx] = pred.value;
             this.children[idx]._remove(pred.key, null, true);
         } else if (this.children[idx + 1] && this.children[idx + 1].n >= t) {
-            // Right child has enough keys: replace with successor
             const succ = this._getSuccessor(idx);
             this.keys[idx] = succ.key;
             this.values[idx] = succ.value;
             this.children[idx + 1]._remove(succ.key, null, true);
         } else {
-            // Both children at minimum: merge them, then delete from merged child
             this._merge(idx);
             this.children[idx]._remove(key, null, true);
         }
     }
 
-    // Core removal engine.
-    // removeEntire=false: remove one value from the Set; delete key entry if Set empties
-    // removeEntire=true:  delete the entire key entry regardless of Set contents
-    // Returns true if a key entry was fully removed, false otherwise
     _remove(key, value, removeEntire) {
         let i = 0;
-        while (i < this.n && key > this.keys[i]) {
+        while (i < this.n && _btreeCmp(key, this.keys[i]) > 0) {
             i++;
         }
 
-        if (i < this.n && key === this.keys[i]) {
-            // Key found at this node
+        if (i < this.n && _btreeCmp(key, this.keys[i]) === 0) {
             let shouldRemoveEntry = removeEntire;
 
             if (!shouldRemoveEntry && this.values[i]) {
@@ -1600,17 +1626,14 @@ class BTreeNode {
             }
             return false;
         } else {
-            // Key not found at this level — descend
             if (this.leaf) return false;
 
             const isLastChild = (i === this.n);
 
-            // Ensure the child we descend into has enough keys for safe deletion
             if (this.children[i] && this.children[i].n < this.order) {
                 this._fill(i);
             }
 
-            // After _fill, if the last child was merged, idx shifted
             if (isLastChild && i > this.n) {
                 return this.children[i - 1]
                     ? this.children[i - 1]._remove(key, value, removeEntire)
@@ -1623,20 +1646,23 @@ class BTreeNode {
         }
     }
 
-    // Public remove: remove a single (key, value) pair
     remove(key, value) {
         return this._remove(key, value, false);
     }
 
-    // Public removeKey: remove an entire key entry (used internally for predecessor/successor cleanup)
     removeKey(key) {
         return this._remove(key, null, true);
     }
 
     verify() {
         const issues = [];
+        for (let i = 0; i < this.n; i++) {
+            if (this.keys[i] === undefined || this.keys[i] === null) {
+                issues.push(`Invalid key (${this.keys[i]}) at index ${i}`);
+            }
+        }
         for (let i = 1; i < this.n; i++) {
-            if (this.keys[i] <= this.keys[i - 1]) {
+            if (_btreeCmp(this.keys[i], this.keys[i - 1]) <= 0) {
                 issues.push(`Key order violation at index ${i}`);
             }
         }
@@ -1657,14 +1683,11 @@ class BTreeIndex {
         this._root = null;
         this._order = order;
         this._size = 0;
-        this._lastVerification = Date.now();
-        this._verificationInterval = 60000;
     }
 
     insert(key, value) {
-        if (Date.now() - this._lastVerification > this._verificationInterval) {
-            this.verify();
-        }
+        // Reject keys that break comparison semantics
+        if (key === undefined || key === null || (typeof key === 'number' && isNaN(key))) return;
 
         // Check for exact duplicate (key, value) to keep _size accurate
         if (this._root) {
@@ -1685,13 +1708,13 @@ class BTreeIndex {
                 s.children[0] = this._root;
                 s.splitChild(0, this._root);
 
-                // FIX: Check if promoted median equals key
                 let i = 0;
-                if (s.keys[0] === key) {
+                const cmp = _btreeCmp(s.keys[0], key);
+                if (cmp === 0) {
                     if (!s.values[0]) s.values[0] = new Set();
                     s.values[0].add(value);
                 } else {
-                    if (s.keys[0] < key) i++;
+                    if (cmp < 0) i++;
                     s.children[i].insertNonFull(key, value);
                 }
 
@@ -1740,7 +1763,6 @@ class BTreeIndex {
         const existing = this._root.search(key);
         if (existing && existing.has(value)) {
             this._root.remove(key, value);
-            // Shrink root if it became empty (all keys merged down)
             if (this._root.n === 0 && !this._root.leaf && this._root.children[0]) {
                 this._root = this._root.children[0];
             }
@@ -1749,12 +1771,9 @@ class BTreeIndex {
     }
 
     verify() {
-        this._lastVerification = Date.now();
         if (!this._root) return { healthy: true, issues: [] };
         const issues = this._root.verify();
         if (issues.length > 0) {
-            // NOTE: verify detects structural violations but cannot auto-repair.
-            // A full rebuild is required to fix a corrupted index.
             console.warn('BTree index issues detected (rebuild required):', issues);
         }
         return {
@@ -2634,7 +2653,7 @@ class Document {
         this._attachments = data._attachments || [];
         this._data = null;
         this._packedData = data.packedData || null;
-        this._compression = new BrowserCompressionUtility();
+        this._compression = _sharedCompression;
         this._serializer = serializer;
 
         if (data.data) {
@@ -3579,6 +3598,30 @@ class PerformanceMonitor {
     }
 }
 
+// ========================
+// Stable Cache Key Utility
+// ========================
+
+/**
+ * Generate a deterministic cache key from query filter + options.
+ * Uses sorted-keys JSON.stringify for stability, avoiding the overhead
+ * of full TurboSerial serialize + Base64 encode on every query call.
+ * @param {object} filter
+ * @param {object} options
+ * @returns {string}
+ */
+function _stableCacheKey(filter, options) {
+    const replacer = (_, v) => {
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            const sorted = {};
+            for (const k of Object.keys(v).sort()) sorted[k] = v[k];
+            return sorted;
+        }
+        return v;
+    };
+    return JSON.stringify({ f: filter, o: options }, replacer);
+}
+
 // ========================
 // Collection Class (Optimized)
 // ========================
@@ -3858,7 +3901,7 @@ class Collection {
 
         const startTime = performance.now();
 
-        const cacheKey = this._base64.encode(this._serializer.serialize({filter, options}));
+        const cacheKey = _stableCacheKey(filter, options);
         const cached = this._cacheStrategy.get(cacheKey);
 
         if (cached) {
@@ -4428,7 +4471,7 @@ class Database {
 
     async export(format = 'json', password = null) {
         const data = {
-            version: '0.10.2',
+            version: '0.11.1',
             database: this.name,
             timestamp: Date.now(),
             collections: {}
@@ -4614,7 +4657,7 @@ class LacertaDB {
 
     async createBackup(password = null) {
         const backup = {
-            version: '0.10.2',
+            version: '0.11.1',
             timestamp: Date.now(),
             databases: {}
         };