document-dataply 0.0.14-alpha.0 → 0.0.14-alpha.2

package/dist/cjs/index.js

@@ -66,7 +66,7 @@ var require_cjs = __commonJS({
       AsyncMVCCStrategy: () => AsyncMVCCStrategy2,
       AsyncMVCCTransaction: () => AsyncMVCCTransaction2,
       BPTreeAsync: () => BPTreeAsync2,
-      BPTreeAsyncTransaction: () => BPTreeAsyncTransaction2,
+      BPTreeAsyncTransaction: () => BPTreeAsyncTransaction,
       BPTreeSync: () => BPTreeSync,
       BPTreeSyncTransaction: () => BPTreeSyncTransaction,
       BitmapPageManager: () => BitmapPageManager,
@@ -82,6 +82,8 @@ var require_cjs = __commonJS({
       IndexPageManager: () => IndexPageManager,
       InvertedWeakMap: () => InvertedWeakMap,
       LRUMap: () => LRUMap2,
+      Logger: () => Logger2,
+      LoggerManager: () => LoggerManager,
       MVCCStrategy: () => MVCCStrategy2,
       MVCCTransaction: () => MVCCTransaction2,
       MetadataPageManager: () => MetadataPageManager,
@@ -476,11 +478,7 @@ var require_cjs = __commonJS({
        */
       rollback() {
         const { created, updated, deleted } = this.getResultEntries();
-        this.writeBuffer.clear();
-        this.deleteBuffer.clear();
-        this.createdKeys.clear();
-        this.deletedValues.clear();
-        this.originallyExisted.clear();
+        this._cleanupAll();
         this.committed = true;
         if (this.root !== this) {
           this.root.activeTransactions.delete(this);
@@ -516,6 +514,19 @@ var require_cjs = __commonJS({
         }
         return Array.from(conflicts);
       }
+      /**
+       * Cleans up all buffers and history.
+       * This method is called by the commit method.
+       */
+      _cleanupAll() {
+        this.writeBuffer.clear();
+        this.deleteBuffer.clear();
+        this.createdKeys.clear();
+        this.deletedValues.clear();
+        this.originallyExisted.clear();
+        this.keyVersions.clear();
+        this.bufferHistory.clear();
+      }
       /**
        * Cleans up both deletedCache and versionIndex based on minActiveVersion.
        * Root transactions call this after commit to reclaim memory.
@@ -707,6 +718,7 @@ var require_cjs = __commonJS({
         if (this.parent) {
           const failure = this.parent._merge(this);
           if (failure) {
+            this.rollback();
             return {
               label,
               success: false,
@@ -717,11 +729,13 @@ var require_cjs = __commonJS({
               deleted
             };
           }
+          this._cleanupAll();
           this.committed = true;
         } else {
           if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
             const failure = this._merge(this);
             if (failure) {
+              this.rollback();
               return {
                 label,
                 success: false,
@@ -732,13 +746,7 @@ var require_cjs = __commonJS({
                 deleted: []
               };
             }
-            this.writeBuffer.clear();
-            this.deleteBuffer.clear();
-            this.createdKeys.clear();
-            this.deletedValues.clear();
-            this.originallyExisted.clear();
-            this.keyVersions.clear();
-            this.bufferHistory.clear();
+            this._cleanupAll();
             this.localVersion = 0;
             this.snapshotVersion = this.version;
           }
@@ -1372,6 +1380,7 @@ var require_cjs = __commonJS({
         if (this.parent) {
           const failure = await this.parent._merge(this);
           if (failure) {
+            this.rollback();
             return {
               label,
               success: false,
@@ -1382,11 +1391,13 @@ var require_cjs = __commonJS({
               deleted
             };
           }
+          this._cleanupAll();
           this.committed = true;
         } else {
           if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
             const failure = await this._merge(this);
             if (failure) {
+              this.rollback();
               return {
                 label,
                 success: false,
@@ -1397,13 +1408,7 @@ var require_cjs = __commonJS({
                 deleted: []
               };
             }
-            this.writeBuffer.clear();
-            this.deleteBuffer.clear();
-            this.createdKeys.clear();
-            this.deletedValues.clear();
-            this.originallyExisted.clear();
-            this.keyVersions.clear();
-            this.bufferHistory.clear();
+            this._cleanupAll();
             this.localVersion = 0;
             this.snapshotVersion = this.version;
           }
@@ -1985,30 +1990,22 @@ var require_cjs = __commonJS({
        */
       _insertValueIntoLeaf(leaf, key, value) {
         if (leaf.values.length) {
-          for (let i = 0, len = leaf.values.length; i < len; i++) {
-            const nValue = leaf.values[i];
-            if (this.comparator.isSame(value, nValue)) {
-              if (leaf.keys[i].includes(key)) {
-                return false;
-              }
-              leaf.keys[i].push(key);
-              return true;
-            } else if (this.comparator.isLower(value, nValue)) {
-              leaf.values.splice(i, 0, value);
-              leaf.keys.splice(i, 0, [key]);
-              return true;
-            } else if (i + 1 === leaf.values.length) {
-              leaf.values.push(value);
-              leaf.keys.push([key]);
-              return true;
+          const { index, found } = this._binarySearchValues(leaf.values, value);
+          if (found) {
+            if (leaf.keys[index].includes(key)) {
+              return false;
             }
+            leaf.keys[index].push(key);
+            return true;
           }
+          leaf.values.splice(index, 0, value);
+          leaf.keys.splice(index, 0, [key]);
+          return true;
         } else {
           leaf.values = [value];
           leaf.keys = [[key]];
           return true;
         }
-        return false;
       }
       _cloneNode(node) {
         return JSON.parse(JSON.stringify(node));
@@ -2299,12 +2296,8 @@ var require_cjs = __commonJS({
           const midValue = parentNode.values[mid];
           parentNode.values = parentNode.values.slice(0, mid);
           parentNode.keys = parentNode.keys.slice(0, mid + 1);
-          for (const k2 of parentNode.keys) {
-            const n = this._cloneNode(this.getNode(k2));
-            n.parent = parentNode.id;
-            this._updateNode(n);
-          }
-          for (const k2 of newSiblingNodeRecursive.keys) {
+          for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+            const k2 = newSiblingNodeRecursive.keys[i];
             const n = this._cloneNode(this.getNode(k2));
             n.parent = newSiblingNodeRecursive.id;
             this._updateNode(n);
@@ -2386,7 +2379,7 @@ var require_cjs = __commonJS({
             for (let i = 0; i < len; i++) {
               const nValue = node.values[i];
               const keys = node.keys[i];
-              for (let j = 0, kLen = keys.length; j < kLen; j++) {
+              for (let j = 0, len2 = keys.length; j < len2; j++) {
                 yield [keys[j], nValue];
               }
             }
@@ -2465,7 +2458,7 @@ var require_cjs = __commonJS({
         while (true) {
           for (let i = 0, len = node.values.length; i < len; i++) {
             const keys = node.keys[i];
-            for (let j = 0, kLen = keys.length; j < kLen; j++) {
+            for (let j = 0, len2 = keys.length; j < len2; j++) {
               if (keys[j] === key) {
                 return node.values[i];
               }
@@ -2574,8 +2567,16 @@ var require_cjs = __commonJS({
         const sorted = [...entries].sort((a, b2) => this.comparator.asc(a[1], b2[1]));
         let currentLeaf = null;
         let modified = false;
-        for (const [key, value] of sorted) {
-          const targetLeaf = this.locateLeaf(value);
+        let cachedLeafId = null;
+        let cachedLeafMaxValue = null;
+        for (let i = 0, len = sorted.length; i < len; i++) {
+          const [key, value] = sorted[i];
+          let targetLeaf;
+          if (cachedLeafId !== null && cachedLeafMaxValue !== null && currentLeaf !== null && (this.comparator.isLower(value, cachedLeafMaxValue) || this.comparator.isSame(value, cachedLeafMaxValue))) {
+            targetLeaf = currentLeaf;
+          } else {
+            targetLeaf = this.locateLeaf(value);
+          }
           if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
           } else {
             if (currentLeaf !== null && modified) {
@@ -2584,8 +2585,10 @@ var require_cjs = __commonJS({
             currentLeaf = this._cloneNode(targetLeaf);
             modified = false;
           }
+          cachedLeafId = currentLeaf.id;
           const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
           modified = modified || changed;
+          cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
           if (currentLeaf.values.length === this.order) {
             this._updateNode(currentLeaf);
             let after = this._createNode(
@@ -2606,6 +2609,8 @@ var require_cjs = __commonJS({
             this._updateNode(after);
             this._insertInParent(currentLeaf, after.values[0], after);
             currentLeaf = null;
+            cachedLeafId = null;
+            cachedLeafMaxValue = null;
             modified = false;
           }
         }
@@ -2613,6 +2618,85 @@ var require_cjs = __commonJS({
           this._updateNode(currentLeaf);
         }
       }
+      bulkLoad(entries) {
+        if (entries.length === 0) return;
+        const root = this.getNode(this.rootId);
+        if (!root.leaf || root.values.length > 0) {
+          throw new Error("bulkLoad can only be called on an empty tree. Use batchInsert for non-empty trees.");
+        }
+        const sorted = [...entries].sort((a, b2) => this.comparator.asc(a[1], b2[1]));
+        const grouped = [];
+        for (let i = 0, len = sorted.length; i < len; i++) {
+          const [key, value] = sorted[i];
+          const last = grouped[grouped.length - 1];
+          if (last && this.comparator.isSame(last.value, value)) {
+            if (!last.keys.includes(key)) {
+              last.keys.push(key);
+            }
+          } else {
+            grouped.push({ keys: [key], value });
+          }
+        }
+        this._deleteNode(root);
+        const maxLeafSize = this.order - 1;
+        const leaves = [];
+        for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+          const chunk = grouped.slice(i, i + maxLeafSize);
+          const leafKeys = chunk.map((g2) => g2.keys);
+          const leafValues = chunk.map((g2) => g2.value);
+          const leaf = this._createNode(
+            true,
+            leafKeys,
+            leafValues,
+            null,
+            null,
+            null
+          );
+          leaves.push(leaf);
+        }
+        for (let i = 0, len = leaves.length; i < len; i++) {
+          if (i > 0) {
+            leaves[i].prev = leaves[i - 1].id;
+          }
+          if (i < len - 1) {
+            leaves[i].next = leaves[i + 1].id;
+          }
+          this._updateNode(leaves[i]);
+        }
+        let currentLevel = leaves;
+        while (currentLevel.length > 1) {
+          const nextLevel = [];
+          for (let i = 0, len = currentLevel.length; i < len; i += this.order) {
+            const children = currentLevel.slice(i, i + this.order);
+            const childIds = children.map((c) => c.id);
+            const separators = [];
+            for (let j = 1, len2 = children.length; j < len2; j++) {
+              separators.push(children[j].values[0]);
+            }
+            const internalNode = this._createNode(
+              false,
+              childIds,
+              separators,
+              null,
+              null,
+              null
+            );
+            for (let j = 0, len2 = children.length; j < len2; j++) {
+              const child = children[j];
+              child.parent = internalNode.id;
+              this._updateNode(child);
+            }
+            nextLevel.push(internalNode);
+          }
+          currentLevel = nextLevel;
+        }
+        const newRoot = currentLevel[0];
+        this._writeHead({
+          root: newRoot.id,
+          order: this.order,
+          data: this.strategy.head.data
+        });
+      }
       _deleteEntry(node, key) {
         if (!node.leaf) {
           let keyIndex = -1;
@@ -2716,7 +2800,8 @@ var require_cjs = __commonJS({
             siblingNode.values.push(...node.values);
             if (!siblingNode.leaf) {
               const keys = siblingNode.keys;
-              for (const key2 of keys) {
+              for (let i = 0, len = keys.length; i < len; i++) {
+                const key2 = keys[i];
                 const node2 = this._cloneNode(this.getNode(key2));
                 node2.parent = siblingNode.id;
                 this._updateNode(node2);
@@ -2784,21 +2869,24 @@ var require_cjs = __commonJS({
               this._updateNode(siblingNode);
             }
             if (!siblingNode.leaf) {
-              for (const key2 of siblingNode.keys) {
+              for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+                const key2 = siblingNode.keys[i];
                 const n = this._cloneNode(this.getNode(key2));
                 n.parent = siblingNode.id;
                 this._updateNode(n);
               }
             }
             if (!node.leaf) {
-              for (const key2 of node.keys) {
+              for (let i = 0, len = node.keys.length; i < len; i++) {
+                const key2 = node.keys[i];
                 const n = this._cloneNode(this.getNode(key2));
                 n.parent = node.id;
                 this._updateNode(n);
               }
             }
             if (!parentNode.leaf) {
-              for (const key2 of parentNode.keys) {
+              for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+                const key2 = parentNode.keys[i];
                 const n = this._cloneNode(this.getNode(key2));
                 n.parent = parentNode.id;
                 this._updateNode(n);
@@ -2875,8 +2963,12 @@ var require_cjs = __commonJS({
             result = this.rootTx.commit(label);
             if (result.success) {
               this.rootTx.rootId = this.rootId;
+            } else {
+              this.mvcc.rollback();
             }
           }
+        } else {
+          this.mvcc.rollback();
         }
         return result;
       }
@@ -2972,6 +3064,14 @@ var require_cjs = __commonJS({
           throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
         }
       }
+      bulkLoad(entries) {
+        const tx = this.createTransaction();
+        tx.bulkLoad(entries);
+        const result = tx.commit();
+        if (!result.success) {
+          throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+        }
+      }
     };
     var Ryoiki2 = class _Ryoiki2 {
       readings;
@@ -3229,7 +3329,7 @@ var require_cjs = __commonJS({
         this._free(this.writings, lockId);
       }
     };
-    var BPTreeAsyncTransaction2 = class extends BPTreeTransaction {
+    var BPTreeAsyncTransaction = class extends BPTreeTransaction {
       lock;
       constructor(rootTx, mvccRoot, mvcc, strategy, comparator, option) {
         super(
@@ -3385,12 +3485,8 @@ var require_cjs = __commonJS({
           const midValue = parentNode.values[mid];
           parentNode.values = parentNode.values.slice(0, mid);
           parentNode.keys = parentNode.keys.slice(0, mid + 1);
-          for (const k2 of parentNode.keys) {
-            const n = this._cloneNode(await this.getNode(k2));
-            n.parent = parentNode.id;
-            await this._updateNode(n);
-          }
-          for (const k2 of newSiblingNodeRecursive.keys) {
+          for (let i = 0, len = newSiblingNodeRecursive.keys.length; i < len; i++) {
+            const k2 = newSiblingNodeRecursive.keys[i];
             const n = this._cloneNode(await this.getNode(k2));
             n.parent = newSiblingNodeRecursive.id;
             await this._updateNode(n);
@@ -3482,7 +3578,7 @@ var require_cjs = __commonJS({
             for (let i = 0; i < len; i++) {
               const nValue = node.values[i];
               const keys = node.keys[i];
-              for (let j = 0, kLen = keys.length; j < kLen; j++) {
+              for (let j = 0, len2 = keys.length; j < len2; j++) {
                 yield [keys[j], nValue];
               }
             }
@@ -3560,7 +3656,7 @@ var require_cjs = __commonJS({
         while (true) {
           for (let i = 0, len = node.values.length; i < len; i++) {
             const keys = node.keys[i];
-            for (let j = 0, kLen = keys.length; j < kLen; j++) {
+            for (let j = 0, len2 = keys.length; j < len2; j++) {
               if (keys[j] === key) {
                 return node.values[i];
               }
@@ -3672,8 +3768,16 @@ var require_cjs = __commonJS({
           const sorted = [...entries].sort((a, b2) => this.comparator.asc(a[1], b2[1]));
           let currentLeaf = null;
           let modified = false;
-          for (const [key, value] of sorted) {
-            const targetLeaf = await this.locateLeaf(value);
+          let cachedLeafId = null;
+          let cachedLeafMaxValue = null;
+          for (let i = 0, len = sorted.length; i < len; i++) {
+            const [key, value] = sorted[i];
+            let targetLeaf;
+            if (cachedLeafId !== null && cachedLeafMaxValue !== null && currentLeaf !== null && (this.comparator.isLower(value, cachedLeafMaxValue) || this.comparator.isSame(value, cachedLeafMaxValue))) {
+              targetLeaf = currentLeaf;
+            } else {
+              targetLeaf = await this.locateLeaf(value);
+            }
             if (currentLeaf !== null && currentLeaf.id === targetLeaf.id) {
             } else {
               if (currentLeaf !== null && modified) {
@@ -3682,8 +3786,10 @@ var require_cjs = __commonJS({
               currentLeaf = this._cloneNode(targetLeaf);
               modified = false;
             }
+            cachedLeafId = currentLeaf.id;
             const changed = this._insertValueIntoLeaf(currentLeaf, key, value);
             modified = modified || changed;
+            cachedLeafMaxValue = currentLeaf.values[currentLeaf.values.length - 1];
             if (currentLeaf.values.length === this.order) {
               await this._updateNode(currentLeaf);
               let after = await this._createNode(
@@ -3704,6 +3810,8 @@ var require_cjs = __commonJS({
               await this._updateNode(after);
               await this._insertInParent(currentLeaf, after.values[0], after);
               currentLeaf = null;
+              cachedLeafId = null;
+              cachedLeafMaxValue = null;
               modified = false;
             }
           }
@@ -3712,6 +3820,87 @@ var require_cjs = __commonJS({
           }
         });
       }
+      async bulkLoad(entries) {
+        if (entries.length === 0) return;
+        return this.writeLock(0, async () => {
+          const root = await this.getNode(this.rootId);
+          if (!root.leaf || root.values.length > 0) {
+            throw new Error("bulkLoad can only be called on an empty tree. Use batchInsert for non-empty trees.");
+          }
+          const sorted = [...entries].sort((a, b2) => this.comparator.asc(a[1], b2[1]));
+          const grouped = [];
+          for (let i = 0, len = sorted.length; i < len; i++) {
+            const [key, value] = sorted[i];
+            const last = grouped[grouped.length - 1];
+            if (last && this.comparator.isSame(last.value, value)) {
+              if (!last.keys.includes(key)) {
+                last.keys.push(key);
+              }
+            } else {
+              grouped.push({ keys: [key], value });
+            }
+          }
+          await this._deleteNode(root);
+          const maxLeafSize = this.order - 1;
+          const leaves = [];
+          for (let i = 0, len = grouped.length; i < len; i += maxLeafSize) {
+            const chunk = grouped.slice(i, i + maxLeafSize);
+            const leafKeys = chunk.map((g2) => g2.keys);
+            const leafValues = chunk.map((g2) => g2.value);
+            const leaf = await this._createNode(
+              true,
+              leafKeys,
+              leafValues,
+              null,
+              null,
+              null
+            );
+            leaves.push(leaf);
+          }
+          for (let i = 0, len = leaves.length; i < len; i++) {
+            if (i > 0) {
+              leaves[i].prev = leaves[i - 1].id;
+            }
+            if (i < len - 1) {
+              leaves[i].next = leaves[i + 1].id;
+            }
+            await this._updateNode(leaves[i]);
+          }
+          let currentLevel = leaves;
+          while (currentLevel.length > 1) {
+            const nextLevel = [];
+            for (let i = 0, len = currentLevel.length; i < len; i += this.order) {
+              const children = currentLevel.slice(i, i + this.order);
+              const childIds = children.map((c) => c.id);
+              const separators = [];
+              for (let j = 1, len2 = children.length; j < len2; j++) {
+                separators.push(children[j].values[0]);
+              }
+              const internalNode = await this._createNode(
+                false,
+                childIds,
+                separators,
+                null,
+                null,
+                null
+              );
+              for (let j = 0, len2 = children.length; j < len2; j++) {
+                const child = children[j];
+                child.parent = internalNode.id;
+                await this._updateNode(child);
+              }
+              nextLevel.push(internalNode);
+            }
+            currentLevel = nextLevel;
+          }
+          const newRoot = currentLevel[0];
+          await this._writeHead({
+            root: newRoot.id,
+            order: this.order,
+            data: this.strategy.head.data
+          });
+        });
+      }
       async _deleteEntry(node, key) {
         if (!node.leaf) {
           let keyIndex = -1;
@@ -3815,7 +4004,8 @@ var require_cjs = __commonJS({
             siblingNode.values.push(...node.values);
             if (!siblingNode.leaf) {
               const keys = siblingNode.keys;
-              for (const key2 of keys) {
+              for (let i = 0, len = keys.length; i < len; i++) {
+                const key2 = keys[i];
                 const node2 = this._cloneNode(await this.getNode(key2));
                 node2.parent = siblingNode.id;
                 await this._updateNode(node2);
@@ -3883,21 +4073,24 @@ var require_cjs = __commonJS({
               await this._updateNode(siblingNode);
             }
             if (!siblingNode.leaf) {
-              for (const key2 of siblingNode.keys) {
+              for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
+                const key2 = siblingNode.keys[i];
                 const n = this._cloneNode(await this.getNode(key2));
                 n.parent = siblingNode.id;
                 await this._updateNode(n);
               }
             }
             if (!node.leaf) {
-              for (const key2 of node.keys) {
+              for (let i = 0, len = node.keys.length; i < len; i++) {
+                const key2 = node.keys[i];
                 const n = this._cloneNode(await this.getNode(key2));
                 n.parent = node.id;
                 await this._updateNode(n);
               }
             }
             if (!parentNode.leaf) {
-              for (const key2 of parentNode.keys) {
+              for (let i = 0, len = parentNode.keys.length; i < len; i++) {
+                const key2 = parentNode.keys[i];
                 const n = this._cloneNode(await this.getNode(key2));
                 n.parent = parentNode.id;
                 await this._updateNode(n);
@@ -3976,8 +4169,12 @@ var require_cjs = __commonJS({
             result = await this.rootTx.commit(label);
             if (result.success) {
               this.rootTx.rootId = this.rootId;
+            } else {
+              this.mvcc.rollback();
             }
           }
+        } else {
+          this.mvcc.rollback();
         }
         return result;
       }
@@ -4018,7 +4215,7 @@ var require_cjs = __commonJS({
         }
       }
     };
-    var BPTreeAsync2 = class extends BPTreeAsyncTransaction2 {
+    var BPTreeAsync2 = class extends BPTreeAsyncTransaction {
       constructor(strategy, comparator, option) {
         const mvccRoot = new AsyncMVCCTransaction(new BPTreeMVCCStrategyAsync(strategy), {
           cacheCapacity: option?.capacity ?? void 0
@@ -4038,7 +4235,7 @@ var require_cjs = __commonJS({
        */
       async createTransaction() {
         const nestedTx = this.mvcc.createNested();
-        const tx = new BPTreeAsyncTransaction2(
+        const tx = new BPTreeAsyncTransaction(
           this,
           this.mvcc,
           nestedTx,
@@ -4079,6 +4276,16 @@ var require_cjs = __commonJS({
           }
         });
       }
+      async bulkLoad(entries) {
+        return this.writeLock(1, async () => {
+          const tx = await this.createTransaction();
+          await tx.bulkLoad(entries);
+          const result = await tx.commit();
+          if (!result.success) {
+            throw new Error(`Transaction failed: ${result.error || "Commit failed due to conflict"}`);
+          }
+        });
+      }
     };
     var SerializeStrategy = class {
       order;
@@ -5232,11 +5439,7 @@ var require_cjs = __commonJS({
        */
       rollback() {
         const { created, updated, deleted } = this.getResultEntries();
-        this.writeBuffer.clear();
-        this.deleteBuffer.clear();
-        this.createdKeys.clear();
-        this.deletedValues.clear();
-        this.originallyExisted.clear();
+        this._cleanupAll();
         this.committed = true;
         if (this.root !== this) {
           this.root.activeTransactions.delete(this);
@@ -5272,6 +5475,19 @@ var require_cjs = __commonJS({
         }
         return Array.from(conflicts);
       }
+      /**
+       * Cleans up all buffers and history.
+       * This method is called by the commit method.
+       */
+      _cleanupAll() {
+        this.writeBuffer.clear();
+        this.deleteBuffer.clear();
+        this.createdKeys.clear();
+        this.deletedValues.clear();
+        this.originallyExisted.clear();
+        this.keyVersions.clear();
+        this.bufferHistory.clear();
+      }
       /**
        * Cleans up both deletedCache and versionIndex based on minActiveVersion.
        * Root transactions call this after commit to reclaim memory.
@@ -5463,6 +5679,7 @@ var require_cjs = __commonJS({
         if (this.parent) {
           const failure = this.parent._merge(this);
           if (failure) {
+            this.rollback();
             return {
               label,
               success: false,
@@ -5473,11 +5690,13 @@ var require_cjs = __commonJS({
               deleted
             };
           }
+          this._cleanupAll();
           this.committed = true;
         } else {
           if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
             const failure = this._merge(this);
             if (failure) {
+              this.rollback();
               return {
                 label,
                 success: false,
@@ -5488,13 +5707,7 @@ var require_cjs = __commonJS({
                 deleted: []
               };
             }
-            this.writeBuffer.clear();
-            this.deleteBuffer.clear();
-            this.createdKeys.clear();
-            this.deletedValues.clear();
-            this.originallyExisted.clear();
-            this.keyVersions.clear();
-            this.bufferHistory.clear();
+            this._cleanupAll();
             this.localVersion = 0;
             this.snapshotVersion = this.version;
           }
@@ -6128,6 +6341,7 @@ var require_cjs = __commonJS({
         if (this.parent) {
           const failure = await this.parent._merge(this);
           if (failure) {
+            this.rollback();
             return {
               label,
               success: false,
@@ -6138,11 +6352,13 @@ var require_cjs = __commonJS({
               deleted
             };
           }
+          this._cleanupAll();
           this.committed = true;
         } else {
           if (this.writeBuffer.size > 0 || this.deleteBuffer.size > 0) {
             const failure = await this._merge(this);
             if (failure) {
+              this.rollback();
               return {
                 label,
                 success: false,
@@ -6153,13 +6369,7 @@ var require_cjs = __commonJS({
                 deleted: []
               };
             }
-            this.writeBuffer.clear();
-            this.deleteBuffer.clear();
-            this.createdKeys.clear();
-            this.deletedValues.clear();
-            this.originallyExisted.clear();
-            this.keyVersions.clear();
-            this.bufferHistory.clear();
+            this._cleanupAll();
             this.localVersion = 0;
             this.snapshotVersion = this.version;
           }
@@ -8065,12 +8275,14 @@ var require_cjs = __commonJS({
       buffer;
       view;
       totalWrittenPages = 0;
+      logger;
       /**
        * Constructor
        * @param walFilePath WAL file path
        * @param pageSize Page size
+       * @param logger Logger instance
        */
-      constructor(walFilePath, pageSize) {
+      constructor(walFilePath, pageSize, logger) {
         if ((pageSize & pageSize - 1) !== 0) {
           throw new Error("Page size must be a power of 2");
         }
@@ -8079,6 +8291,7 @@ var require_cjs = __commonJS({
         this.entrySize = 4 + pageSize;
         this.buffer = new Uint8Array(this.entrySize);
         this.view = new DataView(this.buffer.buffer);
+        this.logger = logger;
       }
       /**
        * Opens the log file.
@@ -8106,11 +8319,11 @@ var require_cjs = __commonJS({
           try {
             const manager = new PageManagerFactory().getManager(data);
             if (!manager.verifyChecksum(data)) {
-              console.warn(`[WALManager] Checksum verification failed for PageID ${pageId} during recovery. Ignoring changes.`);
+              this.logger.warn(`Checksum verification failed for PageID ${pageId} during recovery. Ignoring changes.`);
               continue;
             }
           } catch (e) {
-            console.warn(`[WALManager] Failed to verify checksum for PageID ${pageId} during recovery: ${e}. Ignoring changes.`);
+            this.logger.warn(`Failed to verify checksum for PageID ${pageId} during recovery: ${e}. Ignoring changes.`);
             continue;
           }
           promises.push(writePage(pageId, data));
@@ -8423,20 +8636,22 @@ var require_cjs = __commonJS({
        * @param pageCacheCapacity 페이지 캐시 크기
        * @param options 데이터플라이 옵션
        */
-      constructor(fileHandle, pageSize, pageCacheCapacity, options) {
+      constructor(fileHandle, pageSize, pageCacheCapacity, options, logger, walLogger) {
         this.fileHandle = fileHandle;
         this.pageSize = pageSize;
         this.pageCacheCapacity = pageCacheCapacity;
         this.options = options;
         const walPath = options.wal;
-        this.walManager = walPath ? new WALManager(walPath, pageSize) : null;
+        this.walManager = walPath && walLogger ? new WALManager(walPath, pageSize, walLogger) : null;
         this.pageManagerFactory = new PageManagerFactory();
         this.pageStrategy = new PageMVCCStrategy(fileHandle, pageSize, pageCacheCapacity);
+        this.logger = logger;
       }
       pageFactory = new PageManagerFactory();
       walManager;
       pageManagerFactory;
       pageStrategy;
+      logger;
       /** 글로벌 동기화(체크포인트/커밋)를 위한 Mutex */
       lockPromise = Promise.resolve();
       /**
@@ -8461,7 +8676,9 @@ var require_cjs = __commonJS({
        * Performs WAL recovery if necessary.
        */
       async init() {
+        this.logger.info("Initializing");
         if (this.walManager) {
+          this.logger.debug("WALManager found, starting recovery");
           await this.walManager.recover(async (pageId, data) => {
             await this.pageStrategy.write(pageId, data);
           });
@@ -8633,6 +8850,7 @@ var require_cjs = __commonJS({
        * @returns Created or reused page ID
        */
       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 metadataManager = this.pageFactory.getManager(metadata);
@@ -8736,6 +8954,7 @@ var require_cjs = __commonJS({
        * @param tx Transaction
        */
       async freeChain(startPageId, tx) {
+        this.logger.debug(`Freeing chain starting at page ${startPageId}`);
         let currentPageId = startPageId;
         const visited = /* @__PURE__ */ new Set();
         while (currentPageId !== -1 && currentPageId !== 0) {
@@ -8775,6 +8994,7 @@ var require_cjs = __commonJS({
        */
       async commitToWAL(dirtyPages) {
         if (this.walManager) {
+          this.logger.debug(`Committing ${dirtyPages.size} pages to WAL`);
           await this.walManager.prepareCommit(dirtyPages);
           await this.walManager.finalizeCommit(true);
         }
@@ -8786,6 +9006,7 @@ var require_cjs = __commonJS({
        * 3. WAL 로그 파일 비우기 (Clear/Truncate)
        */
       async checkpoint() {
+        this.logger.info("Starting checkpoint");
         await this.runGlobalLock(async () => {
           await this.pageStrategy.flush();
           await this.pageStrategy.sync();
@@ -8798,6 +9019,7 @@ var require_cjs = __commonJS({
        * Closes the page file system.
        */
       async close() {
+        this.logger.info("Closing");
         await this.checkpoint();
         if (this.walManager) {
           this.walManager.close();
@@ -9029,7 +9251,7 @@ var require_cjs = __commonJS({
       }
     };
     var RowTableEngine = class {
-      constructor(pfs, txContext, options) {
+      constructor(pfs, txContext, options, logger) {
         this.pfs = pfs;
         this.txContext = txContext;
         this.options = options;
@@ -9039,6 +9261,7 @@ var require_cjs = __commonJS({
         this.overflowPageManager = this.factory.getManagerFromType(OverflowPageManager.CONSTANT.PAGE_TYPE_OVERFLOW);
         this.rowManager = new Row();
         this.keyManager = new KeyManager();
+        this.logger = logger;
         this.ridBuffer = new Uint8Array(Row.CONSTANT.SIZE_RID);
         this.pageIdBuffer = new Uint8Array(DataPageManager.CONSTANT.SIZE_PAGE_ID);
         this.maxBodySize = this.pfs.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER;
@@ -9067,6 +9290,7 @@ var require_cjs = __commonJS({
       maxBodySize;
       ridBuffer;
       pageIdBuffer;
+      logger;
       initialized = false;
       /**
        * Retrieves the BPTree transaction associated with the given transaction.
@@ -9101,6 +9325,7 @@ var require_cjs = __commonJS({
        */
       async init() {
         if (!this.initialized) {
+          this.logger.info("Initializing B+ Tree");
           await this.bptree.init();
           this.initialized = true;
         }
@@ -9148,6 +9373,7 @@ var require_cjs = __commonJS({
        * @returns Metadata
        */
       async getMetadata(tx) {
+        this.logger.debug("Getting metadata");
         if (!this.initialized) {
           throw new Error("RowTableEngine instance is not initialized");
         }
@@ -9173,6 +9399,7 @@ var require_cjs = __commonJS({
        * @returns Array of PKs of the inserted data
        */
       async insert(dataList, incrementRowCount, overflowForcly, tx) {
+        this.logger.debug(`Inserting ${dataList.length} rows (overflowForcly: ${overflowForcly})`);
         if (dataList.length === 0) {
           return [];
         }
@@ -9274,6 +9501,7 @@ var require_cjs = __commonJS({
        * @param tx Transaction
        */
       async update(pk, data, tx) {
+        this.logger.debug(`Updating row with PK: ${pk}`);
         await tx.__acquireWriteLock(0);
         const rid = await this.getRidByPK(pk, tx);
         if (rid === null) {
@@ -9359,6 +9587,7 @@ var require_cjs = __commonJS({
        * @param tx Transaction
        */
       async delete(pk, decrementRowCount, tx) {
+        this.logger.debug(`Deleting row with PK: ${pk}`);
         await tx.__acquireWriteLock(0);
         const rid = await this.getRidByPK(pk, tx);
         if (rid === null) {
@@ -9418,6 +9647,7 @@ var require_cjs = __commonJS({
        * @returns Raw data of the row
        */
       async selectByPK(pk, tx) {
+        this.logger.debug(`Selecting row by PK: ${pk}`);
         const rid = await this.getRidByPK(pk, tx);
         if (rid === null) {
           return null;
@@ -9432,6 +9662,7 @@ var require_cjs = __commonJS({
        * @returns Array of raw data of the rows in the same order as input PKs
        */
       async selectMany(pks, tx) {
+        this.logger.debug(`Selecting many rows (${pks.length} PKs)`);
         const collections = await this.collectItemsByPage(pks, tx);
         return this.fetchRowsByRids(collections, pks.length, tx);
       }
@@ -9752,10 +9983,10 @@ var require_cjs = __commonJS({
           if (shouldTriggerCheckpoint) {
             await this.pfs.checkpoint();
           }
+        } finally {
           this.dirtyPages.clear();
           this.undoPages.clear();
           this.releaseAllLocks();
-        } finally {
           if (this._writeLockRelease) {
             this._writeLockRelease();
             this._writeLockRelease = null;
@@ -9810,25 +10041,99 @@ var require_cjs = __commonJS({
         return this.storage.run(tx, callback);
       }
     };
+    var Colors = {
+      reset: "\x1B[0m",
+      debug: "\x1B[36m",
+      // Cyan
+      info: "\x1B[32m",
+      // Green
+      warn: "\x1B[33m",
+      // Yellow
+      error: "\x1B[31m",
+      // Red
+      white: "\x1B[37m",
+      // White
+      grey: "\x1B[90m"
+      // Grey
+    };
+    var LoggerManager = class {
+      level;
+      constructor(level = 2) {
+        this.level = level;
+      }
+      setLevel(level) {
+        this.level = level;
+      }
+      shouldLog(level) {
+        if (this.level === 0) return false;
+        return level >= this.level;
+      }
+      create(moduleName) {
+        return new Logger2(this, moduleName);
+      }
+    };
+    var Logger2 = class {
+      constructor(parent, moduleName) {
+        this.parent = parent;
+        this.moduleName = moduleName;
+      }
+      debug(message, ...args) {
+        if (this.parent.shouldLog(
+          1
+          /* Debug */
+        )) {
+          console.debug(`${Colors.debug}[DEBUG] [${this.moduleName}]${Colors.reset} ${Colors.white}${message}${Colors.reset}`, ...args);
+        }
+      }
+      info(message, ...args) {
+        if (this.parent.shouldLog(
+          2
+          /* Info */
+        )) {
+          console.info(`${Colors.info}[INFO] [${this.moduleName}]${Colors.reset} ${Colors.white}${message}${Colors.reset}`, ...args);
+        }
+      }
+      warn(message, ...args) {
+        if (this.parent.shouldLog(
+          3
+          /* Warning */
+        )) {
+          console.warn(`${Colors.warn}[WARN] [${this.moduleName}]${Colors.reset} ${Colors.white}${message}${Colors.reset}`, ...args);
+        }
+      }
+      error(message, ...args) {
+        if (this.parent.shouldLog(
+          4
+          /* Error */
+        )) {
+          console.error(`${Colors.error}[ERROR] [${this.moduleName}]${Colors.reset} ${Colors.white}${message}${Colors.reset}`, ...args);
+        }
+      }
+    };
     var DataplyAPI2 = class {
       constructor(file, options) {
         this.file = file;
         this.hook = useHookall(this);
         this.options = this.verboseOptions(options);
+        this.loggerManager = new LoggerManager(this.options.logLevel);
+        this.logger = this.loggerManager.create("DataplyAPI");
         this.isNewlyCreated = !import_node_fs3.default.existsSync(file);
         this.fileHandle = this.createOrOpen(file, this.options);
         this.pfs = new PageFileSystem(
           this.fileHandle,
           this.options.pageSize,
           this.options.pageCacheCapacity,
-          this.options
+          this.options,
+          this.loggerManager.create("PageFileSystem"),
+          options.wal ? this.loggerManager.create("WALManager") : void 0
         );
         this.textCodec = new TextCodec();
         this.txContext = new TransactionContext();
         this.lockManager = new LockManager();
-        this.rowTableEngine = new RowTableEngine(this.pfs, this.txContext, this.options);
+        this.rowTableEngine = new RowTableEngine(this.pfs, this.txContext, this.options, this.loggerManager.create("RowTableEngine"));
         this.initialized = false;
         this.txIdCounter = 0;
+        this.logger.debug(`DataplyAPI instance created with file: ${file}`);
       }
       /**
        * These are not the same options that were used when the database was created.
@@ -9850,6 +10155,10 @@ var require_cjs = __commonJS({
       txContext;
       /** Hook */
       hook;
+      /** Base Logger */
+      loggerManager;
+      /** Logger module for DataplyAPI */
+      logger;
       /** Whether the database was initialized via `init()` */
       initialized;
       /** Whether the database was created this time. */
@@ -9864,6 +10173,7 @@ var require_cjs = __commonJS({
        * @returns Whether the page file is a valid Dataply file
        */
       verifyFormat(fileHandle) {
+        this.logger.debug(`Verifying format for file handle: ${fileHandle}`);
         const size = MetadataPageManager.CONSTANT.OFFSET_MAGIC_STRING + MetadataPageManager.CONSTANT.MAGIC_STRING.length;
         const metadataPage = new Uint8Array(size);
         import_node_fs3.default.readSync(fileHandle, metadataPage, 0, size, 0);
@@ -9883,7 +10193,9 @@ var require_cjs = __commonJS({
           pageCacheCapacity: 1e4,
           pagePreallocationCount: 1e3,
           wal: null,
-          walCheckpointThreshold: 1e3
+          walCheckpointThreshold: 1e3,
+          logLevel: 2
+          /* Info */
         }, options);
       }
       /**
@@ -9894,6 +10206,7 @@ var require_cjs = __commonJS({
        * @param fileHandle File handle
        */
       initializeFile(file, fileHandle, options) {
+        this.logger.info(`Initializing new dataply file: ${file}`);
         const metadataPageManager = new MetadataPageManager();
         const bitmapPageManager = new BitmapPageManager();
         const dataPageManager = new DataPageManager();
@@ -9943,6 +10256,7 @@ var require_cjs = __commonJS({
        * @returns File handle
        */
       createOrOpen(file, options) {
+        this.logger.info(`Opening dataply file: ${file}`);
         let fileHandle;
         if (options.pageCacheCapacity < 100) {
           throw new Error("Page cache capacity must be at least 100");
@@ -9978,6 +10292,7 @@ var require_cjs = __commonJS({
        * If not called, the dataply instance cannot be used.
        */
       async init() {
+        this.logger.info("Initializing DataplyAPI");
         if (this.initialized) {
           return;
         }
@@ -9997,6 +10312,7 @@ var require_cjs = __commonJS({
        * @returns Transaction object
        */
       createTransaction() {
+        this.logger.debug(`Creating transaction: ${this.txIdCounter + 1}`);
         return new Transaction4(
           ++this.txIdCounter,
           this.txContext,
@@ -10021,6 +10337,7 @@ var require_cjs = __commonJS({
        * @returns A release function
        */
       acquireWriteLock() {
+        this.logger.debug("Acquiring write lock");
         const previous = this.writeQueue;
         let release;
         this.writeQueue = new Promise((resolve) => {
@@ -10038,6 +10355,7 @@ var require_cjs = __commonJS({
        * @returns The result of the callback.
        */
       async runWithDefaultWrite(callback, tx) {
+        this.logger.debug("Running with default write transaction");
         if (!tx) {
           const release = await this.acquireWriteLock();
           const internalTx = this.createTransaction();
@@ -10061,6 +10379,7 @@ var require_cjs = __commonJS({
         return result;
       }
       async runWithDefault(callback, tx) {
+        this.logger.debug("Running with default transaction");
         const isInternalTx = !tx;
         if (!tx) {
           tx = this.createTransaction();
@@ -10088,6 +10407,7 @@ var require_cjs = __commonJS({
        * @returns An AsyncGenerator that yields values from the callback.
        */
       async *streamWithDefault(callback, tx) {
+        this.logger.debug("Streaming with default transaction");
         const isInternalTx = !tx;
         if (!tx) {
           tx = this.createTransaction();
@@ -10115,6 +10435,7 @@ var require_cjs = __commonJS({
        * @returns Metadata of the dataply.
        */
       async getMetadata(tx) {
+        this.logger.debug("Getting metadata");
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10128,6 +10449,7 @@ var require_cjs = __commonJS({
        * @returns PK of the added data
        */
       async insert(data, incrementRowCount, tx) {
+        this.logger.debug("Inserting data");
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10148,6 +10470,7 @@ var require_cjs = __commonJS({
        * @returns PK of the added data
        */
       async insertAsOverflow(data, incrementRowCount, tx) {
+        this.logger.debug("Inserting data as overflow");
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10169,6 +10492,7 @@ var require_cjs = __commonJS({
        * @returns Array of PKs of the added data
        */
       async insertBatch(dataList, incrementRowCount, tx) {
+        this.logger.debug(`Inserting batch data: ${dataList.length} items`);
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10187,6 +10511,7 @@ var require_cjs = __commonJS({
        * @param tx Transaction
        */
       async update(pk, data, tx) {
+        this.logger.debug(`Updating data for PK: ${pk}`);
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10204,6 +10529,7 @@ var require_cjs = __commonJS({
        * @param tx Transaction
        */
       async delete(pk, decrementRowCount, tx) {
+        this.logger.debug(`Deleting data for PK: ${pk}`);
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10213,6 +10539,7 @@ var require_cjs = __commonJS({
         }, tx);
       }
       async select(pk, asRaw = false, tx) {
+        this.logger.debug(`Selecting data for PK: ${pk}`);
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10224,6 +10551,7 @@ var require_cjs = __commonJS({
         }, tx);
       }
       async selectMany(pks, asRaw = false, tx) {
+        this.logger.debug(`Selecting many data: ${pks.length} keys`);
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10240,6 +10568,7 @@ var require_cjs = __commonJS({
        * Closes the dataply file.
        */
       async close() {
+        this.logger.info("Closing DataplyAPI");
         if (!this.initialized) {
           throw new Error("Dataply instance is not initialized");
         }
@@ -10860,9 +11189,10 @@ var BinaryHeap = class {
 
 // src/core/QueryManager.ts
 var QueryManager = class {
-  constructor(api, optimizer) {
+  constructor(api, optimizer, logger) {
     this.api = api;
     this.optimizer = optimizer;
+    this.logger = logger;
   }
   operatorConverters = {
     equal: "primaryEqual",
@@ -11174,18 +11504,23 @@ var QueryManager = class {
   async countDocuments(query, tx) {
     return this.api.runWithDefault(async (tx2) => {
       const pks = await this.getKeys(query);
+      this.logger.debug(`Counted ${pks.length} documents matching query`);
       return pks.length;
     }, tx);
   }
   selectDocuments(query, options = {}, tx) {
     for (const field of Object.keys(query)) {
       if (!this.api.indexedFields.has(field)) {
-        throw new Error(`Query field "${field}" is not indexed. Available indexed fields: ${Array.from(this.api.indexedFields).join(", ")}`);
+        const errorMsg = `Query field "${field}" is not indexed. Available indexed fields: ${Array.from(this.api.indexedFields).join(", ")}`;
+        this.logger.error(errorMsg);
+        throw new Error(errorMsg);
       }
     }
     const orderBy = options.orderBy;
     if (orderBy !== void 0 && !this.api.indexedFields.has(orderBy)) {
-      throw new Error(`orderBy field "${orderBy}" is not indexed. Available indexed fields: ${Array.from(this.api.indexedFields).join(", ")}`);
+      const errorMsg = `orderBy field "${orderBy}" is not indexed. Available indexed fields: ${Array.from(this.api.indexedFields).join(", ")}`;
+      this.logger.error(errorMsg);
+      throw new Error(errorMsg);
     }
     const {
       limit = Infinity,
@@ -11282,6 +11617,7 @@ var QueryManager = class {
             others,
             tx2
           )) {
+            self.logger.debug(`Yielding sorted document: ${doc._id}`);
             if (skippedCount < offset) {
               skippedCount++;
               continue;
@@ -11379,10 +11715,76 @@ var DocumentSerializeStrategyAsync = class extends import_dataply2.SerializeStra
   }
 };
 
+// src/utils/eventLoopManager.ts
+function yieldEventLoop() {
+  return new Promise(setImmediate);
+}
+var DeadlineChunker = class {
+  /**
+   * 이벤트 루프를 막을 최대 허용 시간
+   */
+  targetMs;
+  /**
+   * 현재 chunk size
+   */
+  chunkSize;
+  /**
+   * Exponential Weighted Moving Average
+   */
+  ewmaMs;
+  /**
+   * EWMA 평활화 계수
+   */
+  alpha;
+  constructor(startChunkSize = 0, targetMs = 5, alpha = 0.5) {
+    this.chunkSize = startChunkSize;
+    this.targetMs = targetMs;
+    this.alpha = alpha;
+    this.ewmaMs = null;
+  }
+  /**
+   * EWMA 평활화 계수를 사용하여 평균 처리 시간을 업데이트합니다.
+   */
+  updateEstimate(elapsed, count) {
+    const msPerItem = elapsed / count;
+    this.ewmaMs = this.ewmaMs === null ? msPerItem : this.alpha * msPerItem + (1 - this.alpha) * this.ewmaMs;
+  }
+  /**
+   * 현재 chunk size를 업데이트합니다.
+   */
+  nextChunkSize() {
+    if (!this.ewmaMs || this.ewmaMs === 0) return this.chunkSize;
+    const next = Math.floor(this.targetMs / this.ewmaMs);
+    return Math.max(1, next);
+  }
+  /**
+   * 주어진 items를 chunk로 분할하여 처리합니다.
+   */
+  async processInChunks(items, processFn) {
+    let i = 0;
+    let len = items.length;
+    if (this.chunkSize === 0) {
+      this.chunkSize = Math.floor(items.length / 100 * 5);
+    }
+    while (i < len) {
+      const chunk = items.slice(i, i + this.chunkSize);
+      const count = chunk.length;
+      const start = performance.now();
+      await processFn(chunk);
+      const elapsed = performance.now() - start;
+      this.updateEstimate(elapsed, count);
+      this.chunkSize = this.nextChunkSize();
+      i += count;
+      await yieldEventLoop();
+    }
+  }
+};
+
 // src/core/IndexManager.ts
 var IndexManager = class {
-  constructor(api) {
+  constructor(api, logger) {
     this.api = api;
+    this.logger = logger;
     this.trees = /* @__PURE__ */ new Map();
     this.indexedFields = /* @__PURE__ */ new Set(["_id"]);
   }
@@ -11484,6 +11886,7 @@ var IndexManager = class {
    * Register an index. If called before init(), queues it.
    */
   async registerIndex(name, option, tx) {
+    this.logger.debug(`Registering index "${name}" (type: ${option.type})`);
     if (!this.api.isDocInitialized) {
       this.pendingCreateIndices.set(name, option);
       return;
@@ -11556,7 +11959,7 @@ var IndexManager = class {
       this.indices = metadata.indices;
       this.registeredIndices.delete(name);
       const fields = this.getFieldsFromConfig(config);
-      for (let i = 0; i < fields.length; i++) {
+      for (let i = 0, len = fields.length; i < len; i++) {
         const field = fields[i];
         const indexNames = this.fieldToIndices.get(field);
         if (indexNames) {
@@ -11578,6 +11981,7 @@ var IndexManager = class {
    * Backfill indices for newly created indices after data was inserted.
    */
   async backfillIndices(tx) {
+    this.logger.debug(`Starting backfill for fields: ${this.pendingBackfillFields.join(", ")}`);
     return this.api.runWithDefaultWrite(async (tx2) => {
       if (this.pendingBackfillFields.length === 0) {
         return 0;
@@ -11587,16 +11991,14 @@ var IndexManager = class {
       if (metadata.lastId === 0) {
         return 0;
       }
-      let indexTxMap = {};
+      const bulkData = {};
       for (const indexName of backfillTargets) {
         const tree = this.trees.get(indexName);
         if (tree && indexName !== "_id") {
-          indexTxMap[indexName] = await tree.createTransaction();
+          bulkData[indexName] = [];
         }
       }
       let backfilledCount = 0;
-      let chunkCount = 0;
-      const CHUNK_SIZE = 1e3;
       const idTree = this.trees.get("_id");
       if (!idTree) {
         throw new Error("ID tree not found");
@@ -11610,70 +12012,145 @@ var IndexManager = class {
         const flatDoc = this.api.flattenDocument(doc);
         for (let i = 0, len = backfillTargets.length; i < len; i++) {
           const indexName = backfillTargets[i];
-          if (!(indexName in indexTxMap)) continue;
+          if (!(indexName in bulkData)) continue;
           const config = this.registeredIndices.get(indexName);
           if (!config) continue;
-          const btx = indexTxMap[indexName];
           if (config.type === "fts") {
             const primaryField = this.getPrimaryField(config);
             const v2 = flatDoc[primaryField];
             if (v2 === void 0 || typeof v2 !== "string") continue;
             const ftsConfig = this.getFtsConfig(config);
             const tokens = ftsConfig ? tokenize(v2, ftsConfig) : [v2];
-            const batchInsertData = [];
-            for (let i2 = 0, len2 = tokens.length; i2 < len2; i2++) {
-              const token = tokens[i2];
+            for (let j = 0, tLen = tokens.length; j < tLen; j++) {
+              const token = tokens[j];
               const keyToInsert = this.getTokenKey(k2, token);
               const entry = { k: k2, v: token };
-              batchInsertData.push([keyToInsert, entry]);
+              bulkData[indexName].push([keyToInsert, entry]);
             }
-            await btx.batchInsert(batchInsertData);
           } else {
             const indexVal = this.getIndexValue(config, flatDoc);
             if (indexVal === void 0) continue;
             const entry = { k: k2, v: indexVal };
-            const batchInsertData = [[k2, entry]];
-            await btx.batchInsert(batchInsertData);
+            bulkData[indexName].push([k2, entry]);
           }
         }
         backfilledCount++;
-        chunkCount++;
-        if (chunkCount >= CHUNK_SIZE) {
-          try {
-            for (const btx of Object.values(indexTxMap)) {
-              await btx.commit();
-            }
-          } catch (err) {
-            for (const btx of Object.values(indexTxMap)) {
-              await btx.rollback();
-            }
-            throw err;
-          }
-          for (const indexName of backfillTargets) {
-            const tree = this.trees.get(indexName);
-            if (tree && indexName !== "_id") {
-              indexTxMap[indexName] = await tree.createTransaction();
-            }
-          }
-          chunkCount = 0;
-        }
       }
-      if (chunkCount > 0) {
+      for (const indexName of backfillTargets) {
+        const tree = this.trees.get(indexName);
+        if (!tree || indexName === "_id") continue;
+        const entries = bulkData[indexName];
+        if (!entries || entries.length === 0) continue;
+        const treeTx = await tree.createTransaction();
         try {
-          for (const btx of Object.values(indexTxMap)) {
-            await btx.commit();
+          await treeTx.bulkLoad(entries);
+          const res = await treeTx.commit();
+          if (!res.success) {
+            await treeTx.rollback();
+            throw res.error;
           }
         } catch (err) {
-          for (const btx of Object.values(indexTxMap)) {
-            await btx.rollback();
-          }
+          await treeTx.rollback();
           throw err;
         }
+        await yieldEventLoop();
       }
       this.pendingBackfillFields = [];
       return backfilledCount;
     }, tx);
   }
+  /**
+   * Rebuild specified indices by clearing existing tree data and rebuilding via bulkLoad.
+   * If no index names are provided, all indices (except _id) are rebuilt.
+   */
+  async rebuildIndices(indexNames, tx) {
+    const targets = indexNames ?? [...this.registeredIndices.keys()].filter((n) => n !== "_id");
+    for (const name of targets) {
+      if (name === "_id") {
+        throw new Error('Cannot rebuild the "_id" index.');
+      }
+      if (!this.registeredIndices.has(name)) {
+        throw new Error(`Index "${name}" does not exist.`);
+      }
+    }
+    if (targets.length === 0) return 0;
+    this.logger.debug(`Starting rebuild for indices: ${targets.join(", ")}`);
+    return this.api.runWithDefaultWrite(async (tx2) => {
+      const metadata = await this.api.getDocumentInnerMetadata(tx2);
+      if (metadata.lastId === 0) return 0;
+      const bulkData = {};
+      for (const indexName of targets) {
+        bulkData[indexName] = [];
+      }
+      const idTree = this.trees.get("_id");
+      if (!idTree) throw new Error("ID tree not found");
+      let docCount = 0;
+      const stream = idTree.whereStream({ primaryGte: { v: 0 } });
+      for await (const [k2] of stream) {
+        const doc = await this.api.getDocument(k2, tx2);
+        if (!doc) continue;
+        const flatDoc = this.api.flattenDocument(doc);
+        for (let i = 0, len = targets.length; i < len; i++) {
+          const indexName = targets[i];
+          const config = this.registeredIndices.get(indexName);
+          if (!config) continue;
+          if (config.type === "fts") {
+            const primaryField = this.getPrimaryField(config);
+            const v2 = flatDoc[primaryField];
+            if (v2 === void 0 || typeof v2 !== "string") continue;
+            const ftsConfig = this.getFtsConfig(config);
+            const tokens = ftsConfig ? tokenize(v2, ftsConfig) : [v2];
+            for (let j = 0, tLen = tokens.length; j < tLen; j++) {
+              const token = tokens[j];
+              const keyToInsert = this.getTokenKey(k2, token);
+              bulkData[indexName].push([keyToInsert, { k: k2, v: token }]);
+            }
+          } else {
+            const indexVal = this.getIndexValue(config, flatDoc);
+            if (indexVal === void 0) continue;
+            bulkData[indexName].push([k2, { k: k2, v: indexVal }]);
+          }
+        }
+        docCount++;
+      }
+      const perIndexCapacity = Math.floor(this.api.options.pageCacheCapacity / Object.keys(this.api.indices).length);
+      for (const indexName of targets) {
+        metadata.indices[indexName][0] = -1;
+        await this.api.updateDocumentInnerMetadata(metadata, tx2);
+        const tree = new import_dataply3.BPTreeAsync(
+          new DocumentSerializeStrategyAsync(
+            this.api.rowTableEngine.order,
+            this.api,
+            this.api.txContext,
+            indexName
+          ),
+          this.api.comparator,
+          {
+            capacity: perIndexCapacity
+          }
+        );
+        await tree.init();
+        this.trees.set(indexName, tree);
+        const entries = bulkData[indexName];
+        if (entries.length > 0) {
+          const treeTx = await tree.createTransaction();
+          try {
+            await treeTx.bulkLoad(entries);
+            const res = await treeTx.commit();
+            if (!res.success) {
+              await treeTx.rollback();
+              throw res.error;
+            }
+          } catch (err) {
+            await treeTx.rollback();
+            throw err;
+          }
+          await yieldEventLoop();
+        }
+      }
+      return docCount;
+    }, tx);
+  }
   /**
    * Convert CreateIndexOption to IndexMetaConfig for metadata storage.
    */
@@ -11779,72 +12256,19 @@ async function catchPromise(promise) {
   return promise.then((res) => [void 0, res]).catch((reason) => [reason]);
 }
 
-// src/utils/DeadlineChunker.ts
-var DeadlineChunker = class {
-  /**
-   * 이벤트 루프를 막을 최대 허용 시간
-   */
-  targetMs;
-  /**
-   * 현재 chunk size
-   */
-  chunkSize;
-  /**
-   * Exponential Weighted Moving Average
-   */
-  ewmaMs;
-  /**
-   * EWMA 평활화 계수
-   */
-  alpha;
-  constructor(startChunkSize = 0, targetMs = 5, alpha = 0.5) {
-    this.chunkSize = startChunkSize;
-    this.targetMs = targetMs;
-    this.alpha = alpha;
-    this.ewmaMs = null;
-  }
-  /**
-   * EWMA 평활화 계수를 사용하여 평균 처리 시간을 업데이트합니다.
-   */
-  updateEstimate(elapsed, count) {
-    const msPerItem = elapsed / count;
-    this.ewmaMs = this.ewmaMs === null ? msPerItem : this.alpha * msPerItem + (1 - this.alpha) * this.ewmaMs;
-  }
-  /**
-   * 현재 chunk size를 업데이트합니다.
-   */
-  nextChunkSize() {
-    if (!this.ewmaMs || this.ewmaMs === 0) return this.chunkSize;
-    const next = Math.floor(this.targetMs / this.ewmaMs);
-    return Math.max(1, next);
-  }
-  /**
-   * 주어진 items를 chunk로 분할하여 처리합니다.
-   */
-  async processInChunks(items, processFn) {
-    let i = 0;
-    let len = items.length;
-    if (this.chunkSize === 0) {
-      this.chunkSize = Math.floor(items.length / 100 * 5);
-    }
-    while (i < len) {
-      const chunk = items.slice(i, i + this.chunkSize);
-      const count = chunk.length;
-      const start = performance.now();
-      await processFn(chunk);
-      const elapsed = performance.now() - start;
-      this.updateEstimate(elapsed, count);
-      this.chunkSize = this.nextChunkSize();
-      i += count;
-      await new Promise(setImmediate);
-    }
-  }
-};
-
 // src/core/MutationManager.ts
 var MutationManager = class {
-  constructor(api) {
+  constructor(api, logger) {
     this.api = api;
+    this.logger = logger;
+  }
+  async isTreeEmpty(tree, tx) {
+    try {
+      const root = await tree.getNode(tree.rootId, tx);
+      return root.leaf && root.values.length === 0;
+    } catch {
+      return true;
+    }
   }
   async insertDocumentInternal(document, tx) {
     const metadata = await this.api.getDocumentInnerMetadata(tx);
@@ -11887,16 +12311,19 @@ var MutationManager = class {
         }
       }
       await this.api.analysisManager.notifyInsert([flattenDocument], tx2);
+      this.logger.debug(`Inserted single document with ID: ${dataplyDocument._id}`);
       return dataplyDocument._id;
     }, tx);
   }
   async insertBatchDocuments(documents, tx) {
     return this.api.runWithDefaultWrite(async (tx2) => {
+      this.logger.debug(`Batch inserting ${documents.length} documents`);
       const metadata = await this.api.getDocumentInnerMetadata(tx2);
-      const startId = metadata.lastId + 1;
+      let startId = metadata.lastId + 1;
       metadata.lastId += documents.length;
       await this.api.updateDocumentInnerMetadata(metadata, tx2);
-      const ids = [];
+      const ids = new Float64Array(documents.length);
+      const pks = new Float64Array(documents.length);
       const dataplyDocuments = [];
       const flattenedData = [];
       for (let i = 0, len = documents.length; i < len; i++) {
@@ -11908,17 +12335,15 @@ var MutationManager = class {
         dataplyDocuments.push(stringified);
         const flattenDocument = this.api.flattenDocument(dataplyDocument);
         flattenedData.push({ pk: -1, data: flattenDocument });
-        ids.push(id);
+        ids[i] = id;
       }
-      const pks = [];
-      const documentChunker = new DeadlineChunker(1e4);
-      await documentChunker.processInChunks(dataplyDocuments, async (chunk) => {
-        const res = await this.api.insertBatch(chunk, true, tx2);
-        pks.push(...res);
-      });
-      for (let i = 0, len = pks.length; i < len; i++) {
-        flattenedData[i].pk = pks[i];
+      const res = await this.api.insertBatch(dataplyDocuments, true, tx2);
+      for (let i = 0, len = res.length; i < len; i++) {
+        const index = i;
+        pks[index] = res[i];
+        flattenedData[index].pk = res[i];
       }
+      await yieldEventLoop();
       for (const [indexName, config] of this.api.indexManager.registeredIndices) {
         const tree = this.api.trees.get(indexName);
         if (!tree) continue;
@@ -11945,34 +12370,39 @@ var MutationManager = class {
             batchInsertData.push([item.pk, { k: item.pk, v: indexVal }]);
           }
         }
-        const initMaxSize = 5e4;
-        const initChunkSize = Math.min(
-          initMaxSize,
-          Math.max(initMaxSize, Math.floor(batchInsertData.length / 100 * 5))
-        );
-        const chunker = new DeadlineChunker(initChunkSize);
-        await chunker.processInChunks(batchInsertData, async (chunk) => {
-          const [error] = await catchPromise(treeTx.batchInsert(chunk));
+        const isEmptyTree = await this.isTreeEmpty(tree, tx2);
+        if (isEmptyTree) {
+          const [error] = await catchPromise(treeTx.bulkLoad(batchInsertData));
           if (error) {
             throw error;
           }
-        });
-        const res = await treeTx.commit();
-        if (!res.success) {
+        } else {
+          const [error] = await catchPromise(treeTx.batchInsert(batchInsertData));
+          if (error) {
+            throw error;
+          }
+        }
+        const res2 = await treeTx.commit();
+        if (!res2.success) {
           await treeTx.rollback();
-          throw res.error;
+          this.logger.error(`Failed to commit batch insert for index ${indexName}: ${res2.error}`);
+          throw res2.error;
         }
+        await yieldEventLoop();
       }
       const flatDocs = [];
       for (let i = 0, len = flattenedData.length; i < len; i++) {
         flatDocs.push(flattenedData[i].data);
       }
       await this.api.analysisManager.notifyInsert(flatDocs, tx2);
-      return ids;
+      await yieldEventLoop();
+      this.logger.debug(`Successfully batch inserted ${documents.length} documents`);
+      return Array.from(ids);
     }, tx);
   }
   async updateInternal(query, computeUpdatedDoc, tx) {
     const pks = await this.api.queryManager.getKeys(query);
+    this.logger.debug(`Found ${pks.length} documents to update`);
     let updatedCount = 0;
     const updatePairs = [];
     const treeTxs = /* @__PURE__ */ new Map();
@@ -12021,9 +12451,11 @@ var MutationManager = class {
             await treeTx.batchInsert([[pk, { k: pk, v: newIndexVal }]]);
           }
         }
+        await yieldEventLoop();
       }
       updatePairs.push({ oldDocument: oldFlatDoc, newDocument: newFlatDoc });
       await this.api.update(pk, JSON.stringify(updatedDoc), tx);
+      await yieldEventLoop();
       updatedCount++;
     }
     for (const [indexName, treeTx] of treeTxs) {
@@ -12032,10 +12464,14 @@ var MutationManager = class {
         for (const rollbackTx of treeTxs.values()) {
           rollbackTx.rollback();
         }
+        await yieldEventLoop();
+        this.logger.error(`Failed to commit update for index ${indexName}: ${result.error}`);
         throw result.error;
       }
     }
     await this.api.analysisManager.notifyUpdate(updatePairs, tx);
+    await yieldEventLoop();
+    this.logger.debug(`Successfully updated ${updatedCount} documents`);
     return updatedCount;
   }
   async fullUpdate(query, newRecord, tx) {
@@ -12059,6 +12495,7 @@ var MutationManager = class {
   async deleteDocuments(query, tx) {
     return this.api.runWithDefaultWrite(async (tx2) => {
       const pks = await this.api.queryManager.getKeys(query);
+      this.logger.debug(`Found ${pks.length} documents to delete`);
       let deletedCount = 0;
       const deletedFlatDocs = [];
       for (let i = 0, len = pks.length; i < len; i++) {
@@ -12083,12 +12520,16 @@ var MutationManager = class {
             if (indexVal === void 0) continue;
             await tree.delete(pk, { k: pk, v: indexVal });
           }
+          await yieldEventLoop();
         }
         deletedFlatDocs.push(flatDoc);
         await this.api.delete(pk, true, tx2);
+        await yieldEventLoop();
         deletedCount++;
       }
       await this.api.analysisManager.notifyDelete(deletedFlatDocs, tx2);
+      await yieldEventLoop();
+      this.logger.debug(`Successfully deleted ${deletedCount} documents`);
       return deletedCount;
     }, tx);
   }
@@ -12096,8 +12537,9 @@ var MutationManager = class {
 
 // src/core/MetadataManager.ts
 var MetadataManager = class {
-  constructor(api) {
+  constructor(api, logger) {
     this.api = api;
+    this.logger = logger;
   }
   async getDocumentMetadata(tx) {
     const metadata = await this.api.getMetadata(tx);
@@ -12125,6 +12567,7 @@ var MetadataManager = class {
     return JSON.parse(row);
   }
   async updateDocumentInnerMetadata(metadata, tx) {
+    this.logger.debug(`Updating document inner metadata: version ${metadata.version}`);
     await this.api.update(1, JSON.stringify(metadata), tx);
   }
   async migration(version, callback, tx) {
@@ -12134,6 +12577,7 @@ var MetadataManager = class {
       if (currentVersion < version) {
         await callback(tx2);
         const freshMetadata = await this.getDocumentInnerMetadata(tx2);
+        this.logger.info(`Migration applied successfully to schemeVersion ${version}`);
         freshMetadata.schemeVersion = version;
         freshMetadata.updatedAt = Date.now();
         await this.updateDocumentInnerMetadata(freshMetadata, tx2);
@@ -12970,9 +13414,10 @@ var BuiltinAnalysisProviders = [
 
 // src/core/AnalysisManager.ts
 var AnalysisManager = class {
-  constructor(api, schedule, sampleSize) {
+  constructor(api, schedule, sampleSize, logger) {
     this.api = api;
     this.sampleSize = sampleSize;
+    this.logger = logger;
     this.cron = new E(schedule, async () => {
       if (this.flushing) return;
       await this.api.flushAnalysis();
@@ -13101,6 +13546,7 @@ var AnalysisManager = class {
     if (this.flushing) {
       throw new Error("Cannot flush analysis while analysis is already flushing.");
     }
+    this.logger.debug("Starting analysis data flush");
     this.flushing = true;
     for (const [name, provider] of this.providers) {
       if (provider instanceof IntervalAnalysisProvider) {
@@ -13108,6 +13554,7 @@ var AnalysisManager = class {
       }
     }
     this.flushing = false;
+    this.logger.debug("Finished analysis data flush");
   }
   /**
    * Get the analysis header row.
@@ -13235,32 +13682,39 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
   constructor(file, options) {
     super(file, options);
     this.optimizer = new Optimizer(this);
-    this.queryManager = new QueryManager(this, this.optimizer);
-    this.indexManager = new IndexManager(this);
-    this.mutationManager = new MutationManager(this);
-    this.metadataManager = new MetadataManager(this);
+    this.queryManager = new QueryManager(this, this.optimizer, this.loggerManager.create("document-dataply:query"));
+    this.indexManager = new IndexManager(this, this.loggerManager.create("document-dataply:index"));
+    this.mutationManager = new MutationManager(this, this.loggerManager.create("document-dataply:mutation"));
+    this.metadataManager = new MetadataManager(this, this.loggerManager.create("document-dataply:metadata"));
     this.documentFormatter = new DocumentFormatter();
     this.analysisManager = new AnalysisManager(
       this,
       options.analysisSchedule ?? "* */1 * * *",
-      options.analysisSampleSize ?? 1e3
+      options.analysisSampleSize ?? 1e3,
+      this.loggerManager.create("document-dataply:analysis")
     );
     this.hook.onceAfter("close", async () => {
+      this.logger.info("DocumentDataplyAPI closing");
       this.analysisManager.close();
     });
     this.hook.onceAfter("init", async (tx, isNewlyCreated) => {
+      this.logger.info(`Initializing document database. New creation: ${isNewlyCreated}`);
       if (isNewlyCreated) {
         await this.initializeDocumentFile(tx);
+        this.logger.debug("Initialized document file format");
       }
       if (!await this.verifyDocumentFile(tx)) {
+        this.logger.error("Document metadata verification failed");
         throw new Error("Document metadata verification failed");
       }
       const metadata = await this.getDocumentInnerMetadata(tx);
       await this.indexManager.initializeIndices(metadata, isNewlyCreated, tx);
+      this.logger.debug(`Indices initialized. Total indices: ${Object.keys(metadata.indices).length}`);
       this.analysisManager.registerBuiltinProviders();
       await this.analysisManager.initializeProviders(tx);
       this.analysisManager.triggerCron();
       this._initialized = true;
+      this.logger.info("Document database fully initialized");
       return tx;
     });
   }
@@ -13279,6 +13733,22 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
   get indexedFields() {
     return this.indexManager.indexedFields;
   }
+  /**
+   * Method for reliably processing large batches (chunks) of data.
+   * Processes data in fragments to prevent blocking the event loop while handling large volumes of data.
+   * @param items The items to process
+   * @param callback The callback to process each chunk
+   * @param options The options for the chunk splitter
+   * @param options.firstChunkSize The size of the first chunk. Subsequent chunk sizes are determined based on this value and the processing time. If not specified or set to 0, 5% of the total data is used as the initial value.
+   * @param options.alpha A value that determines the weight given to recent processing times. Higher values weigh recent times more heavily. Lower values are recommended for stability, but excessively low values may impact performance. Default is 0.5.
+   * @returns The processed items
+   */
+  processInChunks(items, callback, options) {
+    this.logger.debug(`Processing ${items.length} items in chunks`);
+    const firstChunkSize = options?.firstChunkSize ?? 0;
+    const alpha = options?.alpha ?? 0.5;
+    return new DeadlineChunker(firstChunkSize, alpha).processInChunks(items, callback);
+  }
   /**
    * Register an index.
    * @param name The name of the index
@@ -13318,6 +13788,16 @@ var DocumentDataplyAPI = class extends import_dataply4.DataplyAPI {
   async backfillIndices(tx) {
     return this.indexManager.backfillIndices(tx);
   }
+  /**
+   * Rebuild specified indices by clearing existing tree data and rebuilding via bulkLoad.
+   * If no index names are provided, all indices (except _id) are rebuilt.
+   * @param indexNames Optional array of index names to rebuild
+   * @param tx Optional transaction
+   * @returns The number of documents processed
+   */
+  async rebuildIndices(indexNames, tx) {
+    return this.indexManager.rebuildIndices(indexNames, tx);
+  }
   /**
    * Flush all interval analysis providers, forcing statistics to be recalculated.
    * Call this after bulk inserts or periodically to keep statistics fresh.
@@ -13518,6 +13998,19 @@ var DocumentDataply = class _DocumentDataply {
   constructor(file, options) {
     this.api = new DocumentDataplyAPI(file, options ?? {});
   }
+  /**
+   * Method for reliably processing large batches (chunks) of data.
+   * Processes data in fragments to prevent blocking the event loop while handling large volumes of data.
+   * @param items The items to process
+   * @param callback The callback to process each chunk
+   * @param options The options for the chunk splitter
+   * @param options.firstChunkSize The size of the first chunk. Subsequent chunk sizes are determined based on this value and the processing time. If not specified or set to 0, 5% of the total data is used as the initial value.
+   * @param options.alpha A value that determines the weight given to recent processing times. Higher values weigh recent times more heavily. Lower values are recommended for stability, but excessively low values may impact performance. Default is 0.5.
+   * @returns The processed items
+   */
+  processInChunks(items, callback, options) {
+    return this.api.processInChunks(items, callback, options);
+  }
   /**
    * Create a named index on the database.
    * Can be called before or after init().
@@ -13542,6 +14035,16 @@ var DocumentDataply = class _DocumentDataply {
     await this.api.dropIndex(name, tx);
     return this;
   }
+  /**
+   * Rebuild specified indices by clearing existing data and reconstructing via bulkLoad.
+   * If no index names are provided, rebuilds all indices except '_id'.
+   * @param indexNames Optional array of index names to rebuild
+   * @param tx Optional transaction
+   * @returns The number of documents processed
+   */
+  async rebuildIndices(indexNames, tx) {
+    return this.api.rebuildIndices(indexNames, tx);
+  }
   /**
    * Initialize the document database
    */