serializable-bptree 8.1.2 → 8.1.4

package/dist/cjs/index.cjs

@@ -93,6 +93,42 @@ var StringComparator = class extends ValueComparator {
 // node_modules/mvcc-api/dist/esm/index.mjs
 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;
@@ -100,11 +136,11 @@ var MVCCTransaction = class {
   writeBuffer;
   deleteBuffer;
   createdKeys;
-  // create()로 생성된 키 추적
   deletedValues;
   // delete 시 삭제 전 값 저장
   originallyExisted;
   // 트랜잭션 시작 시점에 디스크에 존재했던 키 (deleted 결과 필터링용)
+  bufferHistory = /* @__PURE__ */ new Map();
   // Nested Transaction Properties
   parent;
   localVersion;
@@ -118,7 +154,8 @@ var MVCCTransaction = class {
   versionIndex = /* @__PURE__ */ new Map();
   deletedCache = /* @__PURE__ */ new Map();
   activeTransactions = /* @__PURE__ */ new Set();
-  constructor(strategy, parent, snapshotVersion) {
+  diskCache;
+  constructor(strategy, options, parent, snapshotVersion) {
     this.snapshotVersion = snapshotVersion ?? 0;
     this.writeBuffer = /* @__PURE__ */ new Map();
     this.deleteBuffer = /* @__PURE__ */ new Set();
@@ -133,6 +170,7 @@ var MVCCTransaction = class {
       this.snapshotLocalVersion = parent.localVersion;
       this.strategy = void 0;
       this.root = parent.root;
+      this.diskCache = parent.diskCache;
     } else {
       if (!strategy) throw new Error("Root Transaction must get Strategy");
       this.strategy = strategy;
@@ -140,8 +178,13 @@ var MVCCTransaction = class {
       this.localVersion = 0;
       this.snapshotLocalVersion = 0;
       this.root = this;
+      this.diskCache = new LRUMap(options?.cacheCapacity ?? 1e3);
     }
   }
+  /**
+   * Checks if the transaction is a root transaction.
+   * @returns True if the transaction is a root transaction, false otherwise.
+   */
   isRoot() {
     return !this.parent;
   }
@@ -158,27 +201,61 @@ var MVCCTransaction = class {
     }
     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
+      });
+    }
+  }
+  _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.
@@ -202,7 +279,11 @@ var MVCCTransaction = class {
         deleted.push({ key, data });
       }
     }
-    return { created, updated, deleted };
+    return {
+      created,
+      updated,
+      deleted
+    };
   }
   /**
    * Rolls back the transaction.
@@ -220,7 +301,12 @@ var MVCCTransaction = class {
     if (this.root !== this) {
       this.root.activeTransactions.delete(this);
     }
-    return { success: true, created, updated, deleted };
+    return {
+      success: true,
+      created,
+      updated,
+      deleted
+    };
   }
   /**
    * Cleans up both deletedCache and versionIndex based on minActiveVersion.
@@ -255,7 +341,9 @@ var MVCCTransaction = class {
             break;
           }
         }
-        if (latestInSnapshotIdx > 0) {
+        if (latestInSnapshotIdx === versions.length - 1) {
+          this.versionIndex.delete(key);
+        } else if (latestInSnapshotIdx > 0) {
           versions.splice(0, latestInSnapshotIdx);
         }
       }
@@ -304,7 +392,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
   createNested() {
     if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
-    const child = new _SyncMVCCTransaction(void 0, this, childVersion);
+    const child = new _SyncMVCCTransaction(void 0, void 0, this, childVersion);
     this.root.activeTransactions.add(child);
     return child;
   }
@@ -312,27 +400,68 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     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);
+  }
+  _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return true;
+      }
+    }
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return false;
+      }
+    }
+    const history = this.bufferHistory.get(key);
+    if (history && snapshotLocalVersion !== void 0) {
+      for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].version <= snapshotLocalVersion) {
+          return history[i].exists;
+        }
+      }
+    }
+    if (this.parent) {
+      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return this._diskExists(key, 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) {
+      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
         return this.writeBuffer.get(key);
       }
     }
     if (this.deleteBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
         return null;
       }
     }
+    const history = this.bufferHistory.get(key);
+    if (history && snapshotLocalVersion !== void 0) {
+      for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].version <= snapshotLocalVersion) {
+          return history[i].exists ? history[i].value : null;
+        }
+      }
+    }
     if (this.parent) {
       return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
     } else {
@@ -397,6 +526,7 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
         this.deletedValues.clear();
         this.originallyExisted.clear();
         this.keyVersions.clear();
+        this.bufferHistory.clear();
         this.localVersion = 0;
         this.snapshotVersion = this.version;
       }
@@ -437,32 +567,22 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
           };
         }
       }
-      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) {
@@ -480,50 +600,57 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
               };
             }
           }
+          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, []);
@@ -534,14 +661,19 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return strategy.exists(key) ? strategy.read(key) : null;
+      const rootAsAny = this.root;
+      if (this._diskExists(key, snapshotVersion)) {
+        const val = rootAsAny.diskCache.has(key) ? rootAsAny.diskCache.get(key) : strategy.read(key);
+        rootAsAny.diskCache.set(key, val);
+        return val;
+      }
+      return null;
     }
     let targetVerObj = null;
     let nextVerObj = null;
     for (const v of versions) {
-      if (v.version <= snapshotVersion) {
-        targetVerObj = v;
-      } else {
+      if (v.version <= snapshotVersion) targetVerObj = v;
+      else {
         nextVerObj = v;
         break;
       }
@@ -558,7 +690,14 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     }
     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) {
@@ -572,31 +711,44 @@ var SyncMVCCTransaction = class _SyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return strategy.exists(key);
+      const rootAsAny = this.root;
+      if (rootAsAny.diskCache.has(key)) return rootAsAny.diskCache.get(key) !== null;
+      const exists = strategy.exists(key);
+      if (!exists) rootAsAny.diskCache.set(key, null);
+      return exists;
     }
     let targetVerObj = null;
+    let nextVerObj = null;
     for (const v of versions) {
-      if (v.version <= snapshotVersion) {
-        targetVerObj = v;
-      } else {
+      if (v.version <= snapshotVersion) targetVerObj = v;
+      else {
+        nextVerObj = v;
         break;
       }
     }
-    if (!targetVerObj) return strategy.exists(key);
+    if (!targetVerObj) {
+      if (nextVerObj) {
+        const cached = this.deletedCache.get(key);
+        if (cached) {
+          const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
+          if (match) return true;
+        }
+      }
+      return false;
+    }
     return targetVerObj.exists;
   }
   _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 });
   }
@@ -909,7 +1061,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
   createNested() {
     if (this.committed) throw new Error("Transaction already committed");
     const childVersion = this.isRoot() ? this.version : this.snapshotVersion;
-    const child = new _AsyncMVCCTransaction(void 0, this, childVersion);
+    const child = new _AsyncMVCCTransaction(void 0, void 0, this, childVersion);
     this.root.activeTransactions.add(child);
     return child;
   }
@@ -917,31 +1069,72 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     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 _existsSnapshot(key, snapshotVersion, snapshotLocalVersion) {
+    if (this.writeBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return true;
+      }
+    }
+    if (this.deleteBuffer.has(key)) {
+      const keyModVersion = this.keyVersions.get(key);
+      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+        return false;
+      }
+    }
+    const history = this.bufferHistory.get(key);
+    if (history && snapshotLocalVersion !== void 0) {
+      for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].version <= snapshotLocalVersion) {
+          return history[i].exists;
+        }
+      }
+    }
+    if (this.parent) {
+      return this.parent._existsSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
+    } else {
+      return await this._diskExists(key, 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) {
+      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
         return this.writeBuffer.get(key);
       }
     }
     if (this.deleteBuffer.has(key)) {
       const keyModVersion = this.keyVersions.get(key);
-      if (snapshotLocalVersion === void 0 || keyModVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
+      if (snapshotLocalVersion === void 0 || keyModVersion <= snapshotLocalVersion) {
         return null;
       }
     }
+    const history = this.bufferHistory.get(key);
+    if (history && snapshotLocalVersion !== void 0) {
+      for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].version <= snapshotLocalVersion) {
+          return history[i].exists ? history[i].value : null;
+        }
+      }
+    }
     if (this.parent) {
       return this.parent._readSnapshot(key, snapshotVersion, this.snapshotLocalVersion);
     } else {
-      return this._diskRead(key, snapshotVersion);
+      return await this._diskRead(key, snapshotVersion);
     }
   }
   async commit(label) {
@@ -1002,6 +1195,7 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
         this.deletedValues.clear();
         this.originallyExisted.clear();
         this.keyVersions.clear();
+        this.bufferHistory.clear();
         this.localVersion = 0;
         this.snapshotVersion = this.version;
       }
@@ -1043,33 +1237,23 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
             };
           }
         }
-        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) {
@@ -1087,51 +1271,58 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
                 };
               }
             }
+            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, []);
@@ -1142,14 +1333,19 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return await strategy.exists(key) ? 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 {
+      if (v.version <= snapshotVersion) targetVerObj = v;
+      else {
         nextVerObj = v;
         break;
       }
@@ -1166,7 +1362,14 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     }
     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) {
@@ -1180,393 +1383,89 @@ var AsyncMVCCTransaction = class _AsyncMVCCTransaction extends MVCCTransaction {
     if (!strategy) throw new Error("Root Transaction missing strategy");
     const versions = this.versionIndex.get(key);
     if (!versions) {
-      return strategy.exists(key);
+      const rootAsAny = this.root;
+      if (rootAsAny.diskCache.has(key)) return rootAsAny.diskCache.get(key) !== null;
+      const exists = await strategy.exists(key);
+      if (!exists) rootAsAny.diskCache.set(key, null);
+      return exists;
     }
     let targetVerObj = null;
+    let nextVerObj = null;
     for (const v of versions) {
-      if (v.version <= snapshotVersion) {
-        targetVerObj = v;
-      } else {
+      if (v.version <= snapshotVersion) targetVerObj = v;
+      else {
+        nextVerObj = v;
         break;
       }
     }
-    if (!targetVerObj) return strategy.exists(key);
+    if (!targetVerObj) {
+      if (nextVerObj) {
+        const cached = this.deletedCache.get(key);
+        if (cached) {
+          const match = cached.find((c) => c.deletedAtVersion === nextVerObj.version);
+          if (match) return true;
+        }
+      }
+      return false;
+    }
     return targetVerObj.exists;
   }
   async _diskDelete(key, snapshotVersion) {
     const strategy = this.strategy;
     if (!strategy) throw new Error("Root Transaction missing strategy");
-    if (await strategy.exists(key)) {
-      const currentVal = await strategy.read(key);
+    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 });
   }
 };
 
-// node_modules/cache-entanglement/dist/esm/index.mjs
-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);
-  }
-};
-
-// src/base/BPTreeTransaction.ts
-var BPTreeTransaction = class _BPTreeTransaction {
-  _cachedRegexp;
-  nodes;
-  deletedNodeBuffer = /* @__PURE__ */ new Map();
-  rootTx;
-  mvccRoot;
-  mvcc;
-  strategy;
-  comparator;
-  option;
-  order;
-  rootId;
-  verifierMap = {
-    gt: (nv, v) => this.comparator.isHigher(nv, v),
-    gte: (nv, v) => this.comparator.isHigher(nv, v) || this.comparator.isSame(nv, v),
-    lt: (nv, v) => this.comparator.isLower(nv, v),
-    lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
-    equal: (nv, v) => this.comparator.isSame(nv, v),
-    notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
-    or: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isSame(nv, v2)),
-    primaryGt: (nv, v) => this.comparator.isPrimaryHigher(nv, v),
-    primaryGte: (nv, v) => this.comparator.isPrimaryHigher(nv, v) || this.comparator.isPrimarySame(nv, v),
-    primaryLt: (nv, v) => this.comparator.isPrimaryLower(nv, v),
-    primaryLte: (nv, v) => this.comparator.isPrimaryLower(nv, v) || this.comparator.isPrimarySame(nv, v),
-    primaryEqual: (nv, v) => this.comparator.isPrimarySame(nv, v),
-    primaryNotEqual: (nv, v) => this.comparator.isPrimarySame(nv, v) === false,
-    primaryOr: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isPrimarySame(nv, v2)),
-    like: (nv, v) => {
-      const nodeValue = this.comparator.match(nv);
-      const value = v;
-      const cache = this._cachedRegexp.cache(value);
-      const regexp = cache.raw;
-      return regexp.test(nodeValue);
+// src/base/BPTreeTransaction.ts
+var BPTreeTransaction = class _BPTreeTransaction {
+  _cachedRegexp = /* @__PURE__ */ new Map();
+  nodes = /* @__PURE__ */ new Map();
+  deletedNodeBuffer = /* @__PURE__ */ new Map();
+  rootTx;
+  mvccRoot;
+  mvcc;
+  strategy;
+  comparator;
+  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),
+    lt: (nv, v) => this.comparator.isLower(nv, v),
+    lte: (nv, v) => this.comparator.isLower(nv, v) || this.comparator.isSame(nv, v),
+    equal: (nv, v) => this.comparator.isSame(nv, v),
+    notEqual: (nv, v) => this.comparator.isSame(nv, v) === false,
+    or: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isSame(nv, v2)),
+    primaryGt: (nv, v) => this.comparator.isPrimaryHigher(nv, v),
+    primaryGte: (nv, v) => this.comparator.isPrimaryHigher(nv, v) || this.comparator.isPrimarySame(nv, v),
+    primaryLt: (nv, v) => this.comparator.isPrimaryLower(nv, v),
+    primaryLte: (nv, v) => this.comparator.isPrimaryLower(nv, v) || this.comparator.isPrimarySame(nv, v),
+    primaryEqual: (nv, v) => this.comparator.isPrimarySame(nv, v),
+    primaryNotEqual: (nv, v) => this.comparator.isPrimarySame(nv, v) === false,
+    primaryOr: (nv, v) => this.ensureValues(v).some((v2) => this.comparator.isPrimarySame(nv, v2)),
+    like: (nv, v) => {
+      const nodeValue = this.comparator.match(nv);
+      const value = v;
+      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);
     }
   };
   verifierStartNode = {
@@ -1737,6 +1636,9 @@ var BPTreeTransaction = class _BPTreeTransaction {
     }
     return true;
   }
+  _cloneNode(node) {
+    return JSON.parse(JSON.stringify(node));
+  }
   /**
    * Selects the best driver key from a condition object.
    * The driver key determines the starting point and traversal direction for queries.
@@ -1769,17 +1671,6 @@ var BPTreeTransaction = class _BPTreeTransaction {
     this.strategy = strategy;
     this.comparator = comparator;
     this.option = option ?? {};
-    this.nodes = new LRUMap(this.option.capacity ?? 1e3);
-    this._cachedRegexp = this._createCachedRegexp();
-  }
-  _createCachedRegexp() {
-    return new CacheEntanglementSync((key) => {
-      const pattern = key.replace(/%/g, ".*").replace(/_/g, ".");
-      const regexp = new RegExp(`^${pattern}$`, "i");
-      return regexp;
-    }, {
-      capacity: this.option.capacity ?? 1e3
-    });
   }
   ensureValues(v) {
     if (!Array.isArray(v)) {
@@ -1810,13 +1701,25 @@ var BPTreeTransaction = class _BPTreeTransaction {
   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;
@@ -1852,9 +1755,6 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     );
   }
   getNode(id) {
-    if (this.nodes.has(id)) {
-      return this.nodes.get(id);
-    }
     return this.mvcc.read(id);
   }
   /**
@@ -1872,23 +1772,22 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       prev
     };
     this.mvcc.create(id, node);
-    this.nodes.set(id, node);
     return node;
   }
   _updateNode(node) {
+    if (this.mvcc.isDeleted(node.id)) {
+      return;
+    }
     this.mvcc.write(node.id, node);
-    this.nodes.set(node.id, node);
   }
   _deleteNode(node) {
+    if (this.mvcc.isDeleted(node.id)) {
+      return;
+    }
     this.mvcc.delete(node.id);
-    this.nodes.delete(node.id);
   }
   _readHead() {
-    if (this.nodes.has("__HEAD__")) {
-      return this.nodes.get("__HEAD__") ?? null;
-    }
-    const head = this.mvcc.read("__HEAD__");
-    return head ?? null;
+    return this.mvcc.read("__HEAD__");
   }
   _writeHead(head) {
     if (!this.mvcc.exists("__HEAD__")) {
@@ -1896,41 +1795,45 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     } else {
       this.mvcc.write("__HEAD__", head);
     }
-    this.nodes.set("__HEAD__", head);
     this.rootId = head.root;
   }
   _insertAtLeaf(node, key, value) {
-    if (node.values.length) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
+    let leaf = node;
+    leaf = this._cloneNode(leaf);
+    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;
+          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.values.splice(i, 0, value);
+          leaf.keys.splice(i, 0, [key]);
+          this._updateNode(leaf);
+          return leaf;
+        } else if (i + 1 === leaf.values.length) {
+          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.values = [value];
+      leaf.keys = [[key]];
+      this._updateNode(leaf);
+      return leaf;
     }
+    return leaf;
   }
   _insertInParent(node, value, pointer) {
+    node = this._cloneNode(node);
+    pointer = this._cloneNode(pointer);
     if (this.rootId === node.id) {
       const root = this._createNode(false, [node.id, pointer.id], [value]);
       this.rootId = root.id;
@@ -1949,7 +1852,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       this._updateNode(pointer);
       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}`);
@@ -1965,7 +1868,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       leftSibling.next = pointer.id;
       this._updateNode(leftSibling);
       if (oldNextId) {
-        const oldNext = this.getNode(oldNextId);
+        const oldNext = this._cloneNode(this.getNode(oldNextId));
         oldNext.prev = pointer.id;
         this._updateNode(oldNext);
       }
@@ -1982,12 +1885,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
       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);
+        const n = this._cloneNode(this.getNode(k));
         n.parent = parentPointer.id;
         this._updateNode(n);
       }
@@ -2122,28 +2025,46 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
   }
   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._writeHead({
+          root,
+          order: this.order,
+          data: this.strategy.head.data
+        });
+      }
+      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) {
@@ -2157,21 +2078,6 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     }
     return false;
   }
-  forceUpdate(id) {
-    if (id) {
-      this.nodes.delete(id);
-      this.getNode(id);
-      return 1;
-    }
-    const keys = Array.from(this.nodes.keys());
-    for (const key of keys) {
-      this.nodes.delete(key);
-    }
-    for (const key of keys) {
-      this.getNode(key);
-    }
-    return keys.length;
-  }
   get(key) {
     let node = this.leftestNode();
     while (true) {
@@ -2257,10 +2163,10 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     return map;
   }
   insert(key, value) {
-    const before = this.insertableNode(value);
-    this._insertAtLeaf(before, key, value);
+    let before = this.insertableNode(value);
+    before = this._insertAtLeaf(before, key, value);
     if (before.values.length === this.order) {
-      const after = this._createNode(
+      let after = this._createNode(
         true,
         [],
         [],
@@ -2269,14 +2175,18 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         null
       );
       const mid = Math.ceil(this.order / 2) - 1;
+      after = this._cloneNode(after);
       after.values = before.values.slice(mid + 1);
       after.keys = before.keys.slice(mid + 1);
       before.values = before.values.slice(0, mid + 1);
       before.keys = before.keys.slice(0, mid + 1);
+      this._updateNode(before);
+      this._updateNode(after);
       this._insertInParent(before, after.values[0], after);
     }
   }
   _deleteEntry(node, key) {
+    node = this._cloneNode(node);
     if (!node.leaf) {
       let keyIndex = -1;
       for (let i = 0, len = node.keys.length; i < len; i++) {
@@ -2295,7 +2205,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
       this._deleteNode(node);
-      const newRoot = this.getNode(keys[0]);
+      const newRoot = this._cloneNode(this.getNode(keys[0]));
       newRoot.parent = null;
       this._updateNode(newRoot);
       this._writeHead({
@@ -2303,17 +2213,17 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         order: this.order,
         data: this.strategy.head.data
       });
-      return;
+      return node;
     } else if (this.rootId === node.id) {
       this._writeHead({
         root: node.id,
         order: this.order,
         data: this.strategy.head.data
       });
-      return;
+      return node;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
-        return;
+        return node;
       }
       let isPredecessor = false;
       let parentNode = this.getNode(node.parent);
@@ -2325,11 +2235,11 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         const nKey = parentNode.keys[i];
         if (nKey === node.id) {
           if (i > 0) {
-            prevNode = this.getNode(parentNode.keys[i - 1]);
+            prevNode = this._cloneNode(this.getNode(parentNode.keys[i - 1]));
             prevValue = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = this.getNode(parentNode.keys[i + 1]);
+            nextNode = this._cloneNode(this.getNode(parentNode.keys[i + 1]));
             postValue = parentNode.values[i];
           }
         }
@@ -2354,7 +2264,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         }
       }
       if (!pointer) {
-        return;
+        return node;
       }
       if (node.values.length + pointer.values.length < this.order) {
         if (!isPredecessor) {
@@ -2368,7 +2278,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         } else {
           pointer.next = node.next;
           if (pointer.next) {
-            const n = this.getNode(pointer.next);
+            const n = this._cloneNode(this.getNode(pointer.next));
             n.prev = pointer.id;
             this._updateNode(n);
           }
@@ -2377,14 +2287,14 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
-            const node2 = this.getNode(key2);
+            const node2 = this._cloneNode(this.getNode(key2));
             node2.parent = pointer.id;
             this._updateNode(node2);
           }
         }
         this._deleteNode(node);
         this._updateNode(pointer);
-        this._deleteEntry(this.getNode(node.parent), node.id);
+        this._deleteEntry(this._cloneNode(this.getNode(node.parent)), node.id);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -2394,7 +2304,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
             pointerKm = pointer.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;
@@ -2405,7 +2315,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
             pointerKm = pointer.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;
@@ -2422,7 +2332,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
             pointerK0 = pointer.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
-            parentNode = this.getNode(node.parent);
+            parentNode = this._cloneNode(this.getNode(node.parent));
             const pointerIndex = parentNode.keys.indexOf(pointer.id);
             if (pointerIndex > 0) {
               parentNode.values[pointerIndex - 1] = pointerK0;
@@ -2433,7 +2343,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
             pointerK0 = pointer.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
-            parentNode = this.getNode(node.parent);
+            parentNode = this._cloneNode(this.getNode(node.parent));
             const pointerIndex = parentNode.keys.indexOf(pointer.id);
             if (pointerIndex > 0) {
               parentNode.values[pointerIndex - 1] = pointer.values[0];
@@ -2445,21 +2355,21 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
         }
         if (!pointer.leaf) {
           for (const key2 of pointer.keys) {
-            const n = this.getNode(key2);
+            const n = this._cloneNode(this.getNode(key2));
             n.parent = pointer.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);
           }
@@ -2468,10 +2378,12 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     } else {
       this._updateNode(node);
     }
+    return node;
   }
   delete(key, value) {
     let node = this.insertableNodeByPrimary(value);
     let found = false;
+    node = this._cloneNode(node);
     while (true) {
       let i = node.values.length;
       while (i--) {
@@ -2486,7 +2398,7 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
               node.values.splice(i, 1);
             }
             this._updateNode(node);
-            this._deleteEntry(node, key);
+            node = this._deleteEntry(node, key);
             found = true;
             break;
           }
@@ -2521,20 +2433,14 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   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;
+      const isRootTx = this.rootTx !== this;
+      if (isRootTx) {
+        result = this.rootTx.commit(label);
+        if (result.success) {
+          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;
@@ -2582,7 +2488,9 @@ var BPTreeMVCCStrategySync = class extends SyncMVCCStrategy {
 // src/BPTreeSync.ts
 var BPTreeSync = class extends BPTreeSyncTransaction {
   constructor(strategy, comparator, option) {
-    const mvccRoot = new SyncMVCCTransaction(new BPTreeMVCCStrategySync(strategy));
+    const mvccRoot = new SyncMVCCTransaction(new BPTreeMVCCStrategySync(strategy), {
+      cacheCapacity: option?.capacity ?? void 0
+    });
     super(
       null,
       mvccRoot,
@@ -2606,7 +2514,7 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       this.comparator,
       this.option
     );
-    tx.init();
+    tx._initInternal();
     return tx;
   }
   insert(key, value) {
@@ -2616,7 +2524,6 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
     if (!result.success) {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
-    this.rootId = tx.getRootId();
   }
   delete(key, value) {
     const tx = this.createTransaction();
@@ -2625,394 +2532,673 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
     if (!result.success) {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
-    this.rootId = tx.getRootId();
   }
 };
 
-// src/transaction/BPTreeAsyncTransaction.ts
-var BPTreeAsyncTransaction = class extends BPTreeTransaction {
-  constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
-    super(
-      rootTx,
-      mvccRoot,
-      mvcc,
-      strategy,
-      comparator,
-      option
-    );
+// node_modules/ryoiki/dist/esm/index.mjs
+var Ryoiki2 = class _Ryoiki2 {
+  readings;
+  writings;
+  readQueue;
+  writeQueue;
+  static async CatchError(promise) {
+    return await promise.then((v) => [void 0, v]).catch((err) => [err]);
   }
-  async getNode(id) {
-    if (this.nodes.has(id)) {
-      return this.nodes.get(id);
+  static IsRangeOverlap(a, b) {
+    const [start1, end1] = a;
+    const [start2, end2] = b;
+    if (end1 <= start2 || end2 <= start1) {
+      return false;
     }
-    return await this.mvcc.read(id);
+    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).`);
   }
   /**
-   * Create a new node with a unique ID.
+   * Constructs a new instance of the Ryoiki class.
    */
-  async _createNode(leaf, keys, values, parent = null, next = null, prev = null) {
-    const id = await this.strategy.id(leaf);
-    const node = {
-      id,
-      keys,
-      values,
-      leaf,
-      parent,
-      next,
-      prev
-    };
-    await this.mvcc.create(id, node);
-    this.nodes.set(id, node);
-    return node;
+  constructor() {
+    this.readings = /* @__PURE__ */ new Map();
+    this.writings = /* @__PURE__ */ new Map();
+    this.readQueue = /* @__PURE__ */ new Map();
+    this.writeQueue = /* @__PURE__ */ new Map();
   }
-  async _updateNode(node) {
-    await this.mvcc.write(node.id, node);
-    this.nodes.set(node.id, node);
+  /**
+   * 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];
   }
-  async _deleteNode(node) {
-    await this.mvcc.delete(node.id);
-    this.nodes.delete(node.id);
+  rangeOverlapping(tasks, range) {
+    return Array.from(tasks.values()).some((t) => _Ryoiki2.IsRangeOverlap(t.range, range));
   }
-  async _readHead() {
-    if (this.nodes.has("__HEAD__")) {
-      return this.nodes.get("__HEAD__") ?? null;
-    }
-    const head = await this.mvcc.read("__HEAD__");
-    return head ?? null;
+  isSameRange(a, b) {
+    const [a1, a2] = a;
+    const [b1, b2] = b;
+    return a1 === b1 && a2 === b2;
   }
-  async _writeHead(head) {
-    if (!await this.mvcc.exists("__HEAD__")) {
-      await this.mvcc.create("__HEAD__", head);
-    } else {
-      await this.mvcc.write("__HEAD__", head);
+  fetchUnitAndRun(queue, workspaces) {
+    for (const [id, unit] of queue) {
+      if (!unit.condition()) {
+        continue;
+      }
+      this._alloc(queue, workspaces, id);
     }
-    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];
-        if (this.comparator.isSame(value, nValue)) {
-          const keys = node.keys[i];
-          if (keys.includes(key)) {
-            break;
-          }
-          keys.push(key);
-          await this._updateNode(node);
-          return;
-        } 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;
-        }
-      }
-    } else {
-      node.values = [value];
-      node.keys = [[key]];
-      await this._updateNode(node);
-      return;
-    }
-  }
-  async _insertInParent(node, value, pointer) {
-    if (this.rootId === node.id) {
-      const root = await this._createNode(false, [node.id, pointer.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;
-      }
-      await this._writeHead({
-        root: root.id,
-        order: this.order,
-        data: this.strategy.head.data
-      });
-      await this._updateNode(node);
-      await this._updateNode(pointer);
-      return;
-    }
-    const parentNode = 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;
-      const oldNextId = leftSibling.next;
-      pointer.prev = leftSibling.id;
-      pointer.next = oldNextId;
-      leftSibling.next = pointer.id;
-      await this._updateNode(leftSibling);
-      if (oldNextId) {
-        const oldNext = await this.getNode(oldNextId);
-        oldNext.prev = pointer.id;
-        await this._updateNode(oldNext);
-      }
-    }
-    await this._updateNode(parentNode);
-    await this._updateNode(pointer);
-    if (parentNode.keys.length > this.order) {
-      const parentPointer = await this._createNode(false, [], []);
-      parentPointer.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);
-      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);
-        n.parent = parentNode.id;
-        await this._updateNode(n);
-      }
-      for (const k of parentPointer.keys) {
-        const n = await this.getNode(k);
-        n.parent = parentPointer.id;
-        await this._updateNode(n);
+  _handleOverload(args, handlers, argPatterns) {
+    for (const [key, pattern] of Object.entries(argPatterns)) {
+      if (this._matchArgs(args, pattern)) {
+        return handlers[key](...args);
       }
-      await this._updateNode(parentNode);
-      await this._insertInParent(parentNode, midValue, parentPointer);
-    }
-  }
-  async insertableNode(value) {
-    let node = await this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, false, true);
-      node = await this.getNode(node.keys[index]);
-    }
-    return node;
-  }
-  async insertableNodeByPrimary(value) {
-    let node = await this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, true, false);
-      node = await this.getNode(node.keys[index]);
-    }
-    return node;
-  }
-  async insertableRightestNodeByPrimary(value) {
-    let node = await this.getNode(this.rootId);
-    while (!node.leaf) {
-      const { index } = this._binarySearchValues(node.values, value, true, true);
-      node = await this.getNode(node.keys[index]);
     }
-    return node;
+    throw new Error("Invalid arguments");
   }
-  async insertableRightestEndNodeByPrimary(value) {
-    const node = await this.insertableRightestNodeByPrimary(value);
-    if (!node.next) {
-      return null;
-    }
-    return await this.getNode(node.next);
+  _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 insertableEndNode(value, direction) {
-    const insertableNode = await this.insertableNode(value);
-    let key;
-    switch (direction) {
-      case -1:
-        key = "prev";
-        break;
-      case 1:
-        key = "next";
-        break;
-      default:
-        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
-    }
-    const guessNode = insertableNode[key];
-    if (!guessNode) {
-      return null;
-    }
-    return await this.getNode(guessNode);
+  _createRandomId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2);
+    return `${timestamp}${random}`;
   }
-  async leftestNode() {
-    let node = await this.getNode(this.rootId);
-    if (node === null) {
-      debugger;
-    }
-    while (!node.leaf) {
-      const keys = node.keys;
-      node = await this.getNode(keys[0]);
+  _alloc(queue, workspaces, lockId) {
+    const unit = queue.get(lockId);
+    if (!unit) {
+      throw _Ryoiki2.ERR_NOT_EXISTS(lockId);
     }
-    return node;
+    workspaces.set(lockId, unit);
+    queue.delete(lockId);
+    unit.alloc();
   }
-  async rightestNode() {
-    let node = await this.getNode(this.rootId);
-    while (!node.leaf) {
-      const keys = node.keys;
-      node = await this.getNode(keys[keys.length - 1]);
+  _free(workspaces, lockId) {
+    const unit = workspaces.get(lockId);
+    if (!unit) {
+      throw _Ryoiki2.ERR_NOT_EXISTS(lockId);
     }
-    return node;
+    workspaces.delete(lockId);
+    unit.free();
   }
-  async *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
-    let node = startNode;
-    let done = false;
-    let hasMatched = false;
-    let nextNodePromise = null;
-    while (!done) {
-      if (endNode && node.id === endNode.id) {
-        done = true;
-        break;
-      }
-      if (direction === 1) {
-        if (node.next && !done) {
-          nextNodePromise = this.getNode(node.next);
-        }
-      } else {
-        if (node.prev && !done) {
-          nextNodePromise = this.getNode(node.prev);
-        }
+  _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 len = node.values.length;
-      if (direction === 1) {
-        for (let i = 0; i < len; i++) {
-          const nValue = node.values[i];
-          const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            for (let j = 0; j < keys.length; j++) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
-          }
-        }
-      } else {
-        let i = len;
-        while (i--) {
-          const nValue = node.values[i];
-          const keys = node.keys[i];
-          if (comparator(nValue, value)) {
-            hasMatched = true;
-            let j = keys.length;
-            while (j--) {
-              yield [keys[j], nValue];
-            }
-          } else if (earlyTerminate && hasMatched) {
-            done = true;
-            break;
-          }
+      const id = this._createRandomId();
+      const alloc = async () => {
+        if (timeoutId !== null) {
+          clearTimeout(timeoutId);
         }
-      }
-      if (done) {
-        if (nextNodePromise) await nextNodePromise;
+        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;
       }
-      if (nextNodePromise) {
-        node = await nextNodePromise;
-        nextNodePromise = null;
-      } else {
-        done = true;
-      }
     }
+    return isLocked;
   }
-  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;
+  /**
+   * 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;
+  }
+  /**
+   * 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)
+    );
+  }
+  /**
+   * 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]
+      }
+    );
+    return this._lock(
+      this.writeQueue,
+      range,
+      timeout,
+      task,
+      () => {
+        return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+      }
+    );
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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);
+  }
+};
+
+// src/transaction/BPTreeAsyncTransaction.ts
+var BPTreeAsyncTransaction = class extends BPTreeTransaction {
+  lock;
+  constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
+    super(
+      rootTx,
+      mvccRoot,
+      mvcc,
+      strategy,
+      comparator,
+      option
+    );
+    this.lock = new Ryoiki2();
+  }
+  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) {
+    return await this.mvcc.read(id);
+  }
+  /**
+   * Create a new node with a unique ID.
+   */
+  async _createNode(leaf, keys, values, parent = null, next = null, prev = null) {
+    const id = await this.strategy.id(leaf);
+    const node = {
+      id,
+      keys,
+      values,
+      leaf,
+      parent,
+      next,
+      prev
+    };
+    const head = await this._readHead();
+    if (head) {
       await this._writeHead({
-        root,
-        order: this.order,
+        root: head.root,
+        order: head.order,
         data: this.strategy.head.data
       });
     }
-    if (this.order < 3) {
-      throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
-    }
+    await this.mvcc.create(id, node);
+    return node;
   }
-  async exists(key, value) {
-    const node = await this.insertableNode(value);
-    const { index, found } = this._binarySearchValues(node.values, value);
-    if (found) {
-      const keys = node.keys[index];
-      if (keys.includes(key)) {
-        return true;
-      }
+  async _updateNode(node) {
+    if (this.mvcc.isDeleted(node.id)) {
+      return;
     }
-    return false;
+    await this.mvcc.write(node.id, this._cloneNode(node));
   }
-  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);
+  async _deleteNode(node) {
+    if (this.mvcc.isDeleted(node.id)) {
+      return;
     }
-    for (const key of keys) {
-      await this.getNode(key);
+    await this.mvcc.delete(node.id);
+  }
+  async _readHead() {
+    return await this.mvcc.read("__HEAD__");
+  }
+  async _writeHead(head) {
+    if (!await this.mvcc.exists("__HEAD__")) {
+      await this.mvcc.create("__HEAD__", this._cloneNode(head));
+    } else {
+      await this.mvcc.write("__HEAD__", this._cloneNode(head));
     }
-    return keys.length;
+    this.rootId = head.root;
   }
-  async get(key) {
-    let node = await this.leftestNode();
-    while (true) {
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const keys = node.keys[i];
-        for (let j = 0, kLen = keys.length; j < kLen; j++) {
-          if (keys[j] === key) {
-            return node.values[i];
+  async _insertAtLeaf(node, key, value) {
+    let leaf = node;
+    leaf = this._cloneNode(leaf);
+    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 = leaf.keys[i];
+          if (keys.includes(key)) {
+            break;
           }
+          keys.push(key);
+          await this._updateNode(leaf);
+          return leaf;
+        } else if (this.comparator.isLower(value, nValue)) {
+          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.values.push(value);
+          leaf.keys.push([key]);
+          await this._updateNode(leaf);
+          return leaf;
         }
       }
-      if (!node.next) break;
-      node = await this.getNode(node.next);
+    } else {
+      leaf.values = [value];
+      leaf.keys = [[key]];
+      await this._updateNode(leaf);
+      return leaf;
     }
-    return void 0;
+    return leaf;
   }
-  async *keysStream(condition, filterValues, limit, order = "asc") {
-    const stream = this.whereStream(condition, limit, order);
-    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
-    for await (const [key] of stream) {
-      if (intersection && !intersection.has(key)) {
-        continue;
+  async _insertInParent(node, value, pointer) {
+    node = this._cloneNode(node);
+    pointer = this._cloneNode(pointer);
+    if (this.rootId === node.id) {
+      const root = await this._createNode(false, [node.id, pointer.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;
       }
-      yield key;
+      await this._writeHead({
+        root: root.id,
+        order: this.order,
+        data: this.strategy.head.data
+      });
+      await this._updateNode(node);
+      await this._updateNode(pointer);
+      return;
     }
-  }
-  async *whereStream(condition, limit, order = "asc") {
-    const driverKey = this.getDriverKey(condition);
-    if (!driverKey) return;
-    const value = condition[driverKey];
-    let startNode = await this.verifierStartNode[driverKey](value);
-    let endNode = await this.verifierEndNode[driverKey](value);
-    let direction = this.verifierDirection[driverKey];
-    const comparator = this.verifierMap[driverKey];
-    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
-    if (order === "desc") {
-      startNode = endNode ?? await this.rightestNode();
-      endNode = null;
-      direction *= -1;
+    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}`);
     }
-    const generator = this.getPairsGenerator(
-      value,
-      startNode,
-      endNode,
-      comparator,
+    parentNode.values.splice(nodeIndex, 0, value);
+    parentNode.keys.splice(nodeIndex + 1, 0, pointer.id);
+    pointer.parent = parentNode.id;
+    if (pointer.leaf) {
+      const leftSibling = node;
+      const oldNextId = leftSibling.next;
+      pointer.prev = leftSibling.id;
+      pointer.next = oldNextId;
+      leftSibling.next = pointer.id;
+      await this._updateNode(leftSibling);
+      if (oldNextId) {
+        const oldNext = this._cloneNode(await this.getNode(oldNextId));
+        oldNext.prev = pointer.id;
+        await this._updateNode(oldNext);
+      }
+    }
+    await this._updateNode(parentNode);
+    await this._updateNode(pointer);
+    if (parentNode.keys.length > this.order) {
+      const parentPointer = await this._createNode(false, [], []);
+      parentPointer.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);
+      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._cloneNode(await this.getNode(k));
+        n.parent = parentNode.id;
+        await this._updateNode(n);
+      }
+      for (const k of parentPointer.keys) {
+        const n = this._cloneNode(await this.getNode(k));
+        n.parent = parentPointer.id;
+        await this._updateNode(n);
+      }
+      await this._updateNode(parentNode);
+      await this._insertInParent(parentNode, midValue, parentPointer);
+    }
+  }
+  async insertableNode(value) {
+    let node = await this.getNode(this.rootId);
+    while (!node.leaf) {
+      const { index } = this._binarySearchValues(node.values, value, false, true);
+      node = await this.getNode(node.keys[index]);
+    }
+    return node;
+  }
+  async insertableNodeByPrimary(value) {
+    let node = await this.getNode(this.rootId);
+    while (!node.leaf) {
+      const { index } = this._binarySearchValues(node.values, value, true, false);
+      node = await this.getNode(node.keys[index]);
+    }
+    return node;
+  }
+  async insertableRightestNodeByPrimary(value) {
+    let node = await this.getNode(this.rootId);
+    while (!node.leaf) {
+      const { index } = this._binarySearchValues(node.values, value, true, true);
+      node = await this.getNode(node.keys[index]);
+    }
+    return node;
+  }
+  async insertableRightestEndNodeByPrimary(value) {
+    const node = await this.insertableRightestNodeByPrimary(value);
+    if (!node.next) {
+      return null;
+    }
+    return await this.getNode(node.next);
+  }
+  async insertableEndNode(value, direction) {
+    const insertableNode = await this.insertableNode(value);
+    let key;
+    switch (direction) {
+      case -1:
+        key = "prev";
+        break;
+      case 1:
+        key = "next";
+        break;
+      default:
+        throw new Error(`Direction must be -1 or 1. but got a ${direction}`);
+    }
+    const guessNode = insertableNode[key];
+    if (!guessNode) {
+      return null;
+    }
+    return await this.getNode(guessNode);
+  }
+  async leftestNode() {
+    let node = await this.getNode(this.rootId);
+    if (node === null) {
+      debugger;
+    }
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = await this.getNode(keys[0]);
+    }
+    return node;
+  }
+  async rightestNode() {
+    let node = await this.getNode(this.rootId);
+    while (!node.leaf) {
+      const keys = node.keys;
+      node = await this.getNode(keys[keys.length - 1]);
+    }
+    return node;
+  }
+  async *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
+    let node = startNode;
+    let done = false;
+    let hasMatched = false;
+    let nextNodePromise = null;
+    while (!done) {
+      if (endNode && node.id === endNode.id) {
+        done = true;
+        break;
+      }
+      if (direction === 1) {
+        if (node.next && !done) {
+          nextNodePromise = this.getNode(node.next);
+        }
+      } else {
+        if (node.prev && !done) {
+          nextNodePromise = this.getNode(node.prev);
+        }
+      }
+      const len = node.values.length;
+      if (direction === 1) {
+        for (let i = 0; i < len; i++) {
+          const nValue = node.values[i];
+          const keys = node.keys[i];
+          if (comparator(nValue, value)) {
+            hasMatched = true;
+            for (let j = 0; j < keys.length; j++) {
+              yield [keys[j], nValue];
+            }
+          } else if (earlyTerminate && hasMatched) {
+            done = true;
+            break;
+          }
+        }
+      } else {
+        let i = len;
+        while (i--) {
+          const nValue = node.values[i];
+          const keys = node.keys[i];
+          if (comparator(nValue, value)) {
+            hasMatched = true;
+            let j = keys.length;
+            while (j--) {
+              yield [keys[j], nValue];
+            }
+          } else if (earlyTerminate && hasMatched) {
+            done = true;
+            break;
+          }
+        }
+      }
+      if (done) {
+        if (nextNodePromise) await nextNodePromise;
+        break;
+      }
+      if (nextNodePromise) {
+        node = await nextNodePromise;
+        nextNodePromise = null;
+      } else {
+        done = true;
+      }
+    }
+  }
+  async init() {
+    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");
+    }
+    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;
+        await this._writeHead({
+          root,
+          order: this.order,
+          data: this.strategy.head.data
+        });
+      }
+      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) {
+    const node = await this.insertableNode(value);
+    const { index, found } = this._binarySearchValues(node.values, value);
+    if (found) {
+      const keys = node.keys[index];
+      if (keys.includes(key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async get(key) {
+    let node = await this.leftestNode();
+    while (true) {
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const keys = node.keys[i];
+        for (let j = 0, kLen = keys.length; j < kLen; j++) {
+          if (keys[j] === key) {
+            return node.values[i];
+          }
+        }
+      }
+      if (!node.next) break;
+      node = await this.getNode(node.next);
+    }
+    return void 0;
+  }
+  async *keysStream(condition, filterValues, limit, order = "asc") {
+    const stream = this.whereStream(condition, limit, order);
+    const intersection = filterValues && filterValues.size > 0 ? filterValues : null;
+    for await (const [key] of stream) {
+      if (intersection && !intersection.has(key)) {
+        continue;
+      }
+      yield key;
+    }
+  }
+  async *whereStream(condition, limit, order = "asc") {
+    const driverKey = this.getDriverKey(condition);
+    if (!driverKey) return;
+    const value = condition[driverKey];
+    let startNode = await this.verifierStartNode[driverKey](value);
+    let endNode = await this.verifierEndNode[driverKey](value);
+    let direction = this.verifierDirection[driverKey];
+    const comparator = this.verifierMap[driverKey];
+    const earlyTerminate = this.verifierEarlyTerminate[driverKey];
+    if (order === "desc") {
+      startNode = endNode ?? await this.rightestNode();
+      endNode = null;
+      direction *= -1;
+    }
+    const generator = this.getPairsGenerator(
+      value,
+      startNode,
+      endNode,
+      comparator,
       direction,
       earlyTerminate
     );
@@ -3053,26 +3239,32 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     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);
-    }
+    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) {
+    node = this._cloneNode(node);
     if (!node.leaf) {
       let keyIndex = -1;
       for (let i = 0, len = node.keys.length; i < len; i++) {
@@ -3091,7 +3283,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
       this._deleteNode(node);
-      const newRoot = await this.getNode(keys[0]);
+      const newRoot = this._cloneNode(await this.getNode(keys[0]));
       newRoot.parent = null;
       await this._updateNode(newRoot);
       await this._writeHead({
@@ -3099,14 +3291,17 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         order: this.order,
         data: this.strategy.head.data
       });
-      return;
+      return node;
     } else if (this.rootId === node.id) {
-      const root = await this.getNode(this.rootId);
-      await this._updateNode(root);
-      return;
+      await this._writeHead({
+        root: node.id,
+        order: this.order,
+        data: this.strategy.head.data
+      });
+      return node;
     } else if (node.keys.length < Math.ceil(this.order / 2) && !node.leaf || node.values.length < Math.ceil((this.order - 1) / 2) && node.leaf) {
       if (node.parent === null) {
-        return;
+        return node;
       }
       let isPredecessor = false;
       let parentNode = await this.getNode(node.parent);
@@ -3118,11 +3313,11 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         const nKey = parentNode.keys[i];
         if (nKey === node.id) {
           if (i > 0) {
-            prevNode = await this.getNode(parentNode.keys[i - 1]);
+            prevNode = this._cloneNode(await this.getNode(parentNode.keys[i - 1]));
             prevValue = parentNode.values[i - 1];
           }
           if (i < parentNode.keys.length - 1) {
-            nextNode = await this.getNode(parentNode.keys[i + 1]);
+            nextNode = this._cloneNode(await this.getNode(parentNode.keys[i + 1]));
             postValue = parentNode.values[i];
           }
         }
@@ -3147,7 +3342,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         }
       }
       if (!pointer) {
-        return;
+        return node;
       }
       if (node.values.length + pointer.values.length < this.order) {
         if (!isPredecessor) {
@@ -3161,7 +3356,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         } else {
           pointer.next = node.next;
           if (pointer.next) {
-            const n = await this.getNode(pointer.next);
+            const n = this._cloneNode(await this.getNode(pointer.next));
             n.prev = pointer.id;
             await this._updateNode(n);
           }
@@ -3170,14 +3365,14 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
-            const node2 = await this.getNode(key2);
+            const node2 = this._cloneNode(await this.getNode(key2));
             node2.parent = pointer.id;
             await this._updateNode(node2);
           }
         }
         this._deleteNode(node);
         await this._updateNode(pointer);
-        await this._deleteEntry(await this.getNode(node.parent), node.id);
+        await this._deleteEntry(this._cloneNode(await this.getNode(node.parent)), node.id);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -3187,7 +3382,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
             pointerKm = pointer.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;
@@ -3198,7 +3393,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
             pointerKm = pointer.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;
@@ -3215,7 +3410,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
             pointerK0 = pointer.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
-            parentNode = await this.getNode(node.parent);
+            parentNode = this._cloneNode(await this.getNode(node.parent));
             const pointerIndex = parentNode.keys.indexOf(pointer.id);
             if (pointerIndex > 0) {
               parentNode.values[pointerIndex - 1] = pointerK0;
@@ -3226,7 +3421,7 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
             pointerK0 = pointer.values.splice(0, 1)[0];
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
-            parentNode = await this.getNode(node.parent);
+            parentNode = this._cloneNode(await this.getNode(node.parent));
             const pointerIndex = parentNode.keys.indexOf(pointer.id);
             if (pointerIndex > 0) {
               parentNode.values[pointerIndex - 1] = pointer.values[0];
@@ -3238,21 +3433,21 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
         }
         if (!pointer.leaf) {
           for (const key2 of pointer.keys) {
-            const n = await this.getNode(key2);
+            const n = this._cloneNode(await this.getNode(key2));
             n.parent = pointer.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);
           }
@@ -3261,37 +3456,42 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
     } else {
       await this._updateNode(node);
     }
+    await this._updateNode(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 () => {
+      let node = await this.insertableNodeByPrimary(value);
+      let found = false;
+      node = this._cloneNode(node);
+      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);
+              }
+              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();
@@ -3302,447 +3502,185 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
   }
   async setHeadData(data) {
     const head = await this._readHead();
-    if (head === null) {
-      throw new Error("Head not found");
-    }
-    await this._writeHead({
-      root: head.root,
-      order: head.order,
-      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();
-  }
-};
-
-// src/transaction/BPTreeMVCCStrategyAsync.ts
-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;
-    }
-  }
-};
-
-// src/BPTreeAsync.ts
-var BPTreeAsync = class extends BPTreeAsyncTransaction {
-  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 BPTreeAsyncTransaction(
-      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();
-  }
-};
-
-// src/base/SerializeStrategy.ts
-var SerializeStrategy = class {
-  order;
-  head;
-  constructor(order) {
-    this.order = order;
-    this.head = {
-      order,
-      root: null,
-      data: {}
-    };
-  }
-};
-
-// src/SerializeStrategySync.ts
-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;
-  }
-};
-
-// node_modules/ryoiki/dist/esm/index.mjs
-var Ryoiki2 = 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();
+    if (head === null) {
+      throw new Error("Head not found");
+    }
+    await this._writeHead({
+      root: head.root,
+      order: head.order,
+      data
     });
   }
-  _checkWorking(range, workspaces) {
-    let isLocked = false;
-    for (const lock of workspaces.values()) {
-      if (_Ryoiki2.IsRangeOverlap(range, lock.range)) {
-        isLocked = true;
-        break;
+  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;
+        }
       }
     }
-    return isLocked;
+    return result;
   }
-  /**
-   * 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);
+  async rollback() {
+    return this.mvcc.rollback();
   }
-  /**
-   * 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);
+};
+
+// src/transaction/BPTreeMVCCStrategyAsync.ts
+var BPTreeMVCCStrategyAsync = class extends AsyncMVCCStrategy {
+  constructor(strategy) {
+    super();
+    this.strategy = strategy;
   }
-  /**
-   * 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;
+  async read(key) {
+    if (key === "__HEAD__") {
+      return await this.strategy.readHead();
+    }
+    return await this.strategy.read(key);
   }
-  /**
-   * 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;
+  async write(key, value) {
+    if (key === "__HEAD__") {
+      await this.strategy.writeHead(value);
+    } else {
+      await this.strategy.write(key, value);
+    }
   }
-  /**
-   * 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)
+  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;
+    }
+  }
+};
+
+// src/BPTreeAsync.ts
+var BPTreeAsync = class extends BPTreeAsyncTransaction {
+  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 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.
+   * Creates a new asynchronous transaction.
+   * @returns A new BPTreeAsyncTransaction.
    */
-  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 createTransaction() {
+    const nestedTx = this.mvcc.createNested();
+    const tx = new BPTreeAsyncTransaction(
+      this,
+      this.mvcc,
+      nestedTx,
+      this.strategy,
+      this.comparator,
+      this.option
     );
-    return this._lock(
-      this.writeQueue,
-      range,
-      timeout,
-      task,
-      () => {
-        return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+    await tx._initInternal();
+    return tx;
+  }
+  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"}`);
       }
-    );
+    });
   }
-  /**
-   * 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);
+  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"}`);
+      }
+    });
   }
-  /**
-   * 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);
+};
+
+// src/base/SerializeStrategy.ts
+var SerializeStrategy = class {
+  order;
+  head;
+  constructor(order) {
+    this.order = order;
+    this.head = {
+      order,
+      root: null,
+      data: {}
+    };
+  }
+};
+
+// src/SerializeStrategySync.ts
+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;
   }
 };