serializable-bptree 6.2.3 → 7.0.0

package/dist/cjs/index.cjs

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   BPTreeAsync: () => BPTreeAsync,
+  BPTreeAsyncTransaction: () => BPTreeAsyncTransaction,
   BPTreeSync: () => BPTreeSync,
+  BPTreeSyncTransaction: () => BPTreeSyncTransaction,
   InMemoryStoreStrategyAsync: () => InMemoryStoreStrategyAsync,
   InMemoryStoreStrategySync: () => InMemoryStoreStrategySync,
   NumericComparator: () => NumericComparator,
@@ -761,8 +763,8 @@ var BPTree = class _BPTree {
   }
 };
 
-// src/BPTreeSync.ts
-var BPTreeSync = class extends BPTree {
+// src/base/BPTreeSyncBase.ts
+var BPTreeSyncBase = class extends BPTree {
   constructor(strategy, comparator, option) {
     super(strategy, comparator, option);
     this.nodes = this._createCachedNode();
@@ -871,7 +873,7 @@ var BPTreeSync = class extends BPTree {
         }
       }
     }
-    if (this.rootId === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
       this.bufferForNodeDelete(node);
       const newRoot = this.getNode(keys[0]);
@@ -940,20 +942,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) {
@@ -1178,10 +1171,6 @@ var BPTreeSync = class extends BPTree {
     }
     return node;
   }
-  /**
-   * Find the insertable node using primaryAsc comparison.
-   * This allows finding nodes by primary value only, ignoring unique identifiers.
-   */
   insertableNodeByPrimary(value) {
     let node = this.getNode(this.rootId);
     while (!node.leaf) {
@@ -1262,6 +1251,33 @@ var BPTreeSync = class extends BPTree {
     }
     return node;
   }
+  exists(key, value) {
+    const node = this.insertableNode(value);
+    for (let i = 0, len = node.values.length; i < len; i++) {
+      if (this.comparator.isSame(value, node.values[i])) {
+        const keys = node.keys[i];
+        if (keys.includes(key)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  forceUpdate(id) {
+    if (id) {
+      this.nodes.delete(id);
+      this.getNode(id);
+      return 1;
+    }
+    const keys = Array.from(this.nodes.keys());
+    for (const key of keys) {
+      this.nodes.delete(key);
+    }
+    for (const key of keys) {
+      this.getNode(key);
+    }
+    return keys.length;
+  }
   commitHeadBuffer() {
     if (!this._strategyDirty) {
       return;
@@ -1292,24 +1308,14 @@ var BPTreeSync = class extends BPTree {
     }
     this._nodeDeleteBuffer.clear();
   }
-  /**
-   * Retrieves the value associated with the given key (PK).
-   * Note: This method performs a full scan of leaf nodes as the tree is ordered by Value, not Key.
-   * 
-   * @param key The key to search for.
-   * @returns The value associated with the key, or undefined if not found.
-   */
   get(key) {
     let node = this.leftestNode();
     while (true) {
-      if (node.values) {
-        const len = node.values.length;
-        for (let i = 0; i < len; i++) {
-          const keys = node.keys[i];
-          for (let j = 0; j < keys.length; j++) {
-            if (keys[j] === key) {
-              return node.values[i];
-            }
+      for (let i = 0, len = node.values.length; i < len; i++) {
+        const keys = node.keys[i];
+        for (let j = 0, kLen = keys.length; j < kLen; j++) {
+          if (keys[j] === key) {
+            return node.values[i];
           }
         }
       }
@@ -1428,21 +1434,15 @@ var BPTreeSync = class extends BPTree {
       const nValue = node.values[i];
       if (this.comparator.isSame(value, nValue)) {
         const keys = node.keys[i];
-        if (keys.includes(key)) {
-          if (keys.length > 1) {
-            keys.splice(keys.indexOf(key), 1);
-            this.bufferForNodeUpdate(node);
-          } else if (node.id === this.rootId) {
-            node.values.splice(i, 1);
-            node.keys.splice(i, 1);
-            this.bufferForNodeUpdate(node);
-          } else {
-            keys.splice(keys.indexOf(key), 1);
+        const keyIndex = keys.indexOf(key);
+        if (keyIndex !== -1) {
+          keys.splice(keyIndex, 1);
+          if (keys.length === 0) {
             node.keys.splice(i, 1);
-            node.values.splice(node.values.indexOf(value), 1);
-            this._deleteEntry(node, key, value);
-            this.bufferForNodeUpdate(node);
+            node.values.splice(i, 1);
           }
+          this._deleteEntry(node, key, value);
+          break;
         }
       }
     }
@@ -1451,298 +1451,356 @@ var BPTreeSync = class extends BPTree {
     this.commitNodeUpdateBuffer();
     this.commitNodeDeleteBuffer();
   }
-  exists(key, value) {
-    const node = this.insertableNode(value);
-    for (let i = 0, len = node.values.length; i < len; i++) {
-      const nValue = node.values[i];
-      if (this.comparator.isSame(value, nValue)) {
-        const keys = node.keys[i];
-        return keys.includes(key);
-      }
-    }
-    return false;
+  getHeadData() {
+    return this.strategy.head.data;
   }
   setHeadData(data) {
     this.strategy.head.data = data;
-    this._strategyDirty = true;
-    this.commitHeadBuffer();
+    this.strategy.writeHead(this.strategy.head);
   }
-  forceUpdate() {
-    const keys = [...this.nodes.keys()];
-    this.nodes.clear();
-    this.init();
-    for (const key of keys) {
-      this.getNode(key);
-    }
-    return keys.length;
+};
+
+// src/base/SerializeStrategy.ts
+var SerializeStrategy = class {
+  order;
+  head;
+  constructor(order) {
+    this.order = order;
+    this.head = {
+      order,
+      root: null,
+      data: {}
+    };
   }
 };
 
-// node_modules/ryoiki/dist/esm/index.mjs
-var Ryoiki = class _Ryoiki {
-  readings;
-  writings;
-  readQueue;
-  writeQueue;
-  static async CatchError(promise) {
-    return await promise.then((v) => [void 0, v]).catch((err) => [err]);
-  }
-  static IsRangeOverlap(a, b) {
-    const [start1, end1] = a;
-    const [start2, end2] = b;
-    if (end1 <= start2 || end2 <= start1) {
+// src/SerializeStrategySync.ts
+var SerializeStrategySync = class extends SerializeStrategy {
+  getHeadData(key, defaultValue) {
+    if (!Object.hasOwn(this.head.data, key)) {
+      this.setHeadData(key, defaultValue);
+    }
+    return this.head.data[key];
+  }
+  setHeadData(key, data) {
+    this.head.data[key] = data;
+    this.writeHead(this.head);
+  }
+  autoIncrement(key, defaultValue) {
+    const current = this.getHeadData(key, defaultValue);
+    const next = current + 1;
+    this.setHeadData(key, next);
+    return current;
+  }
+  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);
-    }
+};
+
+// src/transaction/BPTreeSyncSnapshotStrategy.ts
+var BPTreeSyncSnapshotStrategy = class extends SerializeStrategySync {
+  baseStrategy;
+  snapshotHead;
+  constructor(baseStrategy, root) {
+    super(baseStrategy.order);
+    this.baseStrategy = baseStrategy;
+    this.snapshotHead = {
+      ...baseStrategy.head,
+      root,
+      data: { ...baseStrategy.head.data }
+    };
+    this.head = this.snapshotHead;
   }
-  _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}`;
-  }
-  _alloc(queue, workspaces, lockId) {
-    const unit = queue.get(lockId);
-    if (!unit) {
-      throw _Ryoiki.ERR_NOT_EXISTS(lockId);
-    }
-    workspaces.set(lockId, unit);
-    queue.delete(lockId);
-    unit.alloc();
-  }
-  _free(workspaces, lockId) {
-    const unit = workspaces.get(lockId);
-    if (!unit) {
-      throw _Ryoiki.ERR_NOT_EXISTS(lockId);
-    }
-    workspaces.delete(lockId);
-    unit.free();
-  }
-  _lock(queue, range, timeout, task, condition) {
-    return new Promise((resolve, reject) => {
-      let timeoutId = null;
-      if (timeout >= 0) {
-        timeoutId = setTimeout(() => {
-          reject(_Ryoiki.ERR_TIMEOUT(id, timeout));
-        }, timeout);
-      }
-      const id = this._createRandomId();
-      const alloc = async () => {
-        if (timeoutId !== null) {
-          clearTimeout(timeoutId);
-        }
-        const [err, v] = await _Ryoiki.CatchError(task(id));
-        if (err) reject(err);
-        else resolve(v);
-      };
-      const fetch = () => {
-        this.fetchUnitAndRun(this.readQueue, this.readings);
-        this.fetchUnitAndRun(this.writeQueue, this.writings);
-      };
-      queue.set(id, { id, range, condition, alloc, free: fetch });
-      fetch();
-    });
+  write(id, node) {
+    this.baseStrategy.write(id, node);
   }
-  _checkWorking(range, workspaces) {
-    let isLocked = false;
-    for (const lock of workspaces.values()) {
-      if (_Ryoiki.IsRangeOverlap(range, lock.range)) {
-        isLocked = true;
-        break;
-      }
-    }
-    return isLocked;
+  delete(id) {
+    this.baseStrategy.delete(id);
   }
-  /**
-   * 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);
+  readHead() {
+    return this.snapshotHead;
   }
-  /**
-   * 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);
+  writeHead(head) {
+    this.snapshotHead.root = head.root;
+    this.snapshotHead.data = { ...head.data };
   }
-  /**
-   * Checks if a read lock can be acquired within the specified range.
-   * @param range The range to check for read lock availability.
-   * @returns `true` if a read lock can be acquired, `false` otherwise.
-   */
-  canRead(range) {
-    const writing = this.isWriting(range);
-    return !writing;
+  compareAndSwapHead(oldRoot, newRoot) {
+    return this.baseStrategy.compareAndSwapHead(oldRoot, newRoot);
   }
-  /**
-   * 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;
+  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;
+  }
+};
+
+// src/transaction/BPTreeSyncTransaction.ts
+var BPTreeSyncTransaction = class extends BPTreeSyncBase {
+  realBaseTree;
+  realBaseStrategy;
+  txNodes = /* @__PURE__ */ new Map();
+  dirtyIds = /* @__PURE__ */ new Set();
+  createdInTx = /* @__PURE__ */ new Set();
+  initialRootId;
+  transactionRootId;
+  constructor(baseTree) {
+    super(baseTree.strategy, baseTree.comparator, baseTree.option);
+    this.realBaseTree = baseTree;
+    this.realBaseStrategy = baseTree.strategy;
+    this.initialRootId = "";
+    this.transactionRootId = "";
   }
   /**
-   * 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.
+   * Initializes the transaction by capturing the current state of the tree.
    */
-  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]
+  initTransaction() {
+    const head = this.realBaseStrategy.readHead();
+    this.initialRootId = head?.root ?? this.realBaseTree.rootId;
+    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();
+  }
+  getNode(id) {
+    if (this.txNodes.has(id)) {
+      return this.txNodes.get(id);
+    }
+    const baseNode = this.realBaseStrategy.read(id);
+    const clone = JSON.parse(JSON.stringify(baseNode));
+    this.txNodes.set(id, clone);
+    return clone;
+  }
+  bufferForNodeUpdate(node) {
+    this.txNodes.set(node.id, node);
+    this.dirtyIds.add(node.id);
+    this.markPathDirty(node);
+  }
+  bufferForNodeCreate(node) {
+    this.txNodes.set(node.id, node);
+    this.dirtyIds.add(node.id);
+    this.createdInTx.add(node.id);
+    this.markPathDirty(node);
+  }
+  bufferForNodeDelete(node) {
+    this.txNodes.delete(node.id);
+    this.dirtyIds.add(node.id);
+  }
+  markPathDirty(node) {
+    let curr = node;
+    while (curr.parent) {
+      if (this.dirtyIds.has(curr.parent) && this.txNodes.has(curr.parent)) {
+        break;
       }
-    );
-    return this._lock(
-      this.readQueue,
-      range,
-      timeout,
-      task,
-      () => !this.rangeOverlapping(this.writings, range)
-    );
+      const parent = this.getNode(curr.parent);
+      this.dirtyIds.add(parent.id);
+      curr = parent;
+    }
+    if (!curr.parent) {
+      this.transactionRootId = curr.id;
+    }
+  }
+  _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
+    const id = this.realBaseStrategy.id(isLeaf);
+    const node = {
+      id,
+      keys,
+      values,
+      leaf: isLeaf,
+      parent,
+      next,
+      prev
+    };
+    this.bufferForNodeCreate(node);
+    return node;
   }
   /**
-   * 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.
+   * Attempts to commit the transaction.
+   * Uses Optimistic Locking (Compare-And-Swap) on the root node ID to detect conflicts.
+   * 
+   * @returns The transaction result.
    */
-  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]
+  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);
+        }
       }
-    );
-    return this._lock(
-      this.writeQueue,
-      range,
-      timeout,
-      task,
-      () => {
-        return !this.rangeOverlapping(this.writings, range) && !this.rangeOverlapping(this.readings, range);
+    }
+    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.transactionRootId;
+    if (idMapping.has(this.transactionRootId)) {
+      newRootId = idMapping.get(this.transactionRootId);
+    }
+    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: []
+      };
+    }
   }
   /**
-   * Releases a read lock by its lock ID.
-   * @param lockId - The unique identifier for the lock to release.
+   * Rolls back the transaction by clearing all buffered changes.
+   * Internal use only.
    */
-  readUnlock(lockId) {
-    this._free(this.readings, lockId);
+  rollback() {
+    this.txNodes.clear();
+    this.dirtyIds.clear();
+    this.createdInTx.clear();
+  }
+  // Override to do nothing, as transaction handles its own commits
+  commitHeadBuffer() {
+  }
+  commitNodeCreateBuffer() {
+  }
+  commitNodeUpdateBuffer() {
+  }
+  commitNodeDeleteBuffer() {
+  }
+};
+
+// src/BPTreeSync.ts
+var BPTreeSync = class extends BPTreeSyncBase {
+  constructor(strategy, comparator, option) {
+    super(strategy, comparator, option);
   }
   /**
-   * 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");
+    }
   }
 };
 
-// src/BPTreeAsync.ts
-var BPTreeAsync = class extends BPTree {
-  lock;
+// src/base/BPTreeAsyncBase.ts
+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) => {
@@ -1751,24 +1809,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;
@@ -1866,7 +1906,7 @@ var BPTreeAsync = class extends BPTree {
         }
       }
     }
-    if (this.rootId === node.id && node.keys.length === 1) {
+    if (this.rootId === node.id && node.keys.length === 1 && !node.leaf) {
       const keys = node.keys;
       this.bufferForNodeDelete(node);
       const newRoot = await this.getNode(keys[0]);
@@ -1935,28 +1975,19 @@ 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;
-          }
         }
         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;
+            this.bufferForNodeUpdate(n);
           }
         }
         await this._deleteEntry(await this.getNode(node.parent), node.id, guess);
@@ -2033,21 +2064,24 @@ var BPTreeAsync = class extends BPTree {
           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);
           }
         }
         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);
           }
         }
         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);
@@ -2111,14 +2145,14 @@ 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;
+        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;
+        this.bufferForNodeUpdate(n);
       }
       await this._insertInParent(parentNode, midValue, parentPointer);
       this.bufferForNodeUpdate(parentNode);
@@ -2160,23 +2194,19 @@ var BPTreeAsync = class extends BPTree {
         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]);
           break;
         } else if (this.comparator.isLower(value, nValue)) {
-          node = await this.getNode(k[i]);
+          node = await this.getNode(node.keys[i]);
           break;
         } else if (i + 1 === node.values.length) {
-          node = await this.getNode(k[i + 1]);
+          node = await this.getNode(node.keys[i + 1]);
           break;
         }
       }
     }
     return node;
   }
-  /**
-   * Find the insertable node using primaryAsc comparison.
-   * This allows finding nodes by primary value only, ignoring unique identifiers.
-   */
   async insertableNodeByPrimary(value) {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
@@ -2184,13 +2214,13 @@ var BPTreeAsync = class extends BPTree {
         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]);
           break;
         } else if (this.comparator.isPrimaryLower(value, nValue)) {
-          node = await this.getNode(k[i]);
+          node = await this.getNode(node.keys[i]);
           break;
         } else if (i + 1 === node.values.length) {
-          node = await this.getNode(k[i + 1]);
+          node = await this.getNode(node.keys[i + 1]);
           break;
         }
       }
@@ -2204,11 +2234,11 @@ var BPTreeAsync = class extends BPTree {
         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]);
           break;
         }
         if (i + 1 === node.values.length) {
-          node = await this.getNode(k[i + 1]);
+          node = await this.getNode(node.keys[i + 1]);
           break;
         }
       }
@@ -2245,7 +2275,7 @@ var BPTreeAsync = class extends BPTree {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
-      node = await this.getNode(keys[0]);
+      node = await this.getNode(node.keys[0]);
     }
     return node;
   }
@@ -2253,10 +2283,37 @@ var BPTreeAsync = class extends BPTree {
     let node = await this.getNode(this.rootId);
     while (!node.leaf) {
       const keys = node.keys;
-      node = await this.getNode(keys[keys.length - 1]);
+      node = await this.getNode(node.keys[node.keys.length - 1]);
     }
     return node;
   }
+  async exists(key, value) {
+    const node = await this.insertableNode(value);
+    for (let i = 0, len = node.values.length; i < len; i++) {
+      if (this.comparator.isSame(value, node.values[i])) {
+        const keys = node.keys[i];
+        if (keys.includes(key)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  async forceUpdate(id) {
+    if (id) {
+      this.nodes.delete(id);
+      await this.getNode(id);
+      return 1;
+    }
+    const keys = Array.from(this.nodes.keys());
+    for (const key of keys) {
+      this.nodes.delete(key);
+    }
+    for (const key of keys) {
+      await this.getNode(key);
+    }
+    return keys.length;
+  }
   async commitHeadBuffer() {
     if (!this._strategyDirty) {
       return;
@@ -2287,25 +2344,15 @@ var BPTreeAsync = class extends BPTree {
     }
     this._nodeDeleteBuffer.clear();
   }
-  /**
-   * Retrieves the value associated with the given key (PK).
-   * Note: This method performs a full scan of leaf nodes as the tree is ordered by Value, not Key.
-   * 
-   * @param key The key to search for.
-   * @returns The value associated with the key, or undefined if not found.
-   */
   async get(key) {
-    return this.readLock(async () => {
+    return await this.readLock(async () => {
       let node = await this.leftestNode();
       while (true) {
-        if (node.values) {
-          const len = node.values.length;
-          for (let i = 0; i < len; i++) {
-            const keys = node.keys[i];
-            for (let j = 0; j < keys.length; j++) {
-              if (keys[j] === key) {
-                return node.values[i];
-              }
+        for (let i = 0, len = node.values.length; i < len; i++) {
+          const keys = node.keys[i];
+          for (let j = 0, kLen = keys.length; j < kLen; j++) {
+            if (keys[j] === key) {
+              return node.values[i];
             }
           }
         }
@@ -2380,25 +2427,21 @@ var BPTreeAsync = class extends BPTree {
     }
   }
   async keys(condition, filterValues) {
-    return this.readLock(async () => {
-      const set = /* @__PURE__ */ new Set();
-      for await (const key of this.keysStream(condition, filterValues)) {
-        set.add(key);
-      }
-      return set;
-    });
+    const set = /* @__PURE__ */ new Set();
+    for await (const key of this.keysStream(condition, filterValues)) {
+      set.add(key);
+    }
+    return set;
   }
   async where(condition) {
-    return this.readLock(async () => {
-      const map = /* @__PURE__ */ new Map();
-      for await (const [key, value] of this.whereStream(condition)) {
-        map.set(key, value);
-      }
-      return map;
-    });
+    const map = /* @__PURE__ */ new Map();
+    for await (const [key, value] of this.whereStream(condition)) {
+      map.set(key, value);
+    }
+    return map;
   }
   async insert(key, value) {
-    return this.writeLock(async () => {
+    await this.writeLock(async () => {
       const before = await this.insertableNode(value);
       this._insertAtLeaf(before, key, value);
       if (before.values.length === this.order) {
@@ -2425,182 +2468,368 @@ var BPTreeAsync = class extends BPTree {
     });
   }
   async delete(key, value) {
-    return this.writeLock(async () => {
+    await this.writeLock(async () => {
       const node = await this.insertableNode(value);
       let i = node.values.length;
       while (i--) {
         const nValue = node.values[i];
         if (this.comparator.isSame(value, nValue)) {
           const keys = node.keys[i];
-          if (keys.includes(key)) {
-            if (keys.length > 1) {
-              keys.splice(keys.indexOf(key), 1);
-              this.bufferForNodeUpdate(node);
-            } else if (node.id === this.rootId) {
-              node.values.splice(i, 1);
-              node.keys.splice(i, 1);
-              this.bufferForNodeUpdate(node);
-            } else {
-              keys.splice(keys.indexOf(key), 1);
+          const keyIndex = keys.indexOf(key);
+          if (keyIndex !== -1) {
+            keys.splice(keyIndex, 1);
+            if (keys.length === 0) {
               node.keys.splice(i, 1);
-              node.values.splice(node.values.indexOf(value), 1);
-              await this._deleteEntry(node, key, value);
-              this.bufferForNodeUpdate(node);
+              node.values.splice(i, 1);
             }
+            await this._deleteEntry(node, key, value);
+            break;
           }
         }
       }
       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;
-    });
+  getHeadData() {
+    return this.strategy.head.data;
   }
   async setHeadData(data) {
-    return this.writeLock(async () => {
-      this.strategy.head.data = data;
-      this._strategyDirty = true;
-      await this.commitHeadBuffer();
-    });
-  }
-  async forceUpdate() {
-    return this.readLock(async () => {
-      const keys = [...this.nodes.keys()];
-      this.nodes.clear();
-      await this.init();
-      for (const key of keys) {
-        await this.getNode(key);
-      }
-      return keys.length;
-    });
-  }
-};
-
-// src/base/SerializeStrategy.ts
-var SerializeStrategy = class {
-  order;
-  head;
-  constructor(order) {
-    this.order = order;
-    this.head = {
-      order,
-      root: null,
-      data: {}
-    };
+    this.strategy.head.data = data;
+    await this.strategy.writeHead(this.strategy.head);
   }
 };
 
-// src/SerializeStrategySync.ts
-var SerializeStrategySync = class extends SerializeStrategy {
-  getHeadData(key, defaultValue) {
+// src/SerializeStrategyAsync.ts
+var SerializeStrategyAsync = class extends SerializeStrategy {
+  async getHeadData(key, defaultValue) {
     if (!Object.hasOwn(this.head.data, key)) {
-      this.setHeadData(key, defaultValue);
+      await this.setHeadData(key, defaultValue);
     }
     return this.head.data[key];
   }
-  setHeadData(key, data) {
+  async setHeadData(key, data) {
     this.head.data[key] = data;
-    this.writeHead(this.head);
+    await this.writeHead(this.head);
   }
-  autoIncrement(key, defaultValue) {
-    const current = this.getHeadData(key, defaultValue);
+  async autoIncrement(key, defaultValue) {
+    const current = await this.getHeadData(key, defaultValue);
     const next = current + 1;
-    this.setHeadData(key, next);
+    await this.setHeadData(key, next);
     return current;
   }
+  async compareAndSwapHead(oldRoot, newRoot) {
+    if (this.head.root !== oldRoot) {
+      return false;
+    }
+    this.head.root = newRoot;
+    await this.writeHead(this.head);
+    return true;
+  }
 };
-var InMemoryStoreStrategySync = class extends SerializeStrategySync {
+var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
   node;
   constructor(order) {
     super(order);
     this.node = {};
   }
-  id(isLeaf) {
-    return this.autoIncrement("index", 1).toString();
+  async id(isLeaf) {
+    return (await this.autoIncrement("index", 1)).toString();
   }
-  read(id) {
+  async read(id) {
     if (!Object.hasOwn(this.node, id)) {
       throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
     }
-    return this.node[id];
+    const node = this.node[id];
+    return JSON.parse(JSON.stringify(node));
   }
-  write(id, node) {
+  async write(id, node) {
     this.node[id] = node;
   }
-  delete(id) {
+  async delete(id) {
     delete this.node[id];
   }
-  readHead() {
+  async readHead() {
     if (this.head.root === null) {
       return null;
     }
     return this.head;
   }
-  writeHead(head) {
+  async writeHead(head) {
     this.head = head;
   }
 };
 
-// src/SerializeStrategyAsync.ts
-var SerializeStrategyAsync = class extends SerializeStrategy {
+// src/transaction/BPTreeAsyncSnapshotStrategy.ts
+var BPTreeAsyncSnapshotStrategy = class extends SerializeStrategyAsync {
+  baseStrategy;
+  snapshotHead;
+  constructor(baseStrategy, root) {
+    super(baseStrategy.order);
+    this.baseStrategy = baseStrategy;
+    this.snapshotHead = {
+      ...baseStrategy.head,
+      root,
+      data: { ...baseStrategy.head.data }
+    };
+    this.head = this.snapshotHead;
+  }
+  async id(isLeaf) {
+    return await this.baseStrategy.id(isLeaf);
+  }
+  async read(id) {
+    return await this.baseStrategy.read(id);
+  }
+  async write(id, node) {
+    await this.baseStrategy.write(id, node);
+  }
+  async delete(id) {
+    await this.baseStrategy.delete(id);
+  }
+  async readHead() {
+    return this.snapshotHead;
+  }
+  async writeHead(head) {
+    this.snapshotHead.root = head.root;
+    this.snapshotHead.data = { ...head.data };
+  }
+  async compareAndSwapHead(oldRoot, newRoot) {
+    return await this.baseStrategy.compareAndSwapHead(oldRoot, newRoot);
+  }
   async getHeadData(key, defaultValue) {
-    if (!Object.hasOwn(this.head.data, key)) {
-      await this.setHeadData(key, defaultValue);
-    }
-    return this.head.data[key];
+    return this.snapshotHead.data[key] ?? defaultValue;
   }
   async setHeadData(key, data) {
-    this.head.data[key] = data;
-    await this.writeHead(this.head);
+    this.snapshotHead.data[key] = data;
   }
   async autoIncrement(key, defaultValue) {
-    const current = await this.getHeadData(key, defaultValue);
-    const next = current + 1;
-    await this.setHeadData(key, next);
-    return current;
+    return this.snapshotHead.data[key] ?? defaultValue;
   }
 };
-var InMemoryStoreStrategyAsync = class extends SerializeStrategyAsync {
-  node;
-  constructor(order) {
-    super(order);
-    this.node = {};
+
+// src/transaction/BPTreeAsyncTransaction.ts
+var BPTreeAsyncTransaction = class extends BPTreeAsyncBase {
+  realBaseTree;
+  realBaseStrategy;
+  txNodes = /* @__PURE__ */ new Map();
+  dirtyIds = /* @__PURE__ */ new Set();
+  createdInTx = /* @__PURE__ */ new Set();
+  initialRootId;
+  transactionRootId;
+  constructor(baseTree) {
+    super(baseTree.strategy, baseTree.comparator, baseTree.option);
+    this.realBaseTree = baseTree;
+    this.realBaseStrategy = baseTree.strategy;
+    this.initialRootId = "";
+    this.transactionRootId = "";
   }
-  async id(isLeaf) {
-    return (await this.autoIncrement("index", 1)).toString();
+  /**
+   * Initializes the transaction by capturing the current state of the tree.
+   */
+  async initTransaction() {
+    const head = await this.realBaseStrategy.readHead();
+    this.initialRootId = head?.root ?? this.realBaseTree.rootId;
+    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();
   }
-  async read(id) {
-    if (!Object.hasOwn(this.node, id)) {
-      throw new Error(`The tree attempted to reference node '${id}', but couldn't find the corresponding node.`);
+  async getNode(id) {
+    if (this.txNodes.has(id)) {
+      return this.txNodes.get(id);
+    }
+    const baseNode = await this.realBaseStrategy.read(id);
+    const clone = JSON.parse(JSON.stringify(baseNode));
+    this.txNodes.set(id, clone);
+    return clone;
+  }
+  async bufferForNodeUpdate(node) {
+    this.txNodes.set(node.id, node);
+    this.dirtyIds.add(node.id);
+    await this.markPathDirty(node);
+  }
+  async bufferForNodeCreate(node) {
+    this.txNodes.set(node.id, node);
+    this.dirtyIds.add(node.id);
+    this.createdInTx.add(node.id);
+    await this.markPathDirty(node);
+  }
+  async bufferForNodeDelete(node) {
+    this.txNodes.delete(node.id);
+    this.dirtyIds.add(node.id);
+  }
+  async markPathDirty(node) {
+    let curr = node;
+    while (curr.parent) {
+      if (this.dirtyIds.has(curr.parent) && this.txNodes.has(curr.parent)) {
+        break;
+      }
+      const parent = await this.getNode(curr.parent);
+      this.dirtyIds.add(parent.id);
+      curr = parent;
+    }
+    if (!curr.parent) {
+      this.transactionRootId = curr.id;
     }
-    return this.node[id];
   }
-  async write(id, node) {
-    this.node[id] = node;
+  async _createNode(isLeaf, keys, values, leaf = false, parent = null, next = null, prev = null) {
+    const id = await this.realBaseStrategy.id(isLeaf);
+    const node = {
+      id,
+      keys,
+      values,
+      leaf: isLeaf,
+      parent,
+      next,
+      prev
+    };
+    await this.bufferForNodeCreate(node);
+    return node;
   }
-  async delete(id) {
-    delete this.node[id];
+  /**
+   * 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.transactionRootId;
+    if (idMapping.has(this.transactionRootId)) {
+      newRootId = idMapping.get(this.transactionRootId);
+    }
+    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: []
+      };
+    }
   }
-  async readHead() {
-    if (this.head.root === null) {
-      return null;
+  /**
+   * Rolls back the transaction by clearing all buffered changes.
+   * Internal use only.
+   */
+  async rollback() {
+    this.txNodes.clear();
+    this.dirtyIds.clear();
+    this.createdInTx.clear();
+  }
+  async readLock(fn) {
+    return await fn();
+  }
+  async writeLock(fn) {
+    return await fn();
+  }
+  async commitHeadBuffer() {
+  }
+  async commitNodeCreateBuffer() {
+  }
+  async commitNodeUpdateBuffer() {
+  }
+  async commitNodeDeleteBuffer() {
+  }
+};
+
+// src/BPTreeAsync.ts
+var BPTreeAsync = class extends BPTreeAsyncBase {
+  constructor(strategy, comparator, option) {
+    super(strategy, comparator, option);
+  }
+  /**
+   * Creates a new asynchronous transaction.
+   * @returns A promise that resolves to a new BPTreeAsyncTransaction.
+   */
+  async createTransaction() {
+    const tx = new BPTreeAsyncTransaction(this);
+    await tx.initTransaction();
+    return tx;
+  }
+  async insert(key, value) {
+    const tx = await this.createTransaction();
+    await tx.insert(key, value);
+    const { success } = await tx.commit();
+    await this.init();
+    if (!success) {
+      throw new Error("Transaction failed: Commit failed due to conflict");
     }
-    return this.head;
   }
-  async writeHead(head) {
-    this.head = head;
+  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();
   }
 };