dataply 0.0.26-alpha.8 → 0.0.26

package/dist/cjs/index.js

@@ -2191,13 +2191,7 @@ function insertOp(ops, ctx, key, value, comparator) {
 }
 function deleteEntry(ops, ctx, node, key, comparator) {
   if (!node.leaf) {
-    let keyIndex = -1;
-    for (let i = 0, len = node.keys.length; i < len; i++) {
-      if (node.keys[i] === key) {
-        keyIndex = i;
-        break;
-      }
-    }
+    let keyIndex = node.keys.indexOf(key);
     if (keyIndex !== -1) {
       node = cloneNode(node);
       node.keys.splice(keyIndex, 1);
@@ -2236,17 +2230,15 @@ function deleteEntry(ops, ctx, node, key, comparator) {
     let nextNode = null;
     let prevValue = null;
     let postValue = null;
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      const nKey = parentNode.keys[i];
-      if (nKey === node.id) {
-        if (i > 0) {
-          prevNode = ops.getNode(parentNode.keys[i - 1]);
-          prevValue = parentNode.values[i - 1];
-        }
-        if (i < parentNode.keys.length - 1) {
-          nextNode = ops.getNode(parentNode.keys[i + 1]);
-          postValue = parentNode.values[i];
-        }
+    let keyIndex = parentNode.keys.indexOf(node.id);
+    if (keyIndex !== -1) {
+      if (keyIndex > 0) {
+        prevNode = ops.getNode(parentNode.keys[keyIndex - 1]);
+        prevValue = parentNode.values[keyIndex - 1];
+      }
+      if (keyIndex < parentNode.keys.length - 1) {
+        nextNode = ops.getNode(parentNode.keys[keyIndex + 1]);
+        postValue = parentNode.values[keyIndex];
       }
     }
     let siblingNode;
@@ -2279,7 +2271,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         siblingNode = node;
         node = pTemp;
       }
-      siblingNode.keys.push(...node.keys);
+      siblingNode.keys = siblingNode.keys.concat(node.keys);
       if (!node.leaf) {
         siblingNode.values.push(guess);
       } else {
@@ -2290,7 +2282,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
           ops.updateNode(n);
         }
       }
-      siblingNode.values.push(...node.values);
+      siblingNode.values = siblingNode.values.concat(node.values);
       if (!siblingNode.leaf) {
         const keys = siblingNode.keys;
         for (let i = 0, len = keys.length; i < len; i++) {
@@ -2338,8 +2330,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
         if (!node.leaf) {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, guess];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(guess);
           parentNode = cloneNode(ops.getNode(node.parent));
           const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
           if (pointerIndex > 0) {
@@ -2430,6 +2422,13 @@ function deleteOp(ops, ctx, key, comparator, value) {
     break;
   }
 }
+function batchDeleteOp(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  for (let i = 0, len = entries.length; i < len; i++) {
+    const [key, value] = entries[i];
+    deleteOp(ops, ctx, key, comparator, value);
+  }
+}
 function batchInsertOp(ops, ctx, entries, comparator) {
   if (entries.length === 0) return;
   const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
@@ -2985,27 +2984,12 @@ var BPTreeTransaction = class _BPTreeTransaction {
   static CheckConflicts(transactions) {
     return MVCCTransaction.CheckConflicts(transactions.map((tx) => tx.mvcc));
   }
-  /**
-   * 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;
   }
-  /**
-   * Verified if the value satisfies the condition.
-   * 
-   * @param nodeValue The value to verify.
-   * @param condition The condition to verify against.
-   * @returns Returns true if the value satisfies the condition.
-   */
   verify(nodeValue, condition) {
     for (const key in condition) {
       const verify2 = this.verifierMap[key];
@@ -3264,6 +3248,9 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
     this._verifierMapCached = createVerifierMap(this.comparator, this._cachedRegexp, ensureValues);
     this._searchConfigsCached = createSearchConfigs(this.comparator, ensureValues);
   }
+  getRootNode() {
+    return this.getNode(this.rootId);
+  }
   // ─── Legacy protected methods (delegating to ops) ────────────────
   getNode(id) {
     return this._ops.getNode(id);
@@ -3413,6 +3400,9 @@ var BPTreeSyncTransaction = class extends BPTreeTransaction {
   delete(key, value) {
     deleteOp(this._ops, this._ctx, key, this.comparator, value);
   }
+  batchDelete(entries) {
+    batchDeleteOp(this._ops, this._ctx, entries, this.comparator);
+  }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
     const head = this._readHead();
@@ -3534,6 +3524,14 @@ var BPTreeSync = class extends BPTreeSyncTransaction {
       throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
     }
   }
+  batchDelete(entries) {
+    const tx = this.createTransaction();
+    tx.batchDelete(entries);
+    const result = tx.commit();
+    if (!result.success) {
+      throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+    }
+  }
   batchInsert(entries) {
     const tx = this.createTransaction();
     tx.batchInsert(entries);
@@ -4218,13 +4216,7 @@ async function insertOpAsync(ops, ctx, key, value, comparator) {
 }
 async function deleteEntryAsync(ops, ctx, node, key, comparator) {
   if (!node.leaf) {
-    let keyIndex = -1;
-    for (let i = 0, len = node.keys.length; i < len; i++) {
-      if (node.keys[i] === key) {
-        keyIndex = i;
-        break;
-      }
-    }
+    let keyIndex = node.keys.indexOf(key);
     if (keyIndex !== -1) {
       node = cloneNode(node);
       node.keys.splice(keyIndex, 1);
@@ -4253,16 +4245,15 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
     let nextNode = null;
     let prevValue = null;
     let postValue = null;
-    for (let i = 0, len = parentNode.keys.length; i < len; i++) {
-      if (parentNode.keys[i] === node.id) {
-        if (i > 0) {
-          prevNode = await ops.getNode(parentNode.keys[i - 1]);
-          prevValue = parentNode.values[i - 1];
-        }
-        if (i < parentNode.keys.length - 1) {
-          nextNode = await ops.getNode(parentNode.keys[i + 1]);
-          postValue = parentNode.values[i];
-        }
+    let keyIndex = parentNode.keys.indexOf(node.id);
+    if (keyIndex !== -1) {
+      if (keyIndex > 0) {
+        prevNode = await ops.getNode(parentNode.keys[keyIndex - 1]);
+        prevValue = parentNode.values[keyIndex - 1];
+      }
+      if (keyIndex < parentNode.keys.length - 1) {
+        nextNode = await ops.getNode(parentNode.keys[keyIndex + 1]);
+        postValue = parentNode.values[keyIndex];
       }
     }
     let siblingNode;
@@ -4289,11 +4280,11 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
     siblingNode = cloneNode(siblingNode);
     if (node.values.length + siblingNode.values.length < ctx.order) {
       if (!isPredecessor) {
-        const t = siblingNode;
+        const pTemp = siblingNode;
         siblingNode = node;
-        node = t;
+        node = pTemp;
       }
-      siblingNode.keys.push(...node.keys);
+      siblingNode.keys = siblingNode.keys.concat(node.keys);
       if (!node.leaf) {
         siblingNode.values.push(guess);
       } else {
@@ -4304,7 +4295,7 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
           await ops.updateNode(n);
         }
       }
-      siblingNode.values.push(...node.values);
+      siblingNode.values = siblingNode.values.concat(node.values);
       if (!siblingNode.leaf) {
         for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
           const n = cloneNode(await ops.getNode(siblingNode.keys[i]));
@@ -4348,8 +4339,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
         if (!node.leaf) {
           pointerP0 = siblingNode.keys.splice(0, 1)[0];
           pointerK0 = siblingNode.values.splice(0, 1)[0];
-          node.keys = [...node.keys, pointerP0];
-          node.values = [...node.values, guess];
+          node.keys = node.keys.concat(pointerP0);
+          node.values = node.values.concat(guess);
           parentNode = cloneNode(await ops.getNode(node.parent));
           const pi = parentNode.keys.indexOf(siblingNode.id);
           if (pi > 0) {
@@ -4432,6 +4423,13 @@ async function deleteOpAsync(ops, ctx, key, comparator, value) {
     break;
   }
 }
+async function batchDeleteOpAsync(ops, ctx, entries, comparator) {
+  if (entries.length === 0) return;
+  for (let i = 0, len = entries.length; i < len; i++) {
+    const [key, value] = entries[i];
+    await deleteOpAsync(ops, ctx, key, comparator, value);
+  }
+}
 async function batchInsertOpAsync(ops, ctx, entries, comparator) {
   if (entries.length === 0) return;
   const sorted = [...entries].sort((a, b) => comparator.asc(a[1], b[1]));
@@ -4692,6 +4690,9 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       this.lock.writeUnlock(lockId);
     });
   }
+  async getRootNode() {
+    return this.getNode(this.rootId);
+  }
   // ─── Legacy protected methods (delegating to ops) ────────────────
   async getNode(id) {
     return this._ops.getNode(id);
@@ -4851,6 +4852,12 @@ var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       await deleteOpAsync(this._ops, this._ctx, key, this.comparator, value);
     });
   }
+  async batchDelete(entries) {
+    if (entries.length === 0) return;
+    return this.writeLock(0, async () => {
+      await batchDeleteOpAsync(this._ops, this._ctx, entries, this.comparator);
+    });
+  }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
     const head = await this._readHead();
@@ -4976,6 +4983,16 @@ var BPTreeAsync = class extends BPTreeAsyncTransaction {
       }
     });
   }
+  async batchDelete(entries) {
+    return this.writeLock(1, async () => {
+      const tx = await this.createTransaction();
+      await tx.batchDelete(entries);
+      const result = await tx.commit();
+      if (!result.success) {
+        throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+      }
+    });
+  }
   async batchInsert(entries) {
     return this.writeLock(1, async () => {
       const tx = await this.createTransaction();
@@ -5002,8 +5019,6 @@ var BPTreePureSync = class {
   comparator;
   option;
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5017,11 +5032,16 @@ var BPTreePureSync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
+    const readBuffer = /* @__PURE__ */ new Map();
     return {
       getNode(id) {
-        return strategy.read(id);
+        const buffered = readBuffer.get(id);
+        if (buffered) return buffered;
+        const node = strategy.read(id);
+        readBuffer.set(id, node);
+        return node;
       },
       createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = strategy.id(leaf);
@@ -5041,6 +5061,7 @@ var BPTreePureSync = class {
   }
   _createBufferedOps() {
     const strategy = this.strategy;
+    const readBuffer = /* @__PURE__ */ new Map();
     const writeBuffer = /* @__PURE__ */ new Map();
     const deleteBuffer = /* @__PURE__ */ new Set();
     let headBuffer = null;
@@ -5048,7 +5069,11 @@ var BPTreePureSync = class {
       getNode(id) {
         const buffered = writeBuffer.get(id);
         if (buffered) return buffered;
-        return strategy.read(id);
+        const read = readBuffer.get(id);
+        if (read) return read;
+        const node = strategy.read(id);
+        readBuffer.set(id, node);
+        return node;
       },
       createNode(leaf, keys, values, parent = null, next = null, prev = null) {
         const id = strategy.id(leaf);
@@ -5073,6 +5098,7 @@ var BPTreePureSync = class {
     };
     function flush() {
       for (const id of deleteBuffer) {
+        writeBuffer.delete(id);
         strategy.delete(id);
       }
       for (const [id, node] of writeBuffer) {
@@ -5081,19 +5107,42 @@ var BPTreePureSync = class {
       if (headBuffer) {
         strategy.writeHead(headBuffer);
       }
+      readBuffer.clear();
+      writeBuffer.clear();
+      deleteBuffer.clear();
+      headBuffer = null;
     }
     return { ops, flush };
   }
+  _readCtx() {
+    const head = this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  _createCtx() {
+    const strategy = this.strategy;
+    const head = strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   init() {
     const { ops, flush } = this._createBufferedOps();
-    this._ctx = {
+    const ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
       ops,
-      this._ctx,
+      ctx,
       this.strategy.order,
       this.strategy.head,
       (head) => {
@@ -5101,23 +5150,19 @@ var BPTreePureSync = class {
       }
     );
     flush();
-    this._ops = this._createOps();
   }
-  /**
-   * Returns the ID of the root node.
-   */
+  getRootNode() {
+    const ctx = this._readCtx();
+    return this.strategy.read(ctx.rootId);
+  }
   getRootId() {
-    return this._ctx.rootId;
+    const ctx = this._readCtx();
+    return ctx.rootId;
   }
-  /**
-   * Returns the order of the B+Tree.
-   */
   getOrder() {
-    return this._ctx.order;
+    const ctx = this._readCtx();
+    return ctx.order;
   }
-  /**
-   * Verified if the value satisfies the condition.
-   */
   verify(nodeValue, condition) {
     for (const key in condition) {
       const verifyFn = this._verifierMap[key];
@@ -5130,15 +5175,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    return getOp(this._ops, this._ctx.rootId, key);
+    const ctx = this._readCtx();
+    return getOp(this._createReadOps(), ctx.rootId, key);
   }
   exists(key, value) {
-    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const ctx = this._readCtx();
+    return existsOp(this._createReadOps(), ctx.rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
+    const ctx = this._readCtx();
     yield* keysStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5148,9 +5196,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
+    const ctx = this._readCtx();
     yield* whereStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      ctx.rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5176,27 +5225,37 @@ var BPTreePureSync = class {
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    insertOp(ops, this._ctx, key, value, this.comparator);
+    const ctx = this._createCtx();
+    insertOp(ops, ctx, key, value, this.comparator);
     flush();
   }
   delete(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    deleteOp(ops, this._ctx, key, this.comparator, value);
+    const ctx = this._createCtx();
+    deleteOp(ops, ctx, key, this.comparator, value);
+    flush();
+  }
+  batchDelete(entries) {
+    const { ops, flush } = this._createBufferedOps();
+    const ctx = this._createCtx();
+    batchDeleteOp(ops, ctx, entries, this.comparator);
     flush();
   }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
-    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    batchInsertOp(ops, ctx, entries, this.comparator);
     flush();
   }
   bulkLoad(entries) {
     const { ops, flush } = this._createBufferedOps();
-    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    bulkLoadOp(ops, ctx, entries, this.comparator);
     flush();
   }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
-    const head = this._ops.readHead();
+    const head = this.strategy.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
@@ -5224,8 +5283,6 @@ var BPTreePureAsync = class {
   option;
   lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5239,8 +5296,9 @@ var BPTreePureAsync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
+    let headBuffer = null;
     return {
       async getNode(id) {
         return await strategy.read(id);
@@ -5255,9 +5313,12 @@ var BPTreePureAsync = class {
       async deleteNode() {
       },
       async readHead() {
-        return await strategy.readHead();
+        if (headBuffer) return headBuffer;
+        headBuffer = await strategy.readHead();
+        return headBuffer;
       },
-      async writeHead() {
+      async writeHead(head) {
+        headBuffer = head;
       }
     };
   }
@@ -5287,7 +5348,8 @@ var BPTreePureAsync = class {
       },
       async readHead() {
         if (headBuffer) return headBuffer;
-        return await strategy.readHead();
+        headBuffer = await strategy.readHead();
+        return headBuffer;
       },
       async writeHead(head) {
         headBuffer = head;
@@ -5295,6 +5357,7 @@ var BPTreePureAsync = class {
     };
     async function flush() {
       for (const id of deleteBuffer) {
+        writeBuffer.delete(id);
         await strategy.delete(id);
       }
       for (const [id, node] of writeBuffer) {
@@ -5303,9 +5366,31 @@ var BPTreePureAsync = class {
       if (headBuffer) {
         await strategy.writeHead(headBuffer);
       }
+      writeBuffer.clear();
+      deleteBuffer.clear();
+      headBuffer = null;
     }
     return { ops, flush };
   }
+  async _readCtx() {
+    const head = await this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  async _createCtx() {
+    const strategy = this.strategy;
+    const head = await strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   async writeLock(fn) {
     let lockId;
     return this.lock.writeLock(async (_lockId) => {
@@ -5318,14 +5403,14 @@ var BPTreePureAsync = class {
   async init() {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      this._ctx = {
+      const ctx = {
         rootId: "",
         order: this.strategy.order,
         headData: () => this.strategy.head.data
       };
       await initOpAsync(
         ops,
-        this._ctx,
+        ctx,
         this.strategy.order,
         this.strategy.head,
         (head) => {
@@ -5333,14 +5418,19 @@ var BPTreePureAsync = class {
         }
       );
       await flush();
-      this._ops = this._createOps();
     });
   }
-  getRootId() {
-    return this._ctx.rootId;
+  async getRootNode() {
+    const ctx = await this._readCtx();
+    return await this.strategy.read(ctx.rootId);
   }
-  getOrder() {
-    return this._ctx.order;
+  async getRootId() {
+    const ctx = await this._readCtx();
+    return ctx.rootId;
+  }
+  async getOrder() {
+    const ctx = await this._readCtx();
+    return ctx.order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5352,18 +5442,21 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    return getOpAsync(this._ops, this._ctx.rootId, key);
+    const ctx = await this._readCtx();
+    return getOpAsync(this._createReadOps(), ctx.rootId, key);
   }
   async exists(key, value) {
-    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const ctx = await this._readCtx();
+    return existsOpAsync(this._createReadOps(), ctx.rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const ctx = await this._readCtx();
       yield* keysStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5379,9 +5472,10 @@ var BPTreePureAsync = class {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const ctx = await this._readCtx();
       yield* whereStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        ctx.rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5411,34 +5505,46 @@ var BPTreePureAsync = class {
   async insert(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      const ctx = await this._createCtx();
+      await insertOpAsync(ops, ctx, key, value, this.comparator);
       await flush();
     });
   }
   async delete(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      const ctx = await this._createCtx();
+      await deleteOpAsync(ops, ctx, key, this.comparator, value);
       await flush();
     });
   }
   async batchInsert(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await batchInsertOpAsync(ops, ctx, entries, this.comparator);
+      await flush();
+    });
+  }
+  async batchDelete(entries) {
+    return this.writeLock(async () => {
+      const { ops, flush } = this._createBufferedOps();
+      const ctx = await this._createCtx();
+      await batchDeleteOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await bulkLoadOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
-    const head = await this._ops.readHead();
+    const head = await this.strategy.readHead();
     if (head === null) throw new Error("Head not found");
     return head.data;
   }
@@ -9859,7 +9965,7 @@ var PageFileSystem = class {
    * @param tx Transaction
    */
   async updateBitmap(pageId, isFree, tx) {
-    const metadata = await this.getMetadata(tx);
+    const metadata = await this.getMetadata(false, tx);
     const metadataManager = this.pageFactory.getManager(metadata);
     const bitmapPageId = metadataManager.getBitmapPageId(metadata);
     const headerSize = PageManager.CONSTANT.SIZE_PAGE_HEADER;
@@ -9867,7 +9973,7 @@ var PageFileSystem = class {
     let currentBitmapPageId = bitmapPageId;
     let targetBitIndex = pageId;
     while (targetBitIndex >= capacityPerBitmapPage) {
-      const currentBitmapPage = await this.get(currentBitmapPageId, tx);
+      const currentBitmapPage = await this.get(currentBitmapPageId, true, tx);
       const manager = this.pageFactory.getManager(currentBitmapPage);
       targetBitIndex -= capacityPerBitmapPage;
       const nextPageId = manager.getNextPageId(currentBitmapPage);
@@ -9884,7 +9990,7 @@ var PageFileSystem = class {
       }
     }
     await tx.__acquireWriteLock(currentBitmapPageId);
-    const targetBitmapPage = await this.get(currentBitmapPageId, tx);
+    const targetBitmapPage = await this.get(currentBitmapPageId, true, tx);
     const bitmapManager = this.pageFactory.getManager(targetBitmapPage);
     bitmapManager.setBit(targetBitmapPage, targetBitIndex, isFree);
     await this.setPage(currentBitmapPageId, targetBitmapPage, tx);
@@ -9903,20 +10009,22 @@ var PageFileSystem = class {
   }
   /**
    * @param pageIndex 페이지 인덱스
+   * @param copy Copy-on-Read
    * @param tx 트랜잭션
    * @returns 페이지 버퍼
    */
-  async get(pageIndex, tx) {
-    return tx.__readPage(pageIndex);
+  async get(pageIndex, copy, tx) {
+    return tx.__readPage(pageIndex, copy);
   }
   /**
    * Reads the page header.
    * @param pageIndex Page index
+   * @param copy Copy-on-Read
    * @param tx Transaction
    * @returns Page header buffer
    */
-  async getHeader(pageIndex, tx) {
-    const page = await this.get(pageIndex, tx);
+  async getHeader(pageIndex, copy, tx) {
+    const page = await this.get(pageIndex, copy, tx);
     return page.subarray(0, PageManager.CONSTANT.SIZE_PAGE_HEADER);
   }
   /**
@@ -9927,7 +10035,7 @@ var PageFileSystem = class {
    * @returns Page body buffer
    */
   async getBody(pageIndex, recursive = false, tx) {
-    const page = await this.get(pageIndex, tx);
+    const page = await this.get(pageIndex, false, tx);
     const manager = this.pageFactory.getManager(page);
     const fullBody = manager.getBody(page);
     if (!recursive) {
@@ -9945,11 +10053,12 @@ var PageFileSystem = class {
   }
   /**
    * Returns the metadata page.
+   * @param copy Copy-on-Read
    * @param tx Transaction
    * @returns Metadata page
    */
-  async getMetadata(tx) {
-    const page = await this.get(0, tx);
+  async getMetadata(copy, tx) {
+    const page = await this.get(0, copy, tx);
     if (!MetadataPageManager.IsMetadataPage(page)) {
       throw new Error("Invalid metadata page");
     }
@@ -9961,20 +10070,21 @@ var PageFileSystem = class {
    * @returns Number of pages
    */
   async getPageCount(tx) {
-    const metadata = await this.getMetadata(tx);
+    const metadata = await this.getMetadata(false, tx);
     const manager = this.pageFactory.getManager(metadata);
     return manager.getPageCount(metadata);
   }
   /**
    * Returns the root index page.
+   * @param copy Copy-on-Read
    * @param tx Transaction
    * @returns Root index page
    */
-  async getRootIndex(tx) {
-    const metadata = await this.getMetadata(tx);
+  async getRootIndex(copy, tx) {
+    const metadata = await this.getMetadata(false, tx);
     const manager = this.pageFactory.getManager(metadata);
     const rootIndexPageId = manager.getRootIndexPageId(metadata);
-    const rootIndexPage = await this.get(rootIndexPageId, tx);
+    const rootIndexPage = await this.get(rootIndexPageId, copy, tx);
     if (!IndexPageManager.IsIndexPage(rootIndexPage)) {
       throw new Error("Invalid root index page");
     }
@@ -10009,12 +10119,12 @@ var PageFileSystem = class {
   async appendNewPage(pageType = PageManager.CONSTANT.PAGE_TYPE_EMPTY, tx) {
     this.logger.debug(`Appending new page of type ${pageType}`);
     await tx.__acquireWriteLock(0);
-    const metadata = await this.getMetadata(tx);
+    const metadata = await this.getMetadata(true, tx);
     const metadataManager = this.pageFactory.getManager(metadata);
     const freePageId = metadataManager.getFreePageId(metadata);
     if (freePageId !== -1) {
       const reusedPageId = freePageId;
-      const reusedPage = await this.get(reusedPageId, tx);
+      const reusedPage = await this.get(reusedPageId, false, tx);
       const reusedPageManager = this.pageFactory.getManager(reusedPage);
       const nextFreePageId = reusedPageManager.getNextPageId(reusedPage);
       metadataManager.setFreePageId(metadata, nextFreePageId);
@@ -10059,7 +10169,7 @@ var PageFileSystem = class {
     let currentOffset = offset;
     let dataOffset = 0;
     while (dataOffset < data.length) {
-      const page = await this.get(currentPageId, tx);
+      const page = await this.get(currentPageId, true, tx);
       const manager = this.pageFactory.getManager(page);
       const bodyStart = PageManager.CONSTANT.SIZE_PAGE_HEADER;
       const bodySize = this.pageSize - bodyStart;
@@ -10119,7 +10229,7 @@ var PageFileSystem = class {
         break;
       }
       visited.add(currentPageId);
-      const page = await this.get(currentPageId, tx);
+      const page = await this.get(currentPageId, false, tx);
       const nextPageId = this.pageFactory.getManager(page).getNextPageId(page);
       await this.setFreePage(currentPageId, tx);
       currentPageId = nextPageId;
@@ -10135,7 +10245,7 @@ var PageFileSystem = class {
     if (pageId <= 0) return;
     await tx.__acquireWriteLock(0);
     await tx.__acquireWriteLock(pageId);
-    const metadata = await this.getMetadata(tx);
+    const metadata = await this.getMetadata(true, tx);
     const metadataManager = this.pageFactory.getManager(metadata);
     const currentHeadFreePageId = metadataManager.getFreePageId(metadata);
     const emptyPageManager = this.pageFactory.getManagerFromType(PageManager.CONSTANT.PAGE_TYPE_EMPTY);
@@ -10218,12 +10328,12 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
   async id(isLeaf) {
     const tx = this.txContext.get();
     await tx.__acquireWriteLock(0);
-    const metadata = await this.pfs.getMetadata(tx);
+    const metadata = await this.pfs.getMetadata(true, tx);
     const metadataManager = this.factory.getManager(metadata);
     const freePageId = metadataManager.getFreePageId(metadata);
     let pageId;
     if (freePageId !== -1) {
-      const freePage = await this.pfs.get(freePageId, tx);
+      const freePage = await this.pfs.get(freePageId, false, tx);
       const freePageManager = this.factory.getManager(freePage);
       const nextFreePageId = freePageManager.getNextPageId(freePage);
       metadataManager.setFreePageId(metadata, nextFreePageId);
@@ -10239,7 +10349,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
   async read(id) {
     const tx = this.txContext.get();
     const pageId = +id;
-    const page = await this.pfs.get(pageId, tx);
+    const page = await this.pfs.get(pageId, false, tx);
     if (!IndexPageManager.IsIndexPage(page)) {
       throw new Error(`Node ${id} does not exist - not a valid index page`);
     }
@@ -10274,7 +10384,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
   async write(id, node) {
     const tx = this.txContext.get();
     const pageId = +id;
-    let page = await this.pfs.get(pageId, tx);
+    let page = await this.pfs.get(pageId, true, tx);
     if (!IndexPageManager.IsIndexPage(page)) {
       page = this.indexPageManger.create(this.pfs.pageSize, pageId);
     }
@@ -10322,7 +10432,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
   }
   async readHead() {
     const tx = this.txContext.get();
-    const metadataPage = await this.pfs.getMetadata(tx);
+    const metadataPage = await this.pfs.getMetadata(false, tx);
     const manager = this.factory.getManager(metadataPage);
     const rootIndexPageId = manager.getRootIndexPageId(metadataPage);
     if (rootIndexPageId === -1) {
@@ -10342,7 +10452,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     if (root === null) {
       throw new Error("");
     }
-    const metadataPage = await this.pfs.getMetadata(tx);
+    const metadataPage = await this.pfs.getMetadata(true, tx);
     const manager = this.factory.getManager(metadataPage);
     manager.setRootIndexPageId(metadataPage, +root);
     manager.setRootIndexOrder(metadataPage, order);
@@ -10503,7 +10613,7 @@ var RowTableEngine = class {
     if (!this.initialized) {
       throw new Error("RowTableEngine instance is not initialized");
     }
-    const metadataPage = await this.pfs.getMetadata(tx);
+    const metadataPage = await this.pfs.getMetadata(false, tx);
     const manager = this.factory.getManagerFromType(MetadataPageManager.CONSTANT.PAGE_TYPE_METADATA);
     const pageSize = manager.getPageSize(metadataPage);
     const pageCount = manager.getPageCount(metadataPage);
@@ -10531,10 +10641,10 @@ var RowTableEngine = class {
     }
     await tx.__acquireWriteLock(0);
     const pks = [];
-    const metadataPage = await this.pfs.getMetadata(tx);
+    const metadataPage = await this.pfs.getMetadata(false, tx);
     let lastPk = this.metadataPageManager.getLastRowPk(metadataPage);
     let lastInsertDataPageId = this.metadataPageManager.getLastInsertPageId(metadataPage);
-    let lastInsertDataPage = await this.pfs.get(lastInsertDataPageId, tx);
+    let lastInsertDataPage = await this.pfs.get(lastInsertDataPageId, true, tx);
     if (!this.factory.isDataPage(lastInsertDataPage)) {
       throw new Error(`Last insert page is not data page`);
     }
@@ -10556,7 +10666,7 @@ var RowTableEngine = class {
           await this.pfs.setPage(lastInsertDataPageId, lastInsertDataPage, tx);
         } else {
           const newPageId = await this.pfs.appendNewPage(this.dataPageManager.pageType, tx);
-          const newPage = await this.pfs.get(newPageId, tx);
+          const newPage = await this.pfs.get(newPageId, true, tx);
           this.dataPageManager.insert(newPage, row);
           this.setRID(newPageId, 0);
           lastInsertDataPageId = newPageId;
@@ -10571,7 +10681,7 @@ var RowTableEngine = class {
         this.rowManager.setBody(row, data);
         if (slotIndex === -1) {
           const newPageId = await this.pfs.appendNewPage(this.dataPageManager.pageType, tx);
-          const newPage = await this.pfs.get(newPageId, tx);
+          const newPage = await this.pfs.get(newPageId, true, tx);
           this.dataPageManager.insert(newPage, row);
           this.setRID(newPageId, 0);
           lastInsertDataPageId = newPageId;
@@ -10587,7 +10697,7 @@ var RowTableEngine = class {
       pks.push(pk);
     }
     await this.bptree.batchInsert(batchInsertData);
-    const freshMetadataPage = await this.pfs.getMetadata(tx);
+    const freshMetadataPage = await this.pfs.getMetadata(true, tx);
     this.metadataPageManager.setLastInsertPageId(freshMetadataPage, lastInsertDataPageId);
     this.metadataPageManager.setLastRowPk(freshMetadataPage, lastPk);
     if (incrementRowCount) {
@@ -10633,7 +10743,7 @@ var RowTableEngine = class {
     this.keyManager.setBufferFromKey(rid, this.ridBuffer);
     const pageId = this.keyManager.getPageId(this.ridBuffer);
     const slotIndex = this.keyManager.getSlotIndex(this.ridBuffer);
-    const page = await this.pfs.get(pageId, tx);
+    const page = await this.pfs.get(pageId, true, tx);
     if (!this.factory.isDataPage(page)) {
       throw new Error(`RID not found for PK: ${pk}`);
     }
@@ -10669,22 +10779,22 @@ var RowTableEngine = class {
     this.rowManager.setBodySize(newRow, newBodySize);
     this.rowManager.setBody(newRow, data);
     await tx.__acquireWriteLock(0);
-    const metadataPage = await this.pfs.getMetadata(tx);
+    const metadataPage = await this.pfs.getMetadata(false, tx);
     let lastInsertDataPageId = this.metadataPageManager.getLastInsertPageId(metadataPage);
-    let lastInsertDataPage = await this.pfs.get(lastInsertDataPageId, tx);
+    let lastInsertDataPage = await this.pfs.get(lastInsertDataPageId, true, tx);
     if (!this.factory.isDataPage(lastInsertDataPage)) {
       throw new Error("Last insert page is not data page");
     }
     let newSlotIndex = this.dataPageManager.getNextSlotIndex(lastInsertDataPage, newRow);
     if (newSlotIndex === -1) {
       const newPageId = await this.pfs.appendNewPage(this.dataPageManager.pageType, tx);
-      lastInsertDataPage = await this.pfs.get(newPageId, tx);
+      lastInsertDataPage = await this.pfs.get(newPageId, true, tx);
       lastInsertDataPageId = newPageId;
       newSlotIndex = 0;
     }
     this.dataPageManager.insert(lastInsertDataPage, newRow);
     await this.pfs.setPage(lastInsertDataPageId, lastInsertDataPage, tx);
-    const targetPage = await this.pfs.get(pageId, tx);
+    const targetPage = await this.pfs.get(pageId, true, tx);
     if (!this.factory.isDataPage(targetPage)) {
       throw new Error("Target page is not data page");
     }
@@ -10697,7 +10807,7 @@ var RowTableEngine = class {
     const newRidNumeric = this.getRID();
     await this.bptree.delete(oldRidNumeric, pk);
     await this.bptree.insert(newRidNumeric, pk);
-    const freshMetadataPage = await this.pfs.getMetadata(tx);
+    const freshMetadataPage = await this.pfs.getMetadata(true, tx);
     this.metadataPageManager.setLastInsertPageId(freshMetadataPage, lastInsertDataPageId);
     await this.pfs.setMetadata(freshMetadataPage, tx);
   }
@@ -10717,7 +10827,7 @@ var RowTableEngine = class {
     this.keyManager.setBufferFromKey(rid, this.ridBuffer);
     const pageId = this.keyManager.getPageId(this.ridBuffer);
     const slotIndex = this.keyManager.getSlotIndex(this.ridBuffer);
-    const page = await this.pfs.get(pageId, tx);
+    const page = await this.pfs.get(pageId, true, tx);
     if (!this.factory.isDataPage(page)) {
       throw new Error(`RID not found for PK: ${pk}`);
     }
@@ -10733,14 +10843,14 @@ var RowTableEngine = class {
     await this.pfs.setPage(pageId, page, tx);
     await this.bptree.delete(rid, pk);
     if (decrementRowCount) {
-      const metadataPage2 = await this.pfs.getMetadata(tx);
+      const metadataPage2 = await this.pfs.getMetadata(true, tx);
       const currentRowCount = this.metadataPageManager.getRowCount(metadataPage2);
       this.metadataPageManager.setRowCount(metadataPage2, currentRowCount - 1);
       await this.pfs.setMetadata(metadataPage2, tx);
     }
     const insertedRowCount = this.dataPageManager.getInsertedRowCount(page);
     let allDeleted = true;
-    const metadataPage = await this.pfs.getMetadata(tx);
+    const metadataPage = await this.pfs.getMetadata(false, tx);
     const lastInsertPageId = this.metadataPageManager.getLastInsertPageId(metadataPage);
     if (pageId === lastInsertPageId) {
       allDeleted = false;
@@ -10759,6 +10869,82 @@ var RowTableEngine = class {
       await this.pfs.freeChain(pageId, tx);
     }
   }
+  /**
+   * Deletes multiple data in batch.
+   * @param pks Array of PKs to delete
+   * @param decrementRowCount Whether to decrement the row count to metadata
+   * @param tx Transaction
+   */
+  async deleteBatch(pks, decrementRowCount, tx) {
+    this.logger.debug(`Batch deleting ${pks.length} rows`);
+    if (pks.length === 0) {
+      return;
+    }
+    await tx.__acquireWriteLock(0);
+    const collections = await this.collectItemsByPage(pks, tx);
+    if (collections.size === 0) {
+      return;
+    }
+    const metadataPage = await this.pfs.getMetadata(false, tx);
+    const lastInsertPageId = this.metadataPageManager.getLastInsertPageId(metadataPage);
+    const batchDeleteData = [];
+    const pagesToFree = [];
+    let deletedCount = 0;
+    for (const [pageId, items] of collections) {
+      const page = await this.pfs.get(pageId, true, tx);
+      if (!this.factory.isDataPage(page)) {
+        continue;
+      }
+      let pageModified = false;
+      for (const item of items) {
+        const row = this.dataPageManager.getRow(page, item.slotIndex);
+        if (this.rowManager.getDeletedFlag(row)) {
+          continue;
+        }
+        if (this.rowManager.getOverflowFlag(row)) {
+          const overflowPageId = bytesToNumber(this.rowManager.getBody(row));
+          await this.pfs.freeChain(overflowPageId, tx);
+        }
+        this.rowManager.setDeletedFlag(row, true);
+        pageModified = true;
+        this.setRID(pageId, item.slotIndex);
+        batchDeleteData.push([this.getRID(), item.pk]);
+        deletedCount++;
+      }
+      if (pageModified) {
+        await this.pfs.setPage(pageId, page, tx);
+      }
+      if (pageId !== lastInsertPageId) {
+        const insertedRowCount = this.dataPageManager.getInsertedRowCount(page);
+        let allDeleted = true;
+        let i = 0;
+        while (i < insertedRowCount) {
+          const slotRow = this.dataPageManager.getRow(page, i);
+          if (!this.rowManager.getDeletedFlag(slotRow)) {
+            allDeleted = false;
+            break;
+          }
+          i++;
+        }
+        if (allDeleted) {
+          pagesToFree.push(pageId);
+        }
+      }
+    }
+    if (batchDeleteData.length === 0) {
+      return;
+    }
+    await this.bptree.batchDelete(batchDeleteData);
+    if (decrementRowCount) {
+      const freshMetadataPage = await this.pfs.getMetadata(true, tx);
+      const currentRowCount = this.metadataPageManager.getRowCount(freshMetadataPage);
+      this.metadataPageManager.setRowCount(freshMetadataPage, currentRowCount - deletedCount);
+      await this.pfs.setMetadata(freshMetadataPage, tx);
+    }
+    for (const pageId of pagesToFree) {
+      await this.pfs.freeChain(pageId, tx);
+    }
+  }
   /**
    * Looks up the RID corresponding to the PK in the B+ Tree and returns the actual row.
    * @param pk Primary key of the row
@@ -10846,7 +11032,7 @@ var RowTableEngine = class {
     const sortedPageIds = Array.from(collections.keys()).sort((a, b) => a - b);
     await Promise.all(sortedPageIds.map(async (pageId) => {
       const items = collections.get(pageId);
-      const page = await this.pfs.get(pageId, tx);
+      const page = await this.pfs.get(pageId, false, tx);
       if (!this.factory.isDataPage(page)) {
         throw new Error(`Page ${pageId} is not a data page`);
       }
@@ -10871,7 +11057,7 @@ var RowTableEngine = class {
     this.keyManager.setBufferFromKey(rid, this.ridBuffer);
     const pageId = this.keyManager.getPageId(this.ridBuffer);
     const slotIndex = this.keyManager.getSlotIndex(this.ridBuffer);
-    const page = await this.pfs.get(pageId, tx);
+    const page = await this.pfs.get(pageId, false, tx);
     if (!this.factory.isDataPage(page)) {
       throw new Error(`RID not found for PK: ${pk}`);
     }
@@ -10881,7 +11067,7 @@ var RowTableEngine = class {
       return null;
     } else if (this.rowManager.getOverflowFlag(row)) {
       const overflowPageId = bytesToNumber(this.rowManager.getBody(row));
-      const overflowPage = await this.pfs.get(overflowPageId, tx);
+      const overflowPage = await this.pfs.get(overflowPageId, false, tx);
       if (!this.factory.isOverflowPage(overflowPage)) {
         throw new Error(`Overflow page not found for RID: ${rid}`);
       }
@@ -10895,16 +11081,11 @@ var RowTableEngine = class {
    * @returns Row count
    */
   async getRowCount(tx) {
-    const metadataPage = await this.pfs.getMetadata(tx);
+    const metadataPage = await this.pfs.getMetadata(false, tx);
     return this.metadataPageManager.getRowCount(metadataPage);
   }
 };
 
-// src/utils/catchPromise.ts
-async function catchPromise(promise) {
-  return promise.then((res) => [void 0, res]).catch((reason) => [reason]);
-}
-
 // src/core/transaction/LockManager.ts
 var LockManager = class {
   lock;
@@ -11006,16 +11187,20 @@ var Transaction = class {
   /**
    * Reads a page through the MVCC transaction.
    * @param pageId Page ID
+   * @param copy Copy-on-Read
    * @returns Page data
    */
-  async __readPage(pageId) {
+  async __readPage(pageId, copy) {
     const data = await this.mvccTx.read(pageId);
     if (data === null) {
       return new Uint8Array(this.pfs.pageSize);
     }
-    const copy = new Uint8Array(data.length);
-    copy.set(data);
-    return copy;
+    if (copy) {
+      const copy2 = new Uint8Array(data.length);
+      copy2.set(data);
+      return copy2;
+    }
+    return data;
   }
   /**
    * Writes a page through the MVCC transaction.
@@ -11025,9 +11210,7 @@ var Transaction = class {
   async __writePage(pageId, data) {
     const exists = await this.mvccTx.exists(pageId);
     if (exists) {
-      const copy = new Uint8Array(data.length);
-      copy.set(data);
-      await this.mvccTx.write(pageId, copy);
+      await this.mvccTx.write(pageId, data);
     } else {
       await this.mvccTx.create(pageId, data);
     }
@@ -11433,46 +11616,46 @@ var DataplyAPI = class {
    * @returns The result of the callback.
    */
   async withWriteTransaction(callback, tx) {
-    this.logger.debug("Running with default write transaction");
+    this.logger.debug("Running with write transaction");
     if (!tx) {
       const release = await this.acquireWriteLock();
       const internalTx = this.createTransaction();
       internalTx.__setWriteLockRelease(release);
-      const [error2, result2] = await catchPromise(this.txContext.run(internalTx, () => callback(internalTx)));
-      if (error2) {
+      try {
+        const result = await this.txContext.run(internalTx, () => callback(internalTx));
+        await internalTx.commit();
+        return result;
+      } catch (error) {
         await internalTx.rollback();
-        throw error2;
+        throw error;
       }
-      await internalTx.commit();
-      return result2;
     }
     if (!tx.__hasWriteLockRelease()) {
       const release = await this.acquireWriteLock();
       tx.__setWriteLockRelease(release);
     }
-    const [error, result] = await catchPromise(this.txContext.run(tx, () => callback(tx)));
-    if (error) {
-      throw error;
+    if (this.txContext.get() === tx) {
+      return callback(tx);
     }
-    return result;
+    return this.txContext.run(tx, () => callback(tx));
   }
   async withReadTransaction(callback, tx) {
-    this.logger.debug("Running with default transaction");
-    const isInternalTx = !tx;
+    this.logger.debug("Running with read transaction");
     if (!tx) {
-      tx = this.createTransaction();
-    }
-    const [error, result] = await catchPromise(this.txContext.run(tx, () => callback(tx)));
-    if (error) {
-      if (isInternalTx) {
-        await tx.rollback();
+      const internalTx = this.createTransaction();
+      try {
+        const result = await this.txContext.run(internalTx, () => callback(internalTx));
+        await internalTx.commit();
+        return result;
+      } catch (error) {
+        await internalTx.rollback();
+        throw error;
       }
-      throw error;
     }
-    if (isInternalTx) {
-      await tx.commit();
+    if (this.txContext.get() === tx) {
+      return callback(tx);
     }
-    return result;
+    return this.txContext.run(tx, () => callback(tx));
   }
   /**
    * Runs a generator callback function within a transaction context.
@@ -11616,6 +11799,23 @@ var DataplyAPI = class {
       await this.rowTableEngine.delete(pk, decrementRowCount, tx2);
     }, tx);
   }
+  /**
+   * Deletes multiple data in batch.
+   * If a transaction is not provided, it internally creates a single transaction to process.
+   * @param pks Array of PKs to delete
+   * @param decrementRowCount Whether to decrement the row count to metadata
+   * @param tx Transaction
+   */
+  async deleteBatch(pks, decrementRowCount, tx) {
+    this.logger.debug(`Deleting batch data: ${pks.length} items`);
+    if (!this.initialized) {
+      throw new Error("Dataply instance is not initialized");
+    }
+    return this.withWriteTransaction(async (tx2) => {
+      decrementRowCount = decrementRowCount ?? true;
+      await this.rowTableEngine.deleteBatch(pks, decrementRowCount, tx2);
+    }, tx);
+  }
   async select(pk, asRaw = false, tx) {
     this.logger.debug(`Selecting data for PK: ${pk}`);
     if (!this.initialized) {
@@ -11672,15 +11872,6 @@ var Dataply = class {
   get options() {
     return this.api.options;
   }
-  /**
-   * Creates a transaction.
-   * The created transaction object can be used to add or modify data.
-   * A transaction must be terminated by calling either `commit` or `rollback`.
-   * @returns Transaction object
-   */
-  createTransaction() {
-    return this.api.createTransaction();
-  }
   /**
    * Runs a write callback within a transaction context.
    */
@@ -11750,6 +11941,15 @@ var Dataply = class {
   async delete(pk, tx) {
     return this.api.delete(pk, true, tx);
   }
+  /**
+   * Deletes multiple data in batch.
+   * If a transaction is not provided, it internally creates a single transaction to process.
+   * @param pks Array of PKs to delete
+   * @param tx Transaction
+   */
+  async deleteBatch(pks, tx) {
+    return this.api.deleteBatch(pks, true, tx);
+  }
   async select(pk, asRaw = false, tx) {
     return this.api.select(pk, asRaw, tx);
   }