dataply 0.0.16-alpha.2 → 0.0.16-alpha.4

package/dist/cjs/index.js

@@ -31,7 +31,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   BPTreeAsync: () => BPTreeAsync,
+  BPTreeAsyncTransaction: () => BPTreeAsyncTransaction,
   BPTreeSync: () => BPTreeSync,
+  BPTreeSyncTransaction: () => BPTreeSyncTransaction,
   BitmapPageManager: () => BitmapPageManager,
   CacheEntanglementAsync: () => CacheEntanglementAsync2,
   CacheEntanglementSync: () => CacheEntanglementSync2,
@@ -50,7 +52,7 @@ __export(src_exports, {
   OverflowPageManager: () => OverflowPageManager,
   PageManager: () => PageManager,
   PageManagerFactory: () => PageManagerFactory,
-  Ryoiki: () => Ryoiki2,
+  Ryoiki: () => Ryoiki,
   SerializeStrategyAsync: () => SerializeStrategyAsync,
   SerializeStrategySync: () => SerializeStrategySync,
   StringComparator: () => StringComparator,
@@ -496,7 +498,21 @@ var BPTree = class _BPTree {
   comparator;
   option;
   order;
-  root;
+  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;
@@ -729,40 +745,37 @@ 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) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeCreateBuffer.set(node.id, node);
   }
   bufferForNodeUpdate(node) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeUpdateBuffer.set(node.id, node);
   }
   bufferForNodeDelete(node) {
-    if (node.id === this.root.id) {
+    if (node.id === this.rootId) {
       this._strategyDirty = true;
     }
     this._nodeDeleteBuffer.set(node.id, node);
@@ -784,7 +797,7 @@ var BPTree = class _BPTree {
     this.nodes.clear();
   }
 };
-var BPTreeSync = class extends BPTree {
+var BPTreeSyncBase = class extends BPTree {
   constructor(strategy, comparator, option) {
     super(strategy, comparator, option);
     this.nodes = this._createCachedNode();
@@ -860,7 +873,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,
@@ -871,38 +884,37 @@ 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.root.id === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
-      this.bufferForNodeDelete(this.root);
-      this.root = this.getNode(keys[0]);
-      this.root.parent = null;
-      this.strategy.head.root = this.root.id;
-      this.bufferForNodeUpdate(this.root);
+      this.bufferForNodeDelete(node);
+      const newRoot = this.getNode(keys[0]);
+      this.rootId = newRoot.id;
+      newRoot.parent = null;
+      this.strategy.head.root = this.rootId;
+      this.bufferForNodeUpdate(newRoot);
       return;
-    } else if (this.root.id === node.id) {
-      this.bufferForNodeUpdate(this.root);
+    } else if (this.rootId === node.id) {
+      const root = this.getNode(this.rootId);
+      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) {
@@ -960,20 +972,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) {
@@ -997,13 +1000,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];
@@ -1011,13 +1011,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);
@@ -1031,13 +1028,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];
@@ -1045,13 +1039,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);
@@ -1079,12 +1070,14 @@ var BPTreeSync = class extends BPTree {
           }
         }
       }
+    } else {
+      this.bufferForNodeUpdate(node);
     }
   }
   _insertInParent(node, value, pointer) {
-    if (this.root.id === node.id) {
+    if (this.rootId === node.id) {
       const root = this._createNode(false, [node.id, pointer.id], [value]);
-      this.root = root;
+      this.rootId = root.id;
       this.strategy.head.root = root.id;
       node.parent = root.id;
       pointer.parent = root.id;
@@ -1097,31 +1090,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);
@@ -1150,18 +1137,20 @@ var BPTreeSync = class extends BPTree {
     }
   }
   init() {
+    this.clear();
     const head = this.strategy.readHead();
     if (head === null) {
       this.order = this.strategy.order;
-      this.root = this._createNode(true, [], [], true);
-      this.strategy.head.root = this.root.id;
+      const root = this._createNode(true, [], [], true);
+      this.rootId = root.id;
+      this.strategy.head.root = this.rootId;
       this.commitHeadBuffer();
       this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
       this.strategy.head = head;
       this.order = order;
-      this.root = this.getNode(root);
+      this.rootId = root;
     }
     if (this.order < 3) {
       throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -1178,43 +1167,73 @@ var BPTreeSync = class extends BPTree {
     return cache.raw;
   }
   insertableNode(value) {
-    let node = this.getNode(this.root.id);
+    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.root.id);
+    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;
         }
       }
@@ -1222,17 +1241,30 @@ var BPTreeSync = class extends BPTree {
     return node;
   }
   insertableRightestNodeByPrimary(value) {
-    let node = this.getNode(this.root.id);
+    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;
         }
       }
@@ -1266,27 +1298,75 @@ var BPTreeSync = class extends BPTree {
     return this.getNode(guessNode);
   }
   leftestNode() {
-    let node = this.root;
+    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.root;
+    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;
     }
     this._strategyDirty = false;
     this.strategy.writeHead(this.strategy.head);
+    if (this.strategy.head.root) {
+      this.nodes.delete(this.strategy.head.root);
+    }
   }
   commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -1297,33 +1377,25 @@ var BPTreeSync = class extends BPTree {
   commitNodeUpdateBuffer() {
     for (const node of this._nodeUpdateBuffer.values()) {
       this.strategy.write(node.id, node);
+      this.nodes.delete(node.id);
     }
     this._nodeUpdateBuffer.clear();
   }
   commitNodeDeleteBuffer() {
     for (const node of this._nodeDeleteBuffer.values()) {
       this.strategy.delete(node.id);
+      this.nodes.delete(node.id);
     }
     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];
           }
         }
       }
@@ -1442,21 +1514,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.root.id) {
-            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;
         }
       }
     }
@@ -1465,294 +1531,410 @@ 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;
+};
+var SerializeStrategy = class {
+  order;
+  head;
+  constructor(order) {
+    this.order = order;
+    this.head = {
+      order,
+      root: null,
+      data: {}
+    };
   }
 };
-var Ryoiki = class _Ryoiki {
-  readings;
-  writings;
-  readQueue;
-  writeQueue;
-  static async CatchError(promise) {
-    return await promise.then((v) => [void 0, v]).catch((err) => [err]);
+var SerializeStrategySync = class extends SerializeStrategy {
+  getHeadData(key, defaultValue) {
+    if (!Object.hasOwn(this.head.data, key)) {
+      this.setHeadData(key, defaultValue);
+    }
+    return this.head.data[key];
   }
-  static IsRangeOverlap(a, b) {
-    const [start1, end1] = a;
-    const [start2, end2] = b;
-    if (end1 <= start2 || end2 <= start1) {
+  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;
+  }
+  compareAndSwapHead(oldRoot, newRoot) {
+    if (this.head.root !== oldRoot) {
       return false;
     }
+    this.head.root = newRoot;
+    this.writeHead(this.head);
     return true;
   }
-  static ERR_ALREADY_EXISTS(lockId) {
-    return new Error(`The '${lockId}' task already existing in queue or running.`);
+};
+var InMemoryStoreStrategySync = class extends SerializeStrategySync {
+  node;
+  constructor(order) {
+    super(order);
+    this.node = {};
   }
-  static ERR_NOT_EXISTS(lockId) {
-    return new Error(`The '${lockId}' task not existing in task queue.`);
+  id(isLeaf) {
+    return this.autoIncrement("index", 1).toString();
   }
-  static ERR_TIMEOUT(lockId, timeout) {
-    return new Error(`The task with ID '${lockId}' failed to acquire the lock within the timeout(${timeout}ms).`);
+  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));
   }
-  /**
-   * 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();
+  write(id, node) {
+    this.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];
+  delete(id) {
+    delete this.node[id];
   }
-  rangeOverlapping(tasks, range) {
-    return Array.from(tasks.values()).some((t) => _Ryoiki.IsRangeOverlap(t.range, range));
+  readHead() {
+    if (this.head.root === null) {
+      return null;
+    }
+    return this.head;
   }
-  isSameRange(a, b) {
-    const [a1, a2] = a;
-    const [b1, b2] = b;
-    return a1 === b1 && a2 === b2;
+  writeHead(head) {
+    this.head = head;
   }
-  fetchUnitAndRun(queue, workspaces) {
-    for (const [id, unit] of queue) {
-      if (!unit.condition()) {
-        continue;
-      }
-      this._alloc(queue, workspaces, id);
-    }
+};
+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;
   }
-  _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");
+  id(isLeaf) {
+    return this.baseStrategy.id(isLeaf);
   }
-  _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;
-    });
+  read(id) {
+    return this.baseStrategy.read(id);
   }
-  _createRandomId() {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).substring(2);
-    return `${timestamp}${random}`;
+  write(id, node) {
+    this.baseStrategy.write(id, node);
   }
-  _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();
+  delete(id) {
+    this.baseStrategy.delete(id);
   }
-  _free(workspaces, lockId) {
-    const unit = workspaces.get(lockId);
-    if (!unit) {
-      throw _Ryoiki.ERR_NOT_EXISTS(lockId);
-    }
-    workspaces.delete(lockId);
-    unit.free();
+  readHead() {
+    return this.snapshotHead;
   }
-  _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);
+  writeHead(head) {
+    this.snapshotHead.root = head.root;
+    this.snapshotHead.data = { ...head.data };
+  }
+  compareAndSwapHead(oldRoot, newRoot) {
+    return this.baseStrategy.compareAndSwapHead(oldRoot, newRoot);
+  }
+  getHeadData(key, defaultValue) {
+    return this.snapshotHead.data[key] ?? defaultValue;
+  }
+  setHeadData(key, data) {
+    this.snapshotHead.data[key] = data;
+  }
+  autoIncrement(key, defaultValue) {
+    return this.snapshotHead.data[key] ?? defaultValue;
+  }
+};
+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();
+  }
+  /**
+   * 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();
+  }
+  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;
+  }
+  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) {
+        }
       }
-      const id = this._createRandomId();
-      const alloc = async () => {
-        if (timeoutId !== null) {
-          clearTimeout(timeoutId);
+      if (node.prev && !this.dirtyIds.has(node.prev) && !this.deletedIds.has(node.prev)) {
+        try {
+          this.bufferForNodeUpdate(this.getNode(node.prev));
+        } catch (e) {
         }
-        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();
-    });
+      }
+    }
+    this.markPathDirty(node);
+    delete node._p;
   }
-  _checkWorking(range, workspaces) {
-    let isLocked = false;
-    for (const lock of workspaces.values()) {
-      if (_Ryoiki.IsRangeOverlap(range, lock.range)) {
-        isLocked = true;
+  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;
     }
-    return isLocked;
   }
-  /**
-   * Checks if there is any active read lock within the specified range.
-   * @param range The range to check for active read locks.
-   * @returns `true` if there is an active read lock within the range, `false` otherwise.
-   */
-  isReading(range) {
-    return this._checkWorking(range, this.readings);
+  _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;
   }
   /**
-   * 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);
+   * 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: []
+      };
+    }
   }
   /**
-   * 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.
+   * Rolls back the transaction by clearing all buffered changes.
+   * If cleanup is `true`, it also clears the transaction nodes.
+   * @param cleanup Whether to clear the transaction nodes.
+   * @returns The IDs of nodes that were created in this transaction.
    */
-  canRead(range) {
-    const writing = this.isWriting(range);
-    return !writing;
+  rollback(cleanup = true) {
+    const createdIds = Array.from(this.createdInTx);
+    this.txNodes.clear();
+    this.dirtyIds.clear();
+    this.createdInTx.clear();
+    if (cleanup) {
+      for (const id of createdIds) {
+        this.realBaseStrategy.delete(id);
+      }
+    }
+    return createdIds;
   }
-  /**
-   * 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;
+  // Override to do nothing, as transaction handles its own commits
+  commitHeadBuffer() {
   }
-  /**
-   * 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)
-    );
+  commitNodeCreateBuffer() {
   }
-  /**
-   * 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);
-      }
-    );
+  commitNodeUpdateBuffer() {
   }
-  /**
-   * 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);
+  commitNodeDeleteBuffer() {
+  }
+};
+var BPTreeSync = class extends BPTreeSyncBase {
+  constructor(strategy, comparator, option) {
+    super(strategy, comparator, option);
+    this.init();
   }
   /**
-   * Releases a write lock by its lock ID.
-   * @param lockId - The unique identifier for the lock to release.
+   * Creates a new synchronous transaction.
+   * @returns A new BPTreeSyncTransaction.
    */
-  writeUnlock(lockId) {
-    this._free(this.writings, lockId);
+  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");
+    }
   }
 };
-var BPTreeAsync = class extends BPTree {
-  lock;
+var BPTreeAsyncBase = class extends BPTree {
   constructor(strategy, comparator, option) {
     super(strategy, comparator, option);
     this.nodes = this._createCachedNode();
-    this.lock = new Ryoiki();
   }
   _createCachedNode() {
     return new CacheEntanglementAsync(async (key) => {
@@ -1761,24 +1943,6 @@ var BPTreeAsync = class extends BPTree {
       capacity: this.option.capacity ?? 1e3
     });
   }
-  async readLock(callback) {
-    let lockId;
-    return await this.lock.readLock(async (_lockId) => {
-      lockId = _lockId;
-      return await callback();
-    }).finally(() => {
-      this.lock.readUnlock(lockId);
-    });
-  }
-  async writeLock(callback) {
-    let lockId;
-    return await this.lock.writeLock(async (_lockId) => {
-      lockId = _lockId;
-      return await callback();
-    }).finally(() => {
-      this.lock.writeUnlock(lockId);
-    });
-  }
   async *getPairsGenerator(value, startNode, endNode, comparator, direction, earlyTerminate) {
     let node = startNode;
     let done = false;
@@ -1843,7 +2007,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,
@@ -1854,38 +2018,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.root.id === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
-      this.bufferForNodeDelete(this.root);
-      this.root = await this.getNode(keys[0]);
-      this.root.parent = null;
-      this.strategy.head.root = this.root.id;
-      this.bufferForNodeUpdate(this.root);
+      await this.bufferForNodeDelete(node);
+      const newRoot = await this.getNode(keys[0]);
+      this.rootId = newRoot.id;
+      newRoot.parent = null;
+      this.strategy.head.root = this.rootId;
+      await this.bufferForNodeUpdate(newRoot);
       return;
-    } else if (this.root.id === node.id) {
-      this.bufferForNodeUpdate(this.root);
+    } else if (this.rootId === node.id) {
+      const root = await this.getNode(this.rootId);
+      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) {
@@ -1943,33 +2106,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;
@@ -1980,13 +2134,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];
@@ -1994,17 +2145,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;
@@ -2014,13 +2162,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];
@@ -2028,87 +2173,85 @@ 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) {
-    if (this.root.id === node.id) {
+    if (this.rootId === node.id) {
       const root = await this._createNode(false, [node.id, pointer.id], [value]);
-      this.root = root;
+      this.rootId = root.id;
       this.strategy.head.root = root.id;
       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);
+      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);
       }
     }
-    this.bufferForNodeUpdate(parentNode);
-    this.bufferForNodeUpdate(pointer);
+    await this.bufferForNodeUpdate(parentNode);
+    await this.bufferForNodeUpdate(pointer);
     if (parentNode.keys.length > this.order) {
       const parentPointer = await this._createNode(false, [], []);
       parentPointer.parent = parentNode.parent;
@@ -2119,32 +2262,34 @@ 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;
-      this.root = await this._createNode(true, [], [], true);
-      this.strategy.head.root = this.root.id;
+      const root = await this._createNode(true, [], [], true);
+      this.rootId = root.id;
+      this.strategy.head.root = this.rootId;
       await this.commitHeadBuffer();
       await this.commitNodeCreateBuffer();
     } else {
       const { root, order } = head;
       this.strategy.head = head;
       this.order = order;
-      this.root = await this.getNode(root);
+      this.rootId = root;
     }
     if (this.order < 3) {
       throw new Error(`The 'order' parameter must be greater than 2. but got a '${this.order}'.`);
@@ -2161,43 +2306,73 @@ var BPTreeAsync = class extends BPTree {
     return cache.raw;
   }
   async insertableNode(value) {
-    let node = await this.getNode(this.root.id);
+    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.root.id);
+    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;
         }
       }
@@ -2205,17 +2380,30 @@ var BPTreeAsync = class extends BPTree {
     return node;
   }
   async insertableRightestNodeByPrimary(value) {
-    let node = await this.getNode(this.root.id);
+    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;
         }
       }
@@ -2249,27 +2437,75 @@ var BPTreeAsync = class extends BPTree {
     return await this.getNode(guessNode);
   }
   async leftestNode() {
-    let node = this.root;
+    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 = this.root;
+    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;
     }
     this._strategyDirty = false;
     await this.strategy.writeHead(this.strategy.head);
+    if (this.strategy.head.root) {
+      this.nodes.delete(this.strategy.head.root);
+    }
   }
   async commitNodeCreateBuffer() {
     for (const node of this._nodeCreateBuffer.values()) {
@@ -2280,34 +2516,26 @@ var BPTreeAsync = class extends BPTree {
   async commitNodeUpdateBuffer() {
     for (const node of this._nodeUpdateBuffer.values()) {
       await this.strategy.write(node.id, node);
+      this.nodes.delete(node.id);
     }
     this._nodeUpdateBuffer.clear();
   }
   async commitNodeDeleteBuffer() {
     for (const node of this._nodeDeleteBuffer.values()) {
       await this.strategy.delete(node.id);
+      this.nodes.delete(node.id);
     }
     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];
             }
           }
         }
@@ -2379,176 +2607,82 @@ var BPTreeAsync = class extends BPTree {
           break;
         }
       }
-    }
-  }
-  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;
-    });
-  }
-  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;
-    });
-  }
-  async insert(key, value) {
-    return this.writeLock(async () => {
-      const before = await this.insertableNode(value);
-      this._insertAtLeaf(before, key, value);
-      if (before.values.length === this.order) {
-        const after = await this._createNode(
-          true,
-          [],
-          [],
-          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);
-        this.bufferForNodeUpdate(before);
-      }
-      await this.commitHeadBuffer();
-      await this.commitNodeCreateBuffer();
-      await this.commitNodeUpdateBuffer();
-    });
-  }
-  async delete(key, value) {
-    return 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.root.id) {
-              node.values.splice(i, 1);
-              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);
-            }
-          }
-        }
-      }
-      await this.commitHeadBuffer();
-      await this.commitNodeCreateBuffer();
-      await this.commitNodeUpdateBuffer();
-      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;
-    });
-  }
-  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;
-    });
-  }
-};
-var SerializeStrategy = class {
-  order;
-  head;
-  constructor(order) {
-    this.order = order;
-    this.head = {
-      order,
-      root: null,
-      data: {}
-    };
-  }
-};
-var SerializeStrategySync = class extends SerializeStrategy {
-  getHeadData(key, defaultValue) {
-    if (!Object.hasOwn(this.head.data, key)) {
-      this.setHeadData(key, defaultValue);
-    }
-    return this.head.data[key];
-  }
-  setHeadData(key, data) {
-    this.head.data[key] = data;
-    this.writeHead(this.head);
-  }
-  autoIncrement(key, defaultValue) {
-    const current = this.getHeadData(key, defaultValue);
-    const next = current + 1;
-    this.setHeadData(key, next);
-    return current;
-  }
-};
-var InMemoryStoreStrategySync = class extends SerializeStrategySync {
-  node;
-  constructor(order) {
-    super(order);
-    this.node = {};
+    }
   }
-  id(isLeaf) {
-    return this.autoIncrement("index", 1).toString();
+  async keys(condition, filterValues) {
+    const set = /* @__PURE__ */ new Set();
+    for await (const key of this.keysStream(condition, filterValues)) {
+      set.add(key);
+    }
+    return set;
   }
-  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 where(condition) {
+    const map = /* @__PURE__ */ new Map();
+    for await (const [key, value] of this.whereStream(condition)) {
+      map.set(key, value);
     }
-    return this.node[id];
+    return map;
   }
-  write(id, node) {
-    this.node[id] = node;
+  async insert(key, value) {
+    await this.writeLock(async () => {
+      const before = await this.insertableNode(value);
+      await this._insertAtLeaf(before, key, value);
+      if (before.values.length === this.order) {
+        const after = await this._createNode(
+          true,
+          [],
+          [],
+          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);
+        await this.bufferForNodeUpdate(before);
+      }
+      await this.commitHeadBuffer();
+      await this.commitNodeCreateBuffer();
+      await this.commitNodeUpdateBuffer();
+    });
   }
-  delete(id) {
-    delete this.node[id];
+  async delete(key, value) {
+    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];
+          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._deleteEntry(node, key, value);
+            await this.bufferForNodeUpdate(node);
+            break;
+          }
+        }
+      }
+      await this.commitHeadBuffer();
+      await this.commitNodeCreateBuffer();
+      await this.commitNodeUpdateBuffer();
+      await this.commitNodeDeleteBuffer();
+    });
   }
-  readHead() {
-    if (this.head.root === null) {
-      return null;
-    }
-    return this.head;
+  getHeadData() {
+    return this.strategy.head.data;
   }
-  writeHead(head) {
-    this.head = head;
+  async setHeadData(data) {
+    this.strategy.head.data = data;
+    await this.strategy.writeHead(this.strategy.head);
   }
 };
 var SerializeStrategyAsync = class extends SerializeStrategy {
@@ -2568,6 +2702,14 @@ var SerializeStrategyAsync = class extends SerializeStrategy {
     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 InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
   node;
@@ -2582,7 +2724,8 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     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));
   }
   async write(id, node) {
     this.node[id] = node;
@@ -2600,9 +2743,341 @@ var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
     this.head = head;
   }
 };
+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) {
+    return this.snapshotHead.data[key] ?? defaultValue;
+  }
+  async setHeadData(key, data) {
+    this.snapshotHead.data[key] = data;
+  }
+  async autoIncrement(key, defaultValue) {
+    return this.snapshotHead.data[key] ?? defaultValue;
+  }
+};
+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();
+  }
+  /**
+   * 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 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 = await this.realBaseStrategy.read(id);
+    const clone = JSON.parse(JSON.stringify(baseNode));
+    this.txNodes.set(id, clone);
+    return clone;
+  }
+  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 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 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;
+    }
+  }
+  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.
+   * If cleanup is `true`, it also clears the transaction nodes.
+   * @param cleanup Whether to clear the transaction nodes.
+   * @returns The IDs of nodes that were created in this transaction.
+   */
+  async rollback(cleanup = true) {
+    const createdIds = Array.from(this.createdInTx);
+    this.txNodes.clear();
+    this.dirtyIds.clear();
+    this.createdInTx.clear();
+    if (cleanup) {
+      for (const id of createdIds) {
+        await this.realBaseStrategy.delete(id);
+      }
+    }
+    return createdIds;
+  }
+  async readLock(fn) {
+    return await fn();
+  }
+  async writeLock(fn) {
+    return await fn();
+  }
+  async commitHeadBuffer() {
+  }
+  async commitNodeCreateBuffer() {
+  }
+  async commitNodeUpdateBuffer() {
+  }
+  async commitNodeDeleteBuffer() {
+  }
+};
+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();
+  }
+};
 
 // node_modules/ryoiki/dist/esm/index.mjs
-var Ryoiki2 = class _Ryoiki2 {
+var Ryoiki = class _Ryoiki {
   readings;
   writings;
   readQueue;
@@ -2646,7 +3121,7 @@ var Ryoiki2 = class _Ryoiki2 {
     return [start, start + length];
   }
   rangeOverlapping(tasks, range) {
-    return Array.from(tasks.values()).some((t) => _Ryoiki2.IsRangeOverlap(t.range, range));
+    return Array.from(tasks.values()).some((t) => _Ryoiki.IsRangeOverlap(t.range, range));
   }
   isSameRange(a, b) {
     const [a1, a2] = a;
@@ -2687,7 +3162,7 @@ var Ryoiki2 = class _Ryoiki2 {
   _alloc(queue, workspaces, lockId) {
     const unit = queue.get(lockId);
     if (!unit) {
-      throw _Ryoiki2.ERR_NOT_EXISTS(lockId);
+      throw _Ryoiki.ERR_NOT_EXISTS(lockId);
     }
     workspaces.set(lockId, unit);
     queue.delete(lockId);
@@ -2696,7 +3171,7 @@ var Ryoiki2 = class _Ryoiki2 {
   _free(workspaces, lockId) {
     const unit = workspaces.get(lockId);
     if (!unit) {
-      throw _Ryoiki2.ERR_NOT_EXISTS(lockId);
+      throw _Ryoiki.ERR_NOT_EXISTS(lockId);
     }
     workspaces.delete(lockId);
     unit.free();
@@ -2706,7 +3181,7 @@ var Ryoiki2 = class _Ryoiki2 {
       let timeoutId = null;
       if (timeout >= 0) {
         timeoutId = setTimeout(() => {
-          reject(_Ryoiki2.ERR_TIMEOUT(id, timeout));
+          reject(_Ryoiki.ERR_TIMEOUT(id, timeout));
         }, timeout);
       }
       const id = this._createRandomId();
@@ -2714,7 +3189,7 @@ var Ryoiki2 = class _Ryoiki2 {
         if (timeoutId !== null) {
           clearTimeout(timeoutId);
         }
-        const [err, v] = await _Ryoiki2.CatchError(task(id));
+        const [err, v] = await _Ryoiki.CatchError(task(id));
         if (err) reject(err);
         else resolve(v);
       };
@@ -2729,7 +3204,7 @@ var Ryoiki2 = class _Ryoiki2 {
   _checkWorking(range, workspaces) {
     let isLocked = false;
     for (const lock of workspaces.values()) {
-      if (_Ryoiki2.IsRangeOverlap(range, lock.range)) {
+      if (_Ryoiki.IsRangeOverlap(range, lock.range)) {
         isLocked = true;
         break;
       }
@@ -5840,8 +6315,11 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     if (node.leaf) {
       const n = node;
       const keys = new Array(n.keys.length);
-      for (let i = 0, len = keys.length; i < len; i++) {
+      let i = 0;
+      const len = keys.length;
+      while (i < len) {
         keys[i] = +n.keys[i][0];
+        i++;
       }
       this.indexPageManger.setIndexId(page, +n.id);
       this.indexPageManger.setParentIndexId(page, +n.parent);
@@ -5854,8 +6332,11 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     } else {
       const n = node;
       const keys = new Array(n.keys.length);
-      for (let i = 0, len = keys.length; i < len; i++) {
+      let i = 0;
+      const len = keys.length;
+      while (i < len) {
         keys[i] = +n.keys[i];
+        i++;
       }
       this.indexPageManger.setIndexId(page, +n.id);
       this.indexPageManger.setParentIndexId(page, +n.parent);
@@ -5890,9 +6371,11 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     if (rootIndexPageId === -1) {
       return null;
     }
+    const metaOrder = manager.getRootIndexOrder(metadataPage);
+    const order = metaOrder || this.order;
     return {
-      root: manager.getRootIndexPageId(metadataPage).toString(),
-      order: manager.getRootIndexOrder(metadataPage),
+      root: rootIndexPageId.toString(),
+      order,
       data: {}
     };
   }
@@ -5979,8 +6462,9 @@ var RowTableEngine = class {
     this.pageIdBuffer = new Uint8Array(DataPageManager.CONSTANT.SIZE_PAGE_ID);
     this.maxBodySize = this.pfs.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER;
     this.order = this.getOptimalOrder(pfs.pageSize, IndexPageManager.CONSTANT.SIZE_KEY, IndexPageManager.CONSTANT.SIZE_VALUE);
+    this.strategy = new RowIdentifierStrategy(this.order, pfs, txContext);
     this.bptree = new BPTreeAsync(
-      new RowIdentifierStrategy(this.order, pfs, txContext),
+      this.strategy,
       new NumericComparator(),
       {
         capacity: this.options.pageCacheCapacity
@@ -5988,6 +6472,7 @@ var RowTableEngine = class {
     );
   }
   bptree;
+  strategy;
   order;
   factory;
   metadataPageManager;
@@ -5999,6 +6484,35 @@ var RowTableEngine = class {
   ridBuffer;
   pageIdBuffer;
   initialized = false;
+  /**
+   * Retrieves the BPTree transaction associated with the given transaction.
+   * If it doesn't exist, it creates a new one and registers commit/rollback hooks.
+   * @param tx Dataply transaction
+   * @returns BPTree transaction
+   */
+  async getBPTreeTransaction(tx) {
+    let btx = tx.__getBPTreeTransaction();
+    if (!btx) {
+      btx = await this.bptree.createTransaction();
+      tx.__setBPTreeTransaction(btx);
+      tx.onCommit(async () => {
+        if (!tx.__isBPTreeDirty()) {
+          return;
+        }
+        if (!btx) return;
+        const result = await btx.commit();
+        if (result.success) {
+          await this.bptree.init();
+          for (const id of result.obsoleteIds) {
+            await this.strategy.delete(id);
+          }
+        } else {
+          throw new Error(`BPTree transaction commit failed. Current Root: ${this.bptree.getRootId()}`);
+        }
+      });
+    }
+    return btx;
+  }
   /**
    * Initializes the B+ Tree.
    */
@@ -6128,7 +6642,9 @@ var RowTableEngine = class {
       this.metadataPageManager.setRowCount(freshMetadataPage, currentRowCount + 1);
     }
     await this.pfs.setMetadata(freshMetadataPage, tx);
-    await this.bptree.insert(this.getRID(), pk);
+    const btx = await this.getBPTreeTransaction(tx);
+    await btx.insert(this.getRID(), pk);
+    tx.__markBPTreeDirty();
     return pk;
   }
   /**
@@ -6139,11 +6655,8 @@ var RowTableEngine = class {
    * @returns RID or null (if not found)
    */
   async getRidByPK(pk, tx) {
-    const pendingUpdate = tx.__getPendingIndexUpdate(pk);
-    if (pendingUpdate) {
-      return pendingUpdate.newRid;
-    }
-    const keys = await this.bptree.keys({ equal: pk });
+    const btx = await this.getBPTreeTransaction(tx);
+    const keys = await btx.keys({ equal: pk });
     if (keys.size === 0) {
       return null;
     }
@@ -6162,6 +6675,7 @@ var RowTableEngine = class {
    * @param tx Transaction
    */
   async update(pk, data, tx) {
+    await tx.__acquireWriteLock(0);
     const rid = await this.getRidByPK(pk, tx);
     if (rid === null) {
       return;
@@ -6231,16 +6745,10 @@ var RowTableEngine = class {
     const oldRidNumeric = this.getRID();
     this.setRID(lastInsertDataPageId, newSlotIndex);
     const newRidNumeric = this.getRID();
-    if (tx.__getPendingIndexUpdates().size === 0) {
-      tx.onCommit(async () => {
-        const updates = tx.__getPendingIndexUpdates();
-        for (const [key, { newRid, oldRid }] of updates) {
-          await this.bptree.delete(oldRid, key);
-          await this.bptree.insert(newRid, key);
-        }
-      });
-    }
-    tx.__addPendingIndexUpdate(pk, newRidNumeric, oldRidNumeric);
+    const btx = await this.getBPTreeTransaction(tx);
+    await btx.delete(oldRidNumeric, pk);
+    await btx.insert(newRidNumeric, pk);
+    tx.__markBPTreeDirty();
     const freshMetadataPage = await this.pfs.getMetadata(tx);
     this.metadataPageManager.setLastInsertPageId(freshMetadataPage, lastInsertDataPageId);
     await this.pfs.setMetadata(freshMetadataPage, tx);
@@ -6280,6 +6788,9 @@ var RowTableEngine = class {
     }
     this.rowManager.setDeletedFlag(row, true);
     await this.pfs.setPage(pageId, page, tx);
+    const btx = await this.getBPTreeTransaction(tx);
+    await btx.delete(rid, pk);
+    tx.__markBPTreeDirty();
     if (decrementRowCount) {
       const metadataPage2 = await this.pfs.getMetadata(tx);
       const currentRowCount = this.metadataPageManager.getRowCount(metadataPage2);
@@ -6293,12 +6804,14 @@ var RowTableEngine = class {
     if (pageId === lastInsertPageId) {
       allDeleted = false;
     } else {
-      for (let i = 0; i < insertedRowCount; i++) {
+      let i = 0;
+      while (i < insertedRowCount) {
         const slotRow = this.dataPageManager.getRow(page, i);
         if (!this.rowManager.getDeletedFlag(slotRow)) {
           allDeleted = false;
           break;
         }
+        i++;
       }
     }
     if (allDeleted) {
@@ -6361,7 +6874,7 @@ var LockManager = class {
   lock;
   unlockMap = /* @__PURE__ */ new Map();
   constructor() {
-    this.lock = new Ryoiki2();
+    this.lock = new Ryoiki();
   }
   /**
    * Requests a read (Shared) lock for a page.
@@ -6424,12 +6937,41 @@ var Transaction = class {
   pageLocks = /* @__PURE__ */ new Map();
   /** Undo Logs: PageID -> Original Page Buffer (Snapshot) */
   undoPages = /* @__PURE__ */ new Map();
-  /** List of Dirty Pages modified by the transaction */
+  /** Dirty Pages modified by the transaction */
   dirtyPages = /* @__PURE__ */ new Set();
-  /** Pending Index Updates: PK -> { newRid, oldRid } */
-  pendingIndexUpdates = /* @__PURE__ */ new Map();
+  /** BPTree Transaction instance */
+  bptreeTx;
+  /** Whether the BPTree transaction is dirty */
+  bptreeDirty = false;
   /** List of callbacks to execute on commit */
   commitHooks = [];
+  /**
+   * Sets the BPTree transaction.
+   * @param tx BPTree transaction
+   */
+  __setBPTreeTransaction(tx) {
+    this.bptreeTx = tx;
+  }
+  /**
+   * Returns the BPTree transaction.
+   * @returns BPTree transaction
+   */
+  __getBPTreeTransaction() {
+    return this.bptreeTx;
+  }
+  /**
+   * Marks the BPTree transaction as dirty.
+   */
+  __markBPTreeDirty() {
+    this.bptreeDirty = true;
+  }
+  /**
+   * Returns whether the BPTree transaction is dirty.
+   * @returns True if dirty
+   */
+  __isBPTreeDirty() {
+    return this.bptreeDirty;
+  }
   /**
    * Registers a commit hook.
    * @param hook Function to execute
@@ -6465,32 +7007,6 @@ var Transaction = class {
   __hasUndoPage(pageId) {
     return this.undoPages.has(pageId);
   }
-  /**
-   * Adds a Pending Index Update.
-   * Does not call this method directly. It is called by the `VirtualFileSystem` instance.
-   * @param pk PK
-   * @param newRid New RID
-   * @param oldRid Old RID
-   */
-  __addPendingIndexUpdate(pk, newRid, oldRid) {
-    this.pendingIndexUpdates.set(pk, { newRid, oldRid });
-  }
-  /**
-   * Returns a Pending Index Update.
-   * Does not call this method directly. It is called by the `VirtualFileSystem` instance.
-   * @param pk PK
-   * @returns Pending Index Update
-   */
-  __getPendingIndexUpdate(pk) {
-    return this.pendingIndexUpdates.get(pk);
-  }
-  /**
-   * Returns all Pending Index Updates.
-   * Does not call this method directly. It is called by the `VirtualFileSystem` instance.
-   */
-  __getPendingIndexUpdates() {
-    return this.pendingIndexUpdates;
-  }
   /**
    * Acquires a write lock.
    * Does not call this method directly. It is called by the `VirtualFileSystem` instance.
@@ -6518,19 +7034,22 @@ var Transaction = class {
    * Commits the transaction.
    */
   async commit() {
-    await this.vfs.prepareCommit(this);
-    await this.vfs.finalizeCommit(this);
     await this.context.run(this, async () => {
       for (const hook of this.commitHooks) {
         await hook();
       }
     });
+    await this.vfs.prepareCommit(this);
+    await this.vfs.finalizeCommit(this);
     this.releaseAllLocks();
   }
   /**
    * Rolls back the transaction.
    */
-  async rollback() {
+  async rollback(cleanup = true) {
+    if (this.bptreeTx) {
+      await this.bptreeTx.rollback(cleanup);
+    }
     await this.vfs.rollback(this);
     this.releaseAllLocks();
   }
@@ -6669,6 +7188,8 @@ var DataplyAPI = class {
     metadataPageManager.setMagicString(metadataPage);
     metadataPageManager.setPageSize(metadataPage, options.pageSize);
     metadataPageManager.setRootIndexPageId(metadataPage, -1);
+    const order = Math.floor((options.pageSize - IndexPageManager.CONSTANT.OFFSET_KEYS_AND_VALUES + IndexPageManager.CONSTANT.SIZE_KEY) / (IndexPageManager.CONSTANT.SIZE_KEY + IndexPageManager.CONSTANT.SIZE_VALUE));
+    metadataPageManager.setRootIndexOrder(metadataPage, order);
     metadataPageManager.setBitmapPageId(metadataPage, 1);
     metadataPageManager.setLastInsertPageId(metadataPage, 2);
     metadataPageManager.setPageCount(metadataPage, 3);
@@ -7047,7 +7568,9 @@ var GlobalTransaction = class {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BPTreeAsync,
+  BPTreeAsyncTransaction,
   BPTreeSync,
+  BPTreeSyncTransaction,
   BitmapPageManager,
   CacheEntanglementAsync,
   CacheEntanglementSync,