serializable-bptree 6.2.3 → 7.0.1

package/dist/cjs/index.cjs

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   BPTreeAsync: () => BPTreeAsync,
+  BPTreeAsyncTransaction: () => BPTreeAsyncTransaction,
   BPTreeSync: () => BPTreeSync,
+  BPTreeSyncTransaction: () => BPTreeSyncTransaction,
   InMemoryStoreStrategyAsync: () => InMemoryStoreStrategyAsync,
   InMemoryStoreStrategySync: () => InMemoryStoreStrategySync,
   NumericComparator: () => NumericComparator,
@@ -473,6 +475,20 @@ var BPTree = class _BPTree {
   option;
   order;
   rootId;
+  /**
+   * Returns the ID of the root node.
+   * @returns The root node ID.
+   */
+  getRootId() {
+    return this.rootId;
+  }
+  /**
+   * Returns the order of the B+Tree.
+   * @returns The order of the tree.
+   */
+  getOrder() {
+    return this.order;
+  }
   _strategyDirty;
   _nodeCreateBuffer;
   _nodeUpdateBuffer;
@@ -705,24 +721,21 @@ var BPTree = class _BPTree {
             break;
           }
           keys.push(key);
-          this.bufferForNodeUpdate(node);
-          break;
+          return this.bufferForNodeUpdate(node);
         } else if (this.comparator.isLower(value, nValue)) {
           node.values.splice(i, 0, value);
           node.keys.splice(i, 0, [key]);
-          this.bufferForNodeUpdate(node);
-          break;
+          return this.bufferForNodeUpdate(node);
         } else if (i + 1 === node.values.length) {
           node.values.push(value);
           node.keys.push([key]);
-          this.bufferForNodeUpdate(node);
-          break;
+          return this.bufferForNodeUpdate(node);
         }
       }
     } else {
       node.values = [value];
       node.keys = [[key]];
-      this.bufferForNodeUpdate(node);
+      return this.bufferForNodeUpdate(node);
     }
   }
   bufferForNodeCreate(node) {
@@ -761,8 +774,8 @@ var BPTree = class _BPTree {
   }
 };
 
-// src/BPTreeSync.ts
-var BPTreeSync = class extends BPTree {
+// src/base/BPTreeSyncBase.ts
+var BPTreeSyncBase = class extends BPTree {
   constructor(strategy, comparator, option) {
     super(strategy, comparator, option);
     this.nodes = this._createCachedNode();
@@ -838,7 +851,7 @@ var BPTreeSync = class extends BPTree {
     }
     return id;
   }
-  _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
+  _createNode(isLeaf, keys, values, leaf = isLeaf, parent = null, next = null, prev = null) {
     const id = this._createNodeId(isLeaf);
     const node = {
       id,
@@ -849,29 +862,26 @@ var BPTreeSync = class extends BPTree {
       next,
       prev
     };
-    this._nodeCreateBuffer.set(id, node);
+    this.bufferForNodeCreate(node);
     return node;
   }
   _deleteEntry(node, key, value) {
     if (!node.leaf) {
+      let keyIndex = -1;
       for (let i = 0, len = node.keys.length; i < len; i++) {
-        const nKey = node.keys[i];
-        if (nKey === key) {
-          node.keys.splice(i, 1);
-          this.bufferForNodeUpdate(node);
+        if (node.keys[i] === key) {
+          keyIndex = i;
           break;
         }
       }
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        if (this.comparator.isSame(value, nValue)) {
-          node.values.splice(i, 1);
-          this.bufferForNodeUpdate(node);
-          break;
-        }
+      if (keyIndex !== -1) {
+        node.keys.splice(keyIndex, 1);
+        const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
+        node.values.splice(valueIndex, 1);
+        this.bufferForNodeUpdate(node);
       }
     }
-    if (this.rootId === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
       this.bufferForNodeDelete(node);
       const newRoot = this.getNode(keys[0]);
@@ -940,20 +950,11 @@ var BPTreeSync = class extends BPTree {
           pointer.values.push(guess);
         } else {
           pointer.next = node.next;
-          pointer.prev = node.id;
           if (pointer.next) {
-            const n = this.getNode(node.next);
+            const n = this.getNode(pointer.next);
             n.prev = pointer.id;
             this.bufferForNodeUpdate(n);
           }
-          if (pointer.prev) {
-            const n = this.getNode(node.id);
-            n.next = pointer.id;
-            this.bufferForNodeUpdate(n);
-          }
-          if (isPredecessor) {
-            pointer.prev = null;
-          }
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {
@@ -977,13 +978,10 @@ var BPTreeSync = class extends BPTree {
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
             parentNode = this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerKm;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const nodeIndex = parentNode.keys.indexOf(node.id);
+            if (nodeIndex > 0) {
+              parentNode.values[nodeIndex - 1] = pointerKm;
+              this.bufferForNodeUpdate(parentNode);
             }
           } else {
             pointerPm = pointer.keys.splice(-1)[0];
@@ -991,13 +989,10 @@ var BPTreeSync = class extends BPTree {
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
             parentNode = this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerKm;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const nodeIndex = parentNode.keys.indexOf(node.id);
+            if (nodeIndex > 0) {
+              parentNode.values[nodeIndex - 1] = pointerKm;
+              this.bufferForNodeUpdate(parentNode);
             }
           }
           this.bufferForNodeUpdate(node);
@@ -1011,13 +1006,10 @@ var BPTreeSync = class extends BPTree {
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
             parentNode = this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerK0;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            if (pointerIndex > 0) {
+              parentNode.values[pointerIndex - 1] = pointerK0;
+              this.bufferForNodeUpdate(parentNode);
             }
           } else {
             pointerP0 = pointer.keys.splice(0, 1)[0];
@@ -1025,13 +1017,10 @@ var BPTreeSync = class extends BPTree {
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
             parentNode = this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointer.values[0];
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            if (pointerIndex > 0) {
+              parentNode.values[pointerIndex - 1] = pointer.values[0];
+              this.bufferForNodeUpdate(parentNode);
             }
           }
           this.bufferForNodeUpdate(node);
@@ -1059,6 +1048,8 @@ var BPTreeSync = class extends BPTree {
           }
         }
       }
+    } else {
+      this.bufferForNodeUpdate(node);
     }
   }
   _insertInParent(node, value, pointer) {
@@ -1077,31 +1068,25 @@ var BPTreeSync = class extends BPTree {
       return;
     }
     const parentNode = this.getNode(node.parent);
-    let insertIndex = 0;
-    for (let i = 0; i < parentNode.values.length; i++) {
-      if (this.comparator.asc(value, parentNode.values[i]) > 0) {
-        insertIndex = i + 1;
-      } else {
-        break;
-      }
+    const nodeIndex = parentNode.keys.indexOf(node.id);
+    if (nodeIndex === -1) {
+      throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
     }
+    const insertIndex = nodeIndex;
     parentNode.values.splice(insertIndex, 0, value);
     parentNode.keys.splice(insertIndex + 1, 0, pointer.id);
     pointer.parent = parentNode.id;
     if (pointer.leaf) {
-      const leftSiblingId = parentNode.keys[insertIndex];
-      const rightSiblingId = parentNode.keys[insertIndex + 2];
-      if (leftSiblingId) {
-        const leftSibling = this.getNode(leftSiblingId);
-        pointer.prev = leftSibling.id;
-        pointer.next = leftSibling.next;
-        leftSibling.next = pointer.id;
-        this.bufferForNodeUpdate(leftSibling);
-      }
-      if (rightSiblingId) {
-        const rightSibling = this.getNode(rightSiblingId);
-        rightSibling.prev = pointer.id;
-        this.bufferForNodeUpdate(rightSibling);
+      const leftSibling = node;
+      const oldNextId = leftSibling.next;
+      pointer.prev = leftSibling.id;
+      pointer.next = oldNextId;
+      leftSibling.next = pointer.id;
+      this.bufferForNodeUpdate(leftSibling);
+      if (oldNextId) {
+        const oldNext = this.getNode(oldNextId);
+        oldNext.prev = pointer.id;
+        this.bufferForNodeUpdate(oldNext);
       }
     }
     this.bufferForNodeUpdate(parentNode);
@@ -1130,6 +1115,7 @@ var BPTreeSync = class extends BPTree {
     }
   }
   init() {
+    this.clear();
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
@@ -1160,42 +1146,72 @@ var BPTreeSync = class extends BPTree {
   }
   insertableNode(value) {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isSame(value, nValue)) {
           node = this.getNode(k[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (this.comparator.isLower(value, nValue)) {
           node = this.getNode(k[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (i + 1 === node.values.length) {
           node = this.getNode(k[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
     }
     return node;
   }
-  /**
-   * Find the insertable node using primaryAsc comparison.
-   * This allows finding nodes by primary value only, ignoring unique identifiers.
-   */
   insertableNodeByPrimary(value) {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isPrimarySame(value, nValue)) {
           node = this.getNode(k[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (this.comparator.isPrimaryLower(value, nValue)) {
           node = this.getNode(k[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (i + 1 === node.values.length) {
           node = this.getNode(k[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -1204,16 +1220,29 @@ var BPTreeSync = class extends BPTree {
   }
   insertableRightestNodeByPrimary(value) {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isPrimaryLower(value, nValue)) {
           node = this.getNode(k[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         }
         if (i + 1 === node.values.length) {
           node = this.getNode(k[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -1248,20 +1277,65 @@ var BPTreeSync = class extends BPTree {
   }
   leftestNode() {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       const keys = node.keys;
       node = this.getNode(keys[0]);
+      if (node.parent !== parentId) {
+        node.parent = parentId;
+        this.bufferForNodeUpdate(node);
+      }
     }
     return node;
   }
   rightestNode() {
     let node = this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       const keys = node.keys;
       node = this.getNode(keys[keys.length - 1]);
+      if (node.parent !== parentId) {
+        node.parent = parentId;
+        this.bufferForNodeUpdate(node);
+      }
     }
     return node;
   }
+  exists(key, value) {
+    const node = this.insertableNode(value);
+    for (let i = 0, len = node.values.length; i < len; i++) {
+      if (this.comparator.isSame(value, node.values[i])) {
+        const keys = node.keys[i];
+        if (keys.includes(key)) {
+          return true;
+        }
+      }
+    }
+    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;
+  }
   commitHeadBuffer() {
     if (!this._strategyDirty) {
       return;
@@ -1292,24 +1366,14 @@ var BPTreeSync = class extends BPTree {
     }
     this._nodeDeleteBuffer.clear();
   }
-  /**
-   * Retrieves the value associated with the given key (PK).
-   * Note: This method performs a full scan of leaf nodes as the tree is ordered by Value, not Key.
-   * 
-   * @param key The key to search for.
-   * @returns The value associated with the key, or undefined if not found.
-   */
   get(key) {
     let node = this.leftestNode();
     while (true) {
-      if (node.values) {
-        const len = node.values.length;
-        for (let i = 0; i < len; i++) {
-          const keys = node.keys[i];
-          for (let j = 0; j < keys.length; j++) {
-            if (keys[j] === key) {
-              return node.values[i];
-            }
+      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];
           }
         }
       }
@@ -1428,21 +1492,15 @@ var BPTreeSync = class extends BPTree {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
         const keys = node.keys[i];
-        if (keys.includes(key)) {
-          if (keys.length > 1) {
-            keys.splice(keys.indexOf(key), 1);
-            this.bufferForNodeUpdate(node);
-          } else if (node.id === this.rootId) {
-            node.values.splice(i, 1);
+        const keyIndex = keys.indexOf(key);
+        if (keyIndex !== -1) {
+          keys.splice(keyIndex, 1);
+          if (keys.length === 0) {
             node.keys.splice(i, 1);
-            this.bufferForNodeUpdate(node);
-          } else {
-            keys.splice(keys.indexOf(key), 1);
-            node.keys.splice(i, 1);
-            node.values.splice(node.values.indexOf(value), 1);
-            this._deleteEntry(node, key, value);
-            this.bufferForNodeUpdate(node);
+            node.values.splice(i, 1);
           }
+          this._deleteEntry(node, key, value);
+          break;
         }
       }
     }
@@ -1451,327 +1509,424 @@ var BPTreeSync = class extends BPTree {
     this.commitNodeUpdateBuffer();
     this.commitNodeDeleteBuffer();
   }
-  exists(key, value) {
-    const node = this.insertableNode(value);
-    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];
-        return keys.includes(key);
-      }
-    }
-    return false;
+  getHeadData() {
+    return this.strategy.head.data;
   }
   setHeadData(data) {
     this.strategy.head.data = data;
-    this._strategyDirty = true;
-    this.commitHeadBuffer();
+    this.strategy.writeHead(this.strategy.head);
   }
-  forceUpdate() {
-    const keys = [...this.nodes.keys()];
-    this.nodes.clear();
-    this.init();
-    for (const key of keys) {
-      this.getNode(key);
-    }
-    return keys.length;
+};
+
+// src/base/SerializeStrategy.ts
+var SerializeStrategy = class {
+  order;
+  head;
+  constructor(order) {
+    this.order = order;
+    this.head = {
+      order,
+      root: null,
+      data: {}
+    };
   }
 };
 
-// node_modules/ryoiki/dist/esm/index.mjs
-var Ryoiki = class _Ryoiki {
-  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;
+// src/SerializeStrategySync.ts
+var SerializeStrategySync = class extends SerializeStrategy {
+  getHeadData(key, defaultValue) {
+    if (!Object.hasOwn(this.head.data, key)) {
+      this.setHeadData(key, defaultValue);
     }
-    return true;
+    return this.head.data[key];
   }
-  static ERR_ALREADY_EXISTS(lockId) {
-    return new Error(`The '${lockId}' task already existing in queue or running.`);
+  setHeadData(key, data) {
+    this.head.data[key] = data;
+    this.writeHead(this.head);
   }
-  static ERR_NOT_EXISTS(lockId) {
-    return new Error(`The '${lockId}' task not existing in task queue.`);
+  autoIncrement(key, defaultValue) {
+    const current = this.getHeadData(key, defaultValue);
+    const next = current + 1;
+    this.setHeadData(key, next);
+    return current;
   }
-  static ERR_TIMEOUT(lockId, timeout) {
-    return new Error(`The task with ID '${lockId}' failed to acquire the lock within the timeout(${timeout}ms).`);
+  compareAndSwapHead(oldRoot, newRoot) {
+    if (this.head.root !== oldRoot) {
+      return false;
+    }
+    this.head.root = newRoot;
+    this.writeHead(this.head);
+    return true;
   }
-  /**
-   * 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();
+};
+var InMemoryStoreStrategySync = class extends SerializeStrategySync {
+  node;
+  constructor(order) {
+    super(order);
+    this.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];
+  id(isLeaf) {
+    return this.autoIncrement("index", 1).toString();
   }
-  rangeOverlapping(tasks, range) {
-    return Array.from(tasks.values()).some((t) => _Ryoiki.IsRangeOverlap(t.range, range));
+  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));
   }
-  isSameRange(a, b) {
-    const [a1, a2] = a;
-    const [b1, b2] = b;
-    return a1 === b1 && a2 === b2;
+  write(id, node) {
+    this.node[id] = node;
   }
-  fetchUnitAndRun(queue, workspaces) {
-    for (const [id, unit] of queue) {
-      if (!unit.condition()) {
-        continue;
-      }
-      this._alloc(queue, workspaces, id);
-    }
+  delete(id) {
+    delete this.node[id];
   }
-  _handleOverload(args, handlers, argPatterns) {
-    for (const [key, pattern] of Object.entries(argPatterns)) {
-      if (this._matchArgs(args, pattern)) {
-        return handlers[key](...args);
-      }
+  readHead() {
+    if (this.head.root === null) {
+      return null;
     }
-    throw new Error("Invalid arguments");
+    return this.head;
   }
-  _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;
-    });
+  writeHead(head) {
+    this.head = head;
   }
-  _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 _Ryoiki.ERR_NOT_EXISTS(lockId);
-    }
-    workspaces.set(lockId, unit);
-    queue.delete(lockId);
-    unit.alloc();
-  }
-  _free(workspaces, lockId) {
-    const unit = workspaces.get(lockId);
-    if (!unit) {
-      throw _Ryoiki.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(_Ryoiki.ERR_TIMEOUT(id, timeout));
-        }, timeout);
-      }
-      const id = this._createRandomId();
-      const alloc = async () => {
-        if (timeoutId !== null) {
-          clearTimeout(timeoutId);
-        }
-        const [err, v] = await _Ryoiki.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();
-    });
+};
+
+// src/transaction/BPTreeSyncSnapshotStrategy.ts
+var BPTreeSyncSnapshotStrategy = class extends SerializeStrategySync {
+  baseStrategy;
+  snapshotHead;
+  constructor(baseStrategy, root) {
+    super(baseStrategy.order);
+    this.baseStrategy = baseStrategy;
+    this.snapshotHead = {
+      ...baseStrategy.head,
+      root,
+      data: { ...baseStrategy.head.data }
+    };
+    this.head = this.snapshotHead;
   }
-  _checkWorking(range, workspaces) {
-    let isLocked = false;
-    for (const lock of workspaces.values()) {
-      if (_Ryoiki.IsRangeOverlap(range, lock.range)) {
-        isLocked = true;
-        break;
-      }
-    }
-    return isLocked;
+  id(isLeaf) {
+    return this.baseStrategy.id(isLeaf);
   }
-  /**
-   * 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);
+  read(id) {
+    return this.baseStrategy.read(id);
   }
-  /**
-   * 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);
+  write(id, node) {
+    this.baseStrategy.write(id, node);
   }
-  /**
-   * 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;
+  delete(id) {
+    this.baseStrategy.delete(id);
   }
-  /**
-   * 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;
+  readHead() {
+    return this.snapshotHead;
   }
-  /**
-   * 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)
-    );
+  writeHead(head) {
+    this.snapshotHead.root = head.root;
+    this.snapshotHead.data = { ...head.data };
   }
-  /**
-   * 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);
-      }
-    );
+  compareAndSwapHead(oldRoot, newRoot) {
+    return this.baseStrategy.compareAndSwapHead(oldRoot, newRoot);
   }
-  /**
-   * 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);
+  getHeadData(key, defaultValue) {
+    return this.snapshotHead.data[key] ?? defaultValue;
   }
-  /**
-   * 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);
+  setHeadData(key, data) {
+    this.snapshotHead.data[key] = data;
+  }
+  autoIncrement(key, defaultValue) {
+    return this.snapshotHead.data[key] ?? defaultValue;
   }
 };
 
-// src/BPTreeAsync.ts
-var BPTreeAsync = class extends BPTree {
-  lock;
-  constructor(strategy, comparator, option) {
-    super(strategy, comparator, option);
-    this.nodes = this._createCachedNode();
-    this.lock = new Ryoiki();
+// src/transaction/BPTreeSyncTransaction.ts
+var BPTreeSyncTransaction = class extends BPTreeSyncBase {
+  realBaseTree;
+  realBaseStrategy;
+  txNodes = /* @__PURE__ */ new Map();
+  dirtyIds;
+  createdInTx;
+  deletedIds;
+  initialRootId;
+  transactionRootId;
+  constructor(baseTree) {
+    super(baseTree.strategy, baseTree.comparator, baseTree.option);
+    this.realBaseTree = baseTree;
+    this.realBaseStrategy = baseTree.strategy;
+    this.order = baseTree.getOrder();
+    this.initialRootId = "";
+    this.transactionRootId = "";
+    this.dirtyIds = /* @__PURE__ */ new Set();
+    this.createdInTx = /* @__PURE__ */ new Set();
+    this.deletedIds = /* @__PURE__ */ new Set();
   }
-  _createCachedNode() {
-    return new CacheEntanglementAsync(async (key) => {
-      return await this.strategy.read(key);
-    }, {
-      capacity: this.option.capacity ?? 1e3
-    });
+  /**
+   * Initializes the transaction by capturing the current state of the tree.
+   */
+  initTransaction() {
+    const head = this.realBaseStrategy.readHead();
+    if (head) {
+      this.order = head.order;
+      this.initialRootId = head.root;
+    } else {
+      this.initialRootId = this.realBaseTree.getRootId();
+    }
+    if (!this.initialRootId) {
+      const root = this._createNode(true, [], [], true);
+      this.initialRootId = root.id;
+    }
+    this.transactionRootId = this.initialRootId;
+    this.rootId = this.transactionRootId;
+    const snapshotStrategy = new BPTreeSyncSnapshotStrategy(this.realBaseStrategy, this.initialRootId);
+    this.strategy = snapshotStrategy;
+    this.txNodes.clear();
+    this.dirtyIds.clear();
+    this.createdInTx.clear();
+    this.deletedIds.clear();
   }
-  async readLock(callback) {
-    let lockId;
-    return await this.lock.readLock(async (_lockId) => {
-      lockId = _lockId;
-      return await callback();
-    }).finally(() => {
-      this.lock.readUnlock(lockId);
-    });
+  getNode(id) {
+    if (this.txNodes.has(id)) {
+      return this.txNodes.get(id);
+    }
+    if (this.deletedIds.has(id)) {
+      throw new Error(`The tree attempted to reference deleted node '${id}'`);
+    }
+    const baseNode = this.realBaseStrategy.read(id);
+    const clone = JSON.parse(JSON.stringify(baseNode));
+    this.txNodes.set(id, clone);
+    return clone;
   }
-  async writeLock(callback) {
-    let lockId;
-    return await this.lock.writeLock(async (_lockId) => {
-      lockId = _lockId;
-      return await callback();
-    }).finally(() => {
-      this.lock.writeUnlock(lockId);
-    });
+  bufferForNodeUpdate(node) {
+    if (this.dirtyIds.has(node.id) && this.txNodes.has(node.id) && node._p) {
+      this.txNodes.set(node.id, node);
+      return;
+    }
+    node._p = true;
+    this.txNodes.set(node.id, node);
+    this.dirtyIds.add(node.id);
+    if (node.leaf) {
+      if (node.next && !this.dirtyIds.has(node.next) && !this.deletedIds.has(node.next)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.next));
+        } catch (e) {
+        }
+      }
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.prev));
+        } catch (e) {
+        }
+      }
+    }
+    this.markPathDirty(node);
+    delete node._p;
   }
-  async *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
-    let node = startNode;
-    let done = false;
+  bufferForNodeCreate(node) {
+    this.txNodes.set(node.id, node);
+    this.dirtyIds.add(node.id);
+    this.createdInTx.add(node.id);
+    if (node.leaf) {
+      if (node.next && !this.dirtyIds.has(node.next) && !this.deletedIds.has(node.next)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.next));
+        } catch (e) {
+        }
+      }
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.prev));
+        } catch (e) {
+        }
+      }
+    }
+    this.markPathDirty(node);
+  }
+  bufferForNodeDelete(node) {
+    this.txNodes.delete(node.id);
+    this.dirtyIds.add(node.id);
+    this.deletedIds.add(node.id);
+  }
+  markPathDirty(node) {
+    let curr = node;
+    while (curr.parent) {
+      if (this.deletedIds.has(curr.parent)) {
+        break;
+      }
+      if (this.dirtyIds.has(curr.parent) && this.txNodes.has(curr.parent)) {
+        break;
+      }
+      const parent = this.getNode(curr.parent);
+      this.dirtyIds.add(parent.id);
+      curr = parent;
+    }
+    if (!curr.parent) {
+      this.transactionRootId = curr.id;
+    }
+  }
+  _createNode(isLeaf, keys, values, leaf = isLeaf, parent = null, next = null, prev = null) {
+    const id = this.strategy.id(isLeaf);
+    const node = {
+      id,
+      keys,
+      values,
+      leaf,
+      parent,
+      next,
+      prev
+    };
+    this.bufferForNodeCreate(node);
+    return node;
+  }
+  /**
+   * Attempts to commit the transaction.
+   * Uses Optimistic Locking (Compare-And-Swap) on the root node ID to detect conflicts.
+   * 
+   * @returns The transaction result.
+   */
+  commit() {
+    const idMapping = /* @__PURE__ */ new Map();
+    const finalNodes = [];
+    for (const oldId of this.dirtyIds) {
+      if (this.createdInTx.has(oldId)) {
+        idMapping.set(oldId, oldId);
+      } else {
+        const node = this.txNodes.get(oldId);
+        if (node) {
+          const newId = this.realBaseStrategy.id(node.leaf);
+          idMapping.set(oldId, newId);
+        }
+      }
+    }
+    const newCreatedIds = [];
+    for (const oldId of this.dirtyIds) {
+      const node = this.txNodes.get(oldId);
+      if (!node) continue;
+      const newId = idMapping.get(oldId);
+      node.id = newId;
+      if (node.parent && idMapping.has(node.parent)) {
+        node.parent = idMapping.get(node.parent);
+      }
+      if (!node.leaf) {
+        const internal = node;
+        for (let i = 0; i < internal.keys.length; i++) {
+          const childId = internal.keys[i];
+          if (idMapping.has(childId)) {
+            internal.keys[i] = idMapping.get(childId);
+          }
+        }
+      }
+      if (node.leaf) {
+        const leaf = node;
+        if (leaf.next && idMapping.has(leaf.next)) {
+          leaf.next = idMapping.get(leaf.next);
+        }
+        if (leaf.prev && idMapping.has(leaf.prev)) {
+          leaf.prev = idMapping.get(leaf.prev);
+        }
+      }
+      finalNodes.push(node);
+      newCreatedIds.push(newId);
+    }
+    let newRootId = this.rootId;
+    if (idMapping.has(this.rootId)) {
+      newRootId = idMapping.get(this.rootId);
+    }
+    for (const node of finalNodes) {
+      this.realBaseStrategy.write(node.id, node);
+    }
+    const success = this.realBaseStrategy.compareAndSwapHead(this.initialRootId, newRootId);
+    if (success) {
+      const distinctObsolete = /* @__PURE__ */ new Set();
+      for (const oldId of this.dirtyIds) {
+        if (!this.createdInTx.has(oldId) && this.txNodes.has(oldId)) {
+          distinctObsolete.add(oldId);
+        }
+      }
+      return {
+        success: true,
+        createdIds: newCreatedIds,
+        obsoleteIds: Array.from(distinctObsolete)
+      };
+    } else {
+      this.rollback();
+      return {
+        success: false,
+        createdIds: newCreatedIds,
+        obsoleteIds: []
+      };
+    }
+  }
+  /**
+   * Rolls back the transaction by clearing all buffered changes.
+   * Internal use only.
+   */
+  rollback() {
+    this.txNodes.clear();
+    this.dirtyIds.clear();
+    this.createdInTx.clear();
+  }
+  // Override to do nothing, as transaction handles its own commits
+  commitHeadBuffer() {
+  }
+  commitNodeCreateBuffer() {
+  }
+  commitNodeUpdateBuffer() {
+  }
+  commitNodeDeleteBuffer() {
+  }
+};
+
+// src/BPTreeSync.ts
+var BPTreeSync = class extends BPTreeSyncBase {
+  constructor(strategy, comparator, option) {
+    super(strategy, comparator, option);
+    this.init();
+  }
+  /**
+   * Creates a new synchronous transaction.
+   * @returns A new BPTreeSyncTransaction.
+   */
+  createTransaction() {
+    const tx = new BPTreeSyncTransaction(this);
+    tx.initTransaction();
+    return tx;
+  }
+  insert(key, value) {
+    const tx = this.createTransaction();
+    tx.insert(key, value);
+    const { success } = tx.commit();
+    this.init();
+    if (!success) {
+      throw new Error("Transaction failed: Commit failed due to conflict");
+    }
+  }
+  delete(key, value) {
+    const tx = this.createTransaction();
+    tx.delete(key, value);
+    const { success } = tx.commit();
+    this.init();
+    if (!success) {
+      throw new Error("Transaction failed: Commit failed due to conflict");
+    }
+  }
+};
+
+// src/base/BPTreeAsyncBase.ts
+var BPTreeAsyncBase = class extends BPTree {
+  constructor(strategy, comparator, option) {
+    super(strategy, comparator, option);
+    this.nodes = this._createCachedNode();
+  }
+  _createCachedNode() {
+    return new CacheEntanglementAsync(async (key) => {
+      return await this.strategy.read(key);
+    }, {
+      capacity: this.option.capacity ?? 1e3
+    });
+  }
+  async *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
+    let node = startNode;
+    let done = false;
     let hasMatched = false;
     while (!done) {
       if (endNode && node.id === endNode.id) {
@@ -1833,7 +1988,7 @@ var BPTreeAsync = class extends BPTree {
     }
     return id;
   }
-  async _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
+  async _createNode(isLeaf, keys, values, leaf = isLeaf, parent = null, next = null, prev = null) {
     const id = await this._createNodeId(isLeaf);
     const node = {
       id,
@@ -1844,40 +1999,37 @@ var BPTreeAsync = class extends BPTree {
       next,
       prev
     };
-    this._nodeCreateBuffer.set(id, node);
+    await this.bufferForNodeCreate(node);
     return node;
   }
   async _deleteEntry(node, key, value) {
     if (!node.leaf) {
+      let keyIndex = -1;
       for (let i = 0, len = node.keys.length; i < len; i++) {
-        const nKey = node.keys[i];
-        if (nKey === key) {
-          node.keys.splice(i, 1);
-          this.bufferForNodeUpdate(node);
+        if (node.keys[i] === key) {
+          keyIndex = i;
           break;
         }
       }
-      for (let i = 0, len = node.values.length; i < len; i++) {
-        const nValue = node.values[i];
-        if (this.comparator.isSame(value, nValue)) {
-          node.values.splice(i, 1);
-          this.bufferForNodeUpdate(node);
-          break;
-        }
+      if (keyIndex !== -1) {
+        node.keys.splice(keyIndex, 1);
+        const valueIndex = keyIndex > 0 ? keyIndex - 1 : 0;
+        node.values.splice(valueIndex, 1);
+        await this.bufferForNodeUpdate(node);
       }
     }
-    if (this.rootId === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
-      this.bufferForNodeDelete(node);
+      await this.bufferForNodeDelete(node);
       const newRoot = await this.getNode(keys[0]);
       this.rootId = newRoot.id;
       newRoot.parent = null;
       this.strategy.head.root = this.rootId;
-      this.bufferForNodeUpdate(newRoot);
+      await this.bufferForNodeUpdate(newRoot);
       return;
     } else if (this.rootId === node.id) {
       const root = await this.getNode(this.rootId);
-      this.bufferForNodeUpdate(root);
+      await this.bufferForNodeUpdate(root);
       return;
     } 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) {
@@ -1935,33 +2087,24 @@ var BPTreeAsync = class extends BPTree {
           pointer.values.push(guess);
         } else {
           pointer.next = node.next;
-          pointer.prev = node.id;
           if (pointer.next) {
-            const n = await this.getNode(node.next);
+            const n = await this.getNode(pointer.next);
             n.prev = pointer.id;
-            this.bufferForNodeUpdate(n);
-          }
-          if (pointer.prev) {
-            const n = await this.getNode(node.id);
-            n.next = pointer.id;
-            this.bufferForNodeUpdate(n);
-          }
-          if (isPredecessor) {
-            pointer.prev = null;
+            await this.bufferForNodeUpdate(n);
           }
         }
         pointer.values.push(...node.values);
         if (!pointer.leaf) {
           const keys = pointer.keys;
           for (const key2 of keys) {
-            const node2 = await this.getNode(key2);
-            node2.parent = pointer.id;
-            this.bufferForNodeUpdate(node2);
+            const n = await this.getNode(key2);
+            n.parent = pointer.id;
+            await this.bufferForNodeUpdate(n);
           }
         }
         await this._deleteEntry(await this.getNode(node.parent), node.id, guess);
-        this.bufferForNodeUpdate(pointer);
-        this.bufferForNodeDelete(node);
+        await this.bufferForNodeUpdate(pointer);
+        await this.bufferForNodeDelete(node);
       } else {
         if (isPredecessor) {
           let pointerPm;
@@ -1972,13 +2115,10 @@ var BPTreeAsync = class extends BPTree {
             node.keys = [pointerPm, ...node.keys];
             node.values = [guess, ...node.values];
             parentNode = await this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerKm;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const nodeIndex = parentNode.keys.indexOf(node.id);
+            if (nodeIndex > 0) {
+              parentNode.values[nodeIndex - 1] = pointerKm;
+              await this.bufferForNodeUpdate(parentNode);
             }
           } else {
             pointerPm = pointer.keys.splice(-1)[0];
@@ -1986,17 +2126,14 @@ var BPTreeAsync = class extends BPTree {
             node.keys = [pointerPm, ...node.keys];
             node.values = [pointerKm, ...node.values];
             parentNode = await this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerKm;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const nodeIndex = parentNode.keys.indexOf(node.id);
+            if (nodeIndex > 0) {
+              parentNode.values[nodeIndex - 1] = pointerKm;
+              await this.bufferForNodeUpdate(parentNode);
             }
           }
-          this.bufferForNodeUpdate(node);
-          this.bufferForNodeUpdate(pointer);
+          await this.bufferForNodeUpdate(node);
+          await this.bufferForNodeUpdate(pointer);
         } else {
           let pointerP0;
           let pointerK0;
@@ -2006,13 +2143,10 @@ var BPTreeAsync = class extends BPTree {
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, guess];
             parentNode = await this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointerK0;
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            if (pointerIndex > 0) {
+              parentNode.values[pointerIndex - 1] = pointerK0;
+              await this.bufferForNodeUpdate(parentNode);
             }
           } else {
             pointerP0 = pointer.keys.splice(0, 1)[0];
@@ -2020,40 +2154,42 @@ var BPTreeAsync = class extends BPTree {
             node.keys = [...node.keys, pointerP0];
             node.values = [...node.values, pointerK0];
             parentNode = await this.getNode(node.parent);
-            for (let i = 0, len = parentNode.values.length; i < len; i++) {
-              const nValue = parentNode.values[i];
-              if (this.comparator.isSame(guess, nValue)) {
-                parentNode.values[i] = pointer.values[0];
-                this.bufferForNodeUpdate(parentNode);
-                break;
-              }
+            const pointerIndex = parentNode.keys.indexOf(pointer.id);
+            if (pointerIndex > 0) {
+              parentNode.values[pointerIndex - 1] = pointer.values[0];
+              await this.bufferForNodeUpdate(parentNode);
             }
           }
-          this.bufferForNodeUpdate(node);
-          this.bufferForNodeUpdate(pointer);
+          await this.bufferForNodeUpdate(node);
+          await this.bufferForNodeUpdate(pointer);
         }
         if (!pointer.leaf) {
-          for (const key2 of pointer.keys) {
+          const keys = pointer.keys;
+          for (const key2 of keys) {
             const n = await this.getNode(key2);
             n.parent = pointer.id;
-            this.bufferForNodeUpdate(n);
+            await this.bufferForNodeUpdate(n);
           }
         }
         if (!node.leaf) {
-          for (const key2 of node.keys) {
+          const keys = node.keys;
+          for (const key2 of keys) {
             const n = await this.getNode(key2);
             n.parent = node.id;
-            this.bufferForNodeUpdate(n);
+            await this.bufferForNodeUpdate(n);
           }
         }
         if (!parentNode.leaf) {
-          for (const key2 of parentNode.keys) {
+          const keys = parentNode.keys;
+          for (const key2 of keys) {
             const n = await this.getNode(key2);
             n.parent = parentNode.id;
-            this.bufferForNodeUpdate(n);
+            await this.bufferForNodeUpdate(n);
           }
         }
       }
+    } else {
+      await this.bufferForNodeUpdate(node);
     }
   }
   async _insertInParent(node, value, pointer) {
@@ -2064,43 +2200,39 @@ var BPTreeAsync = class extends BPTree {
       node.parent = root.id;
       pointer.parent = root.id;
       if (pointer.leaf) {
-        node.next = pointer.id;
-        pointer.prev = node.id;
+        const nNode = node;
+        nNode.next = pointer.id;
+        const nPointer = pointer;
+        nPointer.prev = node.id;
       }
-      this.bufferForNodeUpdate(node);
-      this.bufferForNodeUpdate(pointer);
+      await this.bufferForNodeUpdate(node);
+      await this.bufferForNodeUpdate(pointer);
       return;
     }
     const parentNode = await this.getNode(node.parent);
-    let insertIndex = 0;
-    for (let i = 0; i < parentNode.values.length; i++) {
-      if (this.comparator.asc(value, parentNode.values[i]) > 0) {
-        insertIndex = i + 1;
-      } else {
-        break;
-      }
+    const nodeIndex = parentNode.keys.indexOf(node.id);
+    if (nodeIndex === -1) {
+      throw new Error(`Node ${node.id} not found in parent ${parentNode.id}`);
     }
+    const insertIndex = nodeIndex;
     parentNode.values.splice(insertIndex, 0, value);
     parentNode.keys.splice(insertIndex + 1, 0, pointer.id);
     pointer.parent = parentNode.id;
     if (pointer.leaf) {
-      const leftSiblingId = parentNode.keys[insertIndex];
-      const rightSiblingId = parentNode.keys[insertIndex + 2];
-      if (leftSiblingId) {
-        const leftSibling = await this.getNode(leftSiblingId);
-        pointer.prev = leftSibling.id;
-        pointer.next = leftSibling.next;
-        leftSibling.next = pointer.id;
-        this.bufferForNodeUpdate(leftSibling);
-      }
-      if (rightSiblingId) {
-        const rightSibling = await this.getNode(rightSiblingId);
-        rightSibling.prev = pointer.id;
-        this.bufferForNodeUpdate(rightSibling);
-      }
-    }
-    this.bufferForNodeUpdate(parentNode);
-    this.bufferForNodeUpdate(pointer);
+      const leftSibling = node;
+      const oldNextId = leftSibling.next;
+      pointer.prev = leftSibling.id;
+      pointer.next = oldNextId;
+      leftSibling.next = pointer.id;
+      await this.bufferForNodeUpdate(leftSibling);
+      if (oldNextId) {
+        const oldNext = await this.getNode(oldNextId);
+        oldNext.prev = pointer.id;
+        await this.bufferForNodeUpdate(oldNext);
+      }
+    }
+    await this.bufferForNodeUpdate(parentNode);
+    await this.bufferForNodeUpdate(pointer);
     if (parentNode.keys.length > this.order) {
       const parentPointer = await this._createNode(false, [], []);
       parentPointer.parent = parentNode.parent;
@@ -2111,20 +2243,21 @@ var BPTreeAsync = class extends BPTree {
       parentNode.values = parentNode.values.slice(0, mid);
       parentNode.keys = parentNode.keys.slice(0, mid + 1);
       for (const k of parentNode.keys) {
-        const node2 = await this.getNode(k);
-        node2.parent = parentNode.id;
-        this.bufferForNodeUpdate(node2);
+        const n = await this.getNode(k);
+        n.parent = parentNode.id;
+        await this.bufferForNodeUpdate(n);
       }
       for (const k of parentPointer.keys) {
-        const node2 = await this.getNode(k);
-        node2.parent = parentPointer.id;
-        this.bufferForNodeUpdate(node2);
+        const n = await this.getNode(k);
+        n.parent = parentPointer.id;
+        await this.bufferForNodeUpdate(n);
       }
       await this._insertInParent(parentNode, midValue, parentPointer);
-      this.bufferForNodeUpdate(parentNode);
+      await this.bufferForNodeUpdate(parentNode);
     }
   }
   async init() {
+    this.clear();
     const head = await this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
@@ -2155,42 +2288,72 @@ var BPTreeAsync = class extends BPTree {
   }
   async insertableNode(value) {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isSame(value, nValue)) {
-          node = await this.getNode(k[i + 1]);
+          node = await this.getNode(node.keys[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (this.comparator.isLower(value, nValue)) {
-          node = await this.getNode(k[i]);
+          node = await this.getNode(node.keys[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (i + 1 === node.values.length) {
-          node = await this.getNode(k[i + 1]);
+          node = await this.getNode(node.keys[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
     }
     return node;
   }
-  /**
-   * Find the insertable node using primaryAsc comparison.
-   * This allows finding nodes by primary value only, ignoring unique identifiers.
-   */
   async insertableNodeByPrimary(value) {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isPrimarySame(value, nValue)) {
-          node = await this.getNode(k[i]);
+          node = await this.getNode(node.keys[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (this.comparator.isPrimaryLower(value, nValue)) {
-          node = await this.getNode(k[i]);
+          node = await this.getNode(node.keys[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         } else if (i + 1 === node.values.length) {
-          node = await this.getNode(k[i + 1]);
+          node = await this.getNode(node.keys[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -2199,16 +2362,29 @@ var BPTreeAsync = class extends BPTree {
   }
   async insertableRightestNodeByPrimary(value) {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       for (let i = 0, len = node.values.length; i < len; i++) {
         const nValue = node.values[i];
         const k = node.keys;
         if (this.comparator.isPrimaryLower(value, nValue)) {
-          node = await this.getNode(k[i]);
+          node = await this.getNode(node.keys[i]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         }
         if (i + 1 === node.values.length) {
-          node = await this.getNode(k[i + 1]);
+          node = await this.getNode(node.keys[i + 1]);
+          if (node.parent !== parentId) {
+            node.parent = parentId;
+            await this.bufferForNodeUpdate(node);
+          }
           break;
         }
       }
@@ -2243,20 +2419,65 @@ var BPTreeAsync = class extends BPTree {
   }
   async leftestNode() {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       const keys = node.keys;
-      node = await this.getNode(keys[0]);
+      node = await this.getNode(node.keys[0]);
+      if (node.parent !== parentId) {
+        node.parent = parentId;
+        await this.bufferForNodeUpdate(node);
+      }
     }
     return node;
   }
   async rightestNode() {
     let node = await this.getNode(this.rootId);
+    if (node.parent !== null) {
+      node.parent = null;
+      await this.bufferForNodeUpdate(node);
+    }
     while (!node.leaf) {
+      const parentId = node.id;
       const keys = node.keys;
-      node = await this.getNode(keys[keys.length - 1]);
+      node = await this.getNode(node.keys[node.keys.length - 1]);
+      if (node.parent !== parentId) {
+        node.parent = parentId;
+        await this.bufferForNodeUpdate(node);
+      }
     }
     return node;
   }
+  async exists(key, value) {
+    const node = await this.insertableNode(value);
+    for (let i = 0, len = node.values.length; i < len; i++) {
+      if (this.comparator.isSame(value, node.values[i])) {
+        const keys = node.keys[i];
+        if (keys.includes(key)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  async forceUpdate(id) {
+    if (id) {
+      this.nodes.delete(id);
+      await this.getNode(id);
+      return 1;
+    }
+    const keys = Array.from(this.nodes.keys());
+    for (const key of keys) {
+      this.nodes.delete(key);
+    }
+    for (const key of keys) {
+      await this.getNode(key);
+    }
+    return keys.length;
+  }
   async commitHeadBuffer() {
     if (!this._strategyDirty) {
       return;
@@ -2287,25 +2508,15 @@ var BPTreeAsync = class extends BPTree {
     }
     this._nodeDeleteBuffer.clear();
   }
-  /**
-   * Retrieves the value associated with the given key (PK).
-   * Note: This method performs a full scan of leaf nodes as the tree is ordered by Value, not Key.
-   * 
-   * @param key The key to search for.
-   * @returns The value associated with the key, or undefined if not found.
-   */
   async get(key) {
-    return this.readLock(async () => {
+    return await this.readLock(async () => {
       let node = await this.leftestNode();
       while (true) {
-        if (node.values) {
-          const len = node.values.length;
-          for (let i = 0; i < len; i++) {
-            const keys = node.keys[i];
-            for (let j = 0; j < keys.length; j++) {
-              if (keys[j] === key) {
-                return node.values[i];
-              }
+        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];
             }
           }
         }
@@ -2380,27 +2591,23 @@ var BPTreeAsync = class extends BPTree {
     }
   }
   async keys(condition, filterValues) {
-    return this.readLock(async () => {
-      const set = /* @__PURE__ */ new Set();
-      for await (const key of this.keysStream(condition, filterValues)) {
-        set.add(key);
-      }
-      return set;
-    });
+    const set = /* @__PURE__ */ new Set();
+    for await (const key of this.keysStream(condition, filterValues)) {
+      set.add(key);
+    }
+    return set;
   }
   async where(condition) {
-    return this.readLock(async () => {
-      const map = /* @__PURE__ */ new Map();
-      for await (const [key, value] of this.whereStream(condition)) {
-        map.set(key, value);
-      }
-      return map;
-    });
+    const map = /* @__PURE__ */ new Map();
+    for await (const [key, value] of this.whereStream(condition)) {
+      map.set(key, value);
+    }
+    return map;
   }
   async insert(key, value) {
-    return this.writeLock(async () => {
+    await this.writeLock(async () => {
       const before = await this.insertableNode(value);
-      this._insertAtLeaf(before, key, value);
+      await this._insertAtLeaf(before, key, value);
       if (before.values.length === this.order) {
         const after = await this._createNode(
           true,
@@ -2417,7 +2624,7 @@ var BPTreeAsync = class extends BPTree {
         before.values = before.values.slice(0, mid + 1);
         before.keys = before.keys.slice(0, mid + 1);
         await this._insertInParent(before, after.values[0], after);
-        this.bufferForNodeUpdate(before);
+        await this.bufferForNodeUpdate(before);
       }
       await this.commitHeadBuffer();
       await this.commitNodeCreateBuffer();
@@ -2425,28 +2632,23 @@ var BPTreeAsync = class extends BPTree {
     });
   }
   async delete(key, value) {
-    return this.writeLock(async () => {
+    await this.writeLock(async () => {
       const node = await this.insertableNode(value);
       let i = node.values.length;
       while (i--) {
         const nValue = node.values[i];
         if (this.comparator.isSame(value, nValue)) {
           const keys = node.keys[i];
-          if (keys.includes(key)) {
-            if (keys.length > 1) {
-              keys.splice(keys.indexOf(key), 1);
-              this.bufferForNodeUpdate(node);
-            } else if (node.id === this.rootId) {
-              node.values.splice(i, 1);
+          const keyIndex = keys.indexOf(key);
+          if (keyIndex !== -1) {
+            keys.splice(keyIndex, 1);
+            if (keys.length === 0) {
               node.keys.splice(i, 1);
-              this.bufferForNodeUpdate(node);
-            } else {
-              keys.splice(keys.indexOf(key), 1);
-              node.keys.splice(i, 1);
-              node.values.splice(node.values.indexOf(value), 1);
-              await this._deleteEntry(node, key, value);
-              this.bufferForNodeUpdate(node);
+              node.values.splice(i, 1);
             }
+            await this._deleteEntry(node, key, value);
+            await this.bufferForNodeUpdate(node);
+            break;
           }
         }
       }
@@ -2456,151 +2658,400 @@ var BPTreeAsync = class extends BPTree {
       await this.commitNodeDeleteBuffer();
     });
   }
-  async exists(key, value) {
-    return this.readLock(async () => {
-      const node = await this.insertableNode(value);
-      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];
-          return keys.includes(key);
-        }
-      }
-      return false;
-    });
+  getHeadData() {
+    return this.strategy.head.data;
   }
   async setHeadData(data) {
-    return this.writeLock(async () => {
-      this.strategy.head.data = data;
-      this._strategyDirty = true;
-      await this.commitHeadBuffer();
-    });
-  }
-  async forceUpdate() {
-    return this.readLock(async () => {
-      const keys = [...this.nodes.keys()];
-      this.nodes.clear();
-      await this.init();
-      for (const key of keys) {
-        await this.getNode(key);
-      }
-      return keys.length;
-    });
-  }
-};
-
-// src/base/SerializeStrategy.ts
-var SerializeStrategy = class {
-  order;
-  head;
-  constructor(order) {
-    this.order = order;
-    this.head = {
-      order,
-      root: null,
-      data: {}
-    };
+    this.strategy.head.data = data;
+    await this.strategy.writeHead(this.strategy.head);
   }
 };
 
-// src/SerializeStrategySync.ts
-var SerializeStrategySync = class extends SerializeStrategy {
-  getHeadData(key, defaultValue) {
+// src/SerializeStrategyAsync.ts
+var SerializeStrategyAsync = class extends SerializeStrategy {
+  async getHeadData(key, defaultValue) {
     if (!Object.hasOwn(this.head.data, key)) {
-      this.setHeadData(key, defaultValue);
+      await this.setHeadData(key, defaultValue);
     }
     return this.head.data[key];
   }
-  setHeadData(key, data) {
+  async setHeadData(key, data) {
     this.head.data[key] = data;
-    this.writeHead(this.head);
+    await this.writeHead(this.head);
   }
-  autoIncrement(key, defaultValue) {
-    const current = this.getHeadData(key, defaultValue);
+  async autoIncrement(key, defaultValue) {
+    const current = await this.getHeadData(key, defaultValue);
     const next = current + 1;
-    this.setHeadData(key, next);
+    await this.setHeadData(key, next);
     return current;
   }
+  async compareAndSwapHead(oldRoot, newRoot) {
+    if (this.head.root !== oldRoot) {
+      return false;
+    }
+    this.head.root = newRoot;
+    await this.writeHead(this.head);
+    return true;
+  }
 };
-var InMemoryStoreStrategySync = class extends SerializeStrategySync {
+var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
   node;
   constructor(order) {
     super(order);
     this.node = {};
   }
-  id(isLeaf) {
-    return this.autoIncrement("index", 1).toString();
+  async id(isLeaf) {
+    return (await this.autoIncrement("index", 1)).toString();
   }
-  read(id) {
+  async 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.`);
     }
-    return this.node[id];
+    const node = this.node[id];
+    return JSON.parse(JSON.stringify(node));
   }
-  write(id, node) {
+  async write(id, node) {
     this.node[id] = node;
   }
-  delete(id) {
+  async delete(id) {
     delete this.node[id];
   }
-  readHead() {
+  async readHead() {
     if (this.head.root === null) {
       return null;
     }
     return this.head;
   }
-  writeHead(head) {
+  async writeHead(head) {
     this.head = head;
   }
 };
 
-// src/SerializeStrategyAsync.ts
-var SerializeStrategyAsync = class extends SerializeStrategy {
+// src/transaction/BPTreeAsyncSnapshotStrategy.ts
+var BPTreeAsyncSnapshotStrategy = class extends SerializeStrategyAsync {
+  baseStrategy;
+  snapshotHead;
+  constructor(baseStrategy, root) {
+    super(baseStrategy.order);
+    this.baseStrategy = baseStrategy;
+    this.snapshotHead = {
+      ...baseStrategy.head,
+      root,
+      data: { ...baseStrategy.head.data }
+    };
+    this.head = this.snapshotHead;
+  }
+  async id(isLeaf) {
+    return await this.baseStrategy.id(isLeaf);
+  }
+  async read(id) {
+    return await this.baseStrategy.read(id);
+  }
+  async write(id, node) {
+    await this.baseStrategy.write(id, node);
+  }
+  async delete(id) {
+    await this.baseStrategy.delete(id);
+  }
+  async readHead() {
+    return this.snapshotHead;
+  }
+  async writeHead(head) {
+    this.snapshotHead.root = head.root;
+    this.snapshotHead.data = { ...head.data };
+  }
+  async compareAndSwapHead(oldRoot, newRoot) {
+    return await this.baseStrategy.compareAndSwapHead(oldRoot, newRoot);
+  }
   async getHeadData(key, defaultValue) {
-    if (!Object.hasOwn(this.head.data, key)) {
-      await this.setHeadData(key, defaultValue);
-    }
-    return this.head.data[key];
+    return this.snapshotHead.data[key] ?? defaultValue;
   }
   async setHeadData(key, data) {
-    this.head.data[key] = data;
-    await this.writeHead(this.head);
+    this.snapshotHead.data[key] = data;
   }
   async autoIncrement(key, defaultValue) {
-    const current = await this.getHeadData(key, defaultValue);
-    const next = current + 1;
-    await this.setHeadData(key, next);
-    return current;
+    return this.snapshotHead.data[key] ?? defaultValue;
   }
 };
-var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
-  node;
-  constructor(order) {
-    super(order);
-    this.node = {};
+
+// src/transaction/BPTreeAsyncTransaction.ts
+var BPTreeAsyncTransaction = class extends BPTreeAsyncBase {
+  realBaseTree;
+  realBaseStrategy;
+  txNodes = /* @__PURE__ */ new Map();
+  dirtyIds;
+  createdInTx;
+  deletedIds;
+  initialRootId;
+  transactionRootId;
+  constructor(baseTree) {
+    super(baseTree.strategy, baseTree.comparator, baseTree.option);
+    this.realBaseTree = baseTree;
+    this.realBaseStrategy = baseTree.strategy;
+    this.order = baseTree.getOrder();
+    this.initialRootId = "";
+    this.transactionRootId = "";
+    this.dirtyIds = /* @__PURE__ */ new Set();
+    this.createdInTx = /* @__PURE__ */ new Set();
+    this.deletedIds = /* @__PURE__ */ new Set();
   }
-  async id(isLeaf) {
-    return (await this.autoIncrement("index", 1)).toString();
+  /**
+   * Initializes the transaction by capturing the current state of the tree.
+   */
+  async initTransaction() {
+    const head = await this.realBaseStrategy.readHead();
+    if (head) {
+      this.order = head.order;
+      this.initialRootId = head.root;
+    } else {
+      this.initialRootId = this.realBaseTree.getRootId();
+    }
+    if (!this.initialRootId) {
+      const root = await this._createNode(true, [], [], true);
+      this.initialRootId = root.id;
+    }
+    this.transactionRootId = this.initialRootId;
+    this.rootId = this.transactionRootId;
+    const snapshotStrategy = new BPTreeAsyncSnapshotStrategy(this.realBaseStrategy, this.initialRootId);
+    this.strategy = snapshotStrategy;
+    this.txNodes.clear();
+    this.dirtyIds.clear();
+    this.createdInTx.clear();
+    this.deletedIds.clear();
   }
-  async 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.`);
+  async getNode(id) {
+    if (this.txNodes.has(id)) {
+      return this.txNodes.get(id);
+    }
+    if (this.deletedIds.has(id)) {
+      throw new Error(`The tree attempted to reference deleted node '${id}'`);
     }
-    return this.node[id];
+    const baseNode = await this.realBaseStrategy.read(id);
+    const clone = JSON.parse(JSON.stringify(baseNode));
+    this.txNodes.set(id, clone);
+    return clone;
   }
-  async write(id, node) {
-    this.node[id] = node;
+  async bufferForNodeUpdate(node) {
+    if (this.dirtyIds.has(node.id) && this.txNodes.has(node.id) && node._p) {
+      this.txNodes.set(node.id, node);
+      return;
+    }
+    node._p = true;
+    this.txNodes.set(node.id, node);
+    this.dirtyIds.add(node.id);
+    if (node.leaf) {
+      if (node.next && !this.dirtyIds.has(node.next) && !this.deletedIds.has(node.next)) {
+        try {
+          await this.bufferForNodeUpdate(await this.getNode(node.next));
+        } catch (e) {
+        }
+      }
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          await this.bufferForNodeUpdate(await this.getNode(node.prev));
+        } catch (e) {
+        }
+      }
+    }
+    await this.markPathDirty(node);
+    delete node._p;
   }
-  async delete(id) {
-    delete this.node[id];
+  async bufferForNodeCreate(node) {
+    this.txNodes.set(node.id, node);
+    this.dirtyIds.add(node.id);
+    this.createdInTx.add(node.id);
+    if (node.leaf) {
+      if (node.next && !this.dirtyIds.has(node.next) && !this.deletedIds.has(node.next)) {
+        try {
+          await this.bufferForNodeUpdate(await this.getNode(node.next));
+        } catch (e) {
+        }
+      }
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          await this.bufferForNodeUpdate(await this.getNode(node.prev));
+        } catch (e) {
+        }
+      }
+    }
+    await this.markPathDirty(node);
   }
-  async readHead() {
-    if (this.head.root === null) {
-      return null;
+  async bufferForNodeDelete(node) {
+    this.txNodes.delete(node.id);
+    this.dirtyIds.add(node.id);
+    this.deletedIds.add(node.id);
+  }
+  async markPathDirty(node) {
+    let curr = node;
+    while (curr.parent) {
+      if (this.deletedIds.has(curr.parent)) {
+        break;
+      }
+      if (this.dirtyIds.has(curr.parent) && this.txNodes.has(curr.parent)) {
+        break;
+      }
+      const parent = await this.getNode(curr.parent);
+      this.dirtyIds.add(parent.id);
+      curr = parent;
+    }
+    if (!curr.parent) {
+      this.transactionRootId = curr.id;
     }
-    return this.head;
   }
-  async writeHead(head) {
-    this.head = head;
+  async _createNode(isLeaf, keys, values, leaf = isLeaf, parent = null, next = null, prev = null) {
+    const id = await this.strategy.id(isLeaf);
+    const node = {
+      id,
+      keys,
+      values,
+      leaf,
+      parent,
+      next,
+      prev
+    };
+    await this.bufferForNodeCreate(node);
+    return node;
+  }
+  /**
+   * Attempts to commit the transaction.
+   * Uses Optimistic Locking (Compare-And-Swap) on the root node ID to detect conflicts.
+   * 
+   * @returns A promise that resolves to the transaction result.
+   */
+  async commit() {
+    const idMapping = /* @__PURE__ */ new Map();
+    const finalNodes = [];
+    for (const oldId of this.dirtyIds) {
+      if (this.createdInTx.has(oldId)) {
+        idMapping.set(oldId, oldId);
+      } else {
+        const node = this.txNodes.get(oldId);
+        if (node) {
+          const newId = await this.realBaseStrategy.id(node.leaf);
+          idMapping.set(oldId, newId);
+        }
+      }
+    }
+    const newCreatedIds = [];
+    for (const oldId of this.dirtyIds) {
+      const node = this.txNodes.get(oldId);
+      if (!node) continue;
+      const newId = idMapping.get(oldId);
+      node.id = newId;
+      if (node.parent && idMapping.has(node.parent)) {
+        node.parent = idMapping.get(node.parent);
+      }
+      if (!node.leaf) {
+        const internal = node;
+        for (let i = 0; i < internal.keys.length; i++) {
+          const childId = internal.keys[i];
+          if (idMapping.has(childId)) {
+            internal.keys[i] = idMapping.get(childId);
+          }
+        }
+      }
+      if (node.leaf) {
+        const leaf = node;
+        if (leaf.next && idMapping.has(leaf.next)) {
+          leaf.next = idMapping.get(leaf.next);
+        }
+        if (leaf.prev && idMapping.has(leaf.prev)) {
+          leaf.prev = idMapping.get(leaf.prev);
+        }
+      }
+      finalNodes.push(node);
+      newCreatedIds.push(newId);
+    }
+    let newRootId = this.rootId;
+    if (idMapping.has(this.rootId)) {
+      newRootId = idMapping.get(this.rootId);
+    }
+    for (const node of finalNodes) {
+      await this.realBaseStrategy.write(node.id, node);
+    }
+    const success = await this.realBaseStrategy.compareAndSwapHead(this.initialRootId, newRootId);
+    if (success) {
+      const distinctObsolete = /* @__PURE__ */ new Set();
+      for (const oldId of this.dirtyIds) {
+        if (!this.createdInTx.has(oldId) && this.txNodes.has(oldId)) {
+          distinctObsolete.add(oldId);
+        }
+      }
+      return {
+        success: true,
+        createdIds: newCreatedIds,
+        obsoleteIds: Array.from(distinctObsolete)
+      };
+    } else {
+      await this.rollback();
+      return {
+        success: false,
+        createdIds: newCreatedIds,
+        obsoleteIds: []
+      };
+    }
+  }
+  /**
+   * Rolls back the transaction by clearing all buffered changes.
+   * Internal use only.
+   */
+  async rollback() {
+    this.txNodes.clear();
+    this.dirtyIds.clear();
+    this.createdInTx.clear();
+  }
+  async readLock(fn) {
+    return await fn();
+  }
+  async writeLock(fn) {
+    return await fn();
+  }
+  async commitHeadBuffer() {
+  }
+  async commitNodeCreateBuffer() {
+  }
+  async commitNodeUpdateBuffer() {
+  }
+  async commitNodeDeleteBuffer() {
+  }
+};
+
+// src/BPTreeAsync.ts
+var BPTreeAsync = class extends BPTreeAsyncBase {
+  constructor(strategy, comparator, option) {
+    super(strategy, comparator, option);
+  }
+  /**
+   * Creates a new asynchronous transaction.
+   * @returns A promise that resolves to a new BPTreeAsyncTransaction.
+   */
+  async createTransaction() {
+    const tx = new BPTreeAsyncTransaction(this);
+    await tx.initTransaction();
+    return tx;
+  }
+  async insert(key, value) {
+    const tx = await this.createTransaction();
+    await tx.insert(key, value);
+    const { success } = await tx.commit();
+    await this.init();
+    if (!success) {
+      throw new Error("Transaction failed: Commit failed due to conflict");
+    }
+  }
+  async delete(key, value) {
+    const tx = await this.createTransaction();
+    await tx.delete(key, value);
+    const { success } = await tx.commit();
+    await this.init();
+    if (!success) {
+      throw new Error("Transaction failed: Commit failed due to conflict");
+    }
+  }
+  async readLock(fn) {
+    return await fn();
+  }
+  async writeLock(fn) {
+    return await fn();
   }
 };