dataply 0.0.1 → 0.0.3

package/dist/cjs/index.js

@@ -36,6 +36,7 @@ __export(src_exports, {
   CacheEntanglementSync: () => CacheEntanglementSync2,
   Dataply: () => Dataply,
   DataplyAPI: () => DataplyAPI,
+  GlobalTransaction: () => GlobalTransaction,
   InMemoryStoreStrategyAsync: () => InMemoryStoreStrategyAsync,
   InMemoryStoreStrategySync: () => InMemoryStoreStrategySync,
   InvertedWeakMap: () => InvertedWeakMap,
@@ -2906,6 +2907,320 @@ var InvertedWeakMap = class {
 // src/core/DataplyAPI.ts
 var import_node_fs3 = __toESM(require("node:fs"));
 
+// node_modules/hookall/dist/esm/index.mjs
+var HookallStore = class extends WeakMap {
+  ensure(obj, key) {
+    if (!this.has(obj)) {
+      const scope2 = {};
+      this.set(obj, scope2);
+    }
+    const scope = this.get(obj);
+    if (!Object.prototype.hasOwnProperty.call(scope, key)) {
+      scope[key] = /* @__PURE__ */ new Map();
+    }
+    return scope[key];
+  }
+};
+var Hookall = class _Hookall {
+  static Global = {};
+  static _Store = new HookallStore();
+  beforeHooks;
+  afterHooks;
+  /**
+   * Create hook system. you can pass a target object or undefined.
+   * If you pass a object, the hook system will be work for object locally. You're going to want this kind of usage in general.
+   * If not specified, will be work for global. This is useful when you want to share your work with multiple files.
+   * @param target The object to work with locally. If not specified, will be work for global.
+   */
+  constructor(target) {
+    this.beforeHooks = _Hookall._Store.ensure(target, "before");
+    this.afterHooks = _Hookall._Store.ensure(target, "after");
+  }
+  _ensureCommand(hooks, command) {
+    if (!hooks.has(command)) {
+      hooks.set(command, []);
+    }
+    return hooks.get(command);
+  }
+  _createWrapper(command, callback, repeat) {
+    return {
+      callback,
+      command,
+      repeat
+    };
+  }
+  _on(hooks, command, callback, repeat) {
+    const wrappers = this._ensureCommand(hooks, command);
+    const wrapper = this._createWrapper(command, callback, repeat);
+    wrappers.unshift(wrapper);
+  }
+  /**
+   * You register a preprocessing function, which is called before the callback function of the `trigger` method.
+   * The value returned by this function is passed as a parameter to the `trigger` method's callback function.
+   * If you register multiple preprocessing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
+   * @param command Command to work.
+   * @param callback Preprocessing function to register.
+   */
+  onBefore(command, callback) {
+    this._on(this.beforeHooks, command, callback, -1);
+    return this;
+  }
+  /**
+   * Similar to the `onBefore` method, but it only runs once.
+   * For more details, please refer to the `onBefore` method.
+   * @param command Command to work.
+   * @param callback Preprocessing function to register.
+   */
+  onceBefore(command, callback) {
+    this._on(this.beforeHooks, command, callback, 1);
+    return this;
+  }
+  /**
+   * You register a post-processing function which is called after the callback function of the `trigger` method finishes.
+   * This function receives the value returned by the `trigger` method's callback function as a parameter.
+   * If you register multiple post-processing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
+   * @param command Command to work.
+   * @param callback Post-preprocessing function to register.
+   */
+  onAfter(command, callback) {
+    this._on(this.afterHooks, command, callback, -1);
+    return this;
+  }
+  /**
+   * Similar to the `onAfter` method, but it only runs once.
+   * For more details, please refer to the `onAfter` method.
+   * @param command Command to work.
+   * @param callback Post-preprocessing function to register.
+   */
+  onceAfter(command, callback) {
+    this._on(this.afterHooks, command, callback, 1);
+    return this;
+  }
+  _off(hooks, command, callback) {
+    const wrappers = this._ensureCommand(hooks, command);
+    if (callback) {
+      const i = wrappers.findIndex((wrapper) => wrapper.callback === callback);
+      if (i !== -1) {
+        wrappers.splice(i, 1);
+      }
+    } else {
+      wrappers.length = 0;
+    }
+    return this;
+  }
+  /**
+   * You remove the preprocessing functions registered with `onBefore` or `onceBefore` methods.
+   * If you don't specify a callback parameter, it removes all preprocessing functions registered for that command.
+   * @param command Commands with preprocessing functions to be deleted.
+   * @param callback Preprocessing function to be deleted.
+   */
+  offBefore(command, callback) {
+    this._off(this.beforeHooks, command, callback);
+    return this;
+  }
+  /**
+   * You remove the post-preprocessing functions registered with `onAfter` or `onceAfter` methods.
+   * If you don't specify a callback parameter, it removes all post-preprocessing functions registered for that command.
+   * @param command Commands with post-preprocessing functions to be deleted.
+   * @param callback post-Preprocessing function to be deleted.
+   */
+  offAfter(command, callback) {
+    this._off(this.afterHooks, command, callback);
+    return this;
+  }
+  async _hookWith(hooks, command, value, ...params) {
+    let wrappers = this._ensureCommand(hooks, command);
+    let i = wrappers.length;
+    while (i--) {
+      const wrapper = wrappers[i];
+      value = await wrapper.callback(value, ...params);
+      wrapper.repeat -= 1;
+      if (wrapper.repeat === 0) {
+        this._off(hooks, command, wrapper.callback);
+      }
+    }
+    return value;
+  }
+  /**
+   * You execute the callback function provided as a parameter. This callback function receives the 'initialValue' parameter.
+   * 
+   * If preprocessing functions are registered, they run first, and the value returned by the preprocessing functions becomes the 'initialValue' parameter.
+   * After the callback function finishes, post-processing functions are called.
+   * These post-processing functions receive the value returned by the callback function as a parameter and run sequentially.
+   * 
+   * The final value returned becomes the result of the `trigger` method.
+   * @param command Command to work.
+   * @param initialValue Initial value to be passed to the callback function.
+   * @param callback The callback function to be executed.
+   */
+  async trigger(command, initialValue, callback, ...params) {
+    let value;
+    value = await this._hookWith(this.beforeHooks, command, initialValue, ...params);
+    value = await callback(value, ...params);
+    value = await this._hookWith(this.afterHooks, command, value, ...params);
+    return value;
+  }
+};
+function useHookall(target = Hookall.Global) {
+  return new Hookall(target);
+}
+var HookallStore2 = class extends WeakMap {
+  ensure(obj, key) {
+    if (!this.has(obj)) {
+      const scope2 = {};
+      this.set(obj, scope2);
+    }
+    const scope = this.get(obj);
+    if (!Object.prototype.hasOwnProperty.call(scope, key)) {
+      scope[key] = /* @__PURE__ */ new Map();
+    }
+    return scope[key];
+  }
+};
+var HookallSync = class _HookallSync {
+  static Global = {};
+  static _Store = new HookallStore2();
+  beforeHooks;
+  afterHooks;
+  /**
+   * Create hook system. you can pass a target object or undefined.
+   * If you pass a object, the hook system will be work for object locally. You're going to want this kind of usage in general.
+   * If not specified, will be work for global. This is useful when you want to share your work with multiple files.
+   * @param target The object to work with locally. If not specified, will be work for global.
+   */
+  constructor(target) {
+    this.beforeHooks = _HookallSync._Store.ensure(target, "before");
+    this.afterHooks = _HookallSync._Store.ensure(target, "after");
+  }
+  _ensureCommand(hooks, command) {
+    if (!hooks.has(command)) {
+      hooks.set(command, []);
+    }
+    return hooks.get(command);
+  }
+  _createWrapper(command, callback, repeat) {
+    return {
+      callback,
+      command,
+      repeat
+    };
+  }
+  _on(hooks, command, callback, repeat) {
+    const wrappers = this._ensureCommand(hooks, command);
+    const wrapper = this._createWrapper(command, callback, repeat);
+    wrappers.unshift(wrapper);
+  }
+  /**
+   * You register a preprocessing function, which is called before the callback function of the `trigger` method.
+   * The value returned by this function is passed as a parameter to the `trigger` method's callback function.
+   * If you register multiple preprocessing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
+   * @param command Command to work.
+   * @param callback Preprocessing function to register.
+   */
+  onBefore(command, callback) {
+    this._on(this.beforeHooks, command, callback, -1);
+    return this;
+  }
+  /**
+   * Similar to the `onBefore` method, but it only runs once.
+   * For more details, please refer to the `onBefore` method.
+   * @param command Command to work.
+   * @param callback Preprocessing function to register.
+   */
+  onceBefore(command, callback) {
+    this._on(this.beforeHooks, command, callback, 1);
+    return this;
+  }
+  /**
+   * You register a post-processing function which is called after the callback function of the `trigger` method finishes.
+   * This function receives the value returned by the `trigger` method's callback function as a parameter.
+   * If you register multiple post-processing functions, they are executed in order, with each function receiving the value returned by the previous one as a parameter.
+   * @param command Command to work.
+   * @param callback Post-preprocessing function to register.
+   */
+  onAfter(command, callback) {
+    this._on(this.afterHooks, command, callback, -1);
+    return this;
+  }
+  /**
+   * Similar to the `onAfter` method, but it only runs once.
+   * For more details, please refer to the `onAfter` method.
+   * @param command Command to work.
+   * @param callback Post-preprocessing function to register.
+   */
+  onceAfter(command, callback) {
+    this._on(this.afterHooks, command, callback, 1);
+    return this;
+  }
+  _off(hooks, command, callback) {
+    const wrappers = this._ensureCommand(hooks, command);
+    if (callback) {
+      const i = wrappers.findIndex((wrapper) => wrapper.callback === callback);
+      if (i !== -1) {
+        wrappers.splice(i, 1);
+      }
+    } else {
+      wrappers.length = 0;
+    }
+    return this;
+  }
+  /**
+   * You remove the preprocessing functions registered with `onBefore` or `onceBefore` methods.
+   * If you don't specify a callback parameter, it removes all preprocessing functions registered for that command.
+   * @param command Commands with preprocessing functions to be deleted.
+   * @param callback Preprocessing function to be deleted.
+   */
+  offBefore(command, callback) {
+    this._off(this.beforeHooks, command, callback);
+    return this;
+  }
+  /**
+   * You remove the post-preprocessing functions registered with `onAfter` or `onceAfter` methods.
+   * If you don't specify a callback parameter, it removes all post-preprocessing functions registered for that command.
+   * @param command Commands with post-preprocessing functions to be deleted.
+   * @param callback post-Preprocessing function to be deleted.
+   */
+  offAfter(command, callback) {
+    this._off(this.afterHooks, command, callback);
+    return this;
+  }
+  _hookWith(hooks, command, value, ...params) {
+    let wrappers = this._ensureCommand(hooks, command);
+    let i = wrappers.length;
+    while (i--) {
+      const wrapper = wrappers[i];
+      value = wrapper.callback(value, ...params);
+      wrapper.repeat -= 1;
+      if (wrapper.repeat === 0) {
+        this._off(hooks, command, wrapper.callback);
+      }
+    }
+    return value;
+  }
+  /**
+   * You execute the callback function provided as a parameter. This callback function receives the 'initialValue' parameter.
+   * 
+   * If preprocessing functions are registered, they run first, and the value returned by the preprocessing functions becomes the 'initialValue' parameter.
+   * After the callback function finishes, post-processing functions are called.
+   * These post-processing functions receive the value returned by the callback function as a parameter and run sequentially.
+   * 
+   * The final value returned becomes the result of the `trigger` method.
+   * @param command Command to work.
+   * @param initialValue Initial value to be passed to the callback function.
+   * @param callback The callback function to be executed.
+   */
+  trigger(command, initialValue, callback, ...params) {
+    let value;
+    value = this._hookWith(this.beforeHooks, command, initialValue, ...params);
+    value = callback(value, ...params);
+    value = this._hookWith(this.afterHooks, command, value, ...params);
+    return value;
+  }
+};
+function useHookallSync(target = HookallSync.Global) {
+  return new HookallSync(target);
+}
+
 // src/utils/numberToBytes.ts
 function numberToBytes(value, buffer, offset = 0, length = buffer.length) {
   if (length === 4) {
@@ -3776,11 +4091,16 @@ var MetadataPageManager = class _MetadataPageManager extends PageManager {
     OFFSET_ROOT_INDEX_ORDER: 126,
     OFFSET_LAST_INSERT_PAGE_ID: 130,
     OFFSET_LAST_ROW_PK: 134,
+    OFFSET_BITMAP_PAGE_ID: 140,
+    OFFSET_FREE_PAGE_ID: 144,
     SIZE_PAGE_COUNT: 4,
     SIZE_PAGE_SIZE: 4,
     SIZE_ROOT_INDEX_PAGE_ID: 4,
     SIZE_ROOT_INDEX_ORDER: 4,
-    SIZE_LAST_INSERT_PAGE_ID: 4
+    SIZE_LAST_INSERT_PAGE_ID: 4,
+    SIZE_ROW_PK: 6,
+    SIZE_BITMAP_PAGE_ID: 4,
+    SIZE_FREE_PAGE_ID: 4
   };
   /**
    * Checks if the page type is `MetadataPage`.
@@ -3882,7 +4202,7 @@ var MetadataPageManager = class _MetadataPageManager extends PageManager {
     return bytesToNumber(
       page,
       _MetadataPageManager.CONSTANT.OFFSET_LAST_ROW_PK,
-      Row.CONSTANT.SIZE_PK
+      _MetadataPageManager.CONSTANT.SIZE_ROW_PK
     );
   }
   /**
@@ -3894,8 +4214,33 @@ var MetadataPageManager = class _MetadataPageManager extends PageManager {
     return bytesToNumber(
       page,
       _MetadataPageManager.CONSTANT.OFFSET_ROW_COUNT,
-      Row.CONSTANT.SIZE_PK
+      _MetadataPageManager.CONSTANT.SIZE_ROW_PK
+    );
+  }
+  /**
+   * Returns the ID of the bitmap page.
+   * @param page Page data
+   * @returns Bitmap page ID
+   */
+  getBitmapPageId(page) {
+    return bytesToNumber(
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_BITMAP_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_BITMAP_PAGE_ID
+    );
+  }
+  /**
+   * Returns the ID of the free page.
+   * @param page Page data
+   * @returns Free page ID
+   */
+  getFreePageId(page) {
+    const id = bytesToNumber(
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_FREE_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_FREE_PAGE_ID
     );
+    return id === 4294967295 ? -1 : id;
   }
   /**
    * Sets the number of pages stored in the database.
@@ -3997,6 +4342,32 @@ var MetadataPageManager = class _MetadataPageManager extends PageManager {
       Row.CONSTANT.SIZE_PK
     );
   }
+  /**
+   * Sets the ID of the bitmap page.
+   * @param page Page data
+   * @param bitmapPageId Bitmap page ID
+   */
+  setBitmapPageId(page, bitmapPageId) {
+    numberToBytes(
+      bitmapPageId,
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_BITMAP_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_BITMAP_PAGE_ID
+    );
+  }
+  /**
+   * Sets the ID of the free page.
+   * @param page Page data
+   * @param pageId Free page ID
+   */
+  setFreePageId(page, pageId) {
+    numberToBytes(
+      pageId,
+      page,
+      _MetadataPageManager.CONSTANT.OFFSET_FREE_PAGE_ID,
+      _MetadataPageManager.CONSTANT.SIZE_FREE_PAGE_ID
+    );
+  }
 };
 var BitmapPageManager = class _BitmapPageManager extends PageManager {
   get pageType() {
@@ -4027,6 +4398,31 @@ var BitmapPageManager = class _BitmapPageManager extends PageManager {
   isEmptyPage(page, index) {
     return bytesToNumber(page, index, 1) === 0;
   }
+  /**
+   * Gets a bit from the bitmap page.
+   * @param page Page data
+   * @param index Bit index
+   * @returns boolean indicating if the bit is set
+   */
+  getBit(page, index) {
+    const bitOffset = Math.floor(index / 8);
+    const offset = _BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER + bitOffset;
+    const value = bytesToNumber(page, offset, 1);
+    return getBit(value, index % 8);
+  }
+  /**
+   * Sets a bit in the bitmap page.
+   * @param page Page data
+   * @param index Bit index
+   * @param flag boolean indicating if the bit is set
+   */
+  setBit(page, index, flag) {
+    const bitOffset = Math.floor(index / 8);
+    const offset = _BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER + bitOffset;
+    const value = bytesToNumber(page, offset, 1);
+    const newValue = setBit(value, index % 8, flag);
+    numberToBytes(newValue, page, offset, 1);
+  }
 };
 var OverflowPageManager = class _OverflowPageManager extends PageManager {
   get pageType() {
@@ -4242,9 +4638,33 @@ var LogManager = class {
       });
     });
   }
+  /**
+   * Writes a commit marker to the log file.
+   * This indicates that the preceding logs are part of a committed transaction.
+   */
+  async writeCommitMarker() {
+    if (this.fd === null) {
+      this.open();
+    }
+    this.view.setUint32(0, 4294967295, true);
+    this.buffer.fill(0, 4);
+    await new Promise((resolve, reject) => {
+      import_node_fs.default.write(this.fd, this.buffer, 0, this.entrySize, null, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+    await new Promise((resolve, reject) => {
+      import_node_fs.default.fsync(this.fd, (err) => {
+        if (err) return reject(err);
+        resolve();
+      });
+    });
+  }
   /**
    * Reads the log file to recover the page map.
    * Runs synchronously as it is called by the VFS constructor.
+   * Only returns pages from committed transactions (ended with a commit marker).
    * @returns Recovered page map
    */
   readAllSync() {
@@ -4254,11 +4674,19 @@ var LogManager = class {
     const restoredPages = /* @__PURE__ */ new Map();
     const currentFileSize = import_node_fs.default.fstatSync(this.fd).size;
     let offset = 0;
+    let pendingPages = /* @__PURE__ */ new Map();
     while (offset + this.entrySize <= currentFileSize) {
       import_node_fs.default.readSync(this.fd, this.buffer, 0, this.entrySize, offset);
       const pageId = this.view.getUint32(0, true);
-      const pageData = this.buffer.slice(4, 4 + this.pageSize);
-      restoredPages.set(pageId, pageData);
+      if (pageId === 4294967295) {
+        for (const [pId, pData] of pendingPages) {
+          restoredPages.set(pId, pData);
+        }
+        pendingPages.clear();
+      } else {
+        const pageData = this.buffer.slice(4, 4 + this.pageSize);
+        pendingPages.set(pageId, pageData);
+      }
       offset += this.entrySize;
     }
     return restoredPages;
@@ -4360,13 +4788,13 @@ var VirtualFileSystem = class {
     }
   }
   /**
-   * Commits the transaction.
+   * Prepares the transaction for commit (Phase 1).
+   * Writes dirty pages to WAL but does not update the main database file.
    * @param tx Transaction
    */
-  async commit(tx) {
+  async prepareCommit(tx) {
     const dirtyPages = tx.__getDirtyPages();
     if (dirtyPages.size === 0) {
-      this.cleanupTransaction(tx);
       return;
     }
     const dirtyPageMap = /* @__PURE__ */ new Map();
@@ -4379,6 +4807,21 @@ var VirtualFileSystem = class {
     if (this.logManager && dirtyPageMap.size > 0) {
       await this.logManager.append(dirtyPageMap);
     }
+  }
+  /**
+   * Finalizes the transaction commit (Phase 2).
+   * Writes commit marker to WAL and updates the main database file (Checkpoint).
+   * @param tx Transaction
+   */
+  async finalizeCommit(tx) {
+    const dirtyPages = tx.__getDirtyPages();
+    if (dirtyPages.size === 0) {
+      this.cleanupTransaction(tx);
+      return;
+    }
+    if (this.logManager) {
+      await this.logManager.writeCommitMarker();
+    }
     const sortedPages = Array.from(dirtyPages).sort((a, b) => a - b);
     const promises = [];
     for (const pageId of sortedPages) {
@@ -4401,6 +4844,15 @@ var VirtualFileSystem = class {
     }
     this.cleanupTransaction(tx);
   }
+  /**
+   * Commits the transaction (Single Phase).
+   * Wrapper for prepare + finalize for backward compatibility.
+   * @param tx Transaction
+   */
+  async commit(tx) {
+    await this.prepareCommit(tx);
+    await this.finalizeCommit(tx);
+  }
   /**
    * Rolls back the transaction.
    * @param tx Transaction
@@ -4448,8 +4900,8 @@ var VirtualFileSystem = class {
    * @param position Start position in file
    */
   _writeAsync(handle, buffer, offset, length, position) {
-    if (position + length > 100 * 1024 * 1024) {
-      return Promise.reject(new Error(`[Safety Limit] File write exceeds 100MB limit at position ${position}`));
+    if (position + length > 512 * 1024 * 1024) {
+      return Promise.reject(new Error(`[Safety Limit] File write exceeds 512MB limit at position ${position}`));
     }
     return new Promise((resolve, reject) => {
       import_node_fs2.default.write(handle, buffer, offset, length, position, (err, bytesWritten) => {
@@ -4627,6 +5079,43 @@ var PageFileSystem = class {
   pageFactory = new PageManagerFactory();
   vfs;
   pageManagerFactory;
+  /**
+   * Updates the bitmap status for a specific page.
+   * @param pageId The ID of the page to update
+   * @param isFree True to mark as free, false to mark as used
+   * @param tx Transaction
+   */
+  async updateBitmap(pageId, isFree, tx) {
+    const metadata = await this.getMetadata(tx);
+    const metadataManager = this.pageFactory.getManager(metadata);
+    const bitmapPageId = metadataManager.getBitmapPageId(metadata);
+    const headerSize = PageManager.CONSTANT.SIZE_PAGE_HEADER;
+    const capacityPerBitmapPage = (this.pageSize - headerSize) * 8;
+    let currentBitmapPageId = bitmapPageId;
+    let targetBitIndex = pageId;
+    while (targetBitIndex >= capacityPerBitmapPage) {
+      const currentBitmapPage = await this.get(currentBitmapPageId, tx);
+      const manager = this.pageFactory.getManager(currentBitmapPage);
+      targetBitIndex -= capacityPerBitmapPage;
+      const nextPageId = manager.getNextPageId(currentBitmapPage);
+      if (nextPageId === -1) {
+        if (!isFree) {
+          throw new Error("Bitmap page not found for reused page");
+        }
+        const newBitmapPageId = await this.appendNewPage(PageManager.CONSTANT.PAGE_TYPE_BITMAP, tx);
+        manager.setNextPageId(currentBitmapPage, newBitmapPageId);
+        await this.setPage(currentBitmapPageId, currentBitmapPage, tx);
+        currentBitmapPageId = newBitmapPageId;
+      } else {
+        currentBitmapPageId = nextPageId;
+      }
+    }
+    await tx.__acquireWriteLock(currentBitmapPageId);
+    const targetBitmapPage = await this.get(currentBitmapPageId, tx);
+    const bitmapManager = this.pageFactory.getManager(targetBitmapPage);
+    bitmapManager.setBit(targetBitmapPage, targetBitIndex, isFree);
+    await this.setPage(currentBitmapPageId, targetBitmapPage, tx);
+  }
   /**
    * VFS 인스턴스를 반환합니다.
    * Transaction 생성 시 사용됩니다.
@@ -4735,12 +5224,28 @@ var PageFileSystem = class {
   }
   /**
    * Appends and inserts a new page.
-   * @returns Created page ID
+   * If a free page is available in the free list, it reuses it.
+   * Otherwise, it appends a new page to the end of the file.
+   * @returns Created or reused page ID
    */
   async appendNewPage(pageType = PageManager.CONSTANT.PAGE_TYPE_EMPTY, tx) {
     await tx.__acquireWriteLock(0);
     const metadata = await this.getMetadata(tx);
     const metadataManager = this.pageFactory.getManager(metadata);
+    const freePageId = metadataManager.getFreePageId(metadata);
+    if (freePageId !== -1) {
+      const reusedPageId = freePageId;
+      const reusedPage = await this.get(reusedPageId, tx);
+      const reusedPageManager = this.pageFactory.getManager(reusedPage);
+      const nextFreePageId = reusedPageManager.getNextPageId(reusedPage);
+      metadataManager.setFreePageId(metadata, nextFreePageId);
+      await this.setPage(0, metadata, tx);
+      await this.updateBitmap(reusedPageId, false, tx);
+      const manager2 = this.pageFactory.getManagerFromType(pageType);
+      const newPage2 = manager2.create(this.pageSize, reusedPageId);
+      await this.setPage(reusedPageId, newPage2, tx);
+      return reusedPageId;
+    }
     const pageCount = metadataManager.getPageCount(metadata);
     const newPageIndex = pageCount;
     const newTotalCount = pageCount + 1;
@@ -4805,6 +5310,26 @@ var PageFileSystem = class {
       }
     }
   }
+  /**
+   * Frees the page and marks it as available in the bitmap.
+   * It also adds the page to the linked list of free pages in metadata.
+   * @param pageId Page ID
+   * @param tx Transaction
+   */
+  async setFreePage(pageId, tx) {
+    await tx.__acquireWriteLock(0);
+    await tx.__acquireWriteLock(pageId);
+    const metadata = await this.getMetadata(tx);
+    const metadataManager = this.pageFactory.getManager(metadata);
+    const currentHeadFreePageId = metadataManager.getFreePageId(metadata);
+    const emptyPageManager = this.pageFactory.getManagerFromType(PageManager.CONSTANT.PAGE_TYPE_EMPTY);
+    const emptyPage = emptyPageManager.create(this.pageSize, pageId);
+    emptyPageManager.setNextPageId(emptyPage, currentHeadFreePageId);
+    await this.setPage(pageId, emptyPage, tx);
+    await this.updateBitmap(pageId, true, tx);
+    metadataManager.setFreePageId(metadata, pageId);
+    await this.setPage(0, metadata, tx);
+  }
   /**
    * Closes the page file system.
    */
@@ -4944,8 +5469,7 @@ var RowIdentifierStrategy = class extends SerializeStrategyAsync {
     while (true) {
       const page = await this.pfs.get(pageId, tx);
       const nextPageId = manager.getNextPageId(page);
-      manager.setNextPageId(page, -1);
-      manager.setRemainingCapacity(page, this.pfs.pageSize - PageManager.CONSTANT.SIZE_PAGE_HEADER);
+      await this.pfs.setFreePage(pageId, tx);
       if (nextPageId === -1) {
         break;
       }
@@ -5337,13 +5861,41 @@ var RowTableEngine = class {
     if (this.rowManager.getDeletedFlag(row)) {
       return;
     }
+    if (this.rowManager.getOverflowFlag(row)) {
+      let overflowPageId = bytesToNumber(this.rowManager.getBody(row));
+      while (overflowPageId !== -1) {
+        const overflowPage = await this.pfs.get(overflowPageId, tx);
+        const manager = this.factory.getManager(overflowPage);
+        const nextPageId = manager.getNextPageId(overflowPage);
+        await this.pfs.setFreePage(overflowPageId, tx);
+        overflowPageId = nextPageId;
+      }
+    }
     this.rowManager.setDeletedFlag(row, true);
     await this.pfs.setPage(pageId, page, tx);
     if (decrementRowCount) {
-      const metadataPage = await this.pfs.getMetadata(tx);
-      const currentRowCount = this.metadataPageManager.getRowCount(metadataPage);
-      this.metadataPageManager.setRowCount(metadataPage, currentRowCount - 1);
-      await this.pfs.setMetadata(metadataPage, tx);
+      const metadataPage2 = await this.pfs.getMetadata(tx);
+      const currentRowCount = this.metadataPageManager.getRowCount(metadataPage2);
+      this.metadataPageManager.setRowCount(metadataPage2, currentRowCount - 1);
+      await this.pfs.setMetadata(metadataPage2, tx);
+    }
+    const insertedRowCount = this.dataPageManager.getInsertedRowCount(page);
+    let allDeleted = true;
+    const metadataPage = await this.pfs.getMetadata(tx);
+    const lastInsertPageId = this.metadataPageManager.getLastInsertPageId(metadataPage);
+    if (pageId === lastInsertPageId) {
+      allDeleted = false;
+    } else {
+      for (let i = 0; i < insertedRowCount; i++) {
+        const slotRow = this.dataPageManager.getRow(page, i);
+        if (!this.rowManager.getDeletedFlag(slotRow)) {
+          allDeleted = false;
+          break;
+        }
+      }
+    }
+    if (allDeleted) {
+      await this.pfs.setFreePage(pageId, tx);
     }
   }
   /**
@@ -5547,11 +6099,19 @@ var Transaction = class {
     this.heldLocks.add(lockId);
     this.pageLocks.set(pageId, lockId);
   }
+  /**
+   * Prepares the transaction for commit (Phase 1 of 2PC).
+   * Writes dirty pages to WAL but does not update the database file yet.
+   */
+  async prepare() {
+    await this.vfs.prepareCommit(this);
+  }
   /**
    * Commits the transaction.
    */
   async commit() {
-    await this.vfs.commit(this);
+    await this.vfs.prepareCommit(this);
+    await this.vfs.finalizeCommit(this);
     await TxContext.run(this, async () => {
       for (const hook of this.commitHooks) {
         await hook();
@@ -5595,11 +6155,20 @@ var Transaction = class {
 
 // src/core/DataplyAPI.ts
 var DataplyAPI = class {
-  constructor(file, fileHandle, options) {
+  constructor(file, options) {
     this.file = file;
-    this.fileHandle = fileHandle;
-    this.options = options;
-    this.pfs = new PageFileSystem(fileHandle, options.pageSize, options.pageCacheCapacity, options.wal);
+    this.hook = {
+      sync: useHookallSync(this),
+      async: useHookall(this)
+    };
+    this.options = this.verboseOptions(options);
+    this.fileHandle = this.createOrOpen(file, this.options);
+    this.pfs = new PageFileSystem(
+      this.fileHandle,
+      this.options.pageSize,
+      this.options.pageCacheCapacity,
+      this.options.wal
+    );
     this.textCodec = new TextCodec();
     this.lockManager = new LockManager();
     this.rowTableEngine = new RowTableEngine(this.pfs, this.options);
@@ -5607,10 +6176,12 @@ var DataplyAPI = class {
     this.txIdCounter = 0;
   }
   options;
+  fileHandle;
   pfs;
   rowTableEngine;
   lockManager;
   textCodec;
+  hook;
   initialized;
   txIdCounter;
   /**
@@ -5619,7 +6190,7 @@ var DataplyAPI = class {
    * @param fileHandle File handle
    * @returns Whether the page file is a valid Dataply file
    */
-  static VerifyFormat(fileHandle) {
+  verifyFormat(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);
@@ -5633,7 +6204,7 @@ var DataplyAPI = class {
    * @param options Options
    * @returns Options filled without omissions
    */
-  static VerboseOptions(options) {
+  verboseOptions(options) {
     return Object.assign({
       pageSize: 8192,
       pageCacheCapacity: 1e4,
@@ -5644,53 +6215,71 @@ var DataplyAPI = class {
    * Initializes the database file.
    * The first page is initialized as the metadata page.
    * The second page is initialized as the first data page.
+   * @param file Database file path
    * @param fileHandle File handle
    */
-  static InitializeFile(fileHandle, options) {
-    const metadataPageManager = new MetadataPageManager();
-    const dataPageManager = new DataPageManager();
-    const metadataPage = new Uint8Array(options.pageSize);
-    const dataPage = new Uint8Array(options.pageSize);
-    metadataPageManager.initial(
-      metadataPage,
-      MetadataPageManager.CONSTANT.PAGE_TYPE_METADATA,
-      0,
-      0,
-      options.pageSize - MetadataPageManager.CONSTANT.SIZE_PAGE_HEADER
-    );
-    metadataPageManager.setMagicString(metadataPage);
-    metadataPageManager.setPageCount(metadataPage, 2);
-    metadataPageManager.setPageSize(metadataPage, options.pageSize);
-    metadataPageManager.setRootIndexPageId(metadataPage, -1);
-    metadataPageManager.setLastInsertPageId(metadataPage, 1);
-    dataPageManager.initial(
-      dataPage,
-      DataPageManager.CONSTANT.PAGE_TYPE_DATA,
-      1,
-      -1,
-      options.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER
-    );
-    import_node_fs3.default.appendFileSync(fileHandle, metadataPage);
-    import_node_fs3.default.appendFileSync(fileHandle, dataPage);
+  initializeFile(file, fileHandle, options) {
+    const fileData = this.hook.sync.trigger("create", new Uint8Array(), (prepareFileData) => {
+      const metadataPageManager = new MetadataPageManager();
+      const bitmapPageManager = new BitmapPageManager();
+      const dataPageManager = new DataPageManager();
+      const metadataPage = new Uint8Array(options.pageSize);
+      const dataPage = new Uint8Array(options.pageSize);
+      metadataPageManager.initial(
+        metadataPage,
+        MetadataPageManager.CONSTANT.PAGE_TYPE_METADATA,
+        0,
+        0,
+        options.pageSize - MetadataPageManager.CONSTANT.SIZE_PAGE_HEADER
+      );
+      metadataPageManager.setMagicString(metadataPage);
+      metadataPageManager.setPageSize(metadataPage, options.pageSize);
+      metadataPageManager.setRootIndexPageId(metadataPage, -1);
+      metadataPageManager.setBitmapPageId(metadataPage, 1);
+      metadataPageManager.setLastInsertPageId(metadataPage, 2);
+      metadataPageManager.setPageCount(metadataPage, 3);
+      metadataPageManager.setFreePageId(metadataPage, -1);
+      const bitmapPage = new Uint8Array(options.pageSize);
+      bitmapPageManager.initial(
+        bitmapPage,
+        BitmapPageManager.CONSTANT.PAGE_TYPE_BITMAP,
+        1,
+        -1,
+        options.pageSize - BitmapPageManager.CONSTANT.SIZE_PAGE_HEADER
+      );
+      dataPageManager.initial(
+        dataPage,
+        DataPageManager.CONSTANT.PAGE_TYPE_DATA,
+        2,
+        -1,
+        options.pageSize - DataPageManager.CONSTANT.SIZE_PAGE_HEADER
+      );
+      return new Uint8Array([
+        ...prepareFileData,
+        ...metadataPage,
+        ...bitmapPage,
+        ...dataPage
+      ]);
+    }, file, fileHandle, options);
+    import_node_fs3.default.appendFileSync(fileHandle, fileData);
   }
   /**
    * Opens the database file. If the file does not exist, it initializes it.
    * @param file Database file path
    * @param options Options
-   * @returns Dataply instance
+   * @returns File handle
    */
-  static Use(file, options) {
-    const verboseOption = this.VerboseOptions(options);
+  createOrOpen(file, options) {
     let fileHandle;
-    if (verboseOption.pageCacheCapacity < 100) {
+    if (options.pageCacheCapacity < 100) {
       throw new Error("Page cache capacity must be at least 100");
     }
     if (!import_node_fs3.default.existsSync(file)) {
-      if (verboseOption.pageSize < 4096) {
+      if (options.pageSize < 4096) {
         throw new Error("Page size must be at least 4096 bytes");
       }
       fileHandle = import_node_fs3.default.openSync(file, "w+");
-      this.InitializeFile(fileHandle, verboseOption);
+      this.initializeFile(file, fileHandle, options);
     } else {
       fileHandle = import_node_fs3.default.openSync(file, "r+");
       const buffer = new Uint8Array(
@@ -5701,14 +6290,14 @@ var DataplyAPI = class {
       if (metadataManager.isMetadataPage(buffer)) {
         const storedPageSize = metadataManager.getPageSize(buffer);
         if (storedPageSize > 0) {
-          verboseOption.pageSize = storedPageSize;
+          options.pageSize = storedPageSize;
         }
       }
     }
-    if (!this.VerifyFormat(fileHandle)) {
+    if (!this.verifyFormat(fileHandle)) {
       throw new Error("Invalid dataply file");
     }
-    return new this(file, fileHandle, verboseOption);
+    return fileHandle;
   }
   /**
    * Initializes the dataply instance.
@@ -5719,8 +6308,12 @@ var DataplyAPI = class {
     if (this.initialized) {
       return;
     }
-    await this.runWithDefault(() => this.rowTableEngine.init());
-    this.initialized = true;
+    await this.runWithDefault(() => {
+      return this.hook.async.trigger("init", void 0, async () => {
+        await this.rowTableEngine.init();
+        this.initialized = true;
+      });
+    });
   }
   /**
    * Creates a transaction.
@@ -5779,10 +6372,11 @@ var DataplyAPI = class {
       throw new Error("Dataply instance is not initialized");
     }
     return this.runWithDefault((tx2) => {
+      incrementRowCount = incrementRowCount ?? true;
       if (typeof data === "string") {
         data = this.textCodec.encode(data);
       }
-      return this.rowTableEngine.insert(data, incrementRowCount ?? true, tx2);
+      return this.rowTableEngine.insert(data, incrementRowCount, tx2);
     }, tx);
   }
   /**
@@ -5798,10 +6392,11 @@ var DataplyAPI = class {
       throw new Error("Dataply instance is not initialized");
     }
     return this.runWithDefault(async (tx2) => {
+      incrementRowCount = incrementRowCount ?? true;
       const pks = [];
       for (const data of dataList) {
         const encoded = typeof data === "string" ? this.textCodec.encode(data) : data;
-        const pk = await this.rowTableEngine.insert(encoded, incrementRowCount ?? true, tx2);
+        const pk = await this.rowTableEngine.insert(encoded, incrementRowCount, tx2);
         pks.push(pk);
       }
       return pks;
@@ -5835,7 +6430,8 @@ var DataplyAPI = class {
       throw new Error("Dataply instance is not initialized");
     }
     return this.runWithDefault(async (tx2) => {
-      await this.rowTableEngine.delete(pk, decrementRowCount ?? true, tx2);
+      decrementRowCount = decrementRowCount ?? true;
+      await this.rowTableEngine.delete(pk, decrementRowCount, tx2);
     }, tx);
   }
   async select(pk, asRaw = false, tx) {
@@ -5856,8 +6452,10 @@ var DataplyAPI = class {
     if (!this.initialized) {
       throw new Error("Dataply instance is not initialized");
     }
-    await this.pfs.close();
-    import_node_fs3.default.closeSync(this.fileHandle);
+    return this.hook.async.trigger("close", void 0, async () => {
+      await this.pfs.close();
+      import_node_fs3.default.closeSync(this.fileHandle);
+    });
   }
 };
 
@@ -5865,7 +6463,7 @@ var DataplyAPI = class {
 var Dataply = class {
   api;
   constructor(file, options) {
-    this.api = DataplyAPI.Use(file, options);
+    this.api = new DataplyAPI(file, options ?? {});
   }
   /**
    * Gets the options used to open the dataply.
@@ -5944,6 +6542,52 @@ var Dataply = class {
     return this.api.close();
   }
 };
+
+// src/core/transaction/GlobalTransaction.ts
+var GlobalTransaction = class {
+  transactions = [];
+  isCommitted = false;
+  isRolledBack = false;
+  /**
+   * Adds a transaction to the global transaction.
+   * @param tx Transaction to add
+   */
+  add(tx) {
+    this.transactions.push(tx);
+  }
+  /**
+   * Commits all transactions atomically.
+   * Phase 1: Prepare (Write WAL)
+   * Phase 2: Commit (Write Commit Marker & Checkpoint)
+   */
+  async commit() {
+    if (this.isCommitted || this.isRolledBack) {
+      throw new Error("Transaction is already finished");
+    }
+    try {
+      await Promise.all(this.transactions.map((tx) => tx.prepare()));
+    } catch (e) {
+      await this.rollback();
+      throw new Error(`Global commit failed during prepare phase: ${e}`);
+    }
+    try {
+      await Promise.all(this.transactions.map((tx) => tx.commit()));
+      this.isCommitted = true;
+    } catch (e) {
+      throw new Error(`Global commit failed during finalize phase: ${e}`);
+    }
+  }
+  /**
+   * Rolls back all transactions.
+   */
+  async rollback() {
+    if (this.isCommitted || this.isRolledBack) {
+      return;
+    }
+    await Promise.all(this.transactions.map((tx) => tx.rollback()));
+    this.isRolledBack = true;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BPTreeAsync,
@@ -5952,6 +6596,7 @@ var Dataply = class {
   CacheEntanglementSync,
   Dataply,
   DataplyAPI,
+  GlobalTransaction,
   InMemoryStoreStrategyAsync,
   InMemoryStoreStrategySync,
   InvertedWeakMap,