dataply 0.0.22-alpha.0 → 0.0.22-alpha.2

package/dist/cjs/index.js

@@ -38,7 +38,7 @@ __export(src_exports, {
   BPTreeSyncTransaction: () => BPTreeSyncTransaction,
   BitmapPageManager: () => BitmapPageManager,
   CacheEntanglementAsync: () => CacheEntanglementAsync,
-  CacheEntanglementSync: () => CacheEntanglementSync2,
+  CacheEntanglementSync: () => CacheEntanglementSync,
   DataPageManager: () => DataPageManager,
   Dataply: () => Dataply,
   DataplyAPI: () => DataplyAPI,
@@ -125,6 +125,42 @@ var StringComparator = class extends ValueComparator {
 };
 var MVCCStrategy = class {
 };
+var LRUMap = class {
+  cache = /* @__PURE__ */ new Map();
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  get(key) {
+    if (!this.cache.has(key)) return void 0;
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+    return this;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
 var MVCCTransaction = class {
   committed;
   snapshotVersion;
@@ -132,7 +168,6 @@ var MVCCTransaction = class {
   writeBuffer;
   deleteBuffer;
   createdKeys;
-  // create()로 생성된 키 추적
   deletedValues;
   // delete 시 삭제 전 값 저장
   originallyExisted;
@@ -151,7 +186,8 @@ var MVCCTransaction = class {
   versionIndex = /* @__PURE__ */ new Map();
   deletedCache = /* @__PURE__ */ new Map();
   activeTransactions = /* @__PURE__ */ new Set();
-  constructor(strategy, parent, snapshotVersion) {
+  diskCache;
+  constructor(strategy, options, parent, snapshotVersion) {
     this.snapshotVersion = snapshotVersion ?? 0;
     this.writeBuffer = /* @__PURE__ */ new Map();
     this.deleteBuffer = /* @__PURE__ */ new Set();
@@ -166,6 +202,7 @@ var MVCCTransaction = class {
       this.snapshotLocalVersion = parent.localVersion;
       this.strategy = void 0;
       this.root = parent.root;
+      this.diskCache = parent.diskCache;
     } else {
       if (!strategy) throw new Error("Root Transaction must get Strategy");
       this.strategy = strategy;
@@ -173,8 +210,13 @@ var MVCCTransaction = class {
       this.localVersion = 0;
       this.snapshotLocalVersion = 0;
       this.root = this;
+      this.diskCache = new LRUMap(options?.cacheCapacity ?? 1e3);
     }
   }
+  /**
+   * Checks if the transaction is a root transaction.
+   * @returns True if the transaction is a root transaction, false otherwise.
+   */
   isRoot() {
     return !this.parent;
   }
@@ -191,7 +233,22 @@ var MVCCTransaction = class {
     }
     return false;
   }
-  // --- Internal buffer manipulation helpers ---
+  /**
+   * Checks if a key was written in this transaction.
+   * @param key The key to check.
+   * @returns True if the key was written in this transaction, false otherwise.
+   */
+  isWrote(key) {
+    return this.writeBuffer.has(key);
+  }
+  /**
+   * Checks if a key was deleted in this transaction.
+   * @param key The key to check.
+   * @returns True if the key was deleted in this transaction, false otherwise.
+   */
+  isDeleted(key) {
+    return this.deleteBuffer.has(key);
+  }
   _recordHistory(key) {
     const existsInWriteBuffer = this.writeBuffer.has(key);
     const existsInDeleteBuffer = this.deleteBuffer.has(key);
@@ -205,6 +262,41 @@ var MVCCTransaction = class {
       });
     }
   }
+  /**
+   * BINARY SEARCH HELPER: Finds the index of the last element in the array 
+   * where item[key] <= target. Assumes the array is sorted by 'key' ascending.
+   */
+  _findLastLE(array, target, property) {
+    let left = 0;
+    let right = array.length - 1;
+    let result = -1;
+    while (left <= right) {
+      const mid = left + right >> 1;
+      if (array[mid][property] <= target) {
+        result = mid;
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+    return result;
+  }
+  /**
+   * BINARY SEARCH HELPER: Finds the index of the element in the array 
+   * where item[key] === target. Assumes the array is sorted by 'key' ascending.
+   */
+  _findExact(array, target, property) {
+    let left = 0;
+    let right = array.length - 1;
+    while (left <= right) {
+      const mid = left + right >> 1;
+      const val = array[mid][property];
+      if (val === target) return mid;
+      if (val < target) left = mid + 1;
+      else right = mid - 1;
+    }
+    return -1;
+  }
   _bufferCreate(key, value, version) {
     if (version === void 0) this.localVersion++;
     const targetVersion = version ?? this.localVersion;
@@ -254,7 +346,11 @@ var MVCCTransaction = class {
         deleted.push({ key, data });
       }
     }
-    return { created, updated, deleted };
+    return {
+      created,
+      updated,
+      deleted
+    };
   }
   /**
    * Rolls back the transaction.
@@ -272,7 +368,12 @@ var MVCCTransaction = class {
     if (this.root !== this) {
       this.root.activeTransactions.delete(this);
     }
-    return { success: true, created, updated, deleted };
+    return {
+      success: true,
+      created,
+      updated,
+      deleted
+    };
   }
   /**
    * Cleans up both deletedCache and versionIndex based on minActiveVersion.
@@ -358,7 +459,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
   createNested() {
     if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
-    const child = new _SyncMVCCTransaction(void 0, this, childVersion);
+    const child = new _SyncMVCCTransaction(void 0, void 0, this, childVersion);
     this.root.activeTransactions.add(child);
     return child;
   }
@@ -381,78 +482,114 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     return this._diskExists(key, this.snapshotVersion);
   }
   _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return true;
-      }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return false;
-      }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists;
-        }
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return true;
+      }
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return false;
+      }
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) return history[idx].exists;
+      }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return current._diskExists(key, snapshotVersion);
       }
     }
-    if (this.parent) {
-      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return this._diskExists(key, snapshotVersion);
-    }
+    return false;
   }
   _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return this.writeBuffer.get(key);
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return current.writeBuffer.get(key);
+        }
       }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return null;
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return null;
+        }
       }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists ? history[i].value : null;
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) {
+          return history[idx].exists ? history[idx].value : null;
         }
       }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return current._diskRead(key, snapshotVersion);
+      }
     }
-    if (this.parent) {
-      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return this._diskRead(key, snapshotVersion);
-    }
+    return null;
   }
   commit(label) {
     const { created, updated, deleted } = this.getResultEntries();
     if (this.committed) {
-      return { label, success: false, error: "Transaction already committed", conflict: void 0, created, updated, deleted };
+      return {
+        label,
+        success: false,
+        error: "Transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
     }
     if (this.hasCommittedAncestor()) {
-      return { label, success: false, error: "Ancestor transaction already committed", conflict: void 0, created, updated, deleted };
+      return {
+        label,
+        success: false,
+        error: "Ancestor transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
     }
     if (this.parent) {
       const failure = this.parent._merge(this);
       if (failure) {
-        return { label, success: false, error: failure.error, conflict: failure.conflict, created, updated, deleted };
+        return {
+          label,
+          success: false,
+          error: failure.error,
+          conflict: failure.conflict,
+          created,
+          updated,
+          deleted
+        };
       }
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
         const failure = this._merge(this);
         if (failure) {
-          return { label, success: false, error: failure.error, conflict: failure.conflict, created: [], updated: [], deleted: [] };
+          return {
+            label,
+            success: false,
+            error: failure.error,
+            conflict: failure.conflict,
+            created: [],
+            updated: [],
+            deleted: []
+          };
         }
         this.writeBuffer.clear();
         this.deleteBuffer.clear();
@@ -465,7 +602,13 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         this.snapshotVersion = this.version;
       }
     }
-    return { label, success: true, created, updated, deleted };
+    return {
+      label,
+      success: true,
+      created,
+      updated,
+      deleted
+    };
   }
   _merge(child) {
     if (this.parent) {
@@ -474,7 +617,11 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
           return {
             error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
-            conflict: { key, parent: this.read(key), child: child.read(key) }
+            conflict: {
+              key,
+              parent: this.read(key),
+              child: child.read(key)
+            }
           };
         }
       }
@@ -483,7 +630,11 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
           return {
             error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
-            conflict: { key, parent: this.read(key), child: child.read(key) }
+            conflict: {
+              key,
+              parent: this.read(key),
+              child: child.read(key)
+            }
           };
         }
       }
@@ -512,7 +663,11 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
             if (lastVer > child.snapshotVersion) {
               return {
                 error: `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`,
-                conflict: { key, parent: this.read(key), child: child.read(key) }
+                conflict: {
+                  key,
+                  parent: this.read(key),
+                  child: child.read(key)
+                }
               };
             }
           }
@@ -520,7 +675,11 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
           if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
             return {
               error: `Commit conflict: Key '${key}' was modified by a newer transaction in the same session (Local v${lastModLocalVer})`,
-              conflict: { key, parent: this.read(key), child: child.read(key) }
+              conflict: {
+                key,
+                parent: this.read(key),
+                child: child.read(key)
+              }
             };
           }
         }
@@ -555,10 +714,14 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
   _diskWrite(key, value, version) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (strategy.exists(key)) {
-      const currentVal = strategy.read(key);
+    const rootAsAny = this.root;
+    if (this._diskExists(key, version)) {
+      const currentVal = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
       if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
       this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: version });
+      rootAsAny.diskCache.set(key, value);
+    } else {
+      rootAsAny.diskCache.set(key, value);
     }
     strategy.write(key, value);
     if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
@@ -569,23 +732,25 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return strategy.exists(key) ? strategy.read(key) : null;
+      const rootAsAny = this.root;
+      if (this._diskExists(key, snapshotVersion)) {
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached2 = this.deletedCache.get(key);
         if (cached2) {
-          const match = cached2.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return match.value;
+          const cIdx = this._findExact(cached2, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return cached2[cIdx].value;
         }
       }
       return null;
@@ -593,12 +758,18 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!targetVerObj.exists) return null;
     if (!nextVerObj) {
       if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
-      return strategy.read(key);
+      if (this._diskExists(key, snapshotVersion)) {
+        const rootAsAny = this.root;
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     const cached = this.deletedCache.get(key);
     if (cached) {
-      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-      if (match) return match.value;
+      const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+      if (cIdx >= 0) return cached[cIdx].value;
     }
     return null;
   }
@@ -607,23 +778,23 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return strategy.exists(key);
+      const rootAsAny = this.root;
+      if (rootAsAny.diskCache.has(key)) return rootAsAny.diskCache.get(key) !== null;
+      const exists = strategy.exists(key);
+      if (!exists) rootAsAny.diskCache.set(key, null);
+      return exists;
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached = this.deletedCache.get(key);
         if (cached) {
-          const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return true;
+          const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return true;
         }
       }
       return false;
@@ -633,11 +804,13 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
   _diskDelete(key, snapshotVersion) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (strategy.exists(key)) {
-      const currentVal = strategy.read(key);
+    const rootAsAny = this.root;
+    if (this._diskExists(key, snapshotVersion)) {
+      const currentVal = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
       if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
       this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
       strategy.delete(key);
+      rootAsAny.diskCache.delete(key);
     }
     if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
     this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
@@ -951,7 +1124,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
   createNested() {
     if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
-    const child = new _AsyncMVCCTransaction(void 0, this, childVersion);
+    const child = new _AsyncMVCCTransaction(void 0, void 0, this, childVersion);
     this.root.activeTransactions.add(child);
     return child;
   }
@@ -974,78 +1147,114 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     return await this._diskExists(key, this.snapshotVersion);
   }
   async _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return true;
-      }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return false;
-      }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists;
-        }
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return true;
+      }
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return false;
+      }
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) return history[idx].exists;
+      }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return await current._diskExists(key, snapshotVersion);
       }
     }
-    if (this.parent) {
-      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return await this._diskExists(key, snapshotVersion);
-    }
+    return false;
   }
   async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return this.writeBuffer.get(key);
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return current.writeBuffer.get(key);
+        }
       }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return null;
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return null;
+        }
       }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists ? history[i].value : null;
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) {
+          return history[idx].exists ? history[idx].value : null;
         }
       }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return await current._diskRead(key, snapshotVersion);
+      }
     }
-    if (this.parent) {
-      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return await this._diskRead(key, snapshotVersion);
-    }
+    return null;
   }
   async commit(label) {
     const { created, updated, deleted } = this.getResultEntries();
     if (this.committed) {
-      return { label, success: false, error: "Transaction already committed", conflict: void 0, created, updated, deleted };
+      return {
+        label,
+        success: false,
+        error: "Transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
     }
     if (this.hasCommittedAncestor()) {
-      return { label, success: false, error: "Ancestor transaction already committed", conflict: void 0, created, updated, deleted };
+      return {
+        label,
+        success: false,
+        error: "Ancestor transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
     }
     if (this.parent) {
       const failure = await this.parent._merge(this);
       if (failure) {
-        return { label, success: false, error: failure.error, conflict: failure.conflict, created, updated, deleted };
+        return {
+          label,
+          success: false,
+          error: failure.error,
+          conflict: failure.conflict,
+          created,
+          updated,
+          deleted
+        };
       }
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
         const failure = await this._merge(this);
         if (failure) {
-          return { label, success: false, error: failure.error, conflict: failure.conflict, created: [], updated: [], deleted: [] };
+          return {
+            label,
+            success: false,
+            error: failure.error,
+            conflict: failure.conflict,
+            created: [],
+            updated: [],
+            deleted: []
+          };
         }
         this.writeBuffer.clear();
         this.deleteBuffer.clear();
@@ -1058,7 +1267,13 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         this.snapshotVersion = this.version;
       }
     }
-    return { label, success: true, created, updated, deleted };
+    return {
+      label,
+      success: true,
+      created,
+      updated,
+      deleted
+    };
   }
   async _merge(child) {
     return this.writeLock(async () => {
@@ -1068,7 +1283,11 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
             return {
               error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
-              conflict: { key, parent: await this.read(key), child: await child.read(key) }
+              conflict: {
+                key,
+                parent: await this.read(key),
+                child: await child.read(key)
+              }
             };
           }
         }
@@ -1077,7 +1296,11 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
           if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
             return {
               error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
-              conflict: { key, parent: await this.read(key), child: await child.read(key) }
+              conflict: {
+                key,
+                parent: await this.read(key),
+                child: await child.read(key)
+              }
             };
           }
         }
@@ -1107,7 +1330,11 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
               if (lastVer > child.snapshotVersion) {
                 return {
                   error: `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`,
-                  conflict: { key, parent: await this.read(key), child: await child.read(key) }
+                  conflict: {
+                    key,
+                    parent: await this.read(key),
+                    child: await child.read(key)
+                  }
                 };
               }
             }
@@ -1115,7 +1342,11 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
             if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
               return {
                 error: `Commit conflict: Key '${key}' was modified by a newer transaction in the same session (Local v${lastModLocalVer})`,
-                conflict: { key, parent: await this.read(key), child: await child.read(key) }
+                conflict: {
+                  key,
+                  parent: await this.read(key),
+                  child: await child.read(key)
+                }
               };
             }
           }
@@ -1151,10 +1382,14 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
   async _diskWrite(key, value, version) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (await strategy.exists(key)) {
-      const currentVal = await strategy.read(key);
+    const rootAsAny = this.root;
+    if (await this._diskExists(key, version)) {
+      const currentVal = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : await strategy.read(key);
       if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
       this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: version });
+      rootAsAny.diskCache.set(key, value);
+    } else {
+      rootAsAny.diskCache.set(key, value);
     }
     await strategy.write(key, value);
     if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
@@ -1165,23 +1400,25 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return await strategy.exists(key) ? await strategy.read(key) : null;
+      const rootAsAny = this.root;
+      if (await this._diskExists(key, snapshotVersion)) {
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : await strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached2 = this.deletedCache.get(key);
         if (cached2) {
-          const match = cached2.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return match.value;
+          const cIdx = this._findExact(cached2, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return cached2[cIdx].value;
         }
       }
       return null;
@@ -1189,12 +1426,18 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!targetVerObj.exists) return null;
     if (!nextVerObj) {
       if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
-      return strategy.read(key);
+      if (await this._diskExists(key, snapshotVersion)) {
+        const rootAsAny = this.root;
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : await strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     const cached = this.deletedCache.get(key);
     if (cached) {
-      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-      if (match) return match.value;
+      const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+      if (cIdx >= 0) return cached[cIdx].value;
     }
     return null;
   }
@@ -1203,366 +1446,47 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return await strategy.exists(key);
+      const rootAsAny = this.root;
+      if (rootAsAny.diskCache.has(key)) return rootAsAny.diskCache.get(key) !== null;
+      const exists = await strategy.exists(key);
+      if (!exists) rootAsAny.diskCache.set(key, null);
+      return exists;
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached = this.deletedCache.get(key);
         if (cached) {
-          const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return true;
-        }
-      }
-      return false;
-    }
-    return targetVerObj.exists;
-  }
-  async _diskDelete(key, snapshotVersion) {
-    const strategy = this.strategy;
-    if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (await strategy.exists(key)) {
-      const currentVal = await strategy.read(key);
-      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
-      this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
-      await strategy.delete(key);
-    }
-    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
-    this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
-  }
-};
-var LRUMap = class {
-  capacity;
-  map;
-  head = null;
-  tail = null;
-  /**
-   * Creates an instance of LRUMap.
-   * @param capacity The maximum number of items the cache can hold.
-   */
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.map = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Promotes a node to the head of the linked list (marks as most recently used).
-   * @param node The node to promote.
-   */
-  promote(node) {
-    this.extract(node);
-    this.prepend(node);
-  }
-  /**
-   * Disconnects a node from the doubly linked list.
-   * @param node The node to extract.
-   */
-  extract(node) {
-    if (node.prev) node.prev.next = node.next;
-    else this.head = node.next;
-    if (node.next) node.next.prev = node.prev;
-    else this.tail = node.prev;
-    node.prev = null;
-    node.next = null;
-  }
-  /**
-   * Inserts a node at the head of the doubly linked list.
-   * @param node The node to prepend.
-   */
-  prepend(node) {
-    node.next = this.head;
-    if (this.head) this.head.prev = node;
-    this.head = node;
-    if (!this.tail) this.tail = node;
-  }
-  /**
-   * Stores or updates a value by key.
-   * If the capacity is exceeded, the least recently used item (tail) is removed.
-   * @param key The key to store.
-   * @param value The value to store.
-   */
-  set(key, value) {
-    const existing = this.map.get(key);
-    if (existing) {
-      existing.value = value;
-      this.promote(existing);
-      return;
-    }
-    const newNode = { key, value, prev: null, next: null };
-    this.map.set(key, newNode);
-    this.prepend(newNode);
-    if (this.map.size > this.capacity && this.tail) {
-      this.map.delete(this.tail.key);
-      this.extract(this.tail);
-    }
-  }
-  /**
-   * Retrieves a value by key.
-   * Accessing the item moves it to the "most recently used" position.
-   * @param key The key to look for.
-   * @returns The value associated with the key, or undefined if not found.
-   */
-  get(key) {
-    const node = this.map.get(key);
-    if (!node) return void 0;
-    this.promote(node);
-    return node.value;
-  }
-  /**
-   * Checks if a key exists in the cache without changing its access order.
-   * @param key The key to check.
-   * @returns True if the key exists, false otherwise.
-   */
-  has(key) {
-    return this.map.has(key);
-  }
-  /**
-   * Removes a key and its associated value from the cache.
-   * @param key The key to remove.
-   * @returns True if the key was found and removed, false otherwise.
-   */
-  delete(key) {
-    const node = this.map.get(key);
-    if (!node) return false;
-    this.extract(node);
-    this.map.delete(key);
-    return true;
-  }
-  /**
-   * Returns an iterator of keys in the order of most recently used to least recently used.
-   * @returns An iterable iterator of keys.
-   */
-  *keys() {
-    let current = this.head;
-    while (current) {
-      yield current.key;
-      current = current.next;
-    }
-  }
-  /**
-   * Returns the current number of items in the cache.
-   */
-  get size() {
-    return this.map.size;
-  }
-  /**
-   * Clears all items from the cache.
-   */
-  clear() {
-    this.map.clear();
-    this.head = null;
-    this.tail = null;
-  }
-};
-var CacheEntanglement = class {
-  creation;
-  beforeUpdateHook;
-  capacity;
-  dependencies;
-  caches;
-  parameters;
-  assignments;
-  dependencyProperties;
-  updateRequirements;
-  constructor(creation, option) {
-    option = option ?? {};
-    const {
-      dependencies,
-      capacity,
-      beforeUpdateHook
-    } = option;
-    this.creation = creation;
-    this.beforeUpdateHook = beforeUpdateHook ?? (() => {
-    });
-    this.capacity = capacity ?? 100;
-    this.assignments = [];
-    this.caches = new LRUMap(this.capacity);
-    this.parameters = /* @__PURE__ */ new Map();
-    this.dependencies = dependencies ?? {};
-    this.dependencyProperties = Object.keys(this.dependencies);
-    this.updateRequirements = /* @__PURE__ */ new Set();
-    for (const name in this.dependencies) {
-      const dependency = this.dependencies[name];
-      if (!dependency.assignments.includes(this)) {
-        dependency.assignments.push(this);
-      }
-    }
-  }
-  bubbleUpdateSignal(key) {
-    this.updateRequirements.add(key);
-    for (let i = 0, len = this.assignments.length; i < len; i++) {
-      const t = this.assignments[i];
-      const instance = t;
-      for (const cacheKey of instance.caches.keys()) {
-        if (cacheKey === key || cacheKey.startsWith(`${key}/`)) {
-          instance.bubbleUpdateSignal(cacheKey);
-        }
-      }
-    }
-  }
-  dependencyKey(key) {
-    const i = key.lastIndexOf("/");
-    if (i === -1) {
-      return key;
-    }
-    return key.substring(0, i);
-  }
-  /**
-   * Returns all keys stored in the instance.
-   */
-  keys() {
-    return this.parameters.keys();
-  }
-  /**
-   * Deletes all cache values stored in the instance.
-   */
-  clear() {
-    for (const key of this.keys()) {
-      this.delete(key);
-    }
-  }
-  /**
-   * Checks if there is a cache value stored in the key within the instance.
-   * @param key The key to search.
-   */
-  exists(key) {
-    return this.parameters.has(key);
-  }
-  /**
-   * Checks if there is a cache value stored in the key within the instance.
-   * This method is an alias for `exists`.
-   * @param key The key to search.
-   */
-  has(key) {
-    return this.exists(key);
-  }
-  /**
-   * Deletes the cache value stored in the key within the instance.
-   * @param key The key to delete.
-   */
-  delete(key) {
-    this.caches.delete(key);
-    this.parameters.delete(key);
-    this.updateRequirements.delete(key);
-    for (let i = 0, len = this.assignments.length; i < len; i++) {
-      const t = this.assignments[i];
-      const instance = t;
-      for (const cacheKey of instance.keys()) {
-        if (cacheKey === key || cacheKey.startsWith(`${key}/`)) {
-          instance.delete(cacheKey);
+          const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return true;
         }
       }
+      return false;
     }
+    return targetVerObj.exists;
   }
-};
-var CacheData = class _CacheData {
-  static StructuredClone = globalThis.structuredClone.bind(globalThis);
-  _value;
-  constructor(value) {
-    this._value = value;
-  }
-  /**
-   * This is cached data.
-   * It was generated at the time of caching, so there is a risk of modification if it's an object due to shallow copying.
-   * Therefore, if it's not a primitive type, please avoid using this value directly and use the `clone` method to use a copied version of the data.
-   */
-  get raw() {
-    return this._value;
-  }
-  /**
-   * The method returns a copied value of the cached data.
-   * You can pass a function as a parameter to copy the value. This parameter function should return the copied value.
-   * 
-   * If no parameter is passed, it defaults to using `structuredClone` function to copy the value.
-   * If you prefer shallow copying instead of deep copying,
-   * you can use the default options `array-shallow-copy`, `object-shallow-copy` and `deep-copy`,
-   * which are replaced with functions to shallow copy arrays and objects, respectively. This is a syntactic sugar.
-   * @param strategy The function that returns the copied value.
-   * If you want to perform a shallow copy, simply pass the strings `array-shallow-copy` or `object-shallow-copy` for easy use.  
-   * The `array-shallow-copy` strategy performs a shallow copy of an array.  
-   * The `object-shallow-copy` strategy performs a shallow copy of an object.  
-   * The `deep-copy` strategy performs a deep copy of the value using `structuredClone`.  
-   * The default is `deep-copy`.
-   */
-  clone(strategy = "deep-copy") {
-    if (strategy && typeof strategy !== "string") {
-      return strategy(this.raw);
-    }
-    switch (strategy) {
-      case "array-shallow-copy":
-        return [].concat(this.raw);
-      case "object-shallow-copy":
-        return Object.assign({}, this.raw);
-      case "deep-copy":
-      default:
-        return _CacheData.StructuredClone(this.raw);
-    }
-  }
-};
-var CacheEntanglementSync = class extends CacheEntanglement {
-  constructor(creation, option) {
-    super(creation, option);
-  }
-  recache(key) {
-    if (!this.parameters.has(key)) {
-      return;
-    }
-    if (!this.caches.has(key) || this.updateRequirements.has(key)) {
-      this.resolve(key, ...this.parameters.get(key));
-    }
-    return this.caches.get(key);
-  }
-  resolve(key, ...parameter) {
-    const resolved = {};
-    const dependencyKey = this.dependencyKey(key);
-    this.beforeUpdateHook(key, dependencyKey, ...parameter);
-    for (let i = 0, len = this.dependencyProperties.length; i < len; i++) {
-      const name = this.dependencyProperties[i];
-      const dependency = this.dependencies[name];
-      if (!dependency.exists(key) && !dependency.exists(dependencyKey)) {
-        throw new Error(`The key '${key}' or '${dependencyKey}' has not been assigned yet in dependency '${name.toString()}'.`, {
-          cause: {
-            from: this
-          }
-        });
-      }
-      const dependencyValue = dependency.recache(key) ?? dependency.recache(dependencyKey);
-      resolved[name] = dependencyValue;
-    }
-    const value = new CacheData(this.creation(key, resolved, ...parameter));
-    this.updateRequirements.delete(key);
-    this.parameters.set(key, parameter);
-    this.caches.set(key, value);
-    return value;
-  }
-  get(key) {
-    if (!this.parameters.has(key)) {
-      throw new Error(`Cache value not found: ${key}`);
-    }
-    return this.cache(key, ...this.parameters.get(key));
-  }
-  cache(key, ...parameter) {
-    if (!this.caches.has(key) || this.updateRequirements.has(key)) {
-      this.resolve(key, ...parameter);
+  async _diskDelete(key, snapshotVersion) {
+    const strategy = this.strategy;
+    if (!strategy) throw new Error("Root Transaction missing strategy");
+    const rootAsAny = this.root;
+    if (await this._diskExists(key, snapshotVersion)) {
+      const currentVal = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : await strategy.read(key);
+      if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
+      this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
+      await strategy.delete(key);
+      rootAsAny.diskCache.delete(key);
     }
-    return this.caches.get(key);
-  }
-  update(key, ...parameter) {
-    this.bubbleUpdateSignal(key);
-    this.resolve(key, ...parameter);
-    return this.caches.get(key);
+    if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
+    this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
   }
 };
 var BPTreeTransaction = class _BPTreeTransaction {
-  _cachedRegexp;
-  nodes;
+  _cachedRegexp = /* @__PURE__ */ new Map();
+  nodes = /* @__PURE__ */ new Map();
   deletedNodeBuffer = /* @__PURE__ */ new Map();
   rootTx;
   mvccRoot;
@@ -1592,8 +1516,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
     like: (nv, v) => {
       const nodeValue = this.comparator.match(nv);
       const value = v;
-      const cache = this._cachedRegexp.cache(value);
-      const regexp = cache.raw;
+      if (!this._cachedRegexp.has(value)) {
+        const pattern = value.replace(/%/g, ".*").replace(/_/g, ".");
+        const regexp2 = new RegExp(`^${pattern}$`, "i");
+        this._cachedRegexp.set(value, regexp2);
+      }
+      const regexp = this._cachedRegexp.get(value);
       return regexp.test(nodeValue);
     }
   };
@@ -1765,6 +1693,9 @@ var BPTreeTransaction = class _BPTreeTransaction {
     }
     return true;
   }
+  _cloneNode(node) {
+    return JSON.parse(JSON.stringify(node));
+  }
   /**
    * Selects the best driver key from a condition object.
    * The driver key determines the starting point and traversal direction for queries.
@@ -1797,17 +1728,6 @@ var BPTreeTransaction = class _BPTreeTransaction {
     this.strategy = strategy;
     this.comparator = comparator;
     this.option = option ?? {};
-    this.nodes = new LRUMap(this.option.capacity ?? 1e3);
-    this._cachedRegexp = this._createCachedRegexp();
-  }
-  _createCachedRegexp() {
-    return new CacheEntanglementSync((key) => {
-      const pattern = key.replace(/%/g, ".*").replace(/_/g, ".");
-      const regexp = new RegExp(`^${pattern}$`, "i");
-      return regexp;
-    }, {
-      capacity: this.option.capacity ?? 1e3
-    });
   }
   ensureValues(v) {
     if (!Array.isArray(v)) {
@@ -1840,7 +1760,6 @@ var BPTreeTransaction = class _BPTreeTransaction {
   }
   _clearCache() {
     this._cachedRegexp.clear();
-    this.nodes.clear();
   }
   /**
    * Clears all cached nodes.
@@ -1891,9 +1810,6 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     );
   }
   getNode(id) {
-    if (this.nodes.has(id)) {
-      return this.nodes.get(id);
-    }
     return this.mvcc.read(id);
   }
   /**
@@ -1911,23 +1827,22 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       prev
     };
     this.mvcc.create(id, node);
-    this.nodes.set(id, node);
     return node;
   }
   _updateNode(node) {
+    if (this.mvcc.isDeleted(node.id)) {
+      return;
+    }
     this.mvcc.write(node.id, node);
-    this.nodes.set(node.id, node);
   }
   _deleteNode(node) {
+    if (this.mvcc.isDeleted(node.id)) {
+      return;
+    }
     this.mvcc.delete(node.id);
-    this.nodes.delete(node.id);
   }
   _readHead() {
-    if (this.nodes.has("__HEAD__")) {
-      return this.nodes.get("__HEAD__") ?? null;
-    }
-    const head = this.mvcc.read("__HEAD__");
-    return head ?? null;
+    return this.mvcc.read("__HEAD__");
   }
   _writeHead(head) {
     if (!this.mvcc.exists("__HEAD__")) {
@@ -1935,49 +1850,56 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     } else {
       this.mvcc.write("__HEAD__", head);
     }
-    this.nodes.set("__HEAD__", head);
     this.rootId = head.root;
   }
   _insertAtLeaf(node, key, value) {
-    if (node.values.length) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
+    let leaf = node;
+    if (leaf.values.length) {
+      for (let i = 0, len = leaf.values.length; i < len; i++) {
+        const nValue = leaf.values[i];
         if (this.comparator.isSame(value, nValue)) {
-          const keys = node.keys[i];
+          const keys = leaf.keys[i];
           if (keys.includes(key)) {
             break;
           }
-          keys.push(key);
-          this._updateNode(node);
-          return;
+          leaf = this._cloneNode(leaf);
+          leaf.keys[i].push(key);
+          this._updateNode(leaf);
+          return leaf;
         } else if (this.comparator.isLower(value, nValue)) {
-          node.values.splice(i, 0, value);
-          node.keys.splice(i, 0, [key]);
-          this._updateNode(node);
-          return;
-        } else if (i + 1 === node.values.length) {
-          node.values.push(value);
-          node.keys.push([key]);
-          this._updateNode(node);
-          return;
+          leaf = this._cloneNode(leaf);
+          leaf.values.splice(i, 0, value);
+          leaf.keys.splice(i, 0, [key]);
+          this._updateNode(leaf);
+          return leaf;
+        } else if (i + 1 === leaf.values.length) {
+          leaf = this._cloneNode(leaf);
+          leaf.values.push(value);
+          leaf.keys.push([key]);
+          this._updateNode(leaf);
+          return leaf;
         }
       }
     } else {
-      node.values = [value];
-      node.keys = [[key]];
-      this._updateNode(node);
-      return;
+      leaf = this._cloneNode(leaf);
+      leaf.values = [value];
+      leaf.keys = [[key]];
+      this._updateNode(leaf);
+      return leaf;
     }
+    return leaf;
   }
-  _insertInParent(node, value, pointer) {
+  _insertInParent(node, value, newSiblingNode) {
     if (this.rootId === node.id) {
-      const root = this._createNode(false, [node.id, pointer.id], [value]);
+      node = this._cloneNode(node);
+      newSiblingNode = this._cloneNode(newSiblingNode);
+      const root = this._createNode(false, [node.id, newSiblingNode.id], [value]);
       this.rootId = root.id;
       node.parent = root.id;
-      pointer.parent = root.id;
-      if (pointer.leaf) {
-        node.next = pointer.id;
-        pointer.prev = node.id;
+      newSiblingNode.parent = root.id;
+      if (newSiblingNode.leaf) {
+        node.next = newSiblingNode.id;
+        newSiblingNode.prev = node.id;
       }
       this._writeHead({
         root: root.id,
@@ -1985,53 +1907,54 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         data: this.strategy.head.data
       });
       this._updateNode(node);
-      this._updateNode(pointer);
+      this._updateNode(newSiblingNode);
       return;
     }
-    const parentNode = this.getNode(node.parent);
+    const parentNode = this._cloneNode(this.getNode(node.parent));
     const nodeIndex = parentNode.keys.indexOf(node.id);
     if (nodeIndex === -1) {
       throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
     }
     parentNode.values.splice(nodeIndex, 0, value);
-    parentNode.keys.splice(nodeIndex + 1, 0, pointer.id);
-    pointer.parent = parentNode.id;
-    if (pointer.leaf) {
-      const leftSibling = node;
+    parentNode.keys.splice(nodeIndex + 1, 0, newSiblingNode.id);
+    newSiblingNode = this._cloneNode(newSiblingNode);
+    newSiblingNode.parent = parentNode.id;
+    if (newSiblingNode.leaf) {
+      const leftSibling = this._cloneNode(node);
       const oldNextId = leftSibling.next;
-      pointer.prev = leftSibling.id;
-      pointer.next = oldNextId;
-      leftSibling.next = pointer.id;
+      newSiblingNode.prev = leftSibling.id;
+      newSiblingNode.next = oldNextId;
+      leftSibling.next = newSiblingNode.id;
       this._updateNode(leftSibling);
       if (oldNextId) {
-        const oldNext = this.getNode(oldNextId);
-        oldNext.prev = pointer.id;
+        const oldNext = this._cloneNode(this.getNode(oldNextId));
+        oldNext.prev = newSiblingNode.id;
         this._updateNode(oldNext);
       }
     }
     this._updateNode(parentNode);
-    this._updateNode(pointer);
+    this._updateNode(newSiblingNode);
     if (parentNode.keys.length > this.order) {
-      const parentPointer = this._createNode(false, [], []);
-      parentPointer.parent = parentNode.parent;
+      const newSiblingNodeRecursive = this._createNode(false, [], []);
+      newSiblingNodeRecursive.parent = parentNode.parent;
       const mid = Math.ceil(this.order / 2) - 1;
-      parentPointer.values = parentNode.values.slice(mid + 1);
-      parentPointer.keys = parentNode.keys.slice(mid + 1);
+      newSiblingNodeRecursive.values = parentNode.values.slice(mid + 1);
+      newSiblingNodeRecursive.keys = parentNode.keys.slice(mid + 1);
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
       for (const k of parentNode.keys) {
-        const n = this.getNode(k);
+        const n = this._cloneNode(this.getNode(k));
         n.parent = parentNode.id;
         this._updateNode(n);
       }
-      for (const k of parentPointer.keys) {
-        const n = this.getNode(k);
-        n.parent = parentPointer.id;
+      for (const k of newSiblingNodeRecursive.keys) {
+        const n = this._cloneNode(this.getNode(k));
+        n.parent = newSiblingNodeRecursive.id;
         this._updateNode(n);
       }
       this._updateNode(parentNode);
-      this._insertInParent(parentNode, midValue, parentPointer);
+      this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
   insertableNode(value) {
@@ -2214,21 +2137,6 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return false;
   }
-  forceUpdate(id) {
-    if (id) {
-      this.nodes.delete(id);
-      this.getNode(id);
-      return 1;
-    }
-    const keys = Array.from(this.nodes.keys());
-    for (const key of keys) {
-      this.nodes.delete(key);
-    }
-    for (const key of keys) {
-      this.getNode(key);
-    }
-    return keys.length;
-  }
   get(key) {
     let node = this.leftestNode();
     while (true) {
@@ -2314,10 +2222,10 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return map;
   }
   insert(key, value) {
-    const before = this.insertableNode(value);
-    this._insertAtLeaf(before, key, value);
+    let before = this.insertableNode(value);
+    before = this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
-      const after = this._createNode(
+      let after = this._createNode(
         true,
         [],
         [],
@@ -2326,10 +2234,13 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         null
       );
       const mid = Math.ceil(this.order / 2) - 1;
+      after = this._cloneNode(after);
       after.values = before.values.slice(mid + 1);
       after.keys = before.keys.slice(mid + 1);
       before.values = before.values.slice(0, mid + 1);
       before.keys = before.keys.slice(0, mid + 1);
+      this._updateNode(before);
+      this._updateNode(after);
       this._insertInParent(before, after.values[0], after);
     }
   }
@@ -2343,6 +2254,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         }
       }
       if (keyIndex !== -1) {
+        node = this._cloneNode(node);
         node.keys.splice(keyIndex, 1);
         const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
         node.values.splice(valueIndex, 1);
@@ -2352,7 +2264,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
       this._deleteNode(node);
-      const newRoot = this.getNode(keys[0]);
+      const newRoot = this._cloneNode(this.getNode(keys[0]));
       newRoot.parent = null;
       this._updateNode(newRoot);
       this._writeHead({
@@ -2360,17 +2272,17 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         order: this.order,
         data: this.strategy.head.data
       });
-      return;
+      return node;
     } else if (this.rootId === node.id) {
       this._writeHead({
         root: node.id,
         order: this.order,
         data: this.strategy.head.data
       });
-      return;
+      return node;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
-        return;
+        return node;
       }
       let isPredecessor = false;
       let parentNode = this.getNode(node.parent);
@@ -2391,78 +2303,80 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
           }
         }
       }
-      let pointer;
+      let siblingNode;
       let guess;
       if (prevNode === null) {
-        pointer = nextNode;
+        siblingNode = nextNode;
         guess = postValue;
       } else if (nextNode === null) {
         isPredecessor = true;
-        pointer = prevNode;
+        siblingNode = prevNode;
         guess = prevValue;
       } else {
         if (node.values.length + nextNode.values.length < this.order) {
-          pointer = nextNode;
+          siblingNode = nextNode;
           guess = postValue;
         } else {
           isPredecessor = true;
-          pointer = prevNode;
+          siblingNode = prevNode;
           guess = prevValue;
         }
       }
-      if (!pointer) {
-        return;
+      if (!siblingNode) {
+        return node;
       }
-      if (node.values.length + pointer.values.length < this.order) {
+      node = this._cloneNode(node);
+      siblingNode = this._cloneNode(siblingNode);
+      if (node.values.length + siblingNode.values.length < this.order) {
         if (!isPredecessor) {
-          const pTemp = pointer;
-          pointer = node;
+          const pTemp = siblingNode;
+          siblingNode = node;
           node = pTemp;
         }
-        pointer.keys.push(...node.keys);
+        siblingNode.keys.push(...node.keys);
         if (!node.leaf) {
-          pointer.values.push(guess);
+          siblingNode.values.push(guess);
         } else {
-          pointer.next = node.next;
-          if (pointer.next) {
-            const n = this.getNode(pointer.next);
-            n.prev = pointer.id;
+          siblingNode.next = node.next;
+          if (siblingNode.next) {
+            const n = this._cloneNode(this.getNode(siblingNode.next));
+            n.prev = siblingNode.id;
             this._updateNode(n);
           }
         }
-        pointer.values.push(...node.values);
-        if (!pointer.leaf) {
-          const keys = pointer.keys;
+        siblingNode.values.push(...node.values);
+        if (!siblingNode.leaf) {
+          const keys = siblingNode.keys;
           for (const key2 of keys) {
-            const node2 = this.getNode(key2);
-            node2.parent = pointer.id;
+            const node2 = this._cloneNode(this.getNode(key2));
+            node2.parent = siblingNode.id;
             this._updateNode(node2);
           }
         }
         this._deleteNode(node);
-        this._updateNode(pointer);
+        this._updateNode(siblingNode);
         this._deleteEntry(this.getNode(node.parent), node.id);
       } else {
         if (isPredecessor) {
           let pointerPm;
           let pointerKm;
           if (!node.leaf) {
-            pointerPm = pointer.keys.splice(-1)[0];
-            pointerKm = pointer.values.splice(-1)[0];
+            pointerPm = siblingNode.keys.splice(-1)[0];
+            pointerKm = siblingNode.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
-            parentNode = this.getNode(node.parent);
+            parentNode = this._cloneNode(this.getNode(node.parent));
             const nodeIndex = parentNode.keys.indexOf(node.id);
             if (nodeIndex > 0) {
               parentNode.values[nodeIndex - 1] = pointerKm;
               this._updateNode(parentNode);
             }
           } else {
-            pointerPm = pointer.keys.splice(-1)[0];
-            pointerKm = pointer.values.splice(-1)[0];
+            pointerPm = siblingNode.keys.splice(-1)[0];
+            pointerKm = siblingNode.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
-            parentNode = this.getNode(node.parent);
+            parentNode = this._cloneNode(this.getNode(node.parent));
             const nodeIndex = parentNode.keys.indexOf(node.id);
             if (nodeIndex > 0) {
               parentNode.values[nodeIndex - 1] = pointerKm;
@@ -2470,61 +2384,62 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
             }
           }
           this._updateNode(node);
-          this._updateNode(pointer);
+          this._updateNode(siblingNode);
         } else {
           let pointerP0;
           let pointerK0;
           if (!node.leaf) {
-            pointerP0 = pointer.keys.splice(0, 1)[0];
-            pointerK0 = pointer.values.splice(0, 1)[0];
+            pointerP0 = siblingNode.keys.splice(0, 1)[0];
+            pointerK0 = siblingNode.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
-            parentNode = this.getNode(node.parent);
-            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            parentNode = this._cloneNode(this.getNode(node.parent));
+            const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
             if (pointerIndex > 0) {
               parentNode.values[pointerIndex - 1] = pointerK0;
               this._updateNode(parentNode);
             }
           } else {
-            pointerP0 = pointer.keys.splice(0, 1)[0];
-            pointerK0 = pointer.values.splice(0, 1)[0];
+            pointerP0 = siblingNode.keys.splice(0, 1)[0];
+            pointerK0 = siblingNode.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
-            parentNode = this.getNode(node.parent);
-            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            parentNode = this._cloneNode(this.getNode(node.parent));
+            const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
             if (pointerIndex > 0) {
-              parentNode.values[pointerIndex - 1] = pointer.values[0];
+              parentNode.values[pointerIndex - 1] = siblingNode.values[0];
               this._updateNode(parentNode);
             }
           }
           this._updateNode(node);
-          this._updateNode(pointer);
+          this._updateNode(siblingNode);
         }
-        if (!pointer.leaf) {
-          for (const key2 of pointer.keys) {
-            const n = this.getNode(key2);
-            n.parent = pointer.id;
+        if (!siblingNode.leaf) {
+          for (const key2 of siblingNode.keys) {
+            const n = this._cloneNode(this.getNode(key2));
+            n.parent = siblingNode.id;
             this._updateNode(n);
           }
         }
         if (!node.leaf) {
           for (const key2 of node.keys) {
-            const n = this.getNode(key2);
+            const n = this._cloneNode(this.getNode(key2));
             n.parent = node.id;
             this._updateNode(n);
           }
         }
         if (!parentNode.leaf) {
           for (const key2 of parentNode.keys) {
-            const n = this.getNode(key2);
+            const n = this._cloneNode(this.getNode(key2));
             n.parent = parentNode.id;
             this._updateNode(n);
           }
         }
       }
     } else {
-      this._updateNode(node);
+      this._updateNode(this._cloneNode(node));
     }
+    return node;
   }
   delete(key, value) {
     let node = this.insertableNodeByPrimary(value);
@@ -2537,13 +2452,15 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
           const keys = node.keys[i];
           const keyIndex = keys.indexOf(key);
           if (keyIndex !== -1) {
-            keys.splice(keyIndex, 1);
-            if (keys.length === 0) {
+            node = this._cloneNode(node);
+            const freshKeys = node.keys[i];
+            freshKeys.splice(keyIndex, 1);
+            if (freshKeys.length === 0) {
               node.keys.splice(i, 1);
               node.values.splice(i, 1);
             }
             this._updateNode(node);
-            this._deleteEntry(node, key);
+            node = this._deleteEntry(node, key);
             found = true;
             break;
           }
@@ -2586,15 +2503,6 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         }
       }
       if (result.success) {
-        for (const r of result.created) {
-          this.nodes.set(r.key, r.data);
-        }
-        for (const r of result.updated) {
-          this.nodes.set(r.key, r.data);
-        }
-        for (const r of result.deleted) {
-          this.nodes.delete(r.key);
-        }
       }
     }
     return result;
@@ -2638,7 +2546,9 @@ var BPTreeMVCCStrategySync = class extends SyncMVCCStrategy {
 };
 var BPTreeSync = class extends BPTreeSyncTransaction {
   constructor(strategy, comparator, option) {
-    const mvccRoot = new SyncMVCCTransaction(new BPTreeMVCCStrategySync(strategy));
+    const mvccRoot = new SyncMVCCTransaction(new BPTreeMVCCStrategySync(strategy), {
+      cacheCapacity: option?.capacity ?? void 0
+    });
     super(
       null,
       mvccRoot,
@@ -2961,9 +2871,6 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     });
   }
   async getNode(id) {
-    if (this.nodes.has(id)) {
-      return this.nodes.get(id);
-    }
     return await this.mvcc.read(id);
   }
   /**
@@ -2980,24 +2887,31 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       next,
       prev
     };
+    const head = await this._readHead();
+    if (head) {
+      await this._writeHead({
+        root: head.root,
+        order: head.order,
+        data: this.strategy.head.data
+      });
+    }
     await this.mvcc.create(id, node);
-    this.nodes.set(id, node);
     return node;
   }
   async _updateNode(node) {
+    if (this.mvcc.isDeleted(node.id)) {
+      return;
+    }
     await this.mvcc.write(node.id, node);
-    this.nodes.set(node.id, node);
   }
   async _deleteNode(node) {
+    if (this.mvcc.isDeleted(node.id)) {
+      return;
+    }
     await this.mvcc.delete(node.id);
-    this.nodes.delete(node.id);
   }
   async _readHead() {
-    if (this.nodes.has("__HEAD__")) {
-      return this.nodes.get("__HEAD__") ?? null;
-    }
-    const head = await this.mvcc.read("__HEAD__");
-    return head ?? null;
+    return await this.mvcc.read("__HEAD__");
   }
   async _writeHead(head) {
     if (!await this.mvcc.exists("__HEAD__")) {
@@ -3005,49 +2919,56 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     } else {
       await this.mvcc.write("__HEAD__", head);
     }
-    this.nodes.set("__HEAD__", head);
     this.rootId = head.root;
   }
   async _insertAtLeaf(node, key, value) {
-    if (node.values.length) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
+    let leaf = node;
+    if (leaf.values.length) {
+      for (let i = 0, len = leaf.values.length; i < len; i++) {
+        const nValue = leaf.values[i];
         if (this.comparator.isSame(value, nValue)) {
-          const keys = node.keys[i];
+          const keys = leaf.keys[i];
           if (keys.includes(key)) {
             break;
           }
-          keys.push(key);
-          await this._updateNode(node);
-          return;
+          leaf = this._cloneNode(leaf);
+          leaf.keys[i].push(key);
+          await this._updateNode(leaf);
+          return leaf;
         } else if (this.comparator.isLower(value, nValue)) {
-          node.values.splice(i, 0, value);
-          node.keys.splice(i, 0, [key]);
-          await this._updateNode(node);
-          return;
-        } else if (i + 1 === node.values.length) {
-          node.values.push(value);
-          node.keys.push([key]);
-          await this._updateNode(node);
-          return;
+          leaf = this._cloneNode(leaf);
+          leaf.values.splice(i, 0, value);
+          leaf.keys.splice(i, 0, [key]);
+          await this._updateNode(leaf);
+          return leaf;
+        } else if (i + 1 === leaf.values.length) {
+          leaf = this._cloneNode(leaf);
+          leaf.values.push(value);
+          leaf.keys.push([key]);
+          await this._updateNode(leaf);
+          return leaf;
         }
       }
     } else {
-      node.values = [value];
-      node.keys = [[key]];
-      await this._updateNode(node);
-      return;
+      leaf = this._cloneNode(leaf);
+      leaf.values = [value];
+      leaf.keys = [[key]];
+      await this._updateNode(leaf);
+      return leaf;
     }
+    return leaf;
   }
-  async _insertInParent(node, value, pointer) {
+  async _insertInParent(node, value, newSiblingNode) {
     if (this.rootId === node.id) {
-      const root = await this._createNode(false, [node.id, pointer.id], [value]);
+      node = this._cloneNode(node);
+      newSiblingNode = this._cloneNode(newSiblingNode);
+      const root = await this._createNode(false, [node.id, newSiblingNode.id], [value]);
       this.rootId = root.id;
       node.parent = root.id;
-      pointer.parent = root.id;
-      if (pointer.leaf) {
-        node.next = pointer.id;
-        pointer.prev = node.id;
+      newSiblingNode.parent = root.id;
+      if (newSiblingNode.leaf) {
+        node.next = newSiblingNode.id;
+        newSiblingNode.prev = node.id;
       }
       await this._writeHead({
         root: root.id,
@@ -3055,53 +2976,54 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         data: this.strategy.head.data
       });
       await this._updateNode(node);
-      await this._updateNode(pointer);
+      await this._updateNode(newSiblingNode);
       return;
     }
-    const parentNode = await this.getNode(node.parent);
+    const parentNode = this._cloneNode(await this.getNode(node.parent));
     const nodeIndex = parentNode.keys.indexOf(node.id);
     if (nodeIndex === -1) {
       throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
     }
     parentNode.values.splice(nodeIndex, 0, value);
-    parentNode.keys.splice(nodeIndex + 1, 0, pointer.id);
-    pointer.parent = parentNode.id;
-    if (pointer.leaf) {
-      const leftSibling = node;
+    parentNode.keys.splice(nodeIndex + 1, 0, newSiblingNode.id);
+    newSiblingNode = this._cloneNode(newSiblingNode);
+    newSiblingNode.parent = parentNode.id;
+    if (newSiblingNode.leaf) {
+      const leftSibling = this._cloneNode(node);
       const oldNextId = leftSibling.next;
-      pointer.prev = leftSibling.id;
-      pointer.next = oldNextId;
-      leftSibling.next = pointer.id;
+      newSiblingNode.prev = leftSibling.id;
+      newSiblingNode.next = oldNextId;
+      leftSibling.next = newSiblingNode.id;
       await this._updateNode(leftSibling);
       if (oldNextId) {
-        const oldNext = await this.getNode(oldNextId);
-        oldNext.prev = pointer.id;
+        const oldNext = this._cloneNode(await this.getNode(oldNextId));
+        oldNext.prev = newSiblingNode.id;
         await this._updateNode(oldNext);
       }
     }
     await this._updateNode(parentNode);
-    await this._updateNode(pointer);
+    await this._updateNode(newSiblingNode);
     if (parentNode.keys.length > this.order) {
-      const parentPointer = await this._createNode(false, [], []);
-      parentPointer.parent = parentNode.parent;
+      const newSiblingNodeRecursive = await this._createNode(false, [], []);
+      newSiblingNodeRecursive.parent = parentNode.parent;
       const mid = Math.ceil(this.order / 2) - 1;
-      parentPointer.values = parentNode.values.slice(mid + 1);
-      parentPointer.keys = parentNode.keys.slice(mid + 1);
+      newSiblingNodeRecursive.values = parentNode.values.slice(mid + 1);
+      newSiblingNodeRecursive.keys = parentNode.keys.slice(mid + 1);
       const midValue = parentNode.values[mid];
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
       for (const k of parentNode.keys) {
-        const n = await this.getNode(k);
+        const n = this._cloneNode(await this.getNode(k));
         n.parent = parentNode.id;
         await this._updateNode(n);
       }
-      for (const k of parentPointer.keys) {
-        const n = await this.getNode(k);
-        n.parent = parentPointer.id;
+      for (const k of newSiblingNodeRecursive.keys) {
+        const n = this._cloneNode(await this.getNode(k));
+        n.parent = newSiblingNodeRecursive.id;
         await this._updateNode(n);
       }
       await this._updateNode(parentNode);
-      await this._insertInParent(parentNode, midValue, parentPointer);
+      await this._insertInParent(parentNode, midValue, newSiblingNodeRecursive);
     }
   }
   async insertableNode(value) {
@@ -3290,21 +3212,6 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     }
     return false;
   }
-  async forceUpdate(id) {
-    if (id) {
-      this.nodes.delete(id);
-      await this.getNode(id);
-      return 1;
-    }
-    const keys = Array.from(this.nodes.keys());
-    for (const key of keys) {
-      this.nodes.delete(key);
-    }
-    for (const key of keys) {
-      await this.getNode(key);
-    }
-    return keys.length;
-  }
   async get(key) {
     let node = await this.leftestNode();
     while (true) {
@@ -3391,10 +3298,10 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async insert(key, value) {
     return this.writeLock(0, async () => {
-      const before = await this.insertableNode(value);
-      await this._insertAtLeaf(before, key, value);
+      let before = await this.insertableNode(value);
+      before = await this._insertAtLeaf(before, key, value);
       if (before.values.length === this.order) {
-        const after = await this._createNode(
+        let after = await this._createNode(
           true,
           [],
           [],
@@ -3403,10 +3310,13 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           null
         );
         const mid = Math.ceil(this.order / 2) - 1;
+        after = this._cloneNode(after);
         after.values = before.values.slice(mid + 1);
         after.keys = before.keys.slice(mid + 1);
         before.values = before.values.slice(0, mid + 1);
         before.keys = before.keys.slice(0, mid + 1);
+        await this._updateNode(before);
+        await this._updateNode(after);
         await this._insertInParent(before, after.values[0], after);
       }
     });
@@ -3421,6 +3331,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         }
       }
       if (keyIndex !== -1) {
+        node = this._cloneNode(node);
         node.keys.splice(keyIndex, 1);
         const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
         node.values.splice(valueIndex, 1);
@@ -3430,7 +3341,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
       this._deleteNode(node);
-      const newRoot = await this.getNode(keys[0]);
+      const newRoot = this._cloneNode(await this.getNode(keys[0]));
       newRoot.parent = null;
       await this._updateNode(newRoot);
       await this._writeHead({
@@ -3438,14 +3349,17 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         order: this.order,
         data: this.strategy.head.data
       });
-      return;
+      return node;
     } else if (this.rootId === node.id) {
-      const root = await this.getNode(this.rootId);
-      await this._updateNode(root);
-      return;
+      await this._writeHead({
+        root: node.id,
+        order: this.order,
+        data: this.strategy.head.data
+      });
+      return node;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
-        return;
+        return node;
       }
       let isPredecessor = false;
       let parentNode = await this.getNode(node.parent);
@@ -3466,78 +3380,80 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           }
         }
       }
-      let pointer;
+      let siblingNode;
       let guess;
       if (prevNode === null) {
-        pointer = nextNode;
+        siblingNode = nextNode;
         guess = postValue;
       } else if (nextNode === null) {
         isPredecessor = true;
-        pointer = prevNode;
+        siblingNode = prevNode;
         guess = prevValue;
       } else {
         if (node.values.length + nextNode.values.length < this.order) {
-          pointer = nextNode;
+          siblingNode = nextNode;
           guess = postValue;
         } else {
           isPredecessor = true;
-          pointer = prevNode;
+          siblingNode = prevNode;
           guess = prevValue;
         }
       }
-      if (!pointer) {
-        return;
+      if (!siblingNode) {
+        return node;
       }
-      if (node.values.length + pointer.values.length < this.order) {
+      node = this._cloneNode(node);
+      siblingNode = this._cloneNode(siblingNode);
+      if (node.values.length + siblingNode.values.length < this.order) {
         if (!isPredecessor) {
-          const pTemp = pointer;
-          pointer = node;
+          const pTemp = siblingNode;
+          siblingNode = node;
           node = pTemp;
         }
-        pointer.keys.push(...node.keys);
+        siblingNode.keys.push(...node.keys);
         if (!node.leaf) {
-          pointer.values.push(guess);
+          siblingNode.values.push(guess);
         } else {
-          pointer.next = node.next;
-          if (pointer.next) {
-            const n = await this.getNode(pointer.next);
-            n.prev = pointer.id;
+          siblingNode.next = node.next;
+          if (siblingNode.next) {
+            const n = this._cloneNode(await this.getNode(siblingNode.next));
+            n.prev = siblingNode.id;
             await this._updateNode(n);
           }
         }
-        pointer.values.push(...node.values);
-        if (!pointer.leaf) {
-          const keys = pointer.keys;
+        siblingNode.values.push(...node.values);
+        if (!siblingNode.leaf) {
+          const keys = siblingNode.keys;
           for (const key2 of keys) {
-            const node2 = await this.getNode(key2);
-            node2.parent = pointer.id;
+            const node2 = this._cloneNode(await this.getNode(key2));
+            node2.parent = siblingNode.id;
             await this._updateNode(node2);
           }
         }
         this._deleteNode(node);
-        await this._updateNode(pointer);
+        await this._updateNode(siblingNode);
         await this._deleteEntry(await this.getNode(node.parent), node.id);
       } else {
         if (isPredecessor) {
           let pointerPm;
           let pointerKm;
           if (!node.leaf) {
-            pointerPm = pointer.keys.splice(-1)[0];
-            pointerKm = pointer.values.splice(-1)[0];
+            pointerPm = siblingNode.keys.splice(-1)[0];
+            pointerKm = siblingNode.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
-            parentNode = await this.getNode(node.parent);
+            parentNode = this._cloneNode(await this.getNode(node.parent));
             const nodeIndex = parentNode.keys.indexOf(node.id);
             if (nodeIndex > 0) {
               parentNode.values[nodeIndex - 1] = pointerKm;
               await this._updateNode(parentNode);
             }
           } else {
-            pointerPm = pointer.keys.splice(-1)[0];
-            pointerKm = pointer.values.splice(-1)[0];
+            pointerPm = siblingNode.keys.splice(-1)[0];
+            pointerKm = siblingNode.values.splice(-1)[0];
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
-            parentNode = await this.getNode(node.parent);
+            parentNode = this._cloneNode(await this.getNode(node.parent));
             const nodeIndex = parentNode.keys.indexOf(node.id);
             if (nodeIndex > 0) {
               parentNode.values[nodeIndex - 1] = pointerKm;
@@ -3545,61 +3461,62 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
             }
           }
           await this._updateNode(node);
-          await this._updateNode(pointer);
+          await this._updateNode(siblingNode);
         } else {
           let pointerP0;
           let pointerK0;
           if (!node.leaf) {
-            pointerP0 = pointer.keys.splice(0, 1)[0];
-            pointerK0 = pointer.values.splice(0, 1)[0];
+            pointerP0 = siblingNode.keys.splice(0, 1)[0];
+            pointerK0 = siblingNode.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
-            parentNode = await this.getNode(node.parent);
-            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            parentNode = this._cloneNode(await this.getNode(node.parent));
+            const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
             if (pointerIndex > 0) {
               parentNode.values[pointerIndex - 1] = pointerK0;
               await this._updateNode(parentNode);
             }
           } else {
-            pointerP0 = pointer.keys.splice(0, 1)[0];
-            pointerK0 = pointer.values.splice(0, 1)[0];
+            pointerP0 = siblingNode.keys.splice(0, 1)[0];
+            pointerK0 = siblingNode.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
-            parentNode = await this.getNode(node.parent);
-            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            parentNode = this._cloneNode(await this.getNode(node.parent));
+            const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
             if (pointerIndex > 0) {
-              parentNode.values[pointerIndex - 1] = pointer.values[0];
+              parentNode.values[pointerIndex - 1] = siblingNode.values[0];
               await this._updateNode(parentNode);
             }
           }
           await this._updateNode(node);
-          await this._updateNode(pointer);
+          await this._updateNode(siblingNode);
         }
-        if (!pointer.leaf) {
-          for (const key2 of pointer.keys) {
-            const n = await this.getNode(key2);
-            n.parent = pointer.id;
+        if (!siblingNode.leaf) {
+          for (const key2 of siblingNode.keys) {
+            const n = this._cloneNode(await this.getNode(key2));
+            n.parent = siblingNode.id;
             await this._updateNode(n);
           }
         }
         if (!node.leaf) {
           for (const key2 of node.keys) {
-            const n = await this.getNode(key2);
+            const n = this._cloneNode(await this.getNode(key2));
             n.parent = node.id;
             await this._updateNode(n);
           }
         }
         if (!parentNode.leaf) {
           for (const key2 of parentNode.keys) {
-            const n = await this.getNode(key2);
+            const n = this._cloneNode(await this.getNode(key2));
             n.parent = parentNode.id;
             await this._updateNode(n);
           }
         }
       }
     } else {
-      await this._updateNode(node);
+      await this._updateNode(this._cloneNode(node));
     }
+    return node;
   }
   async delete(key, value) {
     return this.writeLock(0, async () => {
@@ -3613,13 +3530,15 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
             const keys = node.keys[i];
             const keyIndex = keys.indexOf(key);
             if (keyIndex !== -1) {
-              keys.splice(keyIndex, 1);
-              if (keys.length === 0) {
+              node = this._cloneNode(node);
+              const freshKeys = node.keys[i];
+              freshKeys.splice(keyIndex, 1);
+              if (freshKeys.length === 0) {
                 node.keys.splice(i, 1);
                 node.values.splice(i, 1);
               }
               await this._updateNode(node);
-              await this._deleteEntry(node, key);
+              node = await this._deleteEntry(node, key);
               found = true;
               break;
             }
@@ -3662,21 +3581,10 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
           this.rootTx.rootId = this.rootId;
         }
       }
-      if (result.success) {
-        for (const r of result.created) {
-          this.nodes.set(r.key, r.data);
-        }
-        for (const r of result.updated) {
-          this.nodes.set(r.key, r.data);
-        }
-        for (const r of result.deleted) {
-          this.nodes.delete(r.key);
-        }
-      }
     }
     return result;
   }
-  rollback() {
+  async rollback() {
     return this.mvcc.rollback();
   }
 };
@@ -3715,7 +3623,9 @@ var BPTreeMVCCStrategyAsync = class extends AsyncMVCCStrategy {
 };
 var BPTreeAsync = class extends BPTreeAsyncTransaction {
   constructor(strategy, comparator, option) {
-    const mvccRoot = new AsyncMVCCTransaction(new BPTreeMVCCStrategyAsync(strategy));
+    const mvccRoot = new AsyncMVCCTransaction(new BPTreeMVCCStrategyAsync(strategy), {
+      cacheCapacity: option?.capacity ?? void 0
+    });
     super(
       null,
       mvccRoot,
@@ -4267,7 +4177,7 @@ var LRUMap2 = class {
     this.tail = null;
   }
 };
-var CacheEntanglement2 = class {
+var CacheEntanglement = class {
   creation;
   beforeUpdateHook;
   capacity;
@@ -4368,7 +4278,7 @@ var CacheEntanglement2 = class {
     }
   }
 };
-var CacheData2 = class _CacheData2 {
+var CacheData = class _CacheData {
   static StructuredClone = globalThis.structuredClone.bind(globalThis);
   _value;
   constructor(value) {
@@ -4408,11 +4318,11 @@ var CacheData2 = class _CacheData2 {
         return Object.assign({}, this.raw);
       case "deep-copy":
       default:
-        return _CacheData2.StructuredClone(this.raw);
+        return _CacheData.StructuredClone(this.raw);
     }
   }
 };
-var CacheEntanglementSync2 = class extends CacheEntanglement2 {
+var CacheEntanglementSync = class extends CacheEntanglement {
   constructor(creation, option) {
     super(creation, option);
   }
@@ -4442,7 +4352,7 @@ var CacheEntanglementSync2 = class extends CacheEntanglement2 {
       const dependencyValue = dependency.recache(key) ?? dependency.recache(dependencyKey);
       resolved[name] = dependencyValue;
     }
-    const value = new CacheData2(this.creation(key, resolved, ...parameter));
+    const value = new CacheData(this.creation(key, resolved, ...parameter));
     this.updateRequirements.delete(key);
     this.parameters.set(key, parameter);
     this.caches.set(key, value);
@@ -4466,7 +4376,7 @@ var CacheEntanglementSync2 = class extends CacheEntanglement2 {
     return this.caches.get(key);
   }
 };
-var CacheEntanglementAsync = class extends CacheEntanglement2 {
+var CacheEntanglementAsync = class extends CacheEntanglement {
   constructor(creation, option) {
     super(creation, option);
   }
@@ -4496,7 +4406,7 @@ var CacheEntanglementAsync = class extends CacheEntanglement2 {
       const dependencyValue = await dependency.recache(key) ?? await dependency.recache(dependencyKey);
       resolved[name] = dependencyValue;
     }
-    const value = new CacheData2(await this.creation(key, resolved, ...parameter));
+    const value = new CacheData(await this.creation(key, resolved, ...parameter));
     this.updateRequirements.delete(key);
     this.parameters.set(key, parameter);
     this.caches.set(key, value);
@@ -4601,6 +4511,42 @@ var InvertedWeakMap = class {
 // node_modules/mvcc-api/dist/esm/index.mjs
 var MVCCStrategy2 = class {
 };
+var LRUMap3 = class {
+  cache = /* @__PURE__ */ new Map();
+  capacity;
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  get(key) {
+    if (!this.cache.has(key)) return void 0;
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) this.cache.delete(oldestKey);
+    }
+    this.cache.set(key, value);
+    return this;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
 var MVCCTransaction2 = class {
   committed;
   snapshotVersion;
@@ -4608,7 +4554,6 @@ var MVCCTransaction2 = class {
   writeBuffer;
   deleteBuffer;
   createdKeys;
-  // create()로 생성된 키 추적
   deletedValues;
   // delete 시 삭제 전 값 저장
   originallyExisted;
@@ -4627,7 +4572,8 @@ var MVCCTransaction2 = class {
   versionIndex = /* @__PURE__ */ new Map();
   deletedCache = /* @__PURE__ */ new Map();
   activeTransactions = /* @__PURE__ */ new Set();
-  constructor(strategy, parent, snapshotVersion) {
+  diskCache;
+  constructor(strategy, options, parent, snapshotVersion) {
     this.snapshotVersion = snapshotVersion ?? 0;
     this.writeBuffer = /* @__PURE__ */ new Map();
     this.deleteBuffer = /* @__PURE__ */ new Set();
@@ -4642,6 +4588,7 @@ var MVCCTransaction2 = class {
       this.snapshotLocalVersion = parent.localVersion;
       this.strategy = void 0;
       this.root = parent.root;
+      this.diskCache = parent.diskCache;
     } else {
       if (!strategy) throw new Error("Root Transaction must get Strategy");
       this.strategy = strategy;
@@ -4649,8 +4596,13 @@ var MVCCTransaction2 = class {
       this.localVersion = 0;
       this.snapshotLocalVersion = 0;
       this.root = this;
+      this.diskCache = new LRUMap3(options?.cacheCapacity ?? 1e3);
     }
   }
+  /**
+   * Checks if the transaction is a root transaction.
+   * @returns True if the transaction is a root transaction, false otherwise.
+   */
   isRoot() {
     return !this.parent;
   }
@@ -4667,7 +4619,22 @@ var MVCCTransaction2 = class {
     }
     return false;
   }
-  // --- Internal buffer manipulation helpers ---
+  /**
+   * Checks if a key was written in this transaction.
+   * @param key The key to check.
+   * @returns True if the key was written in this transaction, false otherwise.
+   */
+  isWrote(key) {
+    return this.writeBuffer.has(key);
+  }
+  /**
+   * Checks if a key was deleted in this transaction.
+   * @param key The key to check.
+   * @returns True if the key was deleted in this transaction, false otherwise.
+   */
+  isDeleted(key) {
+    return this.deleteBuffer.has(key);
+  }
   _recordHistory(key) {
     const existsInWriteBuffer = this.writeBuffer.has(key);
     const existsInDeleteBuffer = this.deleteBuffer.has(key);
@@ -4681,6 +4648,41 @@ var MVCCTransaction2 = class {
       });
     }
   }
+  /**
+   * BINARY SEARCH HELPER: Finds the index of the last element in the array 
+   * where item[key] <= target. Assumes the array is sorted by 'key' ascending.
+   */
+  _findLastLE(array, target, property) {
+    let left = 0;
+    let right = array.length - 1;
+    let result = -1;
+    while (left <= right) {
+      const mid = left + right >> 1;
+      if (array[mid][property] <= target) {
+        result = mid;
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+    return result;
+  }
+  /**
+   * BINARY SEARCH HELPER: Finds the index of the element in the array 
+   * where item[key] === target. Assumes the array is sorted by 'key' ascending.
+   */
+  _findExact(array, target, property) {
+    let left = 0;
+    let right = array.length - 1;
+    while (left <= right) {
+      const mid = left + right >> 1;
+      const val = array[mid][property];
+      if (val === target) return mid;
+      if (val < target) left = mid + 1;
+      else right = mid - 1;
+    }
+    return -1;
+  }
   _bufferCreate(key, value, version) {
     if (version === void 0) this.localVersion++;
     const targetVersion = version ?? this.localVersion;
@@ -4730,7 +4732,11 @@ var MVCCTransaction2 = class {
         deleted.push({ key, data });
       }
     }
-    return { created, updated, deleted };
+    return {
+      created,
+      updated,
+      deleted
+    };
   }
   /**
    * Rolls back the transaction.
@@ -4748,7 +4754,12 @@ var MVCCTransaction2 = class {
     if (this.root !== this) {
       this.root.activeTransactions.delete(this);
     }
-    return { success: true, created, updated, deleted };
+    return {
+      success: true,
+      created,
+      updated,
+      deleted
+    };
   }
   /**
    * Cleans up both deletedCache and versionIndex based on minActiveVersion.
@@ -4834,7 +4845,7 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
   createNested() {
     if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
-    const child = new _SyncMVCCTransaction2(void 0, this, childVersion);
+    const child = new _SyncMVCCTransaction2(void 0, void 0, this, childVersion);
     this.root.activeTransactions.add(child);
     return child;
   }
@@ -4857,78 +4868,114 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
     return this._diskExists(key, this.snapshotVersion);
   }
   _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return true;
-      }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return false;
-      }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists;
-        }
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return true;
+      }
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return false;
+      }
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) return history[idx].exists;
+      }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return current._diskExists(key, snapshotVersion);
       }
     }
-    if (this.parent) {
-      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return this._diskExists(key, snapshotVersion);
-    }
+    return false;
   }
   _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return this.writeBuffer.get(key);
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return current.writeBuffer.get(key);
+        }
       }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return null;
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return null;
+        }
       }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists ? history[i].value : null;
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) {
+          return history[idx].exists ? history[idx].value : null;
         }
       }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return current._diskRead(key, snapshotVersion);
+      }
     }
-    if (this.parent) {
-      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return this._diskRead(key, snapshotVersion);
-    }
+    return null;
   }
   commit(label) {
     const { created, updated, deleted } = this.getResultEntries();
     if (this.committed) {
-      return { label, success: false, error: "Transaction already committed", conflict: void 0, created, updated, deleted };
+      return {
+        label,
+        success: false,
+        error: "Transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
     }
     if (this.hasCommittedAncestor()) {
-      return { label, success: false, error: "Ancestor transaction already committed", conflict: void 0, created, updated, deleted };
+      return {
+        label,
+        success: false,
+        error: "Ancestor transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
     }
     if (this.parent) {
       const failure = this.parent._merge(this);
       if (failure) {
-        return { label, success: false, error: failure.error, conflict: failure.conflict, created, updated, deleted };
+        return {
+          label,
+          success: false,
+          error: failure.error,
+          conflict: failure.conflict,
+          created,
+          updated,
+          deleted
+        };
       }
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
         const failure = this._merge(this);
         if (failure) {
-          return { label, success: false, error: failure.error, conflict: failure.conflict, created: [], updated: [], deleted: [] };
+          return {
+            label,
+            success: false,
+            error: failure.error,
+            conflict: failure.conflict,
+            created: [],
+            updated: [],
+            deleted: []
+          };
         }
         this.writeBuffer.clear();
         this.deleteBuffer.clear();
@@ -4941,7 +4988,13 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
         this.snapshotVersion = this.version;
       }
     }
-    return { label, success: true, created, updated, deleted };
+    return {
+      label,
+      success: true,
+      created,
+      updated,
+      deleted
+    };
   }
   _merge(child) {
     if (this.parent) {
@@ -4950,7 +5003,11 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
         if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
           return {
             error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
-            conflict: { key, parent: this.read(key), child: child.read(key) }
+            conflict: {
+              key,
+              parent: this.read(key),
+              child: child.read(key)
+            }
           };
         }
       }
@@ -4959,7 +5016,11 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
         if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
           return {
             error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
-            conflict: { key, parent: this.read(key), child: child.read(key) }
+            conflict: {
+              key,
+              parent: this.read(key),
+              child: child.read(key)
+            }
           };
         }
       }
@@ -4988,7 +5049,11 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
             if (lastVer > child.snapshotVersion) {
               return {
                 error: `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`,
-                conflict: { key, parent: this.read(key), child: child.read(key) }
+                conflict: {
+                  key,
+                  parent: this.read(key),
+                  child: child.read(key)
+                }
               };
             }
           }
@@ -4996,7 +5061,11 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
           if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
             return {
               error: `Commit conflict: Key '${key}' was modified by a newer transaction in the same session (Local v${lastModLocalVer})`,
-              conflict: { key, parent: this.read(key), child: child.read(key) }
+              conflict: {
+                key,
+                parent: this.read(key),
+                child: child.read(key)
+              }
             };
           }
         }
@@ -5031,10 +5100,14 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
   _diskWrite(key, value, version) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (strategy.exists(key)) {
-      const currentVal = strategy.read(key);
+    const rootAsAny = this.root;
+    if (this._diskExists(key, version)) {
+      const currentVal = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
       if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
       this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: version });
+      rootAsAny.diskCache.set(key, value);
+    } else {
+      rootAsAny.diskCache.set(key, value);
     }
     strategy.write(key, value);
     if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
@@ -5045,23 +5118,25 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return strategy.exists(key) ? strategy.read(key) : null;
+      const rootAsAny = this.root;
+      if (this._diskExists(key, snapshotVersion)) {
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached2 = this.deletedCache.get(key);
         if (cached2) {
-          const match = cached2.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return match.value;
+          const cIdx = this._findExact(cached2, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return cached2[cIdx].value;
         }
       }
       return null;
@@ -5069,12 +5144,18 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
     if (!targetVerObj.exists) return null;
     if (!nextVerObj) {
       if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
-      return strategy.read(key);
+      if (this._diskExists(key, snapshotVersion)) {
+        const rootAsAny = this.root;
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     const cached = this.deletedCache.get(key);
     if (cached) {
-      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-      if (match) return match.value;
+      const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+      if (cIdx >= 0) return cached[cIdx].value;
     }
     return null;
   }
@@ -5083,23 +5164,23 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return strategy.exists(key);
+      const rootAsAny = this.root;
+      if (rootAsAny.diskCache.has(key)) return rootAsAny.diskCache.get(key) !== null;
+      const exists = strategy.exists(key);
+      if (!exists) rootAsAny.diskCache.set(key, null);
+      return exists;
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached = this.deletedCache.get(key);
         if (cached) {
-          const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return true;
+          const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return true;
         }
       }
       return false;
@@ -5109,11 +5190,13 @@ var SyncMVCCTransaction2 = class _SyncMVCCTransaction2 extends MVCCTransaction2
   _diskDelete(key, snapshotVersion) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (strategy.exists(key)) {
-      const currentVal = strategy.read(key);
+    const rootAsAny = this.root;
+    if (this._diskExists(key, snapshotVersion)) {
+      const currentVal = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
       if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
       this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
       strategy.delete(key);
+      rootAsAny.diskCache.delete(key);
     }
     if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
     this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
@@ -5427,7 +5510,7 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
   createNested() {
     if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
-    const child = new _AsyncMVCCTransaction2(void 0, this, childVersion);
+    const child = new _AsyncMVCCTransaction2(void 0, void 0, this, childVersion);
     this.root.activeTransactions.add(child);
     return child;
   }
@@ -5450,78 +5533,114 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
     return await this._diskExists(key, this.snapshotVersion);
   }
   async _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return true;
-      }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return false;
-      }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists;
-        }
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return true;
+      }
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) return false;
+      }
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) return history[idx].exists;
+      }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return await current._diskExists(key, snapshotVersion);
       }
     }
-    if (this.parent) {
-      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return await this._diskExists(key, snapshotVersion);
-    }
+    return false;
   }
   async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-    if (this.writeBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return this.writeBuffer.get(key);
+    let current = this;
+    let slVer = snapshotLocalVersion;
+    while (current) {
+      if (current.writeBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return current.writeBuffer.get(key);
+        }
       }
-    }
-    if (this.deleteBuffer.has(key)) {
-      const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-        return null;
+      if (current.deleteBuffer.has(key)) {
+        const keyModVersion = current.keyVersions.get(key);
+        if (slVer === void 0 || keyModVersion <= slVer) {
+          return null;
+        }
       }
-    }
-    const history = this.bufferHistory.get(key);
-    if (history && snapshotLocalVersion !== void 0) {
-      for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].version <= snapshotLocalVersion) {
-          return history[i].exists ? history[i].value : null;
+      const history = current.bufferHistory.get(key);
+      if (history && slVer !== void 0) {
+        const idx = current._findLastLE(history, slVer, "version");
+        if (idx >= 0) {
+          return history[idx].exists ? history[idx].value : null;
         }
       }
+      if (current.parent) {
+        slVer = current.snapshotLocalVersion;
+        current = current.parent;
+      } else {
+        return await current._diskRead(key, snapshotVersion);
+      }
     }
-    if (this.parent) {
-      return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
-    } else {
-      return await this._diskRead(key, snapshotVersion);
-    }
+    return null;
   }
   async commit(label) {
     const { created, updated, deleted } = this.getResultEntries();
     if (this.committed) {
-      return { label, success: false, error: "Transaction already committed", conflict: void 0, created, updated, deleted };
+      return {
+        label,
+        success: false,
+        error: "Transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
     }
     if (this.hasCommittedAncestor()) {
-      return { label, success: false, error: "Ancestor transaction already committed", conflict: void 0, created, updated, deleted };
+      return {
+        label,
+        success: false,
+        error: "Ancestor transaction already committed",
+        conflict: void 0,
+        created,
+        updated,
+        deleted
+      };
     }
     if (this.parent) {
       const failure = await this.parent._merge(this);
       if (failure) {
-        return { label, success: false, error: failure.error, conflict: failure.conflict, created, updated, deleted };
+        return {
+          label,
+          success: false,
+          error: failure.error,
+          conflict: failure.conflict,
+          created,
+          updated,
+          deleted
+        };
       }
       this.committed = true;
     } else {
       if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
         const failure = await this._merge(this);
         if (failure) {
-          return { label, success: false, error: failure.error, conflict: failure.conflict, created: [], updated: [], deleted: [] };
+          return {
+            label,
+            success: false,
+            error: failure.error,
+            conflict: failure.conflict,
+            created: [],
+            updated: [],
+            deleted: []
+          };
         }
         this.writeBuffer.clear();
         this.deleteBuffer.clear();
@@ -5534,7 +5653,13 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
         this.snapshotVersion = this.version;
       }
     }
-    return { label, success: true, created, updated, deleted };
+    return {
+      label,
+      success: true,
+      created,
+      updated,
+      deleted
+    };
   }
   async _merge(child) {
     return this.writeLock(async () => {
@@ -5544,7 +5669,11 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
           if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
             return {
               error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
-              conflict: { key, parent: await this.read(key), child: await child.read(key) }
+              conflict: {
+                key,
+                parent: await this.read(key),
+                child: await child.read(key)
+              }
             };
           }
         }
@@ -5553,7 +5682,11 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
           if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
             return {
               error: `Commit conflict: Key '${key}' was modified by a newer transaction (Local v${lastModLocalVer})`,
-              conflict: { key, parent: await this.read(key), child: await child.read(key) }
+              conflict: {
+                key,
+                parent: await this.read(key),
+                child: await child.read(key)
+              }
             };
           }
         }
@@ -5583,7 +5716,11 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
               if (lastVer > child.snapshotVersion) {
                 return {
                   error: `Commit conflict: Key '${key}' was modified by a newer transaction (v${lastVer})`,
-                  conflict: { key, parent: await this.read(key), child: await child.read(key) }
+                  conflict: {
+                    key,
+                    parent: await this.read(key),
+                    child: await child.read(key)
+                  }
                 };
               }
             }
@@ -5591,7 +5728,11 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
             if (lastModLocalVer !== void 0 && lastModLocalVer > child.snapshotLocalVersion) {
               return {
                 error: `Commit conflict: Key '${key}' was modified by a newer transaction in the same session (Local v${lastModLocalVer})`,
-                conflict: { key, parent: await this.read(key), child: await child.read(key) }
+                conflict: {
+                  key,
+                  parent: await this.read(key),
+                  child: await child.read(key)
+                }
               };
             }
           }
@@ -5627,10 +5768,14 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
   async _diskWrite(key, value, version) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (await strategy.exists(key)) {
-      const currentVal = await strategy.read(key);
+    const rootAsAny = this.root;
+    if (await this._diskExists(key, version)) {
+      const currentVal = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : await strategy.read(key);
       if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
       this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: version });
+      rootAsAny.diskCache.set(key, value);
+    } else {
+      rootAsAny.diskCache.set(key, value);
     }
     await strategy.write(key, value);
     if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
@@ -5641,23 +5786,25 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return await strategy.exists(key) ? await strategy.read(key) : null;
+      const rootAsAny = this.root;
+      if (await this._diskExists(key, snapshotVersion)) {
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : await strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached2 = this.deletedCache.get(key);
         if (cached2) {
-          const match = cached2.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return match.value;
+          const cIdx = this._findExact(cached2, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return cached2[cIdx].value;
         }
       }
       return null;
@@ -5665,12 +5812,18 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
     if (!targetVerObj.exists) return null;
     if (!nextVerObj) {
       if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
-      return strategy.read(key);
+      if (await this._diskExists(key, snapshotVersion)) {
+        const rootAsAny = this.root;
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : await strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     const cached = this.deletedCache.get(key);
     if (cached) {
-      const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-      if (match) return match.value;
+      const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+      if (cIdx >= 0) return cached[cIdx].value;
     }
     return null;
   }
@@ -5679,23 +5832,23 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return await strategy.exists(key);
+      const rootAsAny = this.root;
+      if (rootAsAny.diskCache.has(key)) return rootAsAny.diskCache.get(key) !== null;
+      const exists = await strategy.exists(key);
+      if (!exists) rootAsAny.diskCache.set(key, null);
+      return exists;
     }
     let targetVerObj = null;
     let nextVerObj = null;
-    for (const v of versions) {
-      if (v.version <= snapshotVersion) targetVerObj = v;
-      else {
-        nextVerObj = v;
-        break;
-      }
-    }
+    const idx = this._findLastLE(versions, snapshotVersion, "version");
+    if (idx >= 0) targetVerObj = versions[idx];
+    if (idx + 1 < versions.length) nextVerObj = versions[idx + 1];
     if (!targetVerObj) {
       if (nextVerObj) {
         const cached = this.deletedCache.get(key);
         if (cached) {
-          const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
-          if (match) return true;
+          const cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+          if (cIdx >= 0) return true;
         }
       }
       return false;
@@ -5705,11 +5858,13 @@ var AsyncMVCCTransaction2 = class _AsyncMVCCTransaction2 extends MVCCTransaction
   async _diskDelete(key, snapshotVersion) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (await strategy.exists(key)) {
-      const currentVal = await strategy.read(key);
+    const rootAsAny = this.root;
+    if (await this._diskExists(key, snapshotVersion)) {
+      const currentVal = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : await strategy.read(key);
       if (!this.deletedCache.has(key)) this.deletedCache.set(key, []);
       this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
       await strategy.delete(key);
+      rootAsAny.diskCache.delete(key);
     }
     if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
     this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });