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

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,
@@ -1985,30 +1985,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 +2291,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 +2374,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 +2453,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 +2562,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 +2580,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 +2604,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 +2613,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 +2795,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 +2864,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);
@@ -2972,6 +3055,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 +3320,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 +3476,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 +3569,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 +3647,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 +3759,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 +3777,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 +3801,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 +3811,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 +3995,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 +4064,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);
@@ -4018,7 +4202,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 +4222,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 +4263,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;
@@ -8065,12 +8259,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 +8275,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 +8303,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 +8620,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 +8660,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 +8834,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 +8938,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 +8978,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 +8990,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 +9003,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 +9235,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 +9245,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 +9274,7 @@ var require_cjs = __commonJS({
       maxBodySize;
       ridBuffer;
       pageIdBuffer;
+      logger;
       initialized = false;
       /**
        * Retrieves the BPTree transaction associated with the given transaction.
@@ -9101,6 +9309,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 +9357,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 +9383,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 +9485,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 +9571,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 +9631,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 +9646,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);
       }
@@ -9810,25 +10025,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 Logger(this, moduleName);
+      }
+    };
+    var Logger = 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 +10139,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 +10157,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 +10177,9 @@ var require_cjs = __commonJS({
           pageCacheCapacity: 1e4,
           pagePreallocationCount: 1e3,
           wal: null,
-          walCheckpointThreshold: 1e3
+          walCheckpointThreshold: 1e3,
+          logLevel: 2
+          /* Info */
         }, options);
       }
       /**
@@ -9894,6 +10190,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 +10240,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 +10276,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 +10296,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 +10321,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 +10339,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 +10363,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 +10391,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 +10419,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 +10433,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 +10454,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 +10476,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 +10495,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 +10513,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 +10523,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 +10535,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 +10552,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 +11173,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 +11488,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 +11601,7 @@ var QueryManager = class {
             others,
             tx2
           )) {
+            self.logger.debug(`Yielding sorted document: ${doc._id}`);
             if (skippedCount < offset) {
               skippedCount++;
               continue;
@@ -11381,8 +11701,9 @@ var DocumentSerializeStrategyAsync = class extends import_dataply2.SerializeStra
 
 // 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 +11805,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;
@@ -11578,6 +11900,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 +11910,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,63 +11931,45 @@ 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;
         }
       }
@@ -11674,6 +11977,95 @@ var IndexManager = class {
       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;
+          }
+        }
+      }
+      return docCount;
+    }, tx);
+  }
   /**
    * Convert CreateIndexOption to IndexMetaConfig for metadata storage.
    */
@@ -11843,8 +12235,17 @@ var DeadlineChunker = class {
 
 // src/core/MutationManager.ts
 var MutationManager = class {
-  constructor(api) {
+  constructor(api, logger) {
     this.api = api;
+    this.logger = logger;
+  }
+  async isTreeEmpty(tree) {
+    try {
+      const root = await tree.getNode(tree.rootId);
+      return root.leaf && root.values.length === 0;
+    } catch {
+      return true;
+    }
   }
   async insertDocumentInternal(document, tx) {
     const metadata = await this.api.getDocumentInnerMetadata(tx);
@@ -11945,18 +12346,26 @@ 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);
+        if (isEmptyTree) {
+          const [error] = await catchPromise(treeTx.bulkLoad(batchInsertData));
           if (error) {
             throw error;
           }
-        });
+        } else {
+          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));
+            if (error) {
+              throw error;
+            }
+          });
+        }
         const res = await treeTx.commit();
         if (!res.success) {
           await treeTx.rollback();
@@ -12096,8 +12505,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 +12535,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 +12545,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 +13382,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 +13514,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 +13522,7 @@ var AnalysisManager = class {
       }
     }
     this.flushing = false;
+    this.logger.debug("Finished analysis data flush");
   }
   /**
    * Get the analysis header row.
@@ -13235,32 +13650,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;
     });
   }
@@ -13318,6 +13740,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.
@@ -13542,6 +13974,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
    */