document-dataply 0.0.5 → 0.0.6

package/dist/cjs/index.js

@@ -71,7 +71,7 @@ var require_cjs = __commonJS({
       BPTreeSyncTransaction: () => BPTreeSyncTransaction,
       BitmapPageManager: () => BitmapPageManager,
       CacheEntanglementAsync: () => CacheEntanglementAsync,
-      CacheEntanglementSync: () => CacheEntanglementSync2,
+      CacheEntanglementSync: () => CacheEntanglementSync,
       DataPageManager: () => DataPageManager,
       Dataply: () => Dataply,
       DataplyAPI: () => DataplyAPI2,
@@ -156,6 +156,42 @@ var require_cjs = __commonJS({
     };
     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;
@@ -163,11 +199,11 @@ var require_cjs = __commonJS({
       writeBuffer;
       deleteBuffer;
       createdKeys;
-      // create()로 생성된 키 추적
       deletedValues;
       // delete 시 삭제 전 값 저장
       originallyExisted;
       // 트랜잭션 시작 시점에 디스크에 존재했던 키 (deleted 결과 필터링용)
+      bufferHistory = /* @__PURE__ */ new Map();
       // Nested Transaction Properties
       parent;
       localVersion;
@@ -181,7 +217,8 @@ var require_cjs = __commonJS({
       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();
@@ -196,6 +233,7 @@ var require_cjs = __commonJS({
           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;
@@ -203,8 +241,13 @@ var require_cjs = __commonJS({
           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;
       }
@@ -221,27 +264,96 @@ var require_cjs = __commonJS({
         }
         return false;
       }
-      // --- Internal buffer manipulation helpers ---
-      _bufferCreate(key, value) {
-        this.localVersion++;
+      /**
+       * 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);
+        const currentVer = this.keyVersions.get(key);
+        if (currentVer !== void 0) {
+          if (!this.bufferHistory.has(key)) this.bufferHistory.set(key, []);
+          this.bufferHistory.get(key).push({
+            value: existsInWriteBuffer ? this.writeBuffer.get(key) : this.deletedValues.get(key) ?? null,
+            exists: existsInWriteBuffer || !existsInDeleteBuffer,
+            version: currentVer
+          });
+        }
+      }
+      /**
+       * 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;
+        this._recordHistory(key);
         this.writeBuffer.set(key, value);
         this.createdKeys.add(key);
         this.deleteBuffer.delete(key);
         this.originallyExisted.delete(key);
-        this.keyVersions.set(key, this.localVersion);
+        this.keyVersions.set(key, targetVersion);
       }
-      _bufferWrite(key, value) {
-        this.localVersion++;
+      _bufferWrite(key, value, version) {
+        if (version === void 0) this.localVersion++;
+        const targetVersion = version ?? this.localVersion;
+        this._recordHistory(key);
         this.writeBuffer.set(key, value);
         this.deleteBuffer.delete(key);
-        this.keyVersions.set(key, this.localVersion);
+        this.keyVersions.set(key, targetVersion);
       }
-      _bufferDelete(key) {
-        this.localVersion++;
+      _bufferDelete(key, version) {
+        if (version === void 0) this.localVersion++;
+        const targetVersion = version ?? this.localVersion;
+        this._recordHistory(key);
         this.deleteBuffer.add(key);
         this.writeBuffer.delete(key);
         this.createdKeys.delete(key);
-        this.keyVersions.set(key, this.localVersion);
+        this.keyVersions.set(key, targetVersion);
       }
       /**
        * Returns the entries that will be created, updated, and deleted by this transaction.
@@ -265,7 +377,11 @@ var require_cjs = __commonJS({
             deleted.push({ key, data });
           }
         }
-        return { created, updated, deleted };
+        return {
+          created,
+          updated,
+          deleted
+        };
       }
       /**
        * Rolls back the transaction.
@@ -283,7 +399,36 @@ var require_cjs = __commonJS({
         if (this.root !== this) {
           this.root.activeTransactions.delete(this);
         }
-        return { success: true, created, updated, deleted };
+        return {
+          success: true,
+          created,
+          updated,
+          deleted
+        };
+      }
+      /**
+       * Checks for conflicts among multiple transactions.
+       * A conflict occurs if two or more transactions modify (write or delete) the same key.
+       * @param transactions Array of transactions to check.
+       * @returns An array of keys that are in conflict.
+       */
+      static CheckConflicts(transactions) {
+        const modifiedKeys = /* @__PURE__ */ new Map();
+        const conflicts = /* @__PURE__ */ new Set();
+        for (const tx of transactions) {
+          const txModified = /* @__PURE__ */ new Set([
+            ...tx.writeBuffer.keys(),
+            ...tx.deleteBuffer
+          ]);
+          for (const key of txModified) {
+            const count = modifiedKeys.get(key) ?? 0;
+            if (count > 0) {
+              conflicts.add(key);
+            }
+            modifiedKeys.set(key, count + 1);
+          }
+        }
+        return Array.from(conflicts);
       }
       /**
        * Cleans up both deletedCache and versionIndex based on minActiveVersion.
@@ -318,7 +463,9 @@ var require_cjs = __commonJS({
                 break;
               }
             }
-            if (latestInSnapshotIdx > 0) {
+            if (latestInSnapshotIdx === versions.length - 1) {
+              this.versionIndex.delete(key);
+            } else if (latestInSnapshotIdx > 0) {
               versions.splice(0, latestInSnapshotIdx);
             }
           }
@@ -367,7 +514,7 @@ var require_cjs = __commonJS({
       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;
       }
@@ -375,32 +522,77 @@ var require_cjs = __commonJS({
         if (this.committed) throw new Error("Transaction already committed");
         if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
         if (this.deleteBuffer.has(key)) return null;
-        return this.root._diskRead(key, this.snapshotVersion);
+        if (this.parent) {
+          return this.parent._readSnapshot(key, this.snapshotVersion, this.snapshotLocalVersion);
+        }
+        return this._diskRead(key, this.snapshotVersion);
       }
       exists(key) {
         if (this.committed) throw new Error("Transaction already committed");
         if (this.deleteBuffer.has(key)) return false;
         if (this.writeBuffer.has(key)) return true;
-        return this.root._diskExists(key, this.snapshotVersion);
+        if (this.parent) {
+          return this.parent._existsSnapshot(key, this.snapshotVersion, this.snapshotLocalVersion);
+        }
+        return this._diskExists(key, this.snapshotVersion);
       }
-      _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-        if (this.writeBuffer.has(key)) {
-          const keyModVersion = this.keyVersions.get(key);
-          if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-            return this.writeBuffer.get(key);
+      _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+        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.deleteBuffer.has(key)) {
-          const keyModVersion = this.keyVersions.get(key);
-          if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-            return null;
+        return false;
+      }
+      _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+        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 (current.deleteBuffer.has(key)) {
+            const keyModVersion = current.keyVersions.get(key);
+            if (slVer === void 0 || keyModVersion <= slVer) {
+              return 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();
@@ -460,6 +652,7 @@ var require_cjs = __commonJS({
             this.deletedValues.clear();
             this.originallyExisted.clear();
             this.keyVersions.clear();
+            this.bufferHistory.clear();
             this.localVersion = 0;
             this.snapshotVersion = this.version;
           }
@@ -500,32 +693,22 @@ var require_cjs = __commonJS({
               };
             }
           }
-          const newLocalVersion = this.localVersion + 1;
-          for (const key of child.writeBuffer.keys()) {
-            this.writeBuffer.set(key, child.writeBuffer.get(key));
-            this.deleteBuffer.delete(key);
-            this.keyVersions.set(key, newLocalVersion);
-            if (child.createdKeys.has(key)) {
-              this.createdKeys.add(key);
-            }
+          const mergeVersion = ++this.localVersion;
+          for (const [key, value] of child.writeBuffer) {
+            const wasCreated = child.createdKeys.has(key);
+            if (wasCreated) this._bufferCreate(key, value, mergeVersion);
+            else this._bufferWrite(key, value, mergeVersion);
           }
           for (const key of child.deleteBuffer) {
-            this.deleteBuffer.add(key);
-            this.writeBuffer.delete(key);
-            this.createdKeys.delete(key);
-            this.keyVersions.set(key, newLocalVersion);
             const deletedValue = child.deletedValues.get(key);
-            if (deletedValue !== void 0) {
-              this.deletedValues.set(key, deletedValue);
-            }
-            if (child.originallyExisted.has(key)) {
+            if (deletedValue !== void 0) this.deletedValues.set(key, deletedValue);
+            if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
               this.originallyExisted.add(key);
             }
+            this._bufferDelete(key, mergeVersion);
           }
-          this.localVersion = newLocalVersion;
           this.root.activeTransactions.delete(child);
         } else {
-          const newVersion = this.version + 1;
           if (child !== this) {
             const modifiedKeys = /* @__PURE__ */ new Set([...child.writeBuffer.keys(), ...child.deleteBuffer]);
             for (const key of modifiedKeys) {
@@ -543,50 +726,57 @@ var require_cjs = __commonJS({
                   };
                 }
               }
+              const lastModLocalVer = this.keyVersions.get(key);
+              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)
+                  }
+                };
+              }
             }
-          }
-          for (const [key, value] of child.writeBuffer) {
-            this.writeBuffer.set(key, value);
-            this.deleteBuffer.delete(key);
-            if (child.createdKeys.has(key)) {
-              this.createdKeys.add(key);
-            }
-          }
-          for (const key of child.deleteBuffer) {
-            this.deleteBuffer.add(key);
-            this.writeBuffer.delete(key);
-            this.createdKeys.delete(key);
-            const deletedValue = child.deletedValues.get(key);
-            if (deletedValue !== void 0) {
-              this.deletedValues.set(key, deletedValue);
+            const mergeVersion = ++this.localVersion;
+            for (const [key, value] of child.writeBuffer) {
+              const wasCreated = child.createdKeys.has(key);
+              if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
+                this.originallyExisted.add(key);
+              }
+              if (wasCreated) this._bufferCreate(key, value, mergeVersion);
+              else this._bufferWrite(key, value, mergeVersion);
             }
-            if (child.originallyExisted.has(key)) {
-              this.originallyExisted.add(key);
+            for (const key of child.deleteBuffer) {
+              const deletedValue = child.deletedValues.get(key);
+              if (deletedValue !== void 0) this.deletedValues.set(key, deletedValue);
+              if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
+                this.originallyExisted.add(key);
+              }
+              this._bufferDelete(key, mergeVersion);
             }
+            this.root.activeTransactions.delete(child);
+          } else {
+            const newVersion = this.version + 1;
+            for (const [key, value] of this.writeBuffer) this._diskWrite(key, value, newVersion);
+            for (const key of this.deleteBuffer) this._diskDelete(key, newVersion);
+            this.version = newVersion;
+            this._cleanupDeletedCache();
           }
-          for (const [key, value] of child.writeBuffer) {
-            this._diskWrite(key, value, newVersion);
-          }
-          for (const key of child.deleteBuffer) {
-            this._diskDelete(key, newVersion);
-          }
-          this.version = newVersion;
-          this.root.activeTransactions.delete(child);
-          this._cleanupDeletedCache();
         }
         return null;
       }
-      // --- Internal IO Helpers (Root Only) ---
       _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
-          });
+          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, []);
@@ -597,36 +787,44 @@ var require_cjs = __commonJS({
         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;
         }
         if (!targetVerObj.exists) return null;
         if (!nextVerObj) {
-          return strategy.read(key);
+          if (this.writeBuffer.has(key)) return this.writeBuffer.get(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;
       }
@@ -635,31 +833,40 @@ var require_cjs = __commonJS({
         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;
-        for (const v of versions) {
-          if (v.version <= snapshotVersion) {
-            targetVerObj = v;
-          } else {
-            break;
+        let nextVerObj = null;
+        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 cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+              if (cIdx >= 0) return true;
+            }
           }
+          return false;
         }
-        if (!targetVerObj) return strategy.exists(key);
         return targetVerObj.exists;
       }
       _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
-          });
+          this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
+          strategy.delete(key);
+          rootAsAny.diskCache.delete(key);
         }
-        strategy.delete(key);
         if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
         this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
       }
@@ -972,7 +1179,7 @@ var require_cjs = __commonJS({
       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;
       }
@@ -980,32 +1187,77 @@ var require_cjs = __commonJS({
         if (this.committed) throw new Error("Transaction already committed");
         if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
         if (this.deleteBuffer.has(key)) return null;
-        return this.root._diskRead(key, this.snapshotVersion);
+        if (this.parent) {
+          return this.parent._readSnapshot(key, this.snapshotVersion, this.snapshotLocalVersion);
+        }
+        return await this._diskRead(key, this.snapshotVersion);
       }
       async exists(key) {
         if (this.committed) throw new Error("Transaction already committed");
         if (this.deleteBuffer.has(key)) return false;
         if (this.writeBuffer.has(key)) return true;
-        return this.root._diskExists(key, this.snapshotVersion);
+        if (this.parent) {
+          return this.parent._existsSnapshot(key, this.snapshotVersion, this.snapshotLocalVersion);
+        }
+        return await this._diskExists(key, this.snapshotVersion);
       }
-      async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-        if (this.writeBuffer.has(key)) {
-          const keyModVersion = this.keyVersions.get(key);
-          if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-            return this.writeBuffer.get(key);
+      async _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+        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.deleteBuffer.has(key)) {
-          const keyModVersion = this.keyVersions.get(key);
-          if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-            return null;
+        return false;
+      }
+      async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+        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 (current.deleteBuffer.has(key)) {
+            const keyModVersion = current.keyVersions.get(key);
+            if (slVer === void 0 || keyModVersion <= slVer) {
+              return 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 this._diskRead(key, snapshotVersion);
-        }
+        return null;
       }
       async commit(label) {
         const { created, updated, deleted } = this.getResultEntries();
@@ -1065,6 +1317,7 @@ var require_cjs = __commonJS({
             this.deletedValues.clear();
             this.originallyExisted.clear();
             this.keyVersions.clear();
+            this.bufferHistory.clear();
             this.localVersion = 0;
             this.snapshotVersion = this.version;
           }
@@ -1106,33 +1359,23 @@ var require_cjs = __commonJS({
                 };
               }
             }
-            const newLocalVersion = this.localVersion + 1;
-            for (const key of child.writeBuffer.keys()) {
-              this.writeBuffer.set(key, child.writeBuffer.get(key));
-              this.deleteBuffer.delete(key);
-              this.keyVersions.set(key, newLocalVersion);
-              if (child.createdKeys.has(key)) {
-                this.createdKeys.add(key);
-              }
+            const mergeVersion = ++this.localVersion;
+            for (const [key, value] of child.writeBuffer) {
+              const wasCreated = child.createdKeys.has(key);
+              if (wasCreated) this._bufferCreate(key, value, mergeVersion);
+              else this._bufferWrite(key, value, mergeVersion);
             }
             for (const key of child.deleteBuffer) {
-              this.deleteBuffer.add(key);
-              this.writeBuffer.delete(key);
-              this.createdKeys.delete(key);
-              this.keyVersions.set(key, newLocalVersion);
               const deletedValue = child.deletedValues.get(key);
-              if (deletedValue !== void 0) {
-                this.deletedValues.set(key, deletedValue);
-              }
-              if (child.originallyExisted.has(key)) {
+              if (deletedValue !== void 0) this.deletedValues.set(key, deletedValue);
+              if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
                 this.originallyExisted.add(key);
               }
+              this._bufferDelete(key, mergeVersion);
             }
-            this.localVersion = newLocalVersion;
             this.root.activeTransactions.delete(child);
             return null;
           } else {
-            const newVersion = this.version + 1;
             if (child !== this) {
               const modifiedKeys = /* @__PURE__ */ new Set([...child.writeBuffer.keys(), ...child.deleteBuffer]);
               for (const key of modifiedKeys) {
@@ -1150,51 +1393,58 @@ var require_cjs = __commonJS({
                     };
                   }
                 }
+                const lastModLocalVer = this.keyVersions.get(key);
+                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)
+                    }
+                  };
+                }
               }
-            }
-            for (const [key, value] of child.writeBuffer) {
-              this.writeBuffer.set(key, value);
-              this.deleteBuffer.delete(key);
-              if (child.createdKeys.has(key)) {
-                this.createdKeys.add(key);
-              }
-            }
-            for (const key of child.deleteBuffer) {
-              this.deleteBuffer.add(key);
-              this.writeBuffer.delete(key);
-              this.createdKeys.delete(key);
-              const deletedValue = child.deletedValues.get(key);
-              if (deletedValue !== void 0) {
-                this.deletedValues.set(key, deletedValue);
+              const mergeVersion = ++this.localVersion;
+              for (const [key, value] of child.writeBuffer) {
+                const wasCreated = child.createdKeys.has(key);
+                if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
+                  this.originallyExisted.add(key);
+                }
+                if (wasCreated) this._bufferCreate(key, value, mergeVersion);
+                else this._bufferWrite(key, value, mergeVersion);
               }
-              if (child.originallyExisted.has(key)) {
-                this.originallyExisted.add(key);
+              for (const key of child.deleteBuffer) {
+                const deletedValue = child.deletedValues.get(key);
+                if (deletedValue !== void 0) this.deletedValues.set(key, deletedValue);
+                if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
+                  this.originallyExisted.add(key);
+                }
+                this._bufferDelete(key, mergeVersion);
               }
+              this.root.activeTransactions.delete(child);
+            } else {
+              const newVersion = this.version + 1;
+              for (const [key, value] of this.writeBuffer) await this._diskWrite(key, value, newVersion);
+              for (const key of this.deleteBuffer) await this._diskDelete(key, newVersion);
+              this.version = newVersion;
+              this._cleanupDeletedCache();
             }
-            for (const [key, value] of child.writeBuffer) {
-              await this._diskWrite(key, value, newVersion);
-            }
-            for (const key of child.deleteBuffer) {
-              await this._diskDelete(key, newVersion);
-            }
-            this.version = newVersion;
-            this.root.activeTransactions.delete(child);
-            this._cleanupDeletedCache();
             return null;
           }
         });
       }
-      // --- Internal IO Helpers (Root Only) ---
       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
-          });
+          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, []);
@@ -1205,36 +1455,44 @@ var require_cjs = __commonJS({
         if (!strategy) throw new Error("Root Transaction missing strategy");
         const versions = this.versionIndex.get(key);
         if (!versions) {
-          return await strategy.exists(key) ? 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;
         }
         if (!targetVerObj.exists) return null;
         if (!nextVerObj) {
-          return strategy.read(key);
+          if (this.writeBuffer.has(key)) return this.writeBuffer.get(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;
       }
@@ -1243,359 +1501,47 @@ var require_cjs = __commonJS({
         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 = await strategy.exists(key);
+          if (!exists) rootAsAny.diskCache.set(key, null);
+          return exists;
         }
         let targetVerObj = null;
-        for (const v of versions) {
-          if (v.version <= snapshotVersion) {
-            targetVerObj = v;
-          } else {
-            break;
+        let nextVerObj = null;
+        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 cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+              if (cIdx >= 0) return true;
+            }
           }
+          return false;
         }
-        if (!targetVerObj) return strategy.exists(key);
         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);
+        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
-          });
+          this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
+          await strategy.delete(key);
+          rootAsAny.diskCache.delete(key);
         }
-        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);
-            }
-          }
-        }
-      }
-    };
-    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);
-        }
-        return this.caches.get(key);
-      }
-      update(key, ...parameter) {
-        this.bubbleUpdateSignal(key);
-        this.resolve(key, ...parameter);
-        return this.caches.get(key);
-      }
-    };
     var BPTreeTransaction = class _BPTreeTransaction {
-      _cachedRegexp;
-      nodes;
+      _cachedRegexp = /* @__PURE__ */ new Map();
+      nodes = /* @__PURE__ */ new Map();
       deletedNodeBuffer = /* @__PURE__ */ new Map();
       rootTx;
       mvccRoot;
@@ -1605,6 +1551,8 @@ var require_cjs = __commonJS({
       option;
       order;
       rootId;
+      isInitialized = false;
+      isDestroyed = false;
       verifierMap = {
         gt: (nv, v) => this.comparator.isHigher(nv, v),
         gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
@@ -1623,8 +1571,12 @@ var require_cjs = __commonJS({
         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 +1717,15 @@ var require_cjs = __commonJS({
         }
         return best;
       }
+      /**
+       * Checks for conflicts between multiple transactions.
+       * 
+       * @param transactions Array of BPTreeTransaction instances to check
+       * @returns An array of keys that are in conflict. Empty array if no conflicts.
+       */
+      static CheckConflicts(transactions) {
+        return MVCCTransaction.CheckConflicts(transactions.map((tx) => tx.mvcc));
+      }
       /**
        * Returns the ID of the root node.
        * @returns The root node ID.
@@ -1796,6 +1757,9 @@ var require_cjs = __commonJS({
         }
         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.
@@ -1828,17 +1792,6 @@ var require_cjs = __commonJS({
         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)) {
@@ -1869,13 +1822,25 @@ var require_cjs = __commonJS({
       getResultEntries() {
         return this.mvcc.getResultEntries();
       }
+      _clearCache() {
+        this._cachedRegexp.clear();
+      }
       /**
        * Clears all cached nodes.
        * This method is useful for freeing up memory when the tree is no longer needed.
        */
       clear() {
-        this._cachedRegexp.clear();
-        this.nodes.clear();
+        if (this.rootTx !== this) {
+          throw new Error("Cannot call clear on a nested transaction");
+        }
+        this._clearInternal();
+      }
+      _clearInternal() {
+        if (this.isDestroyed) {
+          throw new Error("Transaction already destroyed");
+        }
+        this._clearCache();
+        this.isDestroyed = true;
       }
       _binarySearchValues(values, target, usePrimary = false, upperBound = false) {
         let low = 0;
@@ -1909,9 +1874,6 @@ var require_cjs = __commonJS({
         );
       }
       getNode(id) {
-        if (this.nodes.has(id)) {
-          return this.nodes.get(id);
-        }
         return this.mvcc.read(id);
       }
       /**
@@ -1929,23 +1891,22 @@ var require_cjs = __commonJS({
           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__")) {
@@ -1953,49 +1914,56 @@ var require_cjs = __commonJS({
         } 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,
@@ -2003,53 +1971,54 @@ var require_cjs = __commonJS({
             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) {
@@ -2179,28 +2148,42 @@ var require_cjs = __commonJS({
         }
       }
       init() {
-        this.clear();
-        const head = this._readHead();
-        if (head === null) {
-          this.order = this.strategy.order;
-          const root = this._createNode(true, [], []);
-          this._writeHead({
-            root: root.id,
-            order: this.order,
-            data: this.strategy.head.data
-          });
-        } else {
-          const { root, order } = head;
-          this.strategy.head = head;
-          this.order = order;
-          this._writeHead({
-            root,
-            order: this.order,
-            data: this.strategy.head.data
-          });
+        if (this.rootTx !== this) {
+          throw new Error("Cannot call init on a nested transaction");
+        }
+        this._initInternal();
+      }
+      _initInternal() {
+        if (this.isInitialized) {
+          throw new Error("Transaction already initialized");
+        }
+        if (this.isDestroyed) {
+          throw new Error("Transaction already destroyed");
         }
-        if (this.order < 3) {
-          throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
+        this.isInitialized = true;
+        try {
+          this._clearCache();
+          const head = this._readHead();
+          if (head === null) {
+            this.order = this.strategy.order;
+            const root = this._createNode(true, [], []);
+            this._writeHead({
+              root: root.id,
+              order: this.order,
+              data: this.strategy.head.data
+            });
+          } else {
+            const { root, order } = head;
+            this.strategy.head = head;
+            this.order = order;
+            this.rootId = root;
+          }
+          if (this.order < 3) {
+            throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
+          }
+        } catch (e) {
+          this.isInitialized = false;
+          throw e;
         }
       }
       exists(key, value) {
@@ -2214,21 +2197,6 @@ var require_cjs = __commonJS({
         }
         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 +2282,10 @@ var require_cjs = __commonJS({
         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 +2294,13 @@ var require_cjs = __commonJS({
             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 +2314,7 @@ var require_cjs = __commonJS({
             }
           }
           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 +2324,7 @@ var require_cjs = __commonJS({
         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 +2332,17 @@ var require_cjs = __commonJS({
             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 +2363,80 @@ var require_cjs = __commonJS({
               }
             }
           }
-          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,63 +2444,70 @@ var require_cjs = __commonJS({
                 }
               }
               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) {
+        if (value === void 0) {
+          value = this.get(key);
+        }
+        if (value === void 0) {
+          return;
+        }
         let node = this.insertableNodeByPrimary(value);
         let found = false;
         while (true) {
@@ -2537,13 +2518,15 @@ var require_cjs = __commonJS({
               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;
               }
@@ -2578,110 +2561,359 @@ var require_cjs = __commonJS({
       commit(label) {
         let result = this.mvcc.commit(label);
         if (result.success) {
-          result = this.mvccRoot.commit(label);
-          if (result.success && this.rootTx !== this) {
-            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);
+          const isRootTx = this.rootTx === this;
+          if (!isRootTx) {
+            result = this.rootTx.commit(label);
+            if (result.success) {
+              this.rootTx.rootId = this.rootId;
             }
-            for (const r of result.deleted) {
-              this.nodes.delete(r.key);
+          }
+        }
+        return result;
+      }
+      rollback() {
+        return this.mvcc.rollback();
+      }
+    };
+    var BPTreeMVCCStrategySync = class extends SyncMVCCStrategy {
+      constructor(strategy) {
+        super();
+        this.strategy = strategy;
+      }
+      read(key) {
+        if (key === "__HEAD__") {
+          return this.strategy.readHead();
+        }
+        return this.strategy.read(key);
+      }
+      write(key, value) {
+        if (key === "__HEAD__") {
+          this.strategy.writeHead(value);
+        } else {
+          this.strategy.write(key, value);
+        }
+      }
+      delete(key) {
+        this.strategy.delete(key);
+      }
+      exists(key) {
+        if (key === "__HEAD__") {
+          return this.strategy.readHead() !== null;
+        }
+        try {
+          const node = this.strategy.read(key);
+          return node !== null && node !== void 0;
+        } catch {
+          return false;
+        }
+      }
+    };
+    var BPTreeSync = class extends BPTreeSyncTransaction {
+      constructor(strategy, comparator, option) {
+        const mvccRoot = new SyncMVCCTransaction(new BPTreeMVCCStrategySync(strategy), {
+          cacheCapacity: option?.capacity ?? void 0
+        });
+        super(
+          null,
+          mvccRoot,
+          mvccRoot,
+          strategy,
+          comparator,
+          option
+        );
+      }
+      /**
+       * Creates a new synchronous transaction.
+       * @returns A new BPTreeSyncTransaction.
+       */
+      createTransaction() {
+        const nestedTx = this.mvcc.createNested();
+        const tx = new BPTreeSyncTransaction(
+          this,
+          this.mvcc,
+          nestedTx,
+          this.strategy,
+          this.comparator,
+          this.option
+        );
+        tx._initInternal();
+        return tx;
+      }
+      insert(key, value) {
+        const tx = this.createTransaction();
+        tx.insert(key, value);
+        const result = tx.commit();
+        if (!result.success) {
+          throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+        }
+      }
+      delete(key, value) {
+        const tx = this.createTransaction();
+        tx.delete(key, value);
+        const result = tx.commit();
+        if (!result.success) {
+          throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+        }
+      }
+    };
+    var Ryoiki22 = class _Ryoiki2 {
+      readings;
+      writings;
+      readQueue;
+      writeQueue;
+      static async CatchError(promise) {
+        return await promise.then((v) => [void 0, v]).catch((err) => [err]);
+      }
+      static IsRangeOverlap(a, b) {
+        const [start1, end1] = a;
+        const [start2, end2] = b;
+        if (end1 <= start2 || end2 <= start1) {
+          return false;
+        }
+        return true;
+      }
+      static ERR_ALREADY_EXISTS(lockId) {
+        return new Error(`The '${lockId}' task already existing in queue or running.`);
+      }
+      static ERR_NOT_EXISTS(lockId) {
+        return new Error(`The '${lockId}' task not existing in task queue.`);
+      }
+      static ERR_TIMEOUT(lockId, timeout) {
+        return new Error(`The task with ID '${lockId}' failed to acquire the lock within the timeout(${timeout}ms).`);
+      }
+      /**
+       * Constructs a new instance of the Ryoiki class.
+       */
+      constructor() {
+        this.readings = /* @__PURE__ */ new Map();
+        this.writings = /* @__PURE__ */ new Map();
+        this.readQueue = /* @__PURE__ */ new Map();
+        this.writeQueue = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Creates a range based on a start value and length.
+       * @param start - The starting value of the range.
+       * @param length - The length of the range.
+       * @returns A range tuple [start, start + length].
+       */
+      range(start, length) {
+        return [start, start + length];
+      }
+      rangeOverlapping(tasks, range) {
+        return Array.from(tasks.values()).some((t) => _Ryoiki2.IsRangeOverlap(t.range, range));
+      }
+      isSameRange(a, b) {
+        const [a1, a2] = a;
+        const [b1, b2] = b;
+        return a1 === b1 && a2 === b2;
+      }
+      fetchUnitAndRun(queue, workspaces) {
+        for (const [id, unit] of queue) {
+          if (!unit.condition()) {
+            continue;
+          }
+          this._alloc(queue, workspaces, id);
+        }
+      }
+      _handleOverload(args, handlers, argPatterns) {
+        for (const [key, pattern] of Object.entries(argPatterns)) {
+          if (this._matchArgs(args, pattern)) {
+            return handlers[key](...args);
+          }
+        }
+        throw new Error("Invalid arguments");
+      }
+      _matchArgs(args, pattern) {
+        return args.every((arg, index) => {
+          const expectedType = pattern[index];
+          if (expectedType === void 0) return typeof arg === "undefined";
+          if (expectedType === Function) return typeof arg === "function";
+          if (expectedType === Number) return typeof arg === "number";
+          if (expectedType === Array) return Array.isArray(arg);
+          return false;
+        });
+      }
+      _createRandomId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2);
+        return `${timestamp}${random}`;
+      }
+      _alloc(queue, workspaces, lockId) {
+        const unit = queue.get(lockId);
+        if (!unit) {
+          throw _Ryoiki2.ERR_NOT_EXISTS(lockId);
+        }
+        workspaces.set(lockId, unit);
+        queue.delete(lockId);
+        unit.alloc();
+      }
+      _free(workspaces, lockId) {
+        const unit = workspaces.get(lockId);
+        if (!unit) {
+          throw _Ryoiki2.ERR_NOT_EXISTS(lockId);
+        }
+        workspaces.delete(lockId);
+        unit.free();
+      }
+      _lock(queue, range, timeout, task, condition) {
+        return new Promise((resolve, reject) => {
+          let timeoutId = null;
+          if (timeout >= 0) {
+            timeoutId = setTimeout(() => {
+              reject(_Ryoiki2.ERR_TIMEOUT(id, timeout));
+            }, timeout);
+          }
+          const id = this._createRandomId();
+          const alloc = async () => {
+            if (timeoutId !== null) {
+              clearTimeout(timeoutId);
             }
+            const [err, v] = await _Ryoiki2.CatchError(task(id));
+            if (err) reject(err);
+            else resolve(v);
+          };
+          const fetch = () => {
+            this.fetchUnitAndRun(this.readQueue, this.readings);
+            this.fetchUnitAndRun(this.writeQueue, this.writings);
+          };
+          queue.set(id, { id, range, condition, alloc, free: fetch });
+          fetch();
+        });
+      }
+      _checkWorking(range, workspaces) {
+        let isLocked = false;
+        for (const lock of workspaces.values()) {
+          if (_Ryoiki2.IsRangeOverlap(range, lock.range)) {
+            isLocked = true;
+            break;
           }
         }
-        return result;
-      }
-      rollback() {
-        return this.mvcc.rollback();
-      }
-    };
-    var BPTreeMVCCStrategySync = class extends SyncMVCCStrategy {
-      constructor(strategy) {
-        super();
-        this.strategy = strategy;
+        return isLocked;
       }
-      read(key) {
-        if (key === "__HEAD__") {
-          return this.strategy.readHead();
-        }
-        return this.strategy.read(key);
+      /**
+       * Checks if there is any active read lock within the specified range.
+       * @param range The range to check for active read locks.
+       * @returns `true` if there is an active read lock within the range, `false` otherwise.
+       */
+      isReading(range) {
+        return this._checkWorking(range, this.readings);
       }
-      write(key, value) {
-        if (key === "__HEAD__") {
-          this.strategy.writeHead(value);
-        } else {
-          this.strategy.write(key, value);
-        }
+      /**
+       * Checks if there is any active write lock within the specified range.
+       * @param range The range to check for active write locks.
+       * @returns `true` if there is an active write lock within the range, `false` otherwise.
+       */
+      isWriting(range) {
+        return this._checkWorking(range, this.writings);
       }
-      delete(key) {
-        this.strategy.delete(key);
+      /**
+       * Checks if a read lock can be acquired within the specified range.
+       * @param range The range to check for read lock availability.
+       * @returns `true` if a read lock can be acquired, `false` otherwise.
+       */
+      canRead(range) {
+        const writing = this.isWriting(range);
+        return !writing;
       }
-      exists(key) {
-        if (key === "__HEAD__") {
-          return this.strategy.readHead() !== null;
-        }
-        try {
-          const node = this.strategy.read(key);
-          return node !== null && node !== void 0;
-        } catch {
-          return false;
-        }
+      /**
+       * Checks if a write lock can be acquired within the specified range.
+       * @param range The range to check for write lock availability.
+       * @returns `true` if a write lock can be acquired, `false` otherwise.
+       */
+      canWrite(range) {
+        const reading = this.isReading(range);
+        const writing = this.isWriting(range);
+        return !reading && !writing;
       }
-    };
-    var BPTreeSync = class extends BPTreeSyncTransaction {
-      constructor(strategy, comparator, option) {
-        const mvccRoot = new SyncMVCCTransaction(new BPTreeMVCCStrategySync(strategy));
-        super(
-          null,
-          mvccRoot,
-          mvccRoot,
-          strategy,
-          comparator,
-          option
+      /**
+       * Internal implementation of the read lock. Handles both overloads.
+       * @template T - The return type of the task.
+       * @param arg0 - Either a range or a task callback.
+       * If a range is provided, the task is the second argument.
+       * @param arg1 - The task to execute, required if a range is provided.
+       * @param arg2 - The timeout for acquiring the lock.
+       * If the lock cannot be acquired within this period, an error will be thrown.
+       * If this value is not provided, no timeout will be set.
+       * @returns A promise resolving to the result of the task execution.
+       */
+      readLock(arg0, arg1, arg2) {
+        const [range, task, timeout] = this._handleOverload(
+          [arg0, arg1, arg2],
+          {
+            rangeTask: (range2, task2) => [range2, task2, -1],
+            rangeTaskTimeout: (range2, task2, timeout2) => [range2, task2, timeout2],
+            task: (task2) => [[-Infinity, Infinity], task2, -1],
+            taskTimeout: (task2, timeout2) => [[-Infinity, Infinity], task2, timeout2]
+          },
+          {
+            task: [Function],
+            taskTimeout: [Function, Number],
+            rangeTask: [Array, Function],
+            rangeTaskTimeout: [Array, Function, Number]
+          }
+        );
+        return this._lock(
+          this.readQueue,
+          range,
+          timeout,
+          task,
+          () => !this.rangeOverlapping(this.writings, range)
         );
       }
       /**
-       * Creates a new synchronous transaction.
-       * @returns A new BPTreeSyncTransaction.
+       * Internal implementation of the write lock. Handles both overloads.
+       * @template T - The return type of the task.
+       * @param arg0 - Either a range or a task callback.
+       * If a range is provided, the task is the second argument.
+       * @param arg1 - The task to execute, required if a range is provided.
+       * @param arg2 - The timeout for acquiring the lock.
+       * If the lock cannot be acquired within this period, an error will be thrown.
+       * If this value is not provided, no timeout will be set.
+       * @returns A promise resolving to the result of the task execution.
        */
-      createTransaction() {
-        const nestedTx = this.mvcc.createNested();
-        const tx = new BPTreeSyncTransaction(
-          this,
-          this.mvcc,
-          nestedTx,
-          this.strategy,
-          this.comparator,
-          this.option
+      writeLock(arg0, arg1, arg2) {
+        const [range, task, timeout] = this._handleOverload(
+          [arg0, arg1, arg2],
+          {
+            rangeTask: (range2, task2) => [range2, task2, -1],
+            rangeTaskTimeout: (range2, task2, timeout2) => [range2, task2, timeout2],
+            task: (task2) => [[-Infinity, Infinity], task2, -1],
+            taskTimeout: (task2, timeout2) => [[-Infinity, Infinity], task2, timeout2]
+          },
+          {
+            task: [Function],
+            taskTimeout: [Function, Number],
+            rangeTask: [Array, Function],
+            rangeTaskTimeout: [Array, Function, Number]
+          }
+        );
+        return this._lock(
+          this.writeQueue,
+          range,
+          timeout,
+          task,
+          () => {
+            return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+          }
         );
-        tx.init();
-        return tx;
       }
-      insert(key, value) {
-        const tx = this.createTransaction();
-        tx.insert(key, value);
-        const result = tx.commit();
-        if (!result.success) {
-          throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
-        }
-        this.rootId = tx.getRootId();
+      /**
+       * Releases a read lock by its lock ID.
+       * @param lockId - The unique identifier for the lock to release.
+       */
+      readUnlock(lockId) {
+        this._free(this.readings, lockId);
       }
-      delete(key, value) {
-        const tx = this.createTransaction();
-        tx.delete(key, value);
-        const result = tx.commit();
-        if (!result.success) {
-          throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
-        }
-        this.rootId = tx.getRootId();
+      /**
+       * Releases a write lock by its lock ID.
+       * @param lockId - The unique identifier for the lock to release.
+       */
+      writeUnlock(lockId) {
+        this._free(this.writings, lockId);
       }
     };
     var BPTreeAsyncTransaction2 = class extends BPTreeTransaction {
+      lock;
       constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
         super(
           rootTx,
@@ -2691,11 +2923,18 @@ var require_cjs = __commonJS({
           comparator,
           option
         );
+        this.lock = new Ryoiki22();
+      }
+      async writeLock(id, fn) {
+        let lockId;
+        return this.lock.writeLock([id, id + 0.1], async (_lockId) => {
+          lockId = _lockId;
+          return fn();
+        }).finally(() => {
+          this.lock.writeUnlock(lockId);
+        });
       }
       async getNode(id) {
-        if (this.nodes.has(id)) {
-          return this.nodes.get(id);
-        }
         return await this.mvcc.read(id);
       }
       /**
@@ -2713,23 +2952,22 @@ var require_cjs = __commonJS({
           prev
         };
         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__")) {
@@ -2737,49 +2975,56 @@ var require_cjs = __commonJS({
         } 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,
@@ -2787,53 +3032,54 @@ var require_cjs = __commonJS({
             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) {
@@ -2969,28 +3215,42 @@ var require_cjs = __commonJS({
         }
       }
       async init() {
-        this.clear();
-        const head = await this._readHead();
-        if (head === null) {
-          this.order = this.strategy.order;
-          const root = await this._createNode(true, [], []);
-          await this._writeHead({
-            root: root.id,
-            order: this.order,
-            data: this.strategy.head.data
-          });
-        } else {
-          const { root, order } = head;
-          this.strategy.head = head;
-          this.order = order;
-          await this._writeHead({
-            root,
-            order: this.order,
-            data: this.strategy.head.data
-          });
+        if (this.rootTx !== this) {
+          throw new Error("Cannot call init on a nested transaction");
+        }
+        return await this._initInternal();
+      }
+      async _initInternal() {
+        if (this.isInitialized) {
+          throw new Error("Transaction already initialized");
+        }
+        if (this.isDestroyed) {
+          throw new Error("Transaction already destroyed");
         }
-        if (this.order < 3) {
-          throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
+        this.isInitialized = true;
+        try {
+          this._clearCache();
+          const head = await this._readHead();
+          if (head === null) {
+            this.order = this.strategy.order;
+            const root = await this._createNode(true, [], []);
+            await this._writeHead({
+              root: root.id,
+              order: this.order,
+              data: this.strategy.head.data
+            });
+          } else {
+            const { root, order } = head;
+            this.strategy.head = head;
+            this.order = order;
+            this.rootId = root;
+          }
+          if (this.order < 3) {
+            throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
+          }
+        } catch (e) {
+          this.isInitialized = false;
+          throw e;
         }
       }
       async exists(key, value) {
@@ -3004,21 +3264,6 @@ var require_cjs = __commonJS({
         }
         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) {
@@ -3099,29 +3344,34 @@ var require_cjs = __commonJS({
       async where(condition, order = "asc") {
         const map = /* @__PURE__ */ new Map();
         for await (const [key, value] of this.whereStream(condition, void 0, order)) {
-          map.set(key, value);
-        }
-        return map;
-      }
-      async insert(key, value) {
-        const before = await this.insertableNode(value);
-        await this._insertAtLeaf(before, key, value);
-        if (before.values.length === this.order) {
-          const after = await this._createNode(
-            true,
-            [],
-            [],
-            before.parent,
-            null,
-            null
-          );
-          const mid = Math.ceil(this.order / 2) - 1;
-          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._insertInParent(before, after.values[0], after);
+          map.set(key, value);
         }
+        return map;
+      }
+      async insert(key, value) {
+        return this.writeLock(0, async () => {
+          let before = await this.insertableNode(value);
+          before = await this._insertAtLeaf(before, key, value);
+          if (before.values.length === this.order) {
+            let after = await this._createNode(
+              true,
+              [],
+              [],
+              before.parent,
+              null,
+              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);
+          }
+        });
       }
       async _deleteEntry(node, key) {
         if (!node.leaf) {
@@ -3133,6 +3383,7 @@ var require_cjs = __commonJS({
             }
           }
           if (keyIndex !== -1) {
+            node = this._cloneNode(node);
             node.keys.splice(keyIndex, 1);
             const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
             node.values.splice(valueIndex, 1);
@@ -3142,7 +3393,7 @@ var require_cjs = __commonJS({
         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({
@@ -3150,14 +3401,17 @@ var require_cjs = __commonJS({
             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);
@@ -3178,78 +3432,80 @@ var require_cjs = __commonJS({
               }
             }
           }
-          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;
@@ -3257,92 +3513,103 @@ var require_cjs = __commonJS({
                 }
               }
               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) {
-        let node = await this.insertableNodeByPrimary(value);
-        let found = false;
-        while (true) {
-          let i = node.values.length;
-          while (i--) {
-            const nValue = node.values[i];
-            if (this.comparator.isSame(value, nValue)) {
-              const keys = node.keys[i];
-              const keyIndex = keys.indexOf(key);
-              if (keyIndex !== -1) {
-                keys.splice(keyIndex, 1);
-                if (keys.length === 0) {
-                  node.keys.splice(i, 1);
-                  node.values.splice(i, 1);
+        return this.writeLock(0, async () => {
+          if (value === void 0) {
+            value = await this.get(key);
+          }
+          if (value === void 0) {
+            return;
+          }
+          let node = await this.insertableNodeByPrimary(value);
+          let found = false;
+          while (true) {
+            let i = node.values.length;
+            while (i--) {
+              const nValue = node.values[i];
+              if (this.comparator.isSame(value, nValue)) {
+                const keys = node.keys[i];
+                const keyIndex = keys.indexOf(key);
+                if (keyIndex !== -1) {
+                  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);
+                  node = await this._deleteEntry(node, key);
+                  found = true;
+                  break;
                 }
-                await this._updateNode(node);
-                await this._deleteEntry(node, key);
-                found = true;
-                break;
               }
             }
+            if (found) break;
+            if (node.next) {
+              node = await this.getNode(node.next);
+              continue;
+            }
+            break;
           }
-          if (found) break;
-          if (node.next) {
-            node = await this.getNode(node.next);
-            continue;
-          }
-          break;
-        }
+        });
       }
       async getHeadData() {
         const head = await this._readHead();
@@ -3362,428 +3629,168 @@ var require_cjs = __commonJS({
           data
         });
       }
-      async commit(label) {
-        let result = await this.mvcc.commit(label);
-        if (result.success) {
-          result = await this.mvccRoot.commit(label);
-          if (result.success && this.rootTx !== this) {
-            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() {
-        return this.mvcc.rollback();
-      }
-    };
-    var BPTreeMVCCStrategyAsync = class extends AsyncMVCCStrategy {
-      constructor(strategy) {
-        super();
-        this.strategy = strategy;
-      }
-      async read(key) {
-        if (key === "__HEAD__") {
-          return await this.strategy.readHead();
-        }
-        return await this.strategy.read(key);
-      }
-      async write(key, value) {
-        if (key === "__HEAD__") {
-          await this.strategy.writeHead(value);
-        } else {
-          await this.strategy.write(key, value);
-        }
-      }
-      async delete(key) {
-        await this.strategy.delete(key);
-      }
-      async exists(key) {
-        if (key === "__HEAD__") {
-          return await this.strategy.readHead() !== null;
-        }
-        try {
-          const node = await this.strategy.read(key);
-          return node !== null && node !== void 0;
-        } catch {
-          return false;
-        }
-      }
-    };
-    var BPTreeAsync2 = class extends BPTreeAsyncTransaction2 {
-      constructor(strategy, comparator, option) {
-        const mvccRoot = new AsyncMVCCTransaction(new BPTreeMVCCStrategyAsync(strategy));
-        super(
-          null,
-          mvccRoot,
-          mvccRoot,
-          strategy,
-          comparator,
-          option
-        );
-      }
-      /**
-       * Creates a new asynchronous transaction.
-       * @returns A new BPTreeAsyncTransaction.
-       */
-      async createTransaction() {
-        const nestedTx = await this.mvcc.createNested();
-        const tx = new BPTreeAsyncTransaction2(
-          this,
-          this.mvcc,
-          nestedTx,
-          this.strategy,
-          this.comparator,
-          this.option
-        );
-        await tx.init();
-        return tx;
-      }
-      async insert(key, value) {
-        const tx = await this.createTransaction();
-        await tx.insert(key, value);
-        const result = await tx.commit();
-        if (!result.success) {
-          throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
-        }
-        this.rootId = tx.getRootId();
-      }
-      async delete(key, value) {
-        const tx = await this.createTransaction();
-        await tx.delete(key, value);
-        const result = await tx.commit();
-        if (!result.success) {
-          throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
-        }
-        this.rootId = tx.getRootId();
-      }
-    };
-    var SerializeStrategy = class {
-      order;
-      head;
-      constructor(order) {
-        this.order = order;
-        this.head = {
-          order,
-          root: null,
-          data: {}
-        };
-      }
-    };
-    var SerializeStrategySync = class extends SerializeStrategy {
-      getHeadData(key, defaultValue) {
-        if (!Object.hasOwn(this.head.data, key)) {
-          this.setHeadData(key, defaultValue);
-        }
-        return this.head.data[key];
-      }
-      setHeadData(key, data) {
-        this.head.data[key] = data;
-        this.writeHead(this.head);
-      }
-      autoIncrement(key, defaultValue) {
-        const current = this.getHeadData(key, defaultValue);
-        const next = current + 1;
-        this.setHeadData(key, next);
-        return current;
-      }
-    };
-    var InMemoryStoreStrategySync = class extends SerializeStrategySync {
-      node;
-      constructor(order) {
-        super(order);
-        this.node = {};
-      }
-      id(isLeaf) {
-        return this.autoIncrement("index", 1).toString();
-      }
-      read(id) {
-        if (!Object.hasOwn(this.node, id)) {
-          throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
-        }
-        const node = this.node[id];
-        return JSON.parse(JSON.stringify(node));
-      }
-      write(id, node) {
-        this.node[id] = node;
-      }
-      delete(id) {
-        delete this.node[id];
-      }
-      readHead() {
-        if (this.head.root === null) {
-          return null;
-        }
-        return this.head;
-      }
-      writeHead(head) {
-        this.head = head;
-      }
-    };
-    var Ryoiki22 = class _Ryoiki2 {
-      readings;
-      writings;
-      readQueue;
-      writeQueue;
-      static async CatchError(promise) {
-        return await promise.then((v) => [void 0, v]).catch((err) => [err]);
-      }
-      static IsRangeOverlap(a, b) {
-        const [start1, end1] = a;
-        const [start2, end2] = b;
-        if (end1 <= start2 || end2 <= start1) {
-          return false;
-        }
-        return true;
-      }
-      static ERR_ALREADY_EXISTS(lockId) {
-        return new Error(`The '${lockId}' task already existing in queue or running.`);
-      }
-      static ERR_NOT_EXISTS(lockId) {
-        return new Error(`The '${lockId}' task not existing in task queue.`);
-      }
-      static ERR_TIMEOUT(lockId, timeout) {
-        return new Error(`The task with ID '${lockId}' failed to acquire the lock within the timeout(${timeout}ms).`);
-      }
-      /**
-       * Constructs a new instance of the Ryoiki class.
-       */
-      constructor() {
-        this.readings = /* @__PURE__ */ new Map();
-        this.writings = /* @__PURE__ */ new Map();
-        this.readQueue = /* @__PURE__ */ new Map();
-        this.writeQueue = /* @__PURE__ */ new Map();
-      }
-      /**
-       * Creates a range based on a start value and length.
-       * @param start - The starting value of the range.
-       * @param length - The length of the range.
-       * @returns A range tuple [start, start + length].
-       */
-      range(start, length) {
-        return [start, start + length];
-      }
-      rangeOverlapping(tasks, range) {
-        return Array.from(tasks.values()).some((t) => _Ryoiki2.IsRangeOverlap(t.range, range));
-      }
-      isSameRange(a, b) {
-        const [a1, a2] = a;
-        const [b1, b2] = b;
-        return a1 === b1 && a2 === b2;
-      }
-      fetchUnitAndRun(queue, workspaces) {
-        for (const [id, unit] of queue) {
-          if (!unit.condition()) {
-            continue;
-          }
-          this._alloc(queue, workspaces, id);
-        }
-      }
-      _handleOverload(args, handlers, argPatterns) {
-        for (const [key, pattern] of Object.entries(argPatterns)) {
-          if (this._matchArgs(args, pattern)) {
-            return handlers[key](...args);
+      async commit(label) {
+        let result = await this.mvcc.commit(label);
+        if (result.success) {
+          const isRootTx = this.rootTx === this;
+          if (!isRootTx) {
+            result = await this.rootTx.commit(label);
+            if (result.success) {
+              this.rootTx.rootId = this.rootId;
+            }
           }
         }
-        throw new Error("Invalid arguments");
+        return result;
       }
-      _matchArgs(args, pattern) {
-        return args.every((arg, index) => {
-          const expectedType = pattern[index];
-          if (expectedType === void 0) return typeof arg === "undefined";
-          if (expectedType === Function) return typeof arg === "function";
-          if (expectedType === Number) return typeof arg === "number";
-          if (expectedType === Array) return Array.isArray(arg);
-          return false;
-        });
+      async rollback() {
+        return this.mvcc.rollback();
       }
-      _createRandomId() {
-        const timestamp = Date.now().toString(36);
-        const random = Math.random().toString(36).substring(2);
-        return `${timestamp}${random}`;
+    };
+    var BPTreeMVCCStrategyAsync = class extends AsyncMVCCStrategy {
+      constructor(strategy) {
+        super();
+        this.strategy = strategy;
       }
-      _alloc(queue, workspaces, lockId) {
-        const unit = queue.get(lockId);
-        if (!unit) {
-          throw _Ryoiki2.ERR_NOT_EXISTS(lockId);
+      async read(key) {
+        if (key === "__HEAD__") {
+          return await this.strategy.readHead();
         }
-        workspaces.set(lockId, unit);
-        queue.delete(lockId);
-        unit.alloc();
+        return await this.strategy.read(key);
       }
-      _free(workspaces, lockId) {
-        const unit = workspaces.get(lockId);
-        if (!unit) {
-          throw _Ryoiki2.ERR_NOT_EXISTS(lockId);
+      async write(key, value) {
+        if (key === "__HEAD__") {
+          await this.strategy.writeHead(value);
+        } else {
+          await this.strategy.write(key, value);
         }
-        workspaces.delete(lockId);
-        unit.free();
       }
-      _lock(queue, range, timeout, task, condition) {
-        return new Promise((resolve, reject) => {
-          let timeoutId = null;
-          if (timeout >= 0) {
-            timeoutId = setTimeout(() => {
-              reject(_Ryoiki2.ERR_TIMEOUT(id, timeout));
-            }, timeout);
-          }
-          const id = this._createRandomId();
-          const alloc = async () => {
-            if (timeoutId !== null) {
-              clearTimeout(timeoutId);
-            }
-            const [err, v] = await _Ryoiki2.CatchError(task(id));
-            if (err) reject(err);
-            else resolve(v);
-          };
-          const fetch = () => {
-            this.fetchUnitAndRun(this.readQueue, this.readings);
-            this.fetchUnitAndRun(this.writeQueue, this.writings);
-          };
-          queue.set(id, { id, range, condition, alloc, free: fetch });
-          fetch();
-        });
+      async delete(key) {
+        await this.strategy.delete(key);
       }
-      _checkWorking(range, workspaces) {
-        let isLocked = false;
-        for (const lock of workspaces.values()) {
-          if (_Ryoiki2.IsRangeOverlap(range, lock.range)) {
-            isLocked = true;
-            break;
-          }
+      async exists(key) {
+        if (key === "__HEAD__") {
+          return await this.strategy.readHead() !== null;
+        }
+        try {
+          const node = await this.strategy.read(key);
+          return node !== null && node !== void 0;
+        } catch {
+          return false;
         }
-        return isLocked;
-      }
-      /**
-       * Checks if there is any active read lock within the specified range.
-       * @param range The range to check for active read locks.
-       * @returns `true` if there is an active read lock within the range, `false` otherwise.
-       */
-      isReading(range) {
-        return this._checkWorking(range, this.readings);
-      }
-      /**
-       * Checks if there is any active write lock within the specified range.
-       * @param range The range to check for active write locks.
-       * @returns `true` if there is an active write lock within the range, `false` otherwise.
-       */
-      isWriting(range) {
-        return this._checkWorking(range, this.writings);
-      }
-      /**
-       * Checks if a read lock can be acquired within the specified range.
-       * @param range The range to check for read lock availability.
-       * @returns `true` if a read lock can be acquired, `false` otherwise.
-       */
-      canRead(range) {
-        const writing = this.isWriting(range);
-        return !writing;
       }
-      /**
-       * Checks if a write lock can be acquired within the specified range.
-       * @param range The range to check for write lock availability.
-       * @returns `true` if a write lock can be acquired, `false` otherwise.
-       */
-      canWrite(range) {
-        const reading = this.isReading(range);
-        const writing = this.isWriting(range);
-        return !reading && !writing;
+    };
+    var BPTreeAsync2 = class extends BPTreeAsyncTransaction2 {
+      constructor(strategy, comparator, option) {
+        const mvccRoot = new AsyncMVCCTransaction(new BPTreeMVCCStrategyAsync(strategy), {
+          cacheCapacity: option?.capacity ?? void 0
+        });
+        super(
+          null,
+          mvccRoot,
+          mvccRoot,
+          strategy,
+          comparator,
+          option
+        );
       }
       /**
-       * Internal implementation of the read lock. Handles both overloads.
-       * @template T - The return type of the task.
-       * @param arg0 - Either a range or a task callback.
-       * If a range is provided, the task is the second argument.
-       * @param arg1 - The task to execute, required if a range is provided.
-       * @param arg2 - The timeout for acquiring the lock.
-       * If the lock cannot be acquired within this period, an error will be thrown.
-       * If this value is not provided, no timeout will be set.
-       * @returns A promise resolving to the result of the task execution.
+       * Creates a new asynchronous transaction.
+       * @returns A new BPTreeAsyncTransaction.
        */
-      readLock(arg0, arg1, arg2) {
-        const [range, task, timeout] = this._handleOverload(
-          [arg0, arg1, arg2],
-          {
-            rangeTask: (range2, task2) => [range2, task2, -1],
-            rangeTaskTimeout: (range2, task2, timeout2) => [range2, task2, timeout2],
-            task: (task2) => [[-Infinity, Infinity], task2, -1],
-            taskTimeout: (task2, timeout2) => [[-Infinity, Infinity], task2, timeout2]
-          },
-          {
-            task: [Function],
-            taskTimeout: [Function, Number],
-            rangeTask: [Array, Function],
-            rangeTaskTimeout: [Array, Function, Number]
-          }
-        );
-        return this._lock(
-          this.readQueue,
-          range,
-          timeout,
-          task,
-          () => !this.rangeOverlapping(this.writings, range)
+      async createTransaction() {
+        const nestedTx = this.mvcc.createNested();
+        const tx = new BPTreeAsyncTransaction2(
+          this,
+          this.mvcc,
+          nestedTx,
+          this.strategy,
+          this.comparator,
+          this.option
         );
+        await tx._initInternal();
+        return tx;
       }
-      /**
-       * Internal implementation of the write lock. Handles both overloads.
-       * @template T - The return type of the task.
-       * @param arg0 - Either a range or a task callback.
-       * If a range is provided, the task is the second argument.
-       * @param arg1 - The task to execute, required if a range is provided.
-       * @param arg2 - The timeout for acquiring the lock.
-       * If the lock cannot be acquired within this period, an error will be thrown.
-       * If this value is not provided, no timeout will be set.
-       * @returns A promise resolving to the result of the task execution.
-       */
-      writeLock(arg0, arg1, arg2) {
-        const [range, task, timeout] = this._handleOverload(
-          [arg0, arg1, arg2],
-          {
-            rangeTask: (range2, task2) => [range2, task2, -1],
-            rangeTaskTimeout: (range2, task2, timeout2) => [range2, task2, timeout2],
-            task: (task2) => [[-Infinity, Infinity], task2, -1],
-            taskTimeout: (task2, timeout2) => [[-Infinity, Infinity], task2, timeout2]
-          },
-          {
-            task: [Function],
-            taskTimeout: [Function, Number],
-            rangeTask: [Array, Function],
-            rangeTaskTimeout: [Array, Function, Number]
+      async insert(key, value) {
+        return this.writeLock(1, async () => {
+          const tx = await this.createTransaction();
+          await tx.insert(key, value);
+          const result = await tx.commit();
+          if (!result.success) {
+            throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
           }
-        );
-        return this._lock(
-          this.writeQueue,
-          range,
-          timeout,
-          task,
-          () => {
-            return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+        });
+      }
+      async delete(key, value) {
+        return this.writeLock(1, async () => {
+          const tx = await this.createTransaction();
+          await tx.delete(key, value);
+          const result = await tx.commit();
+          if (!result.success) {
+            throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
           }
-        );
+        });
+      }
+    };
+    var SerializeStrategy = class {
+      order;
+      head;
+      constructor(order) {
+        this.order = order;
+        this.head = {
+          order,
+          root: null,
+          data: {}
+        };
+      }
+    };
+    var SerializeStrategySync = class extends SerializeStrategy {
+      getHeadData(key, defaultValue) {
+        if (!Object.hasOwn(this.head.data, key)) {
+          this.setHeadData(key, defaultValue);
+        }
+        return this.head.data[key];
+      }
+      setHeadData(key, data) {
+        this.head.data[key] = data;
+        this.writeHead(this.head);
+      }
+      autoIncrement(key, defaultValue) {
+        const current = this.getHeadData(key, defaultValue);
+        const next = current + 1;
+        this.setHeadData(key, next);
+        return current;
+      }
+    };
+    var InMemoryStoreStrategySync = class extends SerializeStrategySync {
+      node;
+      constructor(order) {
+        super(order);
+        this.node = {};
       }
-      /**
-       * Releases a read lock by its lock ID.
-       * @param lockId - The unique identifier for the lock to release.
-       */
-      readUnlock(lockId) {
-        this._free(this.readings, lockId);
+      id(isLeaf) {
+        return this.autoIncrement("index", 1).toString();
       }
-      /**
-       * Releases a write lock by its lock ID.
-       * @param lockId - The unique identifier for the lock to release.
-       */
-      writeUnlock(lockId) {
-        this._free(this.writings, lockId);
+      read(id) {
+        if (!Object.hasOwn(this.node, id)) {
+          throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
+        }
+        const node = this.node[id];
+        return JSON.parse(JSON.stringify(node));
+      }
+      write(id, node) {
+        this.node[id] = node;
+      }
+      delete(id) {
+        delete this.node[id];
+      }
+      readHead() {
+        if (this.head.root === null) {
+          return null;
+        }
+        return this.head;
+      }
+      writeHead(head) {
+        this.head = head;
       }
     };
     var SerializeStrategyAsync2 = class extends SerializeStrategy {
@@ -4224,7 +4231,7 @@ var require_cjs = __commonJS({
         this.tail = null;
       }
     };
-    var CacheEntanglement2 = class {
+    var CacheEntanglement = class {
       creation;
       beforeUpdateHook;
       capacity;
@@ -4325,7 +4332,7 @@ var require_cjs = __commonJS({
         }
       }
     };
-    var CacheData2 = class _CacheData2 {
+    var CacheData = class _CacheData {
       static StructuredClone = globalThis.structuredClone.bind(globalThis);
       _value;
       constructor(value) {
@@ -4365,11 +4372,11 @@ var require_cjs = __commonJS({
             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);
       }
@@ -4399,7 +4406,7 @@ var require_cjs = __commonJS({
           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);
@@ -4423,7 +4430,7 @@ var require_cjs = __commonJS({
         return this.caches.get(key);
       }
     };
-    var CacheEntanglementAsync = class extends CacheEntanglement2 {
+    var CacheEntanglementAsync = class extends CacheEntanglement {
       constructor(creation, option) {
         super(creation, option);
       }
@@ -4453,7 +4460,7 @@ var require_cjs = __commonJS({
           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);
@@ -4556,6 +4563,42 @@ var require_cjs = __commonJS({
     };
     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;
@@ -4563,11 +4606,11 @@ var require_cjs = __commonJS({
       writeBuffer;
       deleteBuffer;
       createdKeys;
-      // create()로 생성된 키 추적
       deletedValues;
       // delete 시 삭제 전 값 저장
       originallyExisted;
       // 트랜잭션 시작 시점에 디스크에 존재했던 키 (deleted 결과 필터링용)
+      bufferHistory = /* @__PURE__ */ new Map();
       // Nested Transaction Properties
       parent;
       localVersion;
@@ -4581,7 +4624,8 @@ var require_cjs = __commonJS({
       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();
@@ -4596,6 +4640,7 @@ var require_cjs = __commonJS({
           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;
@@ -4603,8 +4648,13 @@ var require_cjs = __commonJS({
           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;
       }
@@ -4621,27 +4671,96 @@ var require_cjs = __commonJS({
         }
         return false;
       }
-      // --- Internal buffer manipulation helpers ---
-      _bufferCreate(key, value) {
-        this.localVersion++;
+      /**
+       * 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);
+        const currentVer = this.keyVersions.get(key);
+        if (currentVer !== void 0) {
+          if (!this.bufferHistory.has(key)) this.bufferHistory.set(key, []);
+          this.bufferHistory.get(key).push({
+            value: existsInWriteBuffer ? this.writeBuffer.get(key) : this.deletedValues.get(key) ?? null,
+            exists: existsInWriteBuffer || !existsInDeleteBuffer,
+            version: currentVer
+          });
+        }
+      }
+      /**
+       * 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;
+        this._recordHistory(key);
         this.writeBuffer.set(key, value);
         this.createdKeys.add(key);
         this.deleteBuffer.delete(key);
         this.originallyExisted.delete(key);
-        this.keyVersions.set(key, this.localVersion);
+        this.keyVersions.set(key, targetVersion);
       }
-      _bufferWrite(key, value) {
-        this.localVersion++;
+      _bufferWrite(key, value, version) {
+        if (version === void 0) this.localVersion++;
+        const targetVersion = version ?? this.localVersion;
+        this._recordHistory(key);
         this.writeBuffer.set(key, value);
         this.deleteBuffer.delete(key);
-        this.keyVersions.set(key, this.localVersion);
+        this.keyVersions.set(key, targetVersion);
       }
-      _bufferDelete(key) {
-        this.localVersion++;
+      _bufferDelete(key, version) {
+        if (version === void 0) this.localVersion++;
+        const targetVersion = version ?? this.localVersion;
+        this._recordHistory(key);
         this.deleteBuffer.add(key);
         this.writeBuffer.delete(key);
         this.createdKeys.delete(key);
-        this.keyVersions.set(key, this.localVersion);
+        this.keyVersions.set(key, targetVersion);
       }
       /**
        * Returns the entries that will be created, updated, and deleted by this transaction.
@@ -4665,7 +4784,11 @@ var require_cjs = __commonJS({
             deleted.push({ key, data });
           }
         }
-        return { created, updated, deleted };
+        return {
+          created,
+          updated,
+          deleted
+        };
       }
       /**
        * Rolls back the transaction.
@@ -4683,7 +4806,36 @@ var require_cjs = __commonJS({
         if (this.root !== this) {
           this.root.activeTransactions.delete(this);
         }
-        return { success: true, created, updated, deleted };
+        return {
+          success: true,
+          created,
+          updated,
+          deleted
+        };
+      }
+      /**
+       * Checks for conflicts among multiple transactions.
+       * A conflict occurs if two or more transactions modify (write or delete) the same key.
+       * @param transactions Array of transactions to check.
+       * @returns An array of keys that are in conflict.
+       */
+      static CheckConflicts(transactions) {
+        const modifiedKeys = /* @__PURE__ */ new Map();
+        const conflicts = /* @__PURE__ */ new Set();
+        for (const tx of transactions) {
+          const txModified = /* @__PURE__ */ new Set([
+            ...tx.writeBuffer.keys(),
+            ...tx.deleteBuffer
+          ]);
+          for (const key of txModified) {
+            const count = modifiedKeys.get(key) ?? 0;
+            if (count > 0) {
+              conflicts.add(key);
+            }
+            modifiedKeys.set(key, count + 1);
+          }
+        }
+        return Array.from(conflicts);
       }
       /**
        * Cleans up both deletedCache and versionIndex based on minActiveVersion.
@@ -4718,7 +4870,9 @@ var require_cjs = __commonJS({
                 break;
               }
             }
-            if (latestInSnapshotIdx > 0) {
+            if (latestInSnapshotIdx === versions.length - 1) {
+              this.versionIndex.delete(key);
+            } else if (latestInSnapshotIdx > 0) {
               versions.splice(0, latestInSnapshotIdx);
             }
           }
@@ -4767,7 +4921,7 @@ var require_cjs = __commonJS({
       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;
       }
@@ -4775,32 +4929,77 @@ var require_cjs = __commonJS({
         if (this.committed) throw new Error("Transaction already committed");
         if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
         if (this.deleteBuffer.has(key)) return null;
-        return this.root._diskRead(key, this.snapshotVersion);
+        if (this.parent) {
+          return this.parent._readSnapshot(key, this.snapshotVersion, this.snapshotLocalVersion);
+        }
+        return this._diskRead(key, this.snapshotVersion);
       }
       exists(key) {
         if (this.committed) throw new Error("Transaction already committed");
         if (this.deleteBuffer.has(key)) return false;
         if (this.writeBuffer.has(key)) return true;
-        return this.root._diskExists(key, this.snapshotVersion);
+        if (this.parent) {
+          return this.parent._existsSnapshot(key, this.snapshotVersion, this.snapshotLocalVersion);
+        }
+        return this._diskExists(key, this.snapshotVersion);
       }
-      _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-        if (this.writeBuffer.has(key)) {
-          const keyModVersion = this.keyVersions.get(key);
-          if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-            return this.writeBuffer.get(key);
+      _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+        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.deleteBuffer.has(key)) {
-          const keyModVersion = this.keyVersions.get(key);
-          if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-            return null;
+        return false;
+      }
+      _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+        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 (current.deleteBuffer.has(key)) {
+            const keyModVersion = current.keyVersions.get(key);
+            if (slVer === void 0 || keyModVersion <= slVer) {
+              return 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();
@@ -4860,6 +5059,7 @@ var require_cjs = __commonJS({
             this.deletedValues.clear();
             this.originallyExisted.clear();
             this.keyVersions.clear();
+            this.bufferHistory.clear();
             this.localVersion = 0;
             this.snapshotVersion = this.version;
           }
@@ -4900,32 +5100,22 @@ var require_cjs = __commonJS({
               };
             }
           }
-          const newLocalVersion = this.localVersion + 1;
-          for (const key of child.writeBuffer.keys()) {
-            this.writeBuffer.set(key, child.writeBuffer.get(key));
-            this.deleteBuffer.delete(key);
-            this.keyVersions.set(key, newLocalVersion);
-            if (child.createdKeys.has(key)) {
-              this.createdKeys.add(key);
-            }
+          const mergeVersion = ++this.localVersion;
+          for (const [key, value] of child.writeBuffer) {
+            const wasCreated = child.createdKeys.has(key);
+            if (wasCreated) this._bufferCreate(key, value, mergeVersion);
+            else this._bufferWrite(key, value, mergeVersion);
           }
           for (const key of child.deleteBuffer) {
-            this.deleteBuffer.add(key);
-            this.writeBuffer.delete(key);
-            this.createdKeys.delete(key);
-            this.keyVersions.set(key, newLocalVersion);
             const deletedValue = child.deletedValues.get(key);
-            if (deletedValue !== void 0) {
-              this.deletedValues.set(key, deletedValue);
-            }
-            if (child.originallyExisted.has(key)) {
+            if (deletedValue !== void 0) this.deletedValues.set(key, deletedValue);
+            if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
               this.originallyExisted.add(key);
             }
+            this._bufferDelete(key, mergeVersion);
           }
-          this.localVersion = newLocalVersion;
           this.root.activeTransactions.delete(child);
         } else {
-          const newVersion = this.version + 1;
           if (child !== this) {
             const modifiedKeys = /* @__PURE__ */ new Set([...child.writeBuffer.keys(), ...child.deleteBuffer]);
             for (const key of modifiedKeys) {
@@ -4943,50 +5133,57 @@ var require_cjs = __commonJS({
                   };
                 }
               }
+              const lastModLocalVer = this.keyVersions.get(key);
+              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)
+                  }
+                };
+              }
             }
-          }
-          for (const [key, value] of child.writeBuffer) {
-            this.writeBuffer.set(key, value);
-            this.deleteBuffer.delete(key);
-            if (child.createdKeys.has(key)) {
-              this.createdKeys.add(key);
-            }
-          }
-          for (const key of child.deleteBuffer) {
-            this.deleteBuffer.add(key);
-            this.writeBuffer.delete(key);
-            this.createdKeys.delete(key);
-            const deletedValue = child.deletedValues.get(key);
-            if (deletedValue !== void 0) {
-              this.deletedValues.set(key, deletedValue);
+            const mergeVersion = ++this.localVersion;
+            for (const [key, value] of child.writeBuffer) {
+              const wasCreated = child.createdKeys.has(key);
+              if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
+                this.originallyExisted.add(key);
+              }
+              if (wasCreated) this._bufferCreate(key, value, mergeVersion);
+              else this._bufferWrite(key, value, mergeVersion);
             }
-            if (child.originallyExisted.has(key)) {
-              this.originallyExisted.add(key);
+            for (const key of child.deleteBuffer) {
+              const deletedValue = child.deletedValues.get(key);
+              if (deletedValue !== void 0) this.deletedValues.set(key, deletedValue);
+              if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
+                this.originallyExisted.add(key);
+              }
+              this._bufferDelete(key, mergeVersion);
             }
+            this.root.activeTransactions.delete(child);
+          } else {
+            const newVersion = this.version + 1;
+            for (const [key, value] of this.writeBuffer) this._diskWrite(key, value, newVersion);
+            for (const key of this.deleteBuffer) this._diskDelete(key, newVersion);
+            this.version = newVersion;
+            this._cleanupDeletedCache();
           }
-          for (const [key, value] of child.writeBuffer) {
-            this._diskWrite(key, value, newVersion);
-          }
-          for (const key of child.deleteBuffer) {
-            this._diskDelete(key, newVersion);
-          }
-          this.version = newVersion;
-          this.root.activeTransactions.delete(child);
-          this._cleanupDeletedCache();
         }
         return null;
       }
-      // --- Internal IO Helpers (Root Only) ---
       _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
-          });
+          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, []);
@@ -4997,36 +5194,44 @@ var require_cjs = __commonJS({
         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;
         }
         if (!targetVerObj.exists) return null;
         if (!nextVerObj) {
-          return strategy.read(key);
+          if (this.writeBuffer.has(key)) return this.writeBuffer.get(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;
       }
@@ -5035,31 +5240,40 @@ var require_cjs = __commonJS({
         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;
-        for (const v of versions) {
-          if (v.version <= snapshotVersion) {
-            targetVerObj = v;
-          } else {
-            break;
+        let nextVerObj = null;
+        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 cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+              if (cIdx >= 0) return true;
+            }
           }
+          return false;
         }
-        if (!targetVerObj) return strategy.exists(key);
         return targetVerObj.exists;
       }
       _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
-          });
+          this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
+          strategy.delete(key);
+          rootAsAny.diskCache.delete(key);
         }
-        strategy.delete(key);
         if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
         this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
       }
@@ -5372,7 +5586,7 @@ var require_cjs = __commonJS({
       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;
       }
@@ -5380,32 +5594,77 @@ var require_cjs = __commonJS({
         if (this.committed) throw new Error("Transaction already committed");
         if (this.writeBuffer.has(key)) return this.writeBuffer.get(key);
         if (this.deleteBuffer.has(key)) return null;
-        return this.root._diskRead(key, this.snapshotVersion);
+        if (this.parent) {
+          return this.parent._readSnapshot(key, this.snapshotVersion, this.snapshotLocalVersion);
+        }
+        return await this._diskRead(key, this.snapshotVersion);
       }
       async exists(key) {
         if (this.committed) throw new Error("Transaction already committed");
         if (this.deleteBuffer.has(key)) return false;
         if (this.writeBuffer.has(key)) return true;
-        return this.root._diskExists(key, this.snapshotVersion);
+        if (this.parent) {
+          return this.parent._existsSnapshot(key, this.snapshotVersion, this.snapshotLocalVersion);
+        }
+        return await this._diskExists(key, this.snapshotVersion);
       }
-      async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
-        if (this.writeBuffer.has(key)) {
-          const keyModVersion = this.keyVersions.get(key);
-          if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-            return this.writeBuffer.get(key);
+      async _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+        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.deleteBuffer.has(key)) {
-          const keyModVersion = this.keyVersions.get(key);
-          if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
-            return null;
+        return false;
+      }
+      async _readSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+        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 (current.deleteBuffer.has(key)) {
+            const keyModVersion = current.keyVersions.get(key);
+            if (slVer === void 0 || keyModVersion <= slVer) {
+              return 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 this._diskRead(key, snapshotVersion);
-        }
+        return null;
       }
       async commit(label) {
         const { created, updated, deleted } = this.getResultEntries();
@@ -5465,6 +5724,7 @@ var require_cjs = __commonJS({
             this.deletedValues.clear();
             this.originallyExisted.clear();
             this.keyVersions.clear();
+            this.bufferHistory.clear();
             this.localVersion = 0;
             this.snapshotVersion = this.version;
           }
@@ -5506,33 +5766,23 @@ var require_cjs = __commonJS({
                 };
               }
             }
-            const newLocalVersion = this.localVersion + 1;
-            for (const key of child.writeBuffer.keys()) {
-              this.writeBuffer.set(key, child.writeBuffer.get(key));
-              this.deleteBuffer.delete(key);
-              this.keyVersions.set(key, newLocalVersion);
-              if (child.createdKeys.has(key)) {
-                this.createdKeys.add(key);
-              }
+            const mergeVersion = ++this.localVersion;
+            for (const [key, value] of child.writeBuffer) {
+              const wasCreated = child.createdKeys.has(key);
+              if (wasCreated) this._bufferCreate(key, value, mergeVersion);
+              else this._bufferWrite(key, value, mergeVersion);
             }
             for (const key of child.deleteBuffer) {
-              this.deleteBuffer.add(key);
-              this.writeBuffer.delete(key);
-              this.createdKeys.delete(key);
-              this.keyVersions.set(key, newLocalVersion);
               const deletedValue = child.deletedValues.get(key);
-              if (deletedValue !== void 0) {
-                this.deletedValues.set(key, deletedValue);
-              }
-              if (child.originallyExisted.has(key)) {
+              if (deletedValue !== void 0) this.deletedValues.set(key, deletedValue);
+              if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
                 this.originallyExisted.add(key);
               }
+              this._bufferDelete(key, mergeVersion);
             }
-            this.localVersion = newLocalVersion;
             this.root.activeTransactions.delete(child);
             return null;
           } else {
-            const newVersion = this.version + 1;
             if (child !== this) {
               const modifiedKeys = /* @__PURE__ */ new Set([...child.writeBuffer.keys(), ...child.deleteBuffer]);
               for (const key of modifiedKeys) {
@@ -5550,51 +5800,58 @@ var require_cjs = __commonJS({
                     };
                   }
                 }
+                const lastModLocalVer = this.keyVersions.get(key);
+                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)
+                    }
+                  };
+                }
               }
-            }
-            for (const [key, value] of child.writeBuffer) {
-              this.writeBuffer.set(key, value);
-              this.deleteBuffer.delete(key);
-              if (child.createdKeys.has(key)) {
-                this.createdKeys.add(key);
-              }
-            }
-            for (const key of child.deleteBuffer) {
-              this.deleteBuffer.add(key);
-              this.writeBuffer.delete(key);
-              this.createdKeys.delete(key);
-              const deletedValue = child.deletedValues.get(key);
-              if (deletedValue !== void 0) {
-                this.deletedValues.set(key, deletedValue);
+              const mergeVersion = ++this.localVersion;
+              for (const [key, value] of child.writeBuffer) {
+                const wasCreated = child.createdKeys.has(key);
+                if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
+                  this.originallyExisted.add(key);
+                }
+                if (wasCreated) this._bufferCreate(key, value, mergeVersion);
+                else this._bufferWrite(key, value, mergeVersion);
               }
-              if (child.originallyExisted.has(key)) {
-                this.originallyExisted.add(key);
+              for (const key of child.deleteBuffer) {
+                const deletedValue = child.deletedValues.get(key);
+                if (deletedValue !== void 0) this.deletedValues.set(key, deletedValue);
+                if (child.originallyExisted.has(key) && !this.createdKeys.has(key)) {
+                  this.originallyExisted.add(key);
+                }
+                this._bufferDelete(key, mergeVersion);
               }
+              this.root.activeTransactions.delete(child);
+            } else {
+              const newVersion = this.version + 1;
+              for (const [key, value] of this.writeBuffer) await this._diskWrite(key, value, newVersion);
+              for (const key of this.deleteBuffer) await this._diskDelete(key, newVersion);
+              this.version = newVersion;
+              this._cleanupDeletedCache();
             }
-            for (const [key, value] of child.writeBuffer) {
-              await this._diskWrite(key, value, newVersion);
-            }
-            for (const key of child.deleteBuffer) {
-              await this._diskDelete(key, newVersion);
-            }
-            this.version = newVersion;
-            this.root.activeTransactions.delete(child);
-            this._cleanupDeletedCache();
             return null;
           }
         });
       }
-      // --- Internal IO Helpers (Root Only) ---
       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
-          });
+          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, []);
@@ -5605,36 +5862,44 @@ var require_cjs = __commonJS({
         if (!strategy) throw new Error("Root Transaction missing strategy");
         const versions = this.versionIndex.get(key);
         if (!versions) {
-          return await strategy.exists(key) ? 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;
         }
         if (!targetVerObj.exists) return null;
         if (!nextVerObj) {
-          return strategy.read(key);
+          if (this.writeBuffer.has(key)) return this.writeBuffer.get(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;
       }
@@ -5643,31 +5908,40 @@ var require_cjs = __commonJS({
         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 = await strategy.exists(key);
+          if (!exists) rootAsAny.diskCache.set(key, null);
+          return exists;
         }
         let targetVerObj = null;
-        for (const v of versions) {
-          if (v.version <= snapshotVersion) {
-            targetVerObj = v;
-          } else {
-            break;
+        let nextVerObj = null;
+        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 cIdx = this._findExact(cached, nextVerObj.version, "deletedAtVersion");
+              if (cIdx >= 0) return true;
+            }
           }
+          return false;
         }
-        if (!targetVerObj) return strategy.exists(key);
         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);
+        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
-          });
+          this.deletedCache.get(key).push({ value: currentVal, deletedAtVersion: snapshotVersion });
+          await strategy.delete(key);
+          rootAsAny.diskCache.delete(key);
         }
-        await strategy.delete(key);
         if (!this.versionIndex.has(key)) this.versionIndex.set(key, []);
         this.versionIndex.get(key).push({ version: snapshotVersion, exists: false });
       }
@@ -7537,9 +7811,8 @@ var require_cjs = __commonJS({
       }
     };
     var import_node_fs2 = __toESM2(require("node:fs"));
-    var PageMVCCStrategy = class extends AsyncMVCCStrategy2 {
+    var PageMVCCStrategy = class {
       constructor(fileHandle, pageSize, cacheCapacity) {
-        super();
         this.fileHandle = fileHandle;
         this.pageSize = pageSize;
         this.cache = new LRUMap2(cacheCapacity);
@@ -8336,7 +8609,6 @@ var require_cjs = __commonJS({
             if (!btx) return;
             const result = await btx.commit();
             if (result.success) {
-              await this.bptree.init();
               for (const entry of result.deleted) {
                 await this.strategy.delete(entry.key);
               }
@@ -9813,6 +10085,7 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
         return 0;
       }
       const fieldTxMap = {};
+      const fieldMap = /* @__PURE__ */ new Map();
       for (const field of backfillTargets) {
         const tree = this.trees.get(field);
         if (tree && field !== "_id") {
@@ -9838,16 +10111,35 @@ var DocumentDataplyAPI = class extends import_dataply3.DataplyAPI {
           }
           const v = flatDoc[field];
           const btx = fieldTxMap[field];
-          await btx.insert(k, { k, v });
+          const entry = { k, v };
+          await btx.insert(k, entry);
+          if (!fieldMap.has(btx)) {
+            fieldMap.set(btx, []);
+          }
+          fieldMap.get(btx).push(entry);
         }
         backfilledCount++;
       }
-      const commits = Object.values(fieldTxMap).map((btx) => btx.commit());
-      await Promise.all(commits).catch(async (err) => {
-        const rollbacks = Object.values(fieldTxMap).map((btx) => btx.rollback());
-        await Promise.all(rollbacks);
+      const btxs = Object.values(fieldTxMap);
+      const success = [];
+      try {
+        for (const btx of btxs) {
+          await btx.commit();
+          success.push(btx);
+        }
+      } catch (err) {
+        for (const btx of btxs) {
+          await btx.rollback();
+        }
+        for (const btx of success) {
+          const entries = fieldMap.get(btx);
+          if (!entries) continue;
+          for (const entry of entries) {
+            await btx.delete(entry.k, entry);
+          }
+        }
         throw err;
-      });
+      }
       this.pendingBackfillFields = [];
       return backfilledCount;
     }, tx);